clang-format: [JS] do not break in ArrayType[].

[mprobst]

Summary

Wrapping between the type name and the array type indicator creates
invalid syntax in TypeScript.

Before:

const xIsALongIdent:
    YJustBarelyFitsLinex
        [];  // illegal syntax.

After:

const xIsALongIdent:
    YJustBarelyFitsLinex[];

[djasper]

Looks good.

cfe/trunk/lib/Format/TokenAnnotator.cpp

if (Style.Language == FormatStyle::LK_Java) {
     if (NonComment &&
         NonComment->isOneOf(tok::kw_return, Keywords.kw_yield, tok::kw_continue,
                             tok::kw_break, tok::kw_throw, Keywords.kw_interface,
                             Keywords.kw_type, tok::kw_static, tok::kw_public,
                             tok::kw_private, tok::kw_protected,
                             Keywords.kw_readonly, Keywords.kw_abstract,
                             Keywords.kw_get, Keywords.kw_set))
       return false; // Otherwise automatic semicolon insertion would trigger.
+    if (Left.Tok.getIdentifierInfo() &&
+        Right.startsSequence(tok::l_square, tok::r_square))
+      return false;  // breaking in "foo[]" creates illegal TS type syntax.
     if (Left.is(TT_JsFatArrow) && Right.is(tok::l_brace))
       return false;
     if (Left.is(TT_JsTypeColon))
       return true;
     if (Right.NestingLevel == 0 && Right.is(Keywords.kw_is))
       return false;
     if (Left.is(Keywords.kw_in))
       return Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None;

cfe/trunk/unittests/Format/FormatTestJS.cpp

verifyFormat("var x = {\n"
                "  }\n"
                "};");
   verifyFormat("function someFunc(args: string[]):\n"
                "    {longReturnValue: string[]} {}",
                getGoogleJSStyleWithColumns(60));
   verifyFormat(
       "var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[])\n"
       "                    .someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("const xIsALongIdent:\n""    YJustBarelyFitsLinex[];",
+      getGoogleJSStyleWithColumns(20));
 }
 
 TEST_F(FormatTestJS, UnionIntersectionTypes) {
   verifyFormat("let x: A|B = A | B;");
   verifyFormat("let x: A&B|C = A & B;");
   verifyFormat("let x: Foo<A|B> = new Foo<A|B>();");
   verifyFormat("function(x: A|B): C&D {}");
   verifyFormat("function(x: A|B = A | B): C&D {}");