[clang-format] Parse blocks in braced lists

[strager]

Summary

clang-format completely ruins the formatting of block literal
expressions which appear inside inside braced initializer lists. For
example:

int main() {
  foo({
      ^() {
        return nil;
}
});
}

Teach clang-format to parse blocks inside braced lists:

int main() {
  foo({^() {
    return nil;
  }});
}

[benhamilton]

@djasper isn't available to review.

At a high level, this seems good, but I'd like @klimek to take a look.

lib/Format/UnwrappedLineParser.cpp

1320

Is it standard to return a value from these tryToParseFoo() methods, even if nobody uses it?

I think we should either check the return value somewhere, or make this return void.

1324–1327

Style: Remove curly braces for one-line if blocks.

[klimek]

lib/Format/UnwrappedLineParser.cpp

1324

Isn't this only an Obj-C/Obj-C++ thing?
If it is, I'd call it tryToParseObjCBlockLiteral.

lib/Format/UnwrappedLineParser.h

private:
   // parses the record as a child block, i.e. if the class declaration is an
   // expression.
   void parseRecord(bool ParseAsExpr = false);
   void parseObjCProtocolList();
   void parseObjCUntilAtEnd();
   void parseObjCInterfaceOrImplementation();
   void parseObjCProtocol();
   void parseJavaScriptEs6ImportExport();
+  bool tryToParseBlock();
   bool tryToParseLambda();
   bool tryToParseLambdaIntroducer();
   void tryToParseJSFunction();
   void addUnwrappedLine();
   bool eof() const;
   // LevelDifference is the difference of levels after and before the current
   // token. For example:
   // - if the token is '{' and opens a block, LevelDifference is 1.

lib/Format/UnwrappedLineParser.cpp

case tok::l_paren:
       parseParens();
       break;
     case tok::kw_operator:
       nextToken();
       if (FormatTok->isBinaryOperator())
         nextToken();
       break;
     case tok::caret:
-      nextToken();
-      if (FormatTok->Tok.isAnyIdentifier() ||
-          FormatTok->isSimpleTypeSpecifier())
-        nextToken();
-      if (FormatTok->is(tok::l_paren))
-        parseParens();
-      if (FormatTok->is(tok::l_brace))
-        parseChildBlock();
+      tryToParseBlock();
       break;
     case tok::l_brace:
       if (!tryToParseBracedList()) {
         // A block outside of parentheses must be the last part of a
         // structural element.
         // FIXME: Figure out cases where this is not true, and add projections
         // for them (the one we know is missing are lambdas).
         if (Style.BraceWrapping.AfterFunction)
case tok::kw_new:
       break;
     default:
       nextToken();
       break;
     }
   } while (!eof());
 }
 
+// Parses a block literal expression starting at the initial ^ token.
+//
+// Blocks literal expressions have several forms including the following:
+//
+// \code
+// ^{
+//   return 42;
+// }
+//
+// ^BOOL(int x) {
+//   return x > 0;
+// }
+// \endcode
+bool UnwrappedLineParser::tryToParseBlock() {
+  // Consume the leading ^.
+  assert(FormatTok->is(tok::caret));
+  nextToken();
+  if (!Style.isCpp()) {
+    // Blocks are only supported in C++ and Objective-C.
+    return false;
+  }
+  // Consume the optional return type.
+  if (FormatTok->Tok.isAnyIdentifier() || FormatTok->isSimpleTypeSpecifier())
+    nextToken();
+  // Consume the optional argument list.
+  if (FormatTok->is(tok::l_paren))
+    parseParens();
+  // Consume the required body.
+  if (!FormatTok->is(tok::l_brace))
+    return false;
+  parseChildBlock();
+  return true;
+}
+
 bool UnwrappedLineParser::tryToParseLambda() {
   if (!Style.isCpp()) {
     nextToken();
     return false;
   }
   assert(FormatTok->is(tok::l_square));
   FormatToken &LSquare = *FormatTok;
   if (!tryToParseLambdaIntroducer())
if (Style.Language == FormatStyle::LK_JavaScript) {
       }
     }
     if (FormatTok->Tok.getKind() == ClosingBraceKind) {
       nextToken();
       return !HasError;
     }
     switch (FormatTok->Tok.getKind()) {
     case tok::caret:
-      nextToken();
-      if (FormatTok->is(tok::l_brace)) {
-        parseChildBlock();
-      }
+      tryToParseBlock();
       break;
     case tok::l_square:
       tryToParseLambda();
       break;
     case tok::l_paren:
       parseParens();
       // JavaScript can just have free standing methods and getters/setters in
       // object literals. Detect them by a "{" following ")".

unittests/Format/FormatTest.cpp

verifyFormat("f(^{\n"
                "      g();\n"
                "    }\n"
                "  }\n"
                "});");
   verifyFormat("Block b = ^int *(A *a, B *b) {}");
   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
                "};");
 
+  verifyFormat("foo({^{\n"
+               "  return nil;\n"
+               "}});\n");
+  verifyFormat("foo({^() {\n"
+               "  return nil;\n"
+               "}});\n");
+  verifyFormat("foo({^id {\n"
+               "  return nil;\n"
+               "}});\n");
+  verifyFormat("foo({^id() {\n"
+               "  return nil;\n"
+               "}});\n");
+
+  verifyFormat("foo({.cb = ^{\n"
+               "  return nil;\n"
+               "}});\n");
+  verifyFormat("foo({.cb = ^() {\n"
+               "  return nil;\n"
+               "}});\n");
+  verifyFormat("foo({.cb = ^id {\n"
+               "  return nil;\n"
+               "}});\n");
+  verifyFormat("foo({.cb = ^id() {\n"
+               "  return nil;\n"
+               "}});\n");
+
+  verifyFormat("foo(\n"
+               "    ^{\n"
+               "      return nil;\n"
+               "    },\n"
+               "    ^() {\n"
+               "      return [NSArray new];\n"
+               "    });\n");
+  verifyFormat("foo(\n"
+               "    ^id {\n"
+               "      return nil;\n"
+               "    },\n"
+               "    ^id() {\n"
+               "      return [NSArray new];\n"
+               "    });\n");
+
+  verifyFormat("callbacks cbs = {\n"
+               "    ^{\n"
+               "      return nil;\n"
+               "    },\n"
+               "    ^id {\n"
+               "      return [NSArray new];\n"
+               "    },\n"
+               "};");
+  verifyFormat("callbacks cbs = {\n"
+               "    ^() {\n"
+               "      return nil;\n"
+               "    },\n"
+               "    ^id() {\n"
+               "      return [NSArray new];\n"
+               "    },\n"
+               "};");
+
+  verifyFormat("callbacks cbs = {\n"
+               "    .cb1 =\n"
+               "        ^{\n"
+               "          return nil;\n"
+               "        },\n"
+               "    .cb2 =\n"
+               "        ^id {\n"
+               "          return [NSArray new];\n"
+               "        },\n"
+               "};");
+  verifyFormat("callbacks cbs = {\n"
+               "    .cb1 =\n"
+               "        ^() {\n"
+               "          return nil;\n"
+               "        },\n"
+               "    .cb2 =\n"
+               "        ^id() {\n"
+               "          return nil;\n"
+               "        },\n"
+               "};");
+
   FormatStyle FourIndent = getLLVMStyle();
   FourIndent.ObjCBlockIndentWidth = 4;
   verifyFormat("[operation setCompletionBlock:^{\n"
                "    [self onOperationDone];\n"
                "}];",
                FourIndent);
 }