[clangd] When inserting "using", add "::" in front if that's the style.

[adamcz]

Summary

We guess the style based on the existing using declarations. If there
are any and they all start with ::, we add it to the newly added one
too.

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

public:
   }
 
 private:
   std::vector<const UsingDecl *> &Results;
   const DeclContext *SelectionDeclContext;
   const SourceManager &SM;
 };
 
+bool isFullyQualified(const NestedNameSpecifier *NNS) {
+  if (!NNS)
+    return false;
+  return NNS->getKind() == NestedNameSpecifier::Global ||
+         isFullyQualified(NNS->getPrefix());
+}
+
 struct InsertionPointData {
   // Location to insert the "using" statement. If invalid then the statement
   // should not be inserted at all (it already exists).
   SourceLocation Loc;
   // Extra suffix to place after the "using" statement. Depending on what the
   // insertion point is anchored to, we may need one or more \n to ensure
   // proper formatting.
   std::string Suffix;
+  // Whether using should be fully qualified, even if what the user typed was
+  // not. This is based on our detection of the local style.
+  bool AlwaysFullyQualify = false;
 };
 
 // Finds the best place to insert the "using" statement. Returns invalid
 // SourceLocation if the "using" statement already exists.
 //
 // The insertion point might be a little awkward if the decl we're anchoring to
 // has a comment in an unfortunate place (e.g. directly above function or using
 // decl, or immediately following "namespace {". We should add some helpers for
 // dealing with that and use them in other code modifications as well.
 llvm::Expected<InsertionPointData>
 findInsertionPoint(const Tweak::Selection &Inputs,
                    const NestedNameSpecifierLoc &QualifierToRemove,
                    const llvm::StringRef Name) {
   auto &SM = Inputs.AST->getSourceManager();
 
   // Search for all using decls that affect this point in file. We need this for
   // two reasons: to skip adding "using" if one already exists and to find best
   // place to add it, if it doesn't exist.
   SourceLocation LastUsingLoc;
   std::vector<const UsingDecl *> Usings;
   UsingFinder(Usings, &Inputs.ASTSelection.commonAncestor()->getDeclContext(),
               SM)
       .TraverseAST(Inputs.AST->getASTContext());
 
+  bool AlwaysFullyQualify = true;
   for (auto &U : Usings) {
+    // Only "upgrade" to fully qualified is all relevant using decls are fully
+    // qualified. Otherwise trust what the user typed.
+    if (!isFullyQualified(U->getQualifier()))
+      AlwaysFullyQualify = false;
+
     if (SM.isBeforeInTranslationUnit(Inputs.Cursor, U->getUsingLoc()))
       // "Usings" is sorted, so we're done.
       break;
     if (U->getQualifier()->getAsNamespace()->getCanonicalDecl() ==
             QualifierToRemove.getNestedNameSpecifier()
                 ->getAsNamespace()
                 ->getCanonicalDecl() &&
         U->getName() == Name) {
       return InsertionPointData();
     }
     // Insertion point will be before last UsingDecl that affects cursor
     // position. For most cases this should stick with the local convention of
     // add using inside or outside namespace.
     LastUsingLoc = U->getUsingLoc();
   }
   if (LastUsingLoc.isValid()) {
     InsertionPointData Out;
     Out.Loc = LastUsingLoc;
+    Out.AlwaysFullyQualify = AlwaysFullyQualify;
     return Out;
   }
 
   // No relevant "using" statements. Try the nearest namespace level.
   const DeclContext *ParentDeclCtx =
       &Inputs.ASTSelection.commonAncestor()->getDeclContext();
   while (ParentDeclCtx && !ParentDeclCtx->isFileContext()) {
     ParentDeclCtx = ParentDeclCtx->getLexicalParent();
if (!InsertionPoint) {
     return InsertionPoint.takeError();
   }
 
   if (InsertionPoint->Loc.isValid()) {
     // Add the using statement at appropriate location.
     std::string UsingText;
     llvm::raw_string_ostream UsingTextStream(UsingText);
     UsingTextStream << "using ";
+    if (InsertionPoint->AlwaysFullyQualify &&
+        !isFullyQualified(QualifierToRemove.getNestedNameSpecifier()))
+      UsingTextStream << "::";
     QualifierToRemove.getNestedNameSpecifier()->print(
         UsingTextStream, Inputs.AST->getASTContext().getPrintingPolicy());
     UsingTextStream << Name << ";" << InsertionPoint->Suffix;
 
     assert(SM.getFileID(InsertionPoint->Loc) == SM.getMainFileID());
     if (auto Err = R.add(tooling::Replacement(SM, InsertionPoint->Loc, 0,
                                               UsingTextStream.str()))) {
       return std::move(Err);

clang-tools-extra/clangd/unittests/TweakTests.cpp

one::two::f^f();
              R"cpp(
 #include "test.hpp"
 using one::two::ff;
 
 namespace foo { void fun(); }
 
 void foo::fun() {
   ff();
+})cpp"},
+            // If all other using are fully qualified, add ::
+            {R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using ::one::two::ee;
+
+void fun() {
+  one::two::f^f();
+})cpp",
+             R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using ::one::two::ff;using ::one::two::ee;
+
+void fun() {
+  ff();
+})cpp"},
+            // Make sure we don't add :: if it's already there
+            {R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using ::one::two::ee;
+
+void fun() {
+  ::one::two::f^f();
+})cpp",
+             R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using ::one::two::ff;using ::one::two::ee;
+
+void fun() {
+  ff();
+})cpp"},
+            // If even one using doesn't start with ::, do not add it
+            {R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using one::two::ee;
+
+void fun() {
+  one::two::f^f();
+})cpp",
+             R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using one::two::ff;using one::two::ee;
+
+void fun() {
+  ff();
 })cpp"}};
   llvm::StringMap<std::string> EditedFiles;
   for (const auto &Case : Cases) {
     for (const auto &SubCase : expandCases(Case.TestSource)) {
       ExtraFiles["test.hpp"] = R"cpp(
 namespace one {
 void oo() {}
 namespace two {