[clang-format] Better parsing of lambda captures with initializer expressions.

[curdeius]

Summary

This fixes bug #19986 (https://bugs.llvm.org/show_bug.cgi?id=19986).
The code was incorrectly formatted to (mind additional spaces inside brackets) when lambda capture contained an initializer expression.
This patch does not handle all possible initializers, but the most common once.
To handle these resting cases, we'd have to parse the whole initializer expressions or handle lambda detection differently.

Before:

int i = 100;
auto f1 = [ i, value = 23 ]() { return i + value; };
auto f2 = [ i, value{23} ]() { return i + value; };

After:

int i = 100;
auto f1 = [i, value = 23]() { return i + value; };
auto f2 = [i, value{23}]() { return i + value; };

[curdeius]

Minor: use FormatToken::isNot instead of !FormatToken::is.

[klimek]

Thanks for the patch and the discussion around this. I fixed this in r313622 in what I think is a more principled approach that also works for nested lambdas (and gets rid of a lot of now-obsolete code).
The big problem with this code was that it evolved a bit to the point where we were able to generalize it, but we never did. Let me know if you find any problems with the aforementioned change.

[curdeius]

Ok. Nice patch. You can close https://bugs.llvm.org/show_bug.cgi?id=19986 now.

lib/Format/UnwrappedLineParser.h

   void parseJavaScriptEs6ImportExport();
   bool tryToParseLambda();
   bool tryToParseLambdaIntroducer();
+  bool tryToParseLambdaCaptureInitializer();
   void tryToParseJSFunction();
   void addUnwrappedLine();
   bool eof() const;

lib/Format/UnwrappedLineParser.cpp

     return true;
   }
   do {
-    if (FormatTok->is(tok::amp))
+    if (FormatTok->isOneOf(tok::amp, tok::star))
       nextToken();
     if (!FormatTok->isOneOf(tok::identifier, tok::kw_this))
       return false;
     nextToken();
-    if (FormatTok->is(tok::ellipsis))
+    if (FormatTok->is(tok::equal)) {
+      if (!tryToParseLambdaCaptureInitializer())
+        return false;
+    } else if (FormatTok->is(tok::l_brace)) {
+      if (!tryToParseLambdaCaptureInitializer())
+        return false;
+      if (FormatTok->isNot(tok::r_brace))
+        return false;
       nextToken();
+    } else if (FormatTok->is(tok::ellipsis))
+      nextToken();
     if (FormatTok->is(tok::comma)) {
       nextToken();
     } else if (FormatTok->is(tok::r_square)) {

   return false;
 }
 
+bool UnwrappedLineParser::tryToParseLambdaCaptureInitializer() {
+  // Try to parse a simple initializer expression.
+  nextToken();
+  if (FormatTok->isOneOf(tok::amp, tok::star))
+    nextToken();
+  if (!FormatTok->isOneOf(tok::identifier, tok::kw_this,
+                          tok::numeric_constant)) {
+    return false;
+  }
+  nextToken();
+  return true;
+}
+
 void UnwrappedLineParser::tryToParseJSFunction() {
   assert(FormatTok->is(Keywords.kw_function) ||
          FormatTok->startsSequence(Keywords.kw_async, Keywords.kw_function));

unittests/Format/FormatTest.cpp

   verifyFormat("typedef enum {} EmptyEnum;");
   verifyFormat("typedef enum { A, B, C } ShortEnum;");
   verifyFormat("typedef enum {\n"
-               "  ZERO = 0,\n"             
+               "  ZERO = 0,\n"
                "  ONE = 1,\n"
                "  TWO = 2,\n"
                "  THREE = 3\n"

   verifyFormat("typedef enum { A, B, C } ShortEnum;");
   verifyFormat("typedef enum\n"
                "{\n"
-               "  ZERO = 0,\n"             
+               "  ZERO = 0,\n"
                "  ONE = 1,\n"
                "  TWO = 2,\n"
                "  THREE = 3\n"

   Style.CompactNamespaces = true;
 
   verifyFormat("namespace A { namespace B {\n"
-         "}} // namespace A::B",
-         Style);
+               "}} // namespace A::B",
+               Style);
 
   EXPECT_EQ("namespace out { namespace in {\n"
             "}} // namespace out::in",

   verifyFormat(
       "SomeClass::Constructor() :\n"
       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
-    Style);
+      Style);
 
   verifyFormat(
       "SomeClass::Constructor() :\n"
       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
-    Style);
+      Style);
   verifyFormat(
       "SomeClass::Constructor() :\n"
       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
-    Style);
+      Style);
   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
                "    aaaaaaaaaa(aaaaaa) {}",
-         Style);
+               Style);
 
   verifyFormat("Constructor() :\n"
                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"

                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
-         Style);
+               Style);
 
   verifyFormat("Constructor() :\n"
                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
-         Style);
+               Style);
 
   verifyFormat("Constructor(int Parameter = 0) :\n"
                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
-         Style);
+               Style);
   verifyFormat("Constructor() :\n"
                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
                "}",

   verifyFormat("Constructor() :\n"
                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
-         Style);
+               Style);
 
   // Here a line could be saved by splitting the second initializer onto two
   // lines, but that is not desirable.

                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
-         Style);
+               Style);
 
   FormatStyle OnePerLine = Style;
   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;

             format("Constructor() :\n"
                    "    // Comment forcing unwanted break.\n"
                    "    aaaa(aaaa) {}",
-           Style));
+                   Style));
 
   Style.ColumnLimit = 0;
   verifyFormat("SomeClass::Constructor() :\n"

                "    a(a) {}",
                Style);
   verifyFormat("SomeClass::Constructor() :\n"
-         "    a(a), b(b), c(c) {}",
+               "    a(a), b(b), c(c) {}",
                Style);
   verifyFormat("SomeClass::Constructor() :\n"
                "    a(a) {\n"

 
   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
   verifyFormat("SomeClass::Constructor() :\n"
-         "    a(a), b(b), c(c) {\n"
-         "}",
+               "    a(a), b(b), c(c) {\n"
+               "}",
                Style);
   verifyFormat("SomeClass::Constructor() :\n"
                "    a(a) {\n"
-         "}",
+               "}",
                Style);
 
   Style.ColumnLimit = 80;

   // Binpacking only if there is no trailing comma
   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
                "                      cccccccccc, dddddddddd};",
-         getLLVMStyleWithColumns(50));
+               getLLVMStyleWithColumns(50));
   verifyFormat("const Aaaaaa aaaaa = {\n"
                "    aaaaaaaaaaa,\n"
                "    bbbbbbbbbbb,\n"

   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
+
+  verifyFormat("auto c = [*this]() {};\n");
+  verifyFormat("auto c = [i, *this]() {};\n");
+  verifyFormat("auto c = [i, self = *this]() {};\n");
+  verifyFormat("auto c = [i, value = 123]() {};\n");
+  verifyFormat("auto c = [i, value = i]() {};\n");
+  verifyFormat("auto c = [i, ptr = &i]() {};\n");
+  verifyFormat("auto c = [i, &value = i]() {};\n");
+  verifyFormat("auto c = [i, value{i}]() {};\n");
+  verifyFormat("auto c = [i, ptr{&i}]() {};\n");
+  // TODO: Captures may be initialized with any valid initializer expression.
+  // verifyFormat("auto c = [i, ptr = &i + 10]() {};\n");
+
   verifyFormat("int x = f(*+[] {});");
   verifyFormat("void f() {\n"
                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"