clang-format: [JS] disable ASI on decorators.

[mprobst]

Summary

Automatic Semicolon Insertion in clang-format tries to guess if a line
wrap should insert an implicit semicolong. The previous heuristic would
not trigger ASI if a token was immediately preceded by an @ sign:

function foo(@Bar  // <-- does not trigger due to preceding @
            baz) {}

However decorators can have arbitrary parameters:

function foo(@Bar(param, param, param)  // <-- precending @ missed
            baz) {}

While it would be possible to precisely find the matching @, just
conversatively disabling ASI for the entire line is simpler, while also
not regressing ASI substatially.

cfe/trunk/lib/Format/UnwrappedLineParser.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "UnwrappedLineParser.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include <algorithm>
+
 #define DEBUG_TYPE "format-parser"
 
 namespace clang {
 namespace format {
 
 class FormatTokenSource {
 public:
   virtual ~FormatTokenSource() {}
bool IsOnSameLine =
           ? Next->NewlinesBefore == 0
           : CommentsBeforeNextToken.front()->NewlinesBefore == 0;
   if (IsOnSameLine)
     return;
 
   bool PreviousMustBeValue = mustBeJSIdentOrValue(Keywords, Previous);
   bool PreviousStartsTemplateExpr =
       Previous->is(TT_TemplateString) && Previous->TokenText.endswith("${");
-  if (PreviousMustBeValue && Line && Line->Tokens.size() > 1) {
-    // If the token before the previous one is an '@', the previous token is an
-    // annotation and can precede another identifier/value.
-    const FormatToken *PrePrevious = std::prev(Line->Tokens.end(), 2)->Tok;
-    if (PrePrevious->is(tok::at))
+  if (PreviousMustBeValue || Previous->is(tok::r_paren)) {
+    // If the line contains an '@' sign, the previous token might be an
+    // annotation, which can precede another identifier/value.
+    bool HasAt = std::find_if(Line->Tokens.begin(), Line->Tokens.end(),
+                              [](UnwrappedLineNode &LineNode) {
+                                return LineNode.Tok->is(tok::at);
+                              }) != Line->Tokens.end();
+    if (HasAt)
       return;
   }
   if (Next->is(tok::exclaim) && PreviousMustBeValue)
     return addUnwrappedLine();
   bool NextMustBeValue = mustBeJSIdentOrValue(Keywords, Next);
   bool NextEndsTemplateExpr =
       Next->is(TT_TemplateString) && Next->TokenText.startswith("}");
   if (NextMustBeValue && !NextEndsTemplateExpr && !PreviousStartsTemplateExpr &&

cfe/trunk/unittests/Format/FormatTestJS.cpp

verifyFormat("a\n"
                " class X {}");
   verifyFormat("var a", "var\n"
                         "a");
   verifyFormat("x instanceof String", "x\n"
                                       "instanceof\n"
                                       "String");
   verifyFormat("function f(@Foo bar) {}", "function f(@Foo\n"
                                           "  bar) {}");
+  verifyFormat("function f(@Foo(Param) bar) {}", "function f(@Foo(Param)\n"
+                                                 "  bar) {}");
   verifyFormat("a = true\n"
                "return 1",
                "a = true\n"
                "  return   1");
   verifyFormat("a = 's'\n"
                "return 1",
                "a = 's'\n"
                "  return   1");
verifyFormat("const enum Foo {\n"
                "  B\n"
                "}");
   verifyFormat("export const enum Foo {\n"
                "  A = 1,\n"
                "  B\n"
                "}");
 }
 
-TEST_F(FormatTestJS, MetadataAnnotations) {
+TEST_F(FormatTestJS, Decorators) {
   verifyFormat("@A\nclass C {\n}");
   verifyFormat("@A({arg: 'value'})\nclass C {\n}");
   verifyFormat("@A\n@B\nclass C {\n}");
   verifyFormat("class C {\n  @A x: string;\n}");
   verifyFormat("class C {\n"
                "  @A\n"
                "  private x(): string {\n"
                "    return 'y';\n"