clang-format: [JS] terminate import sorting on `export type X = Y`

[jankuehle]

Summary

https://reviews.llvm.org/D150116 introduced a bug. export type X = Y was considered an export declaration and took part in import sorting. This is not correct. With this change export type X = Y properly terminates import sorting.

[krasimir]

Thank you!

clang/lib/Format/SortJavaScriptImports.cpp

bool parseNamedBindings(const AdditionalKeywords &Keywords,
                           JsModuleReference &Reference) {
     if (Current->is(Keywords.kw_type) && Current->Next &&
         Current->Next->isOneOf(tok::identifier, tok::l_brace)) {
       Reference.IsTypeOnly = true;
       nextToken();
     }
 
     // eat a potential "import X, " prefix.
-    if (Current->is(tok::identifier)) {
+    if (!Reference.IsExport && Current->is(tok::identifier)) {
       Reference.DefaultImport = Current->TokenText;
       nextToken();
       if (Current->is(Keywords.kw_from))
         return true;
       // import X = A.B.C;
       if (Current->is(tok::equal)) {
         Reference.Category = JsModuleReference::ReferenceCategory::ALIAS;
         nextToken();

clang/unittests/Format/SortImportsTestJS.cpp

TEST_F(SortImportsTestJS, ImportExportType) {
   // Merging: empty imports
   verifySort("import type {A} from 'foo';\n", "import type {} from 'foo';\n"
                                               "import type {A} from 'foo';");
 
   // Merging: exports
   verifySort("export {A, type B} from 'foo';\n",
              "export {A} from 'foo';\n"
              "export   {type B} from 'foo';");
+
+  // `export type X = Y;` should terminate import sorting. The following export
+  // statements should therefore not merge.
+  verifySort("export type A = B;\n"
+             "export {X};\n"
+             "export {Y};\n",
+             "export type A = B;\n"
+             "export {X};\n"
+             "export {Y};\n");
 }
 
 } // end namespace
 } // end namespace format
 } // end namespace clang