[clangd] A code action to remove 'using namespace'

[ilya-biryukov]

Summary

Only available in the source files to fit into the model of single-file
actions. Doing the same in headers would require more complicated
machinery, which is out of scope of code actions.

[ilya-biryukov]

The most complicated of the sample actions, requires considerable work and thorough testing before it can be landed.
Serves the purpose of illustrating how to write the two-stage actions.

[ilya-biryukov]

• Update after changes to parent revision

[ilya-biryukov]

• Rebase after parent change

[ilya-biryukov]

• Update to reflect changes in parent revision

[ilya-biryukov]

• Remove the header file

[ilya-biryukov]

• Move to the monorepo

[ilya-biryukov]

• Rebase

[ilya-biryukov]

• Update license header

[ilya-biryukov]

This was finalized and landed as D68562

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);
 
 /// Gets the symbol ID for a declaration, if possible.
 llvm::Optional<SymbolID> getSymbolID(const Decl *D);
 

clang-tools-extra/clangd/AST.cpp

if (auto *Func = llvm::dyn_cast<FunctionDecl>(&ND))
     return Func->getTemplateSpecializationArgs();
   if (auto *Cls = llvm::dyn_cast<ClassTemplateSpecializationDecl>(&ND))
     return &Cls->getTemplateInstantiationArgs();
   if (auto *Var = llvm::dyn_cast<VarTemplateSpecializationDecl>(&ND))
     return &Var->getTemplateInstantiationArgs();
   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 ";
-    if (auto *Qual = UD->getQualifier())
-      Qual->print(Out, PP);
-    UD->getNominatedNamespaceAsWritten()->printName(Out);
+    Out << "using namespace " << printUsingNamespaceName(Ctx, *UD);
     return Out.str();
   }
   ND.getDeclName().print(Out, PP);
   if (!Out.str().empty()) {
     // FIXME(ibiryukov): do not show args not explicitly written by the user.
     if (auto *ArgList = getTemplateSpecializationArgs(ND))
       printTemplateArgumentList(Out, ArgList->asArray(), PP);
     return Out.str();

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

 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../..)
 
 # A target containing all code tweaks (i.e. mini-refactorings) provided by
 # clangd.
 # Built as an object library to make sure linker does not remove global
 # constructors that register individual tweaks in a global registry.
 # To enable these tweaks in exectubales or shared libraries, add
 # $<TARGET_OBJECTS:obj.clangDaemonTweaks> to a list of sources, see
 # clangd/tool/CMakeLists.txt for an example.
 add_clang_library(clangDaemonTweaks OBJECT
   QualifyName.cpp
+  RemoveUsingNamespace.cpp
   SwapIfBranches.cpp
   )

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

+//===--- RemoveUsingNamespace.cpp --------------------------------*- C++-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "AST.h"
+#include "ClangdUnit.h"
+#include "SourceCode.h"
+#include "refactor/Tweak.h"
+#include "clang/AST/RecursiveASTVisitor.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>);
+class RemoveUsingNamespace : public Tweak {
+public:
+  TweakID id() const override {
+    return llvm::StringLiteral("remove-using-namespace");
+  }
+
+  bool prepare(const Selection &Inputs) override;
+  Expected<tooling::Replacements> apply(const Selection &Inputs) override;
+  std::string title() const override;
+
+private:
+  UsingDirectiveDecl *TargetDirective = nullptr;
+};
+REGISTER_TWEAK(RemoveUsingNamespace);
+
+class FindNodeUnderCursor : public RecursiveASTVisitor<FindNodeUnderCursor> {
+public:
+  FindNodeUnderCursor(SourceLocation SearchedLoc, UsingDirectiveDecl *&Result)
+      : SearchedLoc(SearchedLoc), Result(Result) {}
+
+  bool VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
+    if (D->getUsingLoc() != SearchedLoc)
+      return true;
+
+    Result = D;
+    return false;
+  }
+
+private:
+  SourceLocation SearchedLoc;
+  UsingDirectiveDecl *&Result;
+};
+
+class FindSameUsings : public RecursiveASTVisitor<FindSameUsings> {
+public:
+  FindSameUsings(UsingDirectiveDecl &Target,
+                 std::vector<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:
+  NamespaceDecl *TargetNS;
+  DeclContext *TargetCtx;
+  std::vector<UsingDirectiveDecl *> &Results;
+};
+
+class FindIdentsToQualify
+    : public tooling::RecursiveSymbolVisitor<FindIdentsToQualify> {
+public:
+  FindIdentsToQualify(ASTContext &Ctx, NamespaceDecl &TargetNS,
+                      std::vector<SourceLocation> &ResultIdents)
+      : RecursiveSymbolVisitor(Ctx.getSourceManager(), Ctx.getLangOpts()),
+        Ctx(Ctx), TargetNS(TargetNS), ResultIdents(ResultIdents) {}
+
+  bool visitSymbolOccurrence(const NamedDecl *D,
+                             llvm::ArrayRef<SourceRange> NameRanges) {
+    if (!D || D->getCanonicalDecl() == TargetNS.getCanonicalDecl())
+      return true;
+    if (!D->getDeclName().isIdentifier() ||
+        D->getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
+      return true; // do not add qualifiers for non-idents, e.g. 'operator+'.
+    // Check the symbol is unqualified and references something inside our
+    // namespace.
+    // FIXME: add a check it's unqualified.
+    if (!TargetNS.InEnclosingNamespaceSetOf(D->getDeclContext()))
+      return true;
+    // FIXME: handle more tricky cases, e.g. we don't need the qualifier if we
+    //        have the using decls for some entities, we might have qualified
+    //        references that need updating too.
+    for (auto R : NameRanges) {
+      if (!Ctx.getSourceManager().isWrittenInMainFile(R.getBegin()))
+        continue; // we can't fix refences outside our file.
+                  // FIXME: this might be a conflict that we need to report.
+      ResultIdents.push_back(R.getBegin());
+    }
+    return true;
+  }
+
+  bool TraverseDecl(Decl *D) {
+    if (!Ctx.getSourceManager().isWrittenInMainFile(D->getLocation()) &&
+        !isa<TranslationUnitDecl>(D))
+      return true; // skip decls outside main file.
+    return RecursiveSymbolVisitor::TraverseDecl(D);
+  }
+
+private:
+  ASTContext &Ctx;
+  NamespaceDecl &TargetNS;
+  std::vector<SourceLocation> &ResultIdents;
+};
+
+// Produces an edit to remove 'using namespace xxx::yyy' and the trailing
+// semicolon.
+llvm::Expected<tooling::Replacement>
+removeUsingDirective(ASTContext &Ctx, UsingDirectiveDecl *D) {
+  auto &SrcMgr = Ctx.getSourceManager();
+  auto R =
+      Lexer::getAsCharRange(D->getSourceRange(), SrcMgr, Ctx.getLangOpts());
+  if (R.isInvalid())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid source range for using "
+                                   "directive");
+  SourceLocation EndLoc = R.getEnd();
+  auto NextTok = Lexer::findNextToken(EndLoc, SrcMgr, Ctx.getLangOpts());
+  if (!NextTok || NextTok->getKind() != tok::semi)
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "no semicolon after using-directive");
+  R.setEnd(NextTok->getEndLoc());
+  // 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(SrcMgr, R, "", Ctx.getLangOpts());
+}
+} // namespace
+  // namespace
+
+bool RemoveUsingNamespace::prepare(const Selection &Inputs) {
+  auto &Ctx = Inputs.AST.getASTContext();
+  // Find the 'using namespace' directive under the cursor.
+  TargetDirective = nullptr;
+  FindNodeUnderCursor(Inputs.Cursor, TargetDirective).TraverseAST(Ctx);
+  if (!TargetDirective)
+    return false;
+  auto *Parent = dyn_cast<Decl>(TargetDirective->getDeclContext());
+  if (!Parent)
+    return false;
+  return true;
+}
+
+Expected<tooling::Replacements>
+RemoveUsingNamespace::apply(const Selection &Inputs) {
+  auto &Ctx = Inputs.AST.getASTContext();
+  // First, collect *all* using namespace directives that redeclare the same
+  // namespace.
+  std::vector<UsingDirectiveDecl *> AllDirectives;
+  FindSameUsings(*TargetDirective, AllDirectives).TraverseAST(Ctx);
+  // Collect all references to symbols from the namespace for which we're
+  // removing the directive.
+  std::vector<SourceLocation> IdentsToQualify;
+  FindIdentsToQualify(Ctx, *TargetDirective->getNominatedNamespace(),
+                      IdentsToQualify)
+      .TraverseAST(Ctx);
+  // 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 R;
+}
+
+std::string RemoveUsingNamespace::title() const {
+  return llvm::formatv("Remove using namespace, add qualifiers instead");
+}
+} // namespace clangd
+} // namespace clang