clang-format: Fix left pointer alignment after delctype/typeof

[euhlmann]

Summary

Change 272124* introduced a regression in spaceRequiredBetween for left aligned pointers to decltype and typeof expressions. This fix adds logic to fix this. The test added is based on a related test in determineStarAmpUsage. Also add test cases for the regression.

• http://llvm.org/viewvc/llvm-project?view=revision&revision=272124

LLVM bug tracker: https://bugs.llvm.org/show_bug.cgi?id=30407

[krasimir]

lib/Format/TokenAnnotator.cpp

2206 ↗

(On Diff #108112)

Please use FormatToken::getPreviousNonComment here and add a test like typedef typeof/*comment*/(int(int, int))* MyFuncPtr;

[euhlmann]

This uses FormatToken::getPreviousNonComment and adds a test. This also fixes a bug in token annotation that was breaking the test (by also using getPreviousNonComment instead of Previous)

[krasimir]

lib/Format/TokenAnnotator.cpp

1402 ↗

(On Diff #109613)

It would be cool if you extract the calls to getPreviousNonComment to a variable, saving the double iteration.

[euhlmann]

Pulled out getPreviousNonComment() into local variable to avoid calling twice.

[euhlmann]

Fix bad formatting

[krasimir]

Looks good! Please reformat the newly added code blocks with clang-format before submitting.

lib/Format/TokenAnnotator.cpp

1402 ↗

(On Diff #109805)

Please reformat this block with clang-format: PrevToken gets indented by two more columns to the right.

2212 ↗

(On Diff #109805)

Pleasereformat this block with clang-format: when I run it, it produces:

if (Right.is(TT_PointerOrReference)) {
  if (Left.is(tok::r_paren) && Line.MightBeFunctionDecl) {
    if (!Left.MatchingParen)
      return true;
    FormatToken *TokenBeforeMatchingParen =
        Left.MatchingParen->getPreviousNonComment();
    if (!TokenBeforeMatchingParen ||
        !TokenBeforeMatchingParen->isOneOf(tok::kw_typeof, tok::kw_decltype))
      return true;
  }
  return (Left.Tok.isLiteral() ||
          (Left.is(tok::kw_const) && Left.Previous &&
           Left.Previous->is(tok::r_paren)) ||
          (!Left.isOneOf(TT_PointerOrReference, tok::l_paren) &&
           (Style.PointerAlignment != FormatStyle::PAS_Left ||
            (Line.IsMultiVariableDeclStmt &&
             (Left.NestingLevel == 0 ||
              (Left.NestingLevel == 1 && Line.First->is(tok::kw_for)))))));
}

[euhlmann]

Ran clang-format over changes and corrected formatting

[euhlmann]

I resolved the formatting issues. I apologize for not paying closer attention to formatting earlier.

I don't have commit access, so if this change looks good now, could someone with access please commit?

cfe/trunk/lib/Format/TokenAnnotator.cpp

TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
 
     if (NextToken->is(tok::l_square) && NextToken->isNot(TT_LambdaLSquare))
       return TT_PointerOrReference;
     if (NextToken->is(tok::kw_operator) && !IsExpression)
       return TT_PointerOrReference;
     if (NextToken->isOneOf(tok::comma, tok::semi))
       return TT_PointerOrReference;
 
-    if (PrevToken->is(tok::r_paren) && PrevToken->MatchingParen &&
-        PrevToken->MatchingParen->Previous &&
-        PrevToken->MatchingParen->Previous->isOneOf(tok::kw_typeof,
-                                                    tok::kw_decltype))
+    if (PrevToken->is(tok::r_paren) && PrevToken->MatchingParen) {
+      FormatToken *TokenBeforeMatchingParen =
+          PrevToken->MatchingParen->getPreviousNonComment();
+      if (TokenBeforeMatchingParen &&
+          TokenBeforeMatchingParen->isOneOf(tok::kw_typeof, tok::kw_decltype))
         return TT_PointerOrReference;
+    }
 
     if (PrevToken->Tok.isLiteral() ||
         PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::kw_true,
                            tok::kw_false, tok::r_brace) ||
         NextToken->Tok.isLiteral() ||
         NextToken->isOneOf(tok::kw_true, tok::kw_false) ||
         NextToken->isUnaryOperator() ||
         // If we know we're in a template argument, there are no named
if (Left.is(tok::coloncolon))
     return false;
   if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less))
     return false;
   if (Right.is(tok::ellipsis))
     return Left.Tok.isLiteral() || (Left.is(tok::identifier) && Left.Previous &&
                                     Left.Previous->is(tok::kw_case));
   if (Left.is(tok::l_square) && Right.is(tok::amp))
     return false;
-  if (Right.is(TT_PointerOrReference))
-    return (Left.is(tok::r_paren) && Line.MightBeFunctionDecl) ||
-           (Left.Tok.isLiteral() ||
+  if (Right.is(TT_PointerOrReference)) {
+    if (Left.is(tok::r_paren) && Line.MightBeFunctionDecl) {
+      if (!Left.MatchingParen)
+        return true;
+      FormatToken *TokenBeforeMatchingParen =
+          Left.MatchingParen->getPreviousNonComment();
+      if (!TokenBeforeMatchingParen ||
+          !TokenBeforeMatchingParen->isOneOf(tok::kw_typeof, tok::kw_decltype))
+        return true;
+    }
+    return (Left.Tok.isLiteral() ||
             (!Left.isOneOf(TT_PointerOrReference, tok::l_paren) &&
              (Style.PointerAlignment != FormatStyle::PAS_Left ||
               (Line.IsMultiVariableDeclStmt &&
                (Left.NestingLevel == 0 ||
                 (Left.NestingLevel == 1 && Line.First->is(tok::kw_for)))))));
+  }
   if (Right.is(TT_FunctionTypeLParen) && Left.isNot(tok::l_paren) &&
       (!Left.is(TT_PointerOrReference) ||
        (Style.PointerAlignment != FormatStyle::PAS_Right &&
         !Line.IsMultiVariableDeclStmt)))
     return true;
   if (Left.is(TT_PointerOrReference))
     return Right.Tok.isLiteral() || Right.is(TT_BlockComment) ||
            (Right.isOneOf(Keywords.kw_override, Keywords.kw_final) &&

cfe/trunk/unittests/Format/FormatTest.cpp

verifyGoogleFormat("template <typename T>\n"
                      "void f(int i = 0, SomeType** temps = NULL);");
 
   FormatStyle Left = getLLVMStyle();
   Left.PointerAlignment = FormatStyle::PAS_Left;
   verifyFormat("x = *a(x) = *a(y);", Left);
   verifyFormat("for (;; *a = b) {\n}", Left);
   verifyFormat("return *this += 1;", Left);
   verifyFormat("throw *x;", Left);
+  verifyFormat("delete *x;", Left);
+  verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
+  verifyFormat("[](const decltype(*a)* ptr) {}", Left);
+  verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
 
   verifyIndependentOfContext("a = *(x + y);");
   verifyIndependentOfContext("a = &(x + y);");
   verifyIndependentOfContext("*(x + y).call();");
   verifyIndependentOfContext("&(x + y)->call();");
   verifyFormat("void f() { &(*I).first; }");
 
   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
   verifyIndependentOfContext("A = new SomeType *[Length]();");
   verifyIndependentOfContext("T **t = new T *;");
   verifyIndependentOfContext("T **t = new T *();");
   verifyGoogleFormat("A = new SomeType*[Length]();");
   verifyGoogleFormat("A = new SomeType*[Length];");
   verifyGoogleFormat("T** t = new T*;");
   verifyGoogleFormat("T** t = new T*();");
 
-  FormatStyle PointerLeft = getLLVMStyle();
-  PointerLeft.PointerAlignment = FormatStyle::PAS_Left;
-  verifyFormat("delete *x;", PointerLeft);
   verifyFormat("STATIC_ASSERT((a & b) == 0);");
   verifyFormat("STATIC_ASSERT(0 == (a & b));");
   verifyFormat("template <bool a, bool b> "
                "typename t::if<x && y>::type f() {}");
   verifyFormat("template <int *y> f() {}");
   verifyFormat("vector<int *> v;");
   verifyFormat("vector<int *const> v;");
   verifyFormat("vector<int *const **const *> v;");