clang-format: [JS] Sort imports case insensitive.

[mprobst]

Summary

ASCII case sorting does not help finding imported symbols quickly, and it is common to have e.g. class Foo and function fooFactory exported/imported from the same file.

[mprobst]

• clang-format: [JS] support trailing commas in imports.

[djasper]

Looks good.

lib/Format/SortJavaScriptImports.cpp

bool operator<(const JsModuleReference &LHS, const JsModuleReference &RHS) {
   if (LHS.Category == JsModuleReference::ReferenceCategory::SIDE_EFFECT)
     // Side effect imports might be ordering sensitive. Consider them equal so
     // that they maintain their relative order in the stable sort below.
     // This retains transitivity because LHS.Category == RHS.Category here.
     return false;
   // Empty URLs sort *last* (for export {...};).
   if (LHS.URL.empty() != RHS.URL.empty())
     return LHS.URL.empty() < RHS.URL.empty();
-  if (LHS.URL != RHS.URL)
-    return LHS.URL < RHS.URL;
+  if (int Res = LHS.URL.compare_lower(RHS.URL))
+    return Res < 0;
   // '*' imports (with prefix) sort before {a, b, ...} imports.
   if (LHS.Prefix.empty() != RHS.Prefix.empty())
     return LHS.Prefix.empty() < RHS.Prefix.empty();
   if (LHS.Prefix != RHS.Prefix)
     return LHS.Prefix > RHS.Prefix;
   return false;
 }
 
private:
   // ``Reference`` changed (e.g. symbol order).
   bool appendReference(std::string &Buffer, JsModuleReference &Reference) {
     // Sort the individual symbols within the import.
     // E.g. `import {b, a} from 'x';` -> `import {a, b} from 'x';`
     SmallVector<JsImportedSymbol, 1> Symbols = Reference.Symbols;
     std::stable_sort(
         Symbols.begin(), Symbols.end(),
         [&](const JsImportedSymbol &LHS, const JsImportedSymbol &RHS) {
-          return LHS.Symbol < RHS.Symbol;
+          int Res = LHS.Symbol.compare_lower(RHS.Symbol);
+          return Res < 0;
         });
     if (Symbols == Reference.Symbols) {
       // No change in symbol order.
       StringRef ReferenceStmt = getSourceText(Reference.Range);
       Buffer += ReferenceStmt;
       return false;
     }
     // Stitch together the module reference start...

unittests/Format/SortImportsTestJS.cpp

verifySort("import {B} from 'a';\n"
              "1;",
              "import {A} from 'b';\n"
              "\n"
              "import {B} from 'a';\n"
              "\n"
              "1;");
 }
 
+TEST_F(SortImportsTestJS, SortCaseInsensitive) {
+  verifySort("import {A} from 'aa';\n"
+             "import {A} from 'Ab';\n"
+             "import {A} from 'b';\n"
+             "import {A} from 'Bc';\n"
+             "\n"
+             "1;",
+             "import {A} from 'b';\n"
+             "import {A} from 'Bc';\n"
+             "import {A} from 'Ab';\n"
+             "import {A} from 'aa';\n"
+             "\n"
+             "1;");
+  verifySort("import {aa, Ab, b, Bc} from 'x';\n"
+             "\n"
+             "1;",
+             "import {b, Bc, Ab, aa} from 'x';\n"
+             "\n"
+             "1;");
+}
+
 } // end namespace
 } // end namespace format
 } // end namespace clang