clang-format: [JS] handle default bindings in imports.

[mprobst]

Summary

Default imports appear outside of named bindings in curly braces:

import A from 'a';
import A, {symbol} from 'a';

[mprobst]

Friendly ping.

[djasper]

It would be helpful to have a before/after to review these patches.

[mprobst]

In D23973#532801, @djasper wrote:

It would be helpful to have a before/after to review these patches.

I assumed the test case was clear enough. Before, we couldn't parse default bindings at all, after, we do, and thus sort the imports in the test case.

cfe/trunk/lib/Format/SortJavaScriptImports.cpp

if (Current->isStringLiteral() && !Reference.IsExport) {
       Reference.Category = JsModuleReference::ReferenceCategory::SIDE_EFFECT;
       Reference.URL =
           Current->TokenText.substr(1, Current->TokenText.size() - 2);
       return true;
     }
 
     if (!parseModuleBindings(Keywords, Reference))
       return false;
-    nextToken();
 
     if (Current->is(Keywords.kw_from)) {
       // imports have a 'from' clause, exports might not.
       nextToken();
       if (!Current->isStringLiteral())
         return false;
       // URL = TokenText without the quotes.
       Reference.URL =
if (Current->isNot(tok::star))
       return false;
     nextToken();
     if (Current->isNot(Keywords.kw_as))
       return false;
     nextToken();
     if (Current->isNot(tok::identifier))
       return false;
     Reference.Prefix = Current->TokenText;
+    nextToken();
     return true;
   }
 
   bool parseNamedBindings(const AdditionalKeywords &Keywords,
                           JsModuleReference &Reference) {
+    if (Current->is(tok::identifier)) {
+      nextToken();
+      if (Current->is(Keywords.kw_from))
+        return true;
+      if (Current->isNot(tok::comma))
+        return false;
+      nextToken(); // eat comma.
+    }
     if (Current->isNot(tok::l_brace))
       return false;
 
     // {sym as alias, sym2 as ...} from '...';
+    while (Current->isNot(tok::r_brace)) {
       nextToken();
-    while (true) {
       if (Current->is(tok::r_brace))
-        return true;
+        break;
       if (Current->isNot(tok::identifier))
         return false;
 
       JsImportedSymbol Symbol;
       Symbol.Symbol = Current->TokenText;
       // Make sure to include any preceding comments.
       Symbol.Range.setBegin(
           Current->getPreviousNonComment()->Next->WhitespaceRange.getBegin());
       nextToken();
 
       if (Current->is(Keywords.kw_as)) {
         nextToken();
         if (Current->isNot(tok::identifier))
           return false;
         Symbol.Alias = Current->TokenText;
         nextToken();
       }
       Symbol.Range.setEnd(Current->Tok.getLocation());
       Reference.Symbols.push_back(Symbol);
 
-      if (Current->is(tok::r_brace))
-        return true;
-      if (Current->isNot(tok::comma))
+      if (!Current->isOneOf(tok::r_brace, tok::comma))
         return false;
-      nextToken();
     }
+    nextToken(); // consume r_brace
+    return true;
   }
 };
 
 tooling::Replacements sortJavaScriptImports(const FormatStyle &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
   // FIXME: Cursor support.
   std::unique_ptr<Environment> Env =
       Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
   JavaScriptImportSorter Sorter(*Env, Style);
   return Sorter.process();
 }
 
 } // end namespace format
 } // end namespace clang

cfe/trunk/unittests/Format/SortImportsTestJS.cpp

verifySort("import {sym} from 'a';\n"
              "\n"
              "let x = 1;",
              "import {sym} from 'a';\n"
              "import {sym} from 'c';\n"
              "import {sym} from 'b';\n"
              "let x = 1;");
 }
 
+TEST_F(SortImportsTestJS, DefaultBinding) {
+  verifySort("import A from 'a';\n"
+             "import B from 'b';\n"
+             "\n"
+             "let x = 1;",
+             "import B from 'b';\n"
+             "import A from 'a';\n"
+             "let x = 1;");
+}
+
+TEST_F(SortImportsTestJS, DefaultAndNamedBinding) {
+  verifySort("import A, {a} from 'a';\n"
+             "import B, {b} from 'b';\n"
+             "\n"
+             "let x = 1;",
+             "import B, {b} from 'b';\n"
+             "import A, {a} from 'a';\n"
+             "let x = 1;");
+}
+
 TEST_F(SortImportsTestJS, WrappedImportStatements) {
   verifySort("import {sym1, sym2} from 'a';\n"
              "import {sym} from 'b';\n"
              "\n"
              "1;",
              "import\n"
              "  {sym}\n"
              "  from 'b';\n"