[clang-format] Fix PointerAlignment within lambdas in a multi-variable declaration statement.

[curdeius]

Summary

Fixes https://github.com/llvm/llvm-project/issues/43115.

Also, handle while loops with initializers (C++20) the same way as for loops.

[HazardyKnusperkeks]

What about if?

[curdeius]

Rebase on top of D119649, add a similar case with a leading comment.

Without it (and if startsWithLoopWithInitializer didn't use startsWith that skips comments), there would be a different spacing of multi-variable initializers in loops, e.g. (-expected, +incorrect):

-/*comment*/ for (int *p, *q; p != q; p = p->next) {
+/*comment*/ for (int* p, *q; p != q; p = p->next) {

[curdeius]

In D119648#3317188, @HazardyKnusperkeks wrote:

What about if?

True, I need to fix them in D119649 too.
And I think that I'll split the fix for while loops from this revision.

[owenpan]

Does any C++ standard support init statements in while loops?

[curdeius]

In D119648#3317212, @owenpan wrote:

Does any C++ standard support init statements in while loops?

Argh, I initially thought about if statements and then somehow my brain turned it into while.
You're right, there are only if and for statements with initializers (C++20 added initializers for ranged-base for loops).

Let me split this revision (fixing if and not while) and clear things up.

[curdeius]

Split from and rebase on top of D119650.

[owenpan]

clang/unittests/Format/FormatTest.cpp

8397–8399

Same as lines 8412-8414.

[curdeius]

clang/unittests/Format/FormatTest.cpp

8397–8399

Some problem with the patch, it wasn't in this commit. Will fix after landing other revisions.

[HazardyKnusperkeks]

In D119648#3317212, @owenpan wrote:

Does any C++ standard support init statements in while loops?

I actually thought there was. But that was a mistake. :)

clang/lib/Format/TokenAnnotator.cpp

28–35

But switch can have such a statement.

[curdeius]

Rebased.

clang/lib/Format/TokenAnnotator.cpp

 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "format-token-annotator"
 
 namespace clang {
 namespace format {
 
 namespace {
 
+/// Returns \c true if the line starts with a token that can start a loop with
+/// an initializer.
+static bool startsWithLoopWithInitializer(const AnnotatedLine &Line) {
+  return Line.startsWith(tok::kw_for) || Line.startsWith(tok::kw_while);
+}
+
 /// Returns \c true if the token can be used as an identifier in
 /// an Objective-C \c \@selector, \c false otherwise.
 ///
 /// Because getFormattingLangOpts() always lexes source code as
 /// Objective-C++, C++ keywords like \c new and \c delete are
 /// lexed as tok::kw_*, not tok::identifier, even for Objective-C.
 ///
 /// For Objective-C and Objective-C++, both identifiers and keywords
 /// are valid inside @selector(...) (or a macro which
case tok::kw_template:
       parseTemplateDeclaration();
       break;
     case tok::comma:
       if (Contexts.back().InCtorInitializer)
         Tok->setType(TT_CtorInitializerComma);
       else if (Contexts.back().InInheritanceList)
         Tok->setType(TT_InheritanceComma);
       else if (Contexts.back().FirstStartOfName &&
-               (Contexts.size() == 1 || Line.startsWith(tok::kw_for))) {
+               (Contexts.size() == 1 || startsWithLoopWithInitializer(Line))) {
         Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true;
         Line.IsMultiVariableDeclStmt = true;
       }
       if (Contexts.back().IsForEachMacro)
         Contexts.back().IsExpression = true;
       break;
     case tok::identifier:
       if (Tok->isOneOf(Keywords.kw___has_include,
if (Left.isTypeOrIdentifier() && Right.Next && Right.Next->Next &&
         Right.Next->Next->is(TT_RangeBasedForLoopColon))
       return getTokenPointerOrReferenceAlignment(Right) !=
              FormatStyle::PAS_Left;
     return !Left.isOneOf(TT_PointerOrReference, tok::l_paren) &&
            (getTokenPointerOrReferenceAlignment(Right) !=
                 FormatStyle::PAS_Left ||
             (Line.IsMultiVariableDeclStmt &&
              (Left.NestingLevel == 0 ||
-              (Left.NestingLevel == 1 && Line.First->is(tok::kw_for)))));
+              (Left.NestingLevel == 1 &&
+               startsWithLoopWithInitializer(Line)))));
   }
   if (Right.is(TT_FunctionTypeLParen) && Left.isNot(tok::l_paren) &&
       (!Left.is(TT_PointerOrReference) ||
        (getTokenPointerOrReferenceAlignment(Left) != FormatStyle::PAS_Right &&
         !Line.IsMultiVariableDeclStmt)))
     return true;
   if (Left.is(TT_PointerOrReference)) {
     // Add a space if the next token is a pointer qualifier and the style
if (Left.Previous && Left.Previous->isTypeOrIdentifier() && Right.Next &&
         Right.Next->is(TT_RangeBasedForLoopColon))
       return getTokenPointerOrReferenceAlignment(Left) !=
              FormatStyle::PAS_Right;
     if (Right.isOneOf(TT_PointerOrReference, TT_ArraySubscriptLSquare,
                       tok::l_paren))
       return false;
     if (getTokenPointerOrReferenceAlignment(Left) == FormatStyle::PAS_Right)
       return false;
-    if (Line.IsMultiVariableDeclStmt)
+    // FIXME: Setting IsMultiVariableDeclStmt for the whole line is error-prone,
+    // because it does not take into account nested scopes like lambdas.
+    // In multi-variable declaration statements, attach */& to the variable
+    // independently of the style. However, avoid doing it if we are in a nested
+    // scope, e.g. lambda. We still need to special-case loops with
+    // initializers.
+    if (Line.IsMultiVariableDeclStmt &&
+        (Left.NestingLevel == Line.First->NestingLevel ||
+         startsWithLoopWithInitializer(Line)))
       return false;
     return Left.Previous && !Left.Previous->isOneOf(
                                 tok::l_paren, tok::coloncolon, tok::l_square);
   }
   // Ensure right pointer alignment with ellipsis e.g. int *...P
   if (Left.is(tok::ellipsis) && Left.Previous &&
       Left.Previous->isOneOf(tok::star, tok::amp, tok::ampamp))
     return Style.PointerAlignment != FormatStyle::PAS_Right;

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
   verifyFormat("for (int a = 0, b++; const int &c : {1, 2, 3})", Style);
   verifyFormat("for (int a = 0, b++; const Foo &c : {1, 2, 3})", Style);
   verifyFormat("for (auto x = 0; auto &c : {1, 2, 3})", Style);
   verifyFormat("for (auto x = 0; int &c : {1, 2, 3})", Style);
   verifyFormat("for (int x = 0; auto &c : {1, 2, 3})", Style);
   verifyFormat("for (int x = 0; int &c : {1, 2, 3})", Style);
   verifyFormat("for (f(); auto &c : {1, 2, 3})", Style);
   verifyFormat("for (f(); int &c : {1, 2, 3})", Style);
+  verifyFormat(
+      "function<int(int &)> res1 = [](int &a) { return 0000000000000; },\n"
+      "                     res2 = [](int &a) { return 0000000000000; };",
+      Style);
 
   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
   verifyFormat("Const unsigned int *c;\n"
                "const unsigned int *d;\n"
                "Const unsigned int &e;\n"
                "const unsigned int &f;\n"
                "const unsigned    &&g;\n"
                "Const unsigned      h;",
TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
   verifyFormat("for (int a = 0, b++; const Foo& c : {1, 2, 3})", Style);
   verifyFormat("for (int a = 0, b++; const Foo* c : {1, 2, 3})", Style);
   verifyFormat("for (auto x = 0; auto& c : {1, 2, 3})", Style);
   verifyFormat("for (auto x = 0; int& c : {1, 2, 3})", Style);
   verifyFormat("for (int x = 0; auto& c : {1, 2, 3})", Style);
   verifyFormat("for (int x = 0; int& c : {1, 2, 3})", Style);
   verifyFormat("for (f(); auto& c : {1, 2, 3})", Style);
   verifyFormat("for (f(); int& c : {1, 2, 3})", Style);
+  verifyFormat(
+      "function<int(int&)> res1 = [](int& a) { return 0000000000000; },\n"
+      "                    res2 = [](int& a) { return 0000000000000; };",
+      Style);
 
   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
   verifyFormat("Const unsigned int* c;\n"
                "const unsigned int* d;\n"
                "Const unsigned int& e;\n"
                "const unsigned int& f;\n"
                "const unsigned&&    g;\n"
                "Const unsigned      h;",
TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
   verifyFormat("for (int a = 0, b++; const Foo & c : {1, 2, 3})", Style);
   verifyFormat("for (int a = 0, b++; const Foo* c : {1, 2, 3})", Style);
   verifyFormat("for (auto x = 0; auto & c : {1, 2, 3})", Style);
   verifyFormat("for (auto x = 0; int & c : {1, 2, 3})", Style);
   verifyFormat("for (int x = 0; auto & c : {1, 2, 3})", Style);
   verifyFormat("for (int x = 0; int & c : {1, 2, 3})", Style);
   verifyFormat("for (f(); auto & c : {1, 2, 3})", Style);
   verifyFormat("for (f(); int & c : {1, 2, 3})", Style);
+  verifyFormat(
+      "function<int(int &)> res1 = [](int & a) { return 0000000000000; },\n"
+      "                     res2 = [](int & a) { return 0000000000000; };",
+      Style);
 
   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
   verifyFormat("Const unsigned int*  c;\n"
                "const unsigned int*  d;\n"
                "Const unsigned int & e;\n"
                "const unsigned int & f;\n"
                "const unsigned &&    g;\n"
                "Const unsigned       h;",
verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
                "    *b = bbbbbbbbbbbbbbbbbbb;",
                Style);
   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
                Style);
   verifyFormat("vector<int*> a, b;", Style);
   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
+  verifyFormat("/*comment*/ for (int *p, *q; p != q; p = p->next) {\n}", Style);
+  verifyFormat("while (int *p, *q; p != q) {\n  p = p->next;\n}", Style);
+  verifyFormat("/*comment*/ while (int *p, *q; p != q) {\n  p = p->next;\n}",
+               Style);
 }
 
 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
   verifyFormat("arr[foo ? bar : baz];");
   verifyFormat("f()[foo ? bar : baz];");
   verifyFormat("(a + b)[foo ? bar : baz];");
   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
 }