clang-format: Support generalized lambda captures.

[strager]

Summary

Teach clang-format about C++14 generalized lambda captures:

auto f = [b = std::move(d)]() {};

(clang-format would not think there's a lambda here because
of the =.)

[strager]

ping

[djasper]

This is the corresponding bug: llvm.org/PR19986

lib/Format/UnwrappedLineParser.cpp

1060–1061

I very much doubt that we'll have an Expression parser here anytime soon. So, I don't think that this FIXME makes much sense. Instead, please provide a comment on what this is actually doing and in which cases it might fail.

1064

I think this list should be extended to figure out certain cases where we know something is fishy. In particular:

• If you find an l_square or less, call into parseSquare and parseAngle respectively.
• If you find an r_brace or semi, something is wrong, break.

[strager]

lib/Format/UnwrappedLineParser.cpp

1060–1061

I copied the comment from elsewhere in the file.

1064

Will do.

[strager]

lib/Format/UnwrappedLineParser.cpp

1060–1061

I expanded the comment, including a reference to the other reference to parseAssigmentExpression.

1064

Handling r_brace and semi is a bit weird, since we end up aborting mid-stream and what's left becomes unparsable/incomplete by clang-format.

parseAngle doesn't exist, and even if it did, the less-than operator wouldn't be handled properly.

I added l_square and l_brace support.

[strager]

Address @djasper's comments.

[djasper]

lib/Format/UnwrappedLineParser.cpp

1060–1061

Again, please remove the FIXME. We aren't going to have an expression parser here (anytime soon) and shouldn't add (more) comments that make people think otherwise.

1064

Ah, parseAngle doesn't exist here. I was thinking about the TokenAnnotator.

I don't understand your comment about mid-stream. This is precisely about the case where the input is corrupt so that clang-format can recover and doesn't just parse the reset of the file input the lambda introducer.

[strager]

lib/Format/UnwrappedLineParser.cpp

1060–1061

We aren't going to have an expression parser here (anytime soon) and shouldn't add (more) comments that make people think otherwise.

If there is enough need for the function, perhaps it will be written.

I don't think the comment implies some code will be written soon.

1064

This is precisely about the case where the input is corrupt so that clang-format can recover and doesn't just parse the reset of the file input the lambda introducer.

If I write this test:

verifyFormat("return [}] {};\n");

I get this output:

/Users/strager/Projects/llvm/tools/clang/unittests/Format/FormatTest.cpp:42: Failure
Value of: IncompleteFormat
  Actual: true
Expected: ExpectedIncompleteFormat
Which is: false
return [}] {};



/Users/strager/Projects/llvm/tools/clang/unittests/Format/FormatTest.cpp:65: Failure
Value of: format(test::messUp(Code), Style)
  Actual: "return [\n}] {};\n"
Expected: Code.str()
Which is: "return [}] {};\n"

How can I fix this?

[djasper]

lib/Format/UnwrappedLineParser.cpp

1064

So, there are two errors in the test.

1. clang-format detects that there is a syntax error and reports this. Use verifyIncompleteFormat instead of verifyFormat.

2. clang-format adds a '\n' after the opening square bracket. Add that in your test string.

lib/Format/UnwrappedLineParser.cpp

bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
   do {
     if (FormatTok->is(tok::amp))
       nextToken();
     if (!FormatTok->isOneOf(tok::identifier, tok::kw_this))
       return false;
     nextToken();
     if (FormatTok->is(tok::ellipsis))
       nextToken();
+    if (FormatTok->is(tok::equal)) {
+      // Generalized lambda capture.
+      nextToken();
+      while (!eof()) {
+        // FIXME: Once we have an expression parser in the UnwrappedLineParser,
+        // replace this by using parseAssigmentExpression() inside. See also
+        // parseBracedList. For now, parsing matching braces ([], (), {}) is
+        // good enough.
+        if (FormatTok->is(tok::l_paren)) {
+          parseParens();
+        } else if (FormatTok->is(tok::l_square)) {
+          parseSquare();
+        } else if (FormatTok->is(tok::l_brace)) {
+          parseBracedList(false);
+        } else if (FormatTok->isOneOf(tok::comma, tok::r_square)) {
+          break;
+        } else {
+          nextToken();
+        }
+      }
+    }
     if (FormatTok->is(tok::comma)) {
       nextToken();
     } else if (FormatTok->is(tok::r_square)) {
       nextToken();
       return true;
     } else {
       return false;
     }
bool UnwrappedLineParser::tryToParseBracedList() {
   return true;
 }
 
 bool UnwrappedLineParser::parseBracedList(bool ContinueOnSemicolons) {
   bool HasError = false;
   nextToken();
 
   // FIXME: Once we have an expression parser in the UnwrappedLineParser,
-  // replace this by using parseAssigmentExpression() inside.
+  // replace this by using parseAssigmentExpression() inside. See also
+  // tryToParseLambdaIntroducer.
   do {
     if (Style.Language == FormatStyle::LK_JavaScript) {
       if (FormatTok->is(Keywords.kw_function)) {
         tryToParseJSFunction();
         continue;
       }
       if (FormatTok->is(TT_JsFatArrow)) {
         nextToken();

unittests/Format/FormatTest.cpp

verifyFormat("SomeFunction(\n"
                "    []() {\n"
                "      int j = 43;\n"
                "      return j;\n"
                "    });");
 
   // More complex introducers.
   verifyFormat("return [i, args...] {};");
 
+  // Lambdas with generalized captures.
+  verifyFormat("auto f = [b = d]() {};\n");
+  verifyFormat("auto f = [b = std::move(d)]() {};\n");
+  verifyFormat("auto f = [b = c, d = e, g]() {};\n");
+  verifyFormat("auto f = [b = a[3]]() {};\n");
+  verifyFormat("auto f = [InRange = a < b && b < c]() {};\n");
+  verifyFormat("auto f = [b = std::vector<int>{1, 2, 3}]() {};\n");
+  verifyFormat("auto f = [b = std::vector<int>{\n"
+               "              1, 2, 3,\n"
+               "}]() {};\n");
+  verifyFormat("return [b = std::vector<int[]>()] {}();\n");
+
   // Not lambdas.
   verifyFormat("constexpr char hello[]{\"hello\"};");
   verifyFormat("double &operator[](int i) { return 0; }\n"
                "int i;");
   verifyFormat("std::unique_ptr<int[]> foo() {}");
   verifyFormat("int i = a[a][a]->f();");
   verifyFormat("int i = (*b)[a]->f();");