[clangd] Fix the code action `RemoveUsingNamespace`

[v1nh1shungry]

Summary

Avoid adding qualifiers before user-defined literals

[tom-anders]

Would be cool if in the future we could instead transform something like

using namespace std;
int main() {
   auto t = 5ms;
}

into

using namespace std::chrono_literals;
int main() {
   auto t = 5ms;
}

But I think your fix certainly improved the behavior for now, so LGTM!

clang-tools-extra/clangd/unittests/tweaks/RemoveUsingNamespaceTests.cpp

253

[v1nh1shungry]

Improve the patch

[v1nh1shungry]

@tom-anders Thanks for reviewing and for your suggestions!

I think your suggestion is excellent, but for now, it is too complex for me to implement.

If this patch is okay, could you please help me commit it? Thanks again!

[v1nh1shungry]

Format codes

clang-tools-extra/clangd/refactor/tweaks/RemoveUsingNamespace.cpp

findExplicitReferences(
         [&](ReferenceLoc Ref) {
           if (Ref.Qualifier)
             return; // This reference is already qualified.
 
           for (auto *T : Ref.Targets) {
             if (!visibleContext(T->getDeclContext())
                      ->Equals(TargetDirective->getNominatedNamespace()))
               return;
+            auto Kind = T->getDeclName().getNameKind();
             // Avoid adding qualifiers before operators, e.g.
             //   using namespace std;
             //   cout << "foo"; // Must not changed to std::cout std:: << "foo"
-            // FIXME: User-defined literals are not handled
-            if (T->isInIdentifierNamespace(
-                    Decl::IdentifierNamespace::IDNS_NonMemberOperator))
+            if (Kind == DeclarationName::CXXOperatorName)
+              return;
+            // Avoid adding qualifiers before user-defined literals, e.g.
+            //   using namespace std;
+            //   auto s = "foo"s; // Must not changed to auto s = "foo" std::s;
+            // FIXME: Add a using-directive for user-defined literals
+            // declared in an inline namespace, e.g.
+            //   using namespace s^td;
+            //   int main() { cout << "foo"s; }
+            // change to
+            //   using namespace std::literals;
+            //   int main() { std::cout << "foo"s; }
+            if (Kind == DeclarationName::NameKind::CXXLiteralOperatorName)
               return;
           }
           SourceLocation Loc = Ref.NameLoc;
           if (Loc.isMacroID()) {
             // Avoid adding qualifiers before macro expansions, it's probably
             // incorrect, e.g.
             //   namespace std { int foo(); }
             //   #define FOO 1 + foo()

clang-tools-extra/clangd/unittests/tweaks/RemoveUsingNamespaceTests.cpp

)cpp",
       struct Foo {};
       void operator+(const Foo &, int) {}
       }
       
       int main() {
         ns::Foo foo;
         foo + 10;
       }
+    )cpp"},
+      {// Does not qualify user-defined literals
+       R"cpp(
+      namespace ns {
+      long double operator "" _w(long double);
+      }
+      using namespace n^s;
+      int main() { 1.5_w; }
+    )cpp",
+       R"cpp(
+      namespace ns {
+      long double operator "" _w(long double);
+      }
+      
+      int main() { 1.5_w; }
     )cpp"}};
   for (auto C : Cases)
     EXPECT_EQ(C.second, apply(C.first)) << C.first;
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang