[clang-format] Ignore case and stable sort using-declarations

[krasimir]

Summary

This ignores case while sorting using-declarations, fixing a case where _ would appear between lowercase and uppercase characters.
It also applies stable sort, so that replacements for the exact same using declarations are not generated.

[krasimir]

• Actually add a test

[krasimir]

ping

[alexfh]

As discussed offline, the sorting should also be stable to avoid no-op replacements for identical using declarations and randomizing the order of using declarations differing only in case (not that I'd expect this to be a frequent thing, but it's better to handle it properly anyway).

[krasimir]

• Stable sort using declarations

[alexfh]

LG, thanks!

lib/Format/UsingDeclarationsSorter.cpp

 struct UsingDeclaration {
   const AnnotatedLine *Line;
   std::string Label;
 
   UsingDeclaration(const AnnotatedLine *Line, const std::string &Label)
       : Line(Line), Label(Label) {}
 
   bool operator<(const UsingDeclaration &Other) const {
-    return Label < Other.Label;
+    return StringRef(Label).compare_lower(Other.Label) < 0;
   }
 };
 
 /// Computes the label of a using declaration starting at tthe using token
 /// \p UsingTok.
 /// If \p UsingTok doesn't begin a using declaration, returns the empty string.
 /// Note that this detects specifically using declarations, as in:
 /// using A::B::C;
std::string computeUsingDeclarationLabel(const FormatToken *UsingTok) {
   return "";
 }
 
 void endUsingDeclarationBlock(
     SmallVectorImpl<UsingDeclaration> *UsingDeclarations,
     const SourceManager &SourceMgr, tooling::Replacements *Fixes) {
   SmallVector<UsingDeclaration, 4> SortedUsingDeclarations(
       UsingDeclarations->begin(), UsingDeclarations->end());
-  std::sort(SortedUsingDeclarations.begin(), SortedUsingDeclarations.end());
+  std::stable_sort(SortedUsingDeclarations.begin(),
+                   SortedUsingDeclarations.end());
   for (size_t I = 0, E = UsingDeclarations->size(); I < E; ++I) {
     if ((*UsingDeclarations)[I].Line == SortedUsingDeclarations[I].Line)
       continue;
     auto Begin = (*UsingDeclarations)[I].Line->First->Tok.getLocation();
     auto End = (*UsingDeclarations)[I].Line->Last->Tok.getEndLoc();
     auto SortedBegin =
         SortedUsingDeclarations[I].Line->First->Tok.getLocation();
     auto SortedEnd = SortedUsingDeclarations[I].Line->Last->Tok.getEndLoc();

unittests/Format/UsingDeclarationsSorterTest.cpp

EXPECT_EQ("using typename z;\n"
                                   "using typename z;"));
 
   EXPECT_EQ("using a, b;\n"
             "using aa;",
             sortUsingDeclarations("using aa;\n"
                                   "using a, b;"));
 }
 
+TEST_F(UsingDeclarationsSorterTest, SortsCaseInsensitively) {
+  EXPECT_EQ("using A;\n"
+            "using a;",
+            sortUsingDeclarations("using A;\n"
+                                  "using a;"));
+  EXPECT_EQ("using a;\n"
+            "using A;",
+            sortUsingDeclarations("using a;\n"
+                                  "using A;"));
+  EXPECT_EQ("using a;\n"
+            "using B;",
+            sortUsingDeclarations("using B;\n"
+                                  "using a;"));
+  EXPECT_EQ("using _;\n"
+            "using a;",
+            sortUsingDeclarations("using a;\n"
+                                  "using _;"));
+  EXPECT_EQ("using a::_;\n"
+            "using a::a;",
+            sortUsingDeclarations("using a::a;\n"
+                                  "using a::_;"));
+
+  EXPECT_EQ("using ::testing::_;\n"
+            "using ::testing::Aardvark;\n"
+            "using ::testing::apple::Honeycrisp;\n"
+            "using ::testing::Xylophone;\n"
+            "using ::testing::zebra::Stripes;",
+            sortUsingDeclarations("using ::testing::Aardvark;\n"
+                                  "using ::testing::Xylophone;\n"
+                                  "using ::testing::_;\n"
+                                  "using ::testing::apple::Honeycrisp;\n"
+                                  "using ::testing::zebra::Stripes;"));
+}
+
+TEST_F(UsingDeclarationsSorterTest, SortsStably) {
+  EXPECT_EQ("using a;\n"
+            "using a;\n"
+            "using A;\n"
+            "using a;\n"
+            "using A;\n"
+            "using a;\n"
+            "using A;\n"
+            "using a;\n"
+            "using B;\n"
+            "using b;\n"
+            "using b;\n"
+            "using B;\n"
+            "using b;\n"
+            "using b;\n"
+            "using b;\n"
+            "using B;\n"
+            "using b;",
+            sortUsingDeclarations("using a;\n"
+                                  "using B;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "using A;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "using B;\n"
+                                  "using b;\n"
+                                  "using A;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "using b;\n"
+                                  "using B;\n"
+                                  "using b;\n"
+                                  "using A;\n"
+                                  "using a;"));
+}
+
 TEST_F(UsingDeclarationsSorterTest, SortsMultipleTopLevelDeclarations) {
   EXPECT_EQ("using a;\n"
             "using b;\n"
             "using c;\n"
             "using d;\n"
             "using e;",
             sortUsingDeclarations("using d;\n"
                                   "using b;\n"