[clang-format] Deduplicate using declarations

[krasimir]

Summary

This deduplicated equivalent using declarations within a block.

[bkramer]

lib/Format/UsingDeclarationsSorter.cpp

115

I'd use a lambda instead.

[krasimir]

• Address review comments

[bkramer]

lg

lib/Format/UsingDeclarationsSorter.cpp

while (Tok && Tok->is(tok::identifier)) {
     Label.append("::");
     Tok = Tok->Next;
   }
   if (HasIdentifier && Tok && Tok->isOneOf(tok::semi, tok::comma))
     return Label;
   return "";
 }
 
+bool usingDeclarationsEqual(const UsingDeclaration &a,
+                            const UsingDeclaration &b) {
+  return a.Label == b.Label;
+}
+
 void endUsingDeclarationBlock(
     SmallVectorImpl<UsingDeclaration> *UsingDeclarations,
     const SourceManager &SourceMgr, tooling::Replacements *Fixes) {
   bool BlockAffected = false;
   for (const UsingDeclaration &Declaration : *UsingDeclarations) {
     if (Declaration.Line->Affected) {
       BlockAffected = true;
       break;
     }
   }
   if (!BlockAffected) {
     UsingDeclarations->clear();
     return;
   }
   SmallVector<UsingDeclaration, 4> SortedUsingDeclarations(
       UsingDeclarations->begin(), UsingDeclarations->end());
   std::stable_sort(SortedUsingDeclarations.begin(),
                    SortedUsingDeclarations.end());
+  SortedUsingDeclarations.erase(std::unique(SortedUsingDeclarations.begin(),
+                                            SortedUsingDeclarations.end(),
+                                            usingDeclarationsEqual),
+                                SortedUsingDeclarations.end());
   for (size_t I = 0, E = UsingDeclarations->size(); I < E; ++I) {
+    if (I >= SortedUsingDeclarations.size()) {
+      // This using declaration has been deduplicated, delete it.
+      auto Begin =
+          (*UsingDeclarations)[I].Line->First->WhitespaceRange.getBegin();
+      auto End = (*UsingDeclarations)[I].Line->Last->Tok.getEndLoc();
+      auto Range = CharSourceRange::getCharRange(Begin, End);
+      auto Err = Fixes->add(tooling::Replacement(SourceMgr, Range, ""));
+      if (Err) {
+        llvm::errs() << "Error while sorting using declarations: "
+                     << llvm::toString(std::move(Err)) << "\n";
+      }
+      continue;
+    }
     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();
     StringRef Text(SourceMgr.getCharacterData(SortedBegin),

unittests/Format/UsingDeclarationsSorterTest.cpp

EXPECT_EQ("using ::testing::_;\n"
                                   "using ::testing::kMax;\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"

 
 TEST_F(UsingDeclarationsSorterTest, SortsUsingDeclarationsWithLeadingkComments) {
   EXPECT_EQ("/* comment */ using a;\n"
             "/* comment */ using b;",
             sortUsingDeclarations("/* comment */ using b;\n"
                                   "/* comment */ using a;"));
 }
 
+TEST_F(UsingDeclarationsSorterTest, DeduplicatesUsingDeclarations) {
+  EXPECT_EQ("using a;\n"
+            "using b;\n"
+            "using c;\n"
+            "\n"
+            "using a;\n"
+            "using e;",
+            sortUsingDeclarations("using c;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "using a;\n"
+                                  "using b;\n"
+                                  "\n"
+                                  "using e;\n"
+                                  "using a;\n"
+                                  "using e;"));
+
+}
+
 } // end namespace
 } // end namespace format
 } // end namespace clang