clang-format: [JS] no ASI on `import {x as\n y}`.

[mprobst]

Summary

ASI did not handle the ES6 as operator correctly.

[djasper]

Looks good.

cfe/trunk/lib/Format/SortJavaScriptImports.cpp

if (Symbols == Reference.Symbols) {
       Buffer += ReferenceStmt;
       return false;
     }
     // Stitch together the module reference start...
     SourceLocation SymbolsStart = Reference.Symbols.front().Range.getBegin();
     SourceLocation SymbolsEnd = Reference.Symbols.back().Range.getEnd();
     Buffer += getSourceText(Reference.Range.getBegin(), SymbolsStart);
     // ... then the references in order ...
-    for (auto *I = Symbols.begin(), *E = Symbols.end(); I != E; ++I) {
+    for (auto I = Symbols.begin(), E = Symbols.end(); I != E; ++I) {
       if (I != Symbols.begin())
         Buffer += ",";
       Buffer += getSourceText(I->Range);
     }
     // ... followed by the module reference end.
     Buffer += getSourceText(SymbolsEnd, Reference.Range.getEnd());
     return true;
   }

cfe/trunk/lib/Format/UnwrappedLineParser.cpp

return Tok.isNot(tok::semi) && Tok.isNot(tok::l_brace) &&
          Tok.isNot(tok::kw_noexcept);
 }
 
 static bool mustBeJSIdent(const AdditionalKeywords &Keywords,
                           const FormatToken *FormatTok) {
   // FIXME: This returns true for C/C++ keywords like 'struct'.
   return FormatTok->is(tok::identifier) &&
          (FormatTok->Tok.getIdentifierInfo() == nullptr ||
-          !FormatTok->isOneOf(Keywords.kw_in, Keywords.kw_of, Keywords.kw_async,
-                              Keywords.kw_await, Keywords.kw_yield,
-                              Keywords.kw_finally, Keywords.kw_function,
-                              Keywords.kw_import, Keywords.kw_is,
-                              Keywords.kw_let, Keywords.kw_var,
+          !FormatTok->isOneOf(Keywords.kw_in, Keywords.kw_of, Keywords.kw_as,
+                              Keywords.kw_async, Keywords.kw_await,
+                              Keywords.kw_yield, Keywords.kw_finally,
+                              Keywords.kw_function, Keywords.kw_import,
+                              Keywords.kw_is, Keywords.kw_let, Keywords.kw_var,
                               Keywords.kw_abstract, Keywords.kw_extends,
                               Keywords.kw_implements, Keywords.kw_instanceof,
                               Keywords.kw_interface, Keywords.kw_throws));
 }
 
 static bool mustBeJSIdentOrValue(const AdditionalKeywords &Keywords,
                                  const FormatToken *FormatTok) {
   return FormatTok->Tok.isLiteral() || mustBeJSIdent(Keywords, FormatTok);

cfe/trunk/unittests/Format/FormatTestJS.cpp

TEST_F(FormatTestJS, Modules) {
   verifyFormat("import SomeThing from 'some/module.js';");
   verifyFormat("import {X, Y} from 'some/module.js';");
   verifyFormat("import a, {X, Y} from 'some/module.js';");
   verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,"
                " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying"
                "} from 'some/module.js';");
   verifyFormat("import {X, Y,} from 'some/module.js';");
   verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
+  // Ensure Automatic Semicolon Insertion does not break on "as\n".
+  verifyFormat("import {X as myX} from 'm';", "import {X as\n"
+                                              " myX} from 'm';");
   verifyFormat("import * as lib from 'some/module.js';");
   verifyFormat("var x = {import: 1};\nx.import = 2;");
 
   verifyFormat("export function fn() {\n"
                "  return 'fn';\n"
                "}");
   verifyFormat("export function A() {}\n"
                "export default function B() {}\n"