[clangd] Add RemoveUsingNamespace tweak.

[usaxena95]

Summary

Removes the 'using namespace' under the cursor and qualifies all accesses in the current file.
E.g.:

using namespace std;
vector<int> foo(std::map<int, int>);

Would become:

std::vector<int> foo(std::map<int, int>);

[ilya-biryukov]

The main comment is about limiting this only to global namespace. PTAL.

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

80

continue rest of the file in the anonymous namespace

111

I think I had this FIXME in some of the versions, but TBF I don't remember why I added it.
Maybe remove?

147

Qualifying identifiers and removing using namespaces might actually conflict.
Could you add a (commented-out) test with an example that fails and a FIXME?

namespace a::b { struct foo {}; }
using namespace a::b;
using namespace b; // we'll try to both qualify this 'b' and remove this line.

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

783

Could we disallow the action outside global namespace for now to make sure it's always correct.

#include <vector>

using namespace std;

is a very common pattern anyway, supporting only it in the first version looks ok.

[usaxena95]

Make the tweak trigger only for TopLevelDecl.

[ilya-biryukov]

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

87

NIT: remove redundant {} around this return

100

I believe this check is redundant in presence of isTopLevelDecl()...
(It used to check the 'using namespace' is not inside a function body)

122

Could you take a look at handling these?

Also happy if we make it a separate change, but we shouldn't delay this.
Both are important cases.

The examples should roughly be:

namespace std {
inline namespace v1 {
  struct vector {};
}
}

using namespace std;
vector v;

and

namespace tokens {
enum Token {
  comma, identifier, numeric
};
}

using namespace tokens;
auto x = comma;

164

NIT: could you rephrase as re-qualify names instead
"add qualifiers" confuses some people, this can be read as "add a const qualifier"

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

781

Argh, this should definitely be fixed :-(
One simple way to handle this particular only qualify references, which come after the first using namespace we are removing.

There's a SourceManager::isBeforeInTranslationUnit function that can be used to find out whether something is written before or after a particular point.

This won't fix all of the cases, but fixing in the general case seems hard.

[merge_guards_bot]

Bulid results are available at http://results.llvm-merge-guard.org/Phabricator-19

See http://jenkins.llvm-merge-guard.org/job/Phabricator/19/ for more details.

[usaxena95]

Addressed comments.

[usaxena95]

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

100

Aah. Makes sense.

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

781

We also need to qualify the map in such cases.
I have made an attempt to fix this by traversing all the parents namespace decl and checking whether they are equal to the concerned namespace.
But this introduces other problems:

namespace aa { namespace bb { struct map {}; }}
using namespace aa::bb;
using namespace a^a;
int main() {
  map m;
}

get changed to

namespace aa { namespace bb { struct map {}; }}
using namespace aa::bb;

int main() {
  aa::map m;
}

Here aa::map is invalid.

[ilya-biryukov]

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

88

Can we use ASTNode.get<TranslationUnitDecl>() to directly to check for this?

Not sure how DynTypedNode works, though, maybe that's impossible.

101

Hm, I'd expect us to simply go up until the first non-trasparent namespace and stop at it.
Consider the following example:

namespace a { namespace b {
  struct Foo {};
}}

using namespace a; // <-- remove this
using namespace b;

Foo x; // <-- Foo does not need to be qualified, as it's inside b.

OTOH, in case of inline namespace we'd choose to qualify:

namespace a { inline namespace b {
  struct Foo {};
}}

using namespace a; // <-- remove this

Foo x; // <-- need to change to a::Foo

Obviously, if we had using namespace a::b we'd not want to qualify, but that's complicated. And it's very rare to have using namespace for an inline namespace.

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

782

This is incorrect, right? We should not be qualifying here.
See the relevant comment on isInsideNamespace

[usaxena95]

Make action unavailable if the namespace contains a using namespace decl.

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

88

Works for the test.
The doc for get<T> says that it returns NULL if the stored node does not have a type that is convertible to T.

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

782

Works fine now.

[ilya-biryukov]

Many thanks, this LG overall, just a few NITs and documentation requests.

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

32

Could you mention current limitation in the comment?
Something like

Currently limited to using namespace directives inside global namespace to simplify implementation.

86

NIT: could be written as a single statement

return Node->Parent
    && Node->Parent->....

up to you, though, both versions look fine.

114

Could you provide the rationale why we do this too?
This information would be super-useful to folks fixing this later

151

Worth documenting why we do this here:

Avoid adding qualifiers before macro expansions, it's probably incorrect, e.g.
    #define FOO 1 + matrix()
    using namespace linalg; // provides matrix
    auto x = FOO; 
 
Should not be changed to:
    auto x = linalg::FOO;

158

NIT: could you add a comment on why we do this? Something like

Directive was not visible before this point.

[usaxena95]

Added documentation.

[ilya-biryukov]

LGTM, many thanks!

A few last NITs too

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

31

NIT: use three slashes

32

NIT: s/a using directives/using directives

91

NIT: end the sentence with a period

91

I believe this function is more general, e.g. it returns the parent class for class members.
I suggest renaming to visibleContext and removing mentions of returning a namespace in the doc comment.

99

NIT: remove braces, LLVM code style suggests to avoid them in simple single-statement loops

116

NIT:s/namepsace/namespace

137

NIT: the comment looks redundant, the variable name is very descriptive. Maybe remove?

139

I'm not 100% certain this is considered to be the end location, as there macros, etc.
Could we instead start with an invalid source location

162

NIT: could you indent the example?
To make it clearly distinguishable from the rest of the comment

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

810

What happens if we remove this one?
Will it still qualify as a::b or as b::?

Could we add a test just to document the behavior?

[usaxena95]

Addressed comments.

[usaxena95]

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

139

Replaced it with uninitialized (which is invalid) SourceLocation. Makes it simpler.

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

810

It qualifies as b::. Added a test for it.

clang-tools-extra/clangd/AST.h

 
 /// Returns the qualified name of ND. The scope doesn't contain unwritten scopes
 /// like inline namespaces.
 std::string printQualifiedName(const NamedDecl &ND);
 
 /// Returns the first enclosing namespace scope starting from \p DC.
 std::string printNamespaceScope(const DeclContext &DC);
 
+/// Returns the name of the namespace inside the 'using namespace' directive, as
+/// written in the code. E.g., passing 'using namespace ::std' will result in
+/// '::std'.
+std::string printUsingNamespaceName(const ASTContext &Ctx,
+                                    const UsingDirectiveDecl &D);
+
 /// Prints unqualified name of the decl for the purpose of displaying it to the
 /// user. Anonymous decls return names of the form "(anonymous {kind})", e.g.
 /// "(anonymous struct)" or "(anonymous namespace)".
 std::string printName(const ASTContext &Ctx, const NamedDecl &ND);
 
 /// Prints template arguments of a decl as written in the source code, including
 /// enclosing '<' and '>', e.g for a partial specialization like: template
 /// <typename U> struct Foo<int, U> will return '<int, U>'. Returns an empty

clang-tools-extra/clangd/AST.cpp

 static NestedNameSpecifier *getQualifier(const NamedDecl &ND) {
   if (auto *V = llvm::dyn_cast<DeclaratorDecl>(&ND))
     return V->getQualifier();
   if (auto *T = llvm::dyn_cast<TagDecl>(&ND))
     return T->getQualifier();
   return nullptr;
 }
 
+std::string printUsingNamespaceName(const ASTContext &Ctx,
+                                    const UsingDirectiveDecl &D) {
+  PrintingPolicy PP(Ctx.getLangOpts());
+  std::string Name;
+  llvm::raw_string_ostream Out(Name);
+
+  if (auto *Qual = D.getQualifier())
+    Qual->print(Out, PP);
+  D.getNominatedNamespaceAsWritten()->printName(Out);
+  return Out.str();
+}
+
 std::string printName(const ASTContext &Ctx, const NamedDecl &ND) {
   std::string Name;
   llvm::raw_string_ostream Out(Name);
   PrintingPolicy PP(Ctx.getLangOpts());
 
   // Handle 'using namespace'. They all have the same name - <using-directive>.
   if (auto *UD = llvm::dyn_cast<UsingDirectiveDecl>(&ND)) {
     Out << "using namespace ";

clang-tools-extra/clangd/refactor/tweaks/CMakeLists.txt

 add_clang_library(clangDaemonTweaks OBJECT
   AnnotateHighlightings.cpp
   DumpAST.cpp
   ExpandAutoType.cpp
   ExpandMacro.cpp
   ExtractFunction.cpp
   ExtractVariable.cpp
   RawStringLiteral.cpp
+  RemoveUsingNamespace.cpp
   SwapIfBranches.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangDaemon
   clangToolingCore
   clangToolingRefactoring
   clangToolingSyntax
   )

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

+//===--- RemoveUsingNamespace.cpp --------------------------------*- C++-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#include "AST.h"
+#include "FindTarget.h"
+#include "Selection.h"
+#include "SourceCode.h"
+#include "refactor/Tweak.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Tooling/Core/Replacement.h"
+#include "clang/Tooling/Refactoring/RecursiveSymbolVisitor.h"
+#include "llvm/ADT/ScopeExit.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+/// Removes the 'using namespace' under the cursor and qualifies all accesses in
+/// the current file. E.g.,
+///   using namespace std;
+///   vector<int> foo(std::map<int, int>);
+/// Would become:
+///   std::vector<int> foo(std::map<int, int>);
+// Currently limited to using namespace directives inside global namespace to
+// simplify implementation. Also the namespace must not contain a using
+// directives.
+class RemoveUsingNamespace : public Tweak {
+public:
+  const char *id() const override;
+
+  bool prepare(const Selection &Inputs) override;
+  Expected<Effect> apply(const Selection &Inputs) override;
+  std::string title() const override;
+  Intent intent() const override { return Refactor; }
+
+private:
+  const UsingDirectiveDecl *TargetDirective = nullptr;
+};
+REGISTER_TWEAK(RemoveUsingNamespace)
+
+class FindSameUsings : public RecursiveASTVisitor<FindSameUsings> {
+public:
+  FindSameUsings(const UsingDirectiveDecl &Target,
+                 std::vector<const UsingDirectiveDecl *> &Results)
+      : TargetNS(Target.getNominatedNamespace()),
+        TargetCtx(Target.getDeclContext()), Results(Results) {}
+
+  bool VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
+    if (D->getNominatedNamespace() != TargetNS ||
+        D->getDeclContext() != TargetCtx)
+      return true;
+    Results.push_back(D);
+    return true;
+  }
+
+private:
+  const NamespaceDecl *TargetNS;
+  const DeclContext *TargetCtx;
+  std::vector<const UsingDirectiveDecl *> &Results;
+};
+
+/// Produce edit removing 'using namespace xxx::yyy' and the trailing semicolon.
+llvm::Expected<tooling::Replacement>
+removeUsingDirective(ASTContext &Ctx, const UsingDirectiveDecl *D) {
+  auto &SM = Ctx.getSourceManager();
+  llvm::Optional<Token> NextTok =
+      Lexer::findNextToken(D->getEndLoc(), SM, Ctx.getLangOpts());
+  if (!NextTok || NextTok->isNot(tok::semi))
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "no semicolon after using-directive");
+  // FIXME: removing the semicolon may be invalid in some obscure cases, e.g.
+  //        if (x) using namespace std; else using namespace bar;
+  return tooling::Replacement(
+      SM,
+      CharSourceRange::getTokenRange(D->getBeginLoc(), NextTok->getLocation()),
+      "", Ctx.getLangOpts());
+}
+
+// Returns true iff the parent of the Node is a TUDecl.
+bool isTopLevelDecl(const SelectionTree::Node *Node) {
+  return Node->Parent && Node->Parent->ASTNode.get<TranslationUnitDecl>();
+}
+
+// Returns the first visible namespace decl that contains this DeclContext
+// For example: Returns ns1 for S1 and a.
+// namespace ns1 {
+// inline namespace ns2 { struct S1 {}; }
+// enum E { a, b, c, d };
+// }
+const DeclContext *visibleNamespace(const DeclContext *D) {
+  while (D->isInlineNamespace() || D->isTransparentContext()) {
+    D = D->getParent();
+  }
+  return D;
+}
+
+bool RemoveUsingNamespace::prepare(const Selection &Inputs) {
+  // Find the 'using namespace' directive under the cursor.
+  auto *CA = Inputs.ASTSelection.commonAncestor();
+  if (!CA)
+    return false;
+  TargetDirective = CA->ASTNode.get<UsingDirectiveDecl>();
+  if (!TargetDirective)
+    return false;
+  if (!dyn_cast<Decl>(TargetDirective->getDeclContext()))
+    return false;
+  // FIXME: Unavailable for namespaces containing using-namespace decl.
+  // It is non-trivial to deal with cases where identifiers come from the inner
+  // namepsace. For example map has to be changed to aa::map.
+  // namespace aa {
+  //   namespace bb { struct map {}; }
+  //   using namespace bb;
+  // }
+  // using namespace a^a;
+  // int main() { map m; }
+  // We need to make this aware of the transitive using-namespace decls.
+  if (!TargetDirective->getNominatedNamespace()->using_directives().empty())
+    return false;
+  return isTopLevelDecl(CA);
+}
+
+Expected<Tweak::Effect> RemoveUsingNamespace::apply(const Selection &Inputs) {
+  auto &Ctx = Inputs.AST.getASTContext();
+  auto &SM = Ctx.getSourceManager();
+  // First, collect *all* using namespace directives that redeclare the same
+  // namespace.
+  std::vector<const UsingDirectiveDecl *> AllDirectives;
+  FindSameUsings(*TargetDirective, AllDirectives).TraverseAST(Ctx);
+
+  // Location of first UsingDirective in the file.
+  SourceLocation FirstUsingDirectiveLoc =
+      SM.getLocForEndOfFile(SM.getMainFileID());
+  for (auto *D : AllDirectives) {
+    if (SM.isBeforeInTranslationUnit(D->getBeginLoc(), FirstUsingDirectiveLoc))
+      FirstUsingDirectiveLoc = D->getBeginLoc();
+  }
+
+  // Collect all references to symbols from the namespace for which we're
+  // removing the directive.
+  std::vector<SourceLocation> IdentsToQualify;
+  for (auto &D : Inputs.AST.getLocalTopLevelDecls()) {
+    findExplicitReferences(D, [&](ReferenceLoc Ref) {
+      if (Ref.Qualifier)
+        return; // This reference is already qualified.
+
+      for (auto *T : Ref.Targets) {
+        if (!visibleNamespace(T->getDeclContext())
+                 ->Equals(TargetDirective->getNominatedNamespace()))
+          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()
+        // using namespace foo; // provides matrix
+        // auto x = FOO; // Must not changed to auto x = std::FOO
+        if (!SM.isMacroArgExpansion(Loc))
+          return; // FIXME: report a warning to the users.
+        Loc = SM.getFileLoc(Ref.NameLoc);
+      }
+      assert(Loc.isFileID());
+      if (SM.getFileID(Loc) != SM.getMainFileID())
+        return; // FIXME: report these to the user as warnings?
+      if (SM.isBeforeInTranslationUnit(Loc, FirstUsingDirectiveLoc))
+        return; // Directive was not visible before this point.
+      IdentsToQualify.push_back(Loc);
+    });
+  }
+  // Remove duplicates.
+  llvm::sort(IdentsToQualify);
+  IdentsToQualify.erase(
+      std::unique(IdentsToQualify.begin(), IdentsToQualify.end()),
+      IdentsToQualify.end());
+
+  // Produce replacements to remove the using directives.
+  tooling::Replacements R;
+  for (auto *D : AllDirectives) {
+    auto RemoveUsing = removeUsingDirective(Ctx, D);
+    if (!RemoveUsing)
+      return RemoveUsing.takeError();
+    if (auto Err = R.add(*RemoveUsing))
+      return std::move(Err);
+  }
+  // Produce replacements to add the qualifiers.
+  std::string Qualifier = printUsingNamespaceName(Ctx, *TargetDirective) + "::";
+  for (auto Loc : IdentsToQualify) {
+    if (auto Err = R.add(tooling::Replacement(Ctx.getSourceManager(), Loc,
+                                              /*Length=*/0, Qualifier)))
+      return std::move(Err);
+  }
+  return Effect::mainFileEdit(SM, std::move(R));
+}
+
+std::string RemoveUsingNamespace::title() const {
+  return llvm::formatv("Remove using namespace, re-qualify names instead.");
+}
+} // namespace
+} // namespace clangd
+} // namespace clang

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

 }
 
 TWEAK_TEST(SwapIfBranches);
 TEST_F(SwapIfBranchesTest, Test) {
   Context = Function;
   EXPECT_EQ(apply("^if (true) {return 100;} else {continue;}"),
             "if (true) {continue;} else {return 100;}");
   EXPECT_EQ(apply("^if () {return 100;} else {continue;}"),
-            "if () {continue;} else {return 100;}") << "broken condition";
+            "if () {continue;} else {return 100;}")
+      << "broken condition";
   EXPECT_AVAILABLE("^i^f^^(^t^r^u^e^) { return 100; } ^e^l^s^e^ { continue; }");
   EXPECT_UNAVAILABLE("if (true) {^return ^100;^ } else { ^continue^;^ }");
   // Available in subexpressions of the condition;
   EXPECT_THAT("if(2 + [[2]] + 2) { return 2 + 2 + 2; } else {continue;}",
               isAvailable());
   // But not as part of the branches.
   EXPECT_THAT("if(2 + 2 + 2) { return 2 + [[2]] + 2; } else { continue; }",
               Not(isAvailable()));

 TEST_F(RawStringLiteralTest, Test) {
   Context = Expression;
   EXPECT_AVAILABLE(R"cpp(^"^f^o^o^\^n^")cpp");
   EXPECT_AVAILABLE(R"cpp(R"(multi )" ^"token " "str\ning")cpp");
   EXPECT_UNAVAILABLE(R"cpp(^"f^o^o^o")cpp"); // no chars need escaping
   EXPECT_UNAVAILABLE(R"cpp(R"(multi )" ^"token " u8"str\ning")cpp"); // nonascii
   EXPECT_UNAVAILABLE(R"cpp(^R^"^(^multi )" "token " "str\ning")cpp"); // raw
   EXPECT_UNAVAILABLE(R"cpp(^"token\n" __FILE__)cpp"); // chunk is macro
-  EXPECT_UNAVAILABLE(R"cpp(^"a\r\n";)cpp"); // forbidden escape char
+  EXPECT_UNAVAILABLE(R"cpp(^"a\r\n";)cpp");           // forbidden escape char
 
   const char *Input = R"cpp(R"(multi
 token)" "\nst^ring\n" "literal")cpp";
   const char *Output = R"cpp(R"(multi
 token
 string
 literal)")cpp";
   EXPECT_EQ(apply(Input), Output);
const std::vector<std::pair<llvm::StringLiteral, llvm::StringLiteral>>
                              break;
                        }
                  })cpp"},*/
           // Macros
           {R"cpp(#define PLUS(x) x++
                  void f(int a) {
                    int y = PLUS([[1+a]]);
                  })cpp",
            /*FIXME: It should be extracted like this.
             R"cpp(#define PLUS(x) x++
                   void f(int a) {
                     auto dummy = 1+a; int y = PLUS(dummy);
                   })cpp"},*/
            R"cpp(#define PLUS(x) x++
                  void f(int a) {
                    auto dummy = PLUS(1+a); int y = dummy;
                  })cpp"},
           // ensure InsertionPoint isn't inside a macro
           {R"cpp(#define LOOP(x) while (1) {a = x;}
                  void f(int a) {
                    if(1)
                     LOOP(5 + [[3]])
                  })cpp",
            /*FIXME: It should be extracted like this. SelectionTree needs to be
              * fixed for macros.
             R"cpp(#define LOOP(x) while (1) {a = x;}
                 void f(int a) {
                   auto dummy = 3; if(1)
                    LOOP(5 + dummy)
                 })cpp"},*/
            R"cpp(#define LOOP(x) while (1) {a = x;}
                  void f(int a) {
                    auto dummy = LOOP(5 + 3); if(1)
                     dummy
                  })cpp"},
           {R"cpp(#define LOOP(x) do {x;} while(1);
                  void f(int a) {
                    if(1)
const std::vector<std::pair<llvm::StringLiteral, llvm::StringLiteral>>
            R"cpp(struct S {
                    S(int);
                  };
                  S operator+(S, S);
 
                  void f() {
                    auto dummy = S(2) + S(3) + S(4); S x = S(1) + dummy + S(5);
                  })cpp"},
-           // Don't try to analyze across macro boundaries
-           // FIXME: it'd be nice to do this someday (in a safe way)
           {R"cpp(#define ECHO(X) X
                  void f() {
                    int x = 1 + [[ECHO(2 + 3) + 4]] + 5;
                  })cpp",
            R"cpp(#define ECHO(X) X
                  void f() {
                    auto dummy = 1 + ECHO(2 + 3) + 4; int x = dummy + 5;
                  })cpp"},
TEST_F(ExpandAutoTypeTest, Test) {
   // function pointers should not be replaced
   EXPECT_THAT(apply("au^to x = &ns::Func;"),
               StartsWith("fail: Could not expand type of function pointer"));
   // lambda types are not replaced
   EXPECT_THAT(apply("au^to x = []{};"),
               StartsWith("fail: Could not expand type of lambda expression"));
   // inline namespaces
   EXPECT_EQ(apply("au^to x = inl_ns::Visible();"),
-              "Visible x = inl_ns::Visible();");
   // local class
   EXPECT_EQ(apply("namespace x { void y() { struct S{}; ^auto z = S(); } }"),
             "namespace x { void y() { struct S{}; S z = S(); } }");
   // replace array types
   EXPECT_EQ(apply(R"cpp(au^to x = "test")cpp"),
             R"cpp(const char * x = "test")cpp");
 }
 
EXPECT_THAT(apply(" [[while(1) switch(1) { continue; }]]"),
               HasSubstr("extracted"));
   // Don't extract break and continue without a loop/switch parent.
   EXPECT_THAT(apply(" for(;;) [[if(1) continue;]] "), StartsWith("fail"));
   EXPECT_THAT(apply(" while(1) [[if(1) break;]] "), StartsWith("fail"));
   EXPECT_THAT(apply(" switch(1) { [[break;]] }"), StartsWith("fail"));
   EXPECT_THAT(apply(" for(;;) { [[while(1) break; break;]] }"),
               StartsWith("fail"));
 }
+
+TWEAK_TEST(RemoveUsingNamespace);
+TEST_F(RemoveUsingNamespaceTest, All) {
+  std::pair<llvm::StringRef /*Input*/, llvm::StringRef /*Expected*/> Cases[] = {
+      {// Remove all occurrences of ns. Qualify only unqualified.
+       R"cpp(
+      namespace ns1 { struct vector {}; }
+      namespace ns2 { struct map {}; }
+      using namespace n^s1;
+      using namespace ns2;
+      using namespace ns1;
+      int main() {
+        ns1::vector v1;
+        vector v2;
+        map m1;
+      }
+    )cpp",
+       R"cpp(
+      namespace ns1 { struct vector {}; }
+      namespace ns2 { struct map {}; }
+      
+      using namespace ns2;
+      
+      int main() {
+        ns1::vector v1;
+        ns1::vector v2;
+        map m1;
+      }
+    )cpp"},
+      {// Ident to be qualified is a macro arg.
+       R"cpp(
+      #define DECLARE(x, y) x y
+      namespace ns { struct vector {}; }
+      using namespace n^s;
+      int main() {
+        DECLARE(ns::vector, v1);
+        DECLARE(vector, v2);
+      }
+    )cpp",
+       R"cpp(
+      #define DECLARE(x, y) x y
+      namespace ns { struct vector {}; }
+      
+      int main() {
+        DECLARE(ns::vector, v1);
+        DECLARE(ns::vector, v2);
+      }
+    )cpp"},
+      {// Nested namespace: Fully qualify ident from inner ns.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace aa::b^b;
+      int main() {
+        map m;
+      }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      
+      int main() {
+        aa::bb::map m;
+      }
+    )cpp"},
+      {// Nested namespace: Fully qualify ident from inner ns.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace a^a;
+      int main() {
+        bb::map m;
+      }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      
+      int main() {
+        aa::bb::map m;
+      }
+    )cpp"},
+      {// Typedef.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace a^a;
+      typedef bb::map map;
+      int main() { map M; }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      
+      typedef aa::bb::map map;
+      int main() { map M; }
+    )cpp"},
+      {// FIXME: Nested namespaces: Not aware of using ns decl of outer ns.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using name[[space aa::b]]b;
+      using namespace aa;
+      int main() {
+        map m;
+      }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      
+      using namespace aa;
+      int main() {
+        aa::bb::map m;
+      }
+    )cpp"},
+      {// Does not qualify ident from inner namespace.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace aa::bb;
+      using namespace a^a;
+      int main() {
+        map m;
+      }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace aa::bb;
+      
+      int main() {
+        map m;
+      }
+    )cpp"},
+      {// Available only for top level namespace decl.
+       R"cpp(
+        namespace aa {
+          namespace bb { struct map {}; }
+          using namespace b^b;
+        }
+        int main() { aa::map m; }
+    )cpp",
+       "unavailable"},
+      {// FIXME: Unavailable for namespaces containing using-namespace decl.
+       R"cpp(
+      namespace aa {
+        namespace bb { struct map {}; }
+        using namespace bb;
+      }
+      using namespace a^a;
+      int main() {
+        map m;
+      }
+    )cpp",
+       "unavailable"},
+      {R"cpp(
+      namespace a::b { struct Foo {}; }
+      using namespace a;
+      using namespace a::[[b]];
+      using namespace b;
+      int main() { Foo F;}
+    )cpp",
+       R"cpp(
+      namespace a::b { struct Foo {}; }
+      using namespace a;
+      
+      
+      int main() { a::b::Foo F;}
+    )cpp"},
+      {// Enumerators.
+       R"cpp(
+      namespace tokens {
+      enum Token {
+        comma, identifier, numeric
+      };
+      }
+      using namespace tok^ens;
+      int main() {
+        auto x = comma;
+      }
+    )cpp",
+       R"cpp(
+      namespace tokens {
+      enum Token {
+        comma, identifier, numeric
+      };
+      }
+      
+      int main() {
+        auto x = tokens::comma;
+      }
+    )cpp"},
+      {// inline namespaces.
+       R"cpp(
+      namespace std { inline namespace ns1 { inline namespace ns2 { struct vector {}; }}}
+      using namespace st^d;
+      int main() {
+        vector V;
+      }
+    )cpp",
+       R"cpp(
+      namespace std { inline namespace ns1 { inline namespace ns2 { struct vector {}; }}}
+      
+      int main() {
+        std::vector V;
+      }
+    )cpp"}};
+  for (auto C : Cases)
+    EXPECT_EQ(C.second, apply(C.first)) << C.first;
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang