clang-format: refine calculating brace types.

[mprobst]

Summary

For C++ code, opening parenthesis following a } indicate a braced init. For JavaScript and other languages, this is an invalid syntactical construct, unless the closing parenthesis belongs to a function - in which situation its a BK_Block.

This fixes indenting IIFEs following top level functions:

function foo() {}
(function() { codeHere(); }());

clang-format used to collapse these lines together.

[mprobst]

• handle ObjC

[djasper]

Looks good.

cfe/trunk/lib/Format/UnwrappedLineParser.cpp

case tok::r_brace:
           // regardless how we mark inner braces here, we will overwrite the
           // BlockKind later if we parse a braced list (where all blocks
           // inside are by default braced lists), or when we explicitly detect
           // blocks (for example while parsing lambdas).
           ProbablyBracedList =
               (Style.Language == FormatStyle::LK_JavaScript &&
                NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in,
                                 Keywords.kw_as)) ||
+              (Style.isCpp() && NextTok->is(tok::l_paren)) ||
               NextTok->isOneOf(tok::comma, tok::period, tok::colon,
                                tok::r_paren, tok::r_square, tok::l_brace,
-                               tok::l_square, tok::l_paren, tok::ellipsis) ||
+                               tok::l_square, tok::ellipsis) ||
               (NextTok->is(tok::identifier) &&
                !PrevTok->isOneOf(tok::semi, tok::r_brace, tok::l_brace)) ||
               (NextTok->is(tok::semi) &&
                (!ExpectClassBody || LBraceStack.size() != 1)) ||
               (NextTok->isBinaryOperator() && !NextIsObjCMethod);
         }
         if (ProbablyBracedList) {
           Tok->BlockKind = BK_BracedInit;

cfe/trunk/unittests/Format/FormatTestJS.cpp

verifyFormat("function outer1(a, b) {\n"
                "}\n"
                "function outer2(a, b) {\n"
                "  function inner2(a, b) {\n"
                "    return a;\n"
                "  }\n"
                "  inner2(a, b);\n"
                "}");
   verifyFormat("function f() {}");
+  verifyFormat("function aFunction() {}\n"
+               "(function f() {\n"
+               "  var x = 1;\n"
+               "}());\n");
+  // Known issue: this should wrap after {}, but calculateBraceTypes
+  // misclassifies the first braces as a BK_BracedInit.
+  verifyFormat("function aFunction(){} {\n"
+               "  let x = 1;\n"
+               "  console.log(x);\n"
+               "}\n");
 }
 
 TEST_F(FormatTestJS, GeneratorFunctions) {
   verifyFormat("function* f() {\n"
                "  let x = 1;\n"
                "  yield x;\n"
                "  yield* something();\n"
                "  yield [1, 2];\n"