[clang-rename] Support renaming qualified symbol

[hokein]

Summary

The patch adds a new feature for renaming qualified symbol references.
Unlike orginal clang-rename behavior, when renaming a qualified symbol to a new
qualified symbol (e.g "A::Foo" => "B::Bar"), this new rename behavior will
consider the prefix qualifiers of the symbol, and calculate the new prefix
qualifiers. It aims to add as few additional qualifiers as possible.

As this is an early version (only supports renaming classes), I don't change
current clang-rename interfaces at the moment, and would like to keep its
(command-line tool) behavior. So I added new interfaces for the prototype.
In the long run, these interfaces should be unified.

No functionality changes in original clang-rename command-line tool.

This patch also contains a few bug fixes of clang-rename which are discovered by
the new unittest:

• fix a potential nullptr accessment when class declaration doesn't have definition.
• add USRs of nested declartaions in "getNamedDeclFor".

[hokein]

A few updates.

[ioeric]

I think this is a great start!

First round with some nits.

clang-rename/RenamingAction.cpp

87

Comments.

clang-rename/RenamingAction.h

45

Comments. Same for other classes.

60

What is USRList?

clang-rename/USRFinder.cpp

139

nit: No braces for one-liners.

200

It is unclear to me what nested declarations are.

clang-rename/USRLocFinder.cpp

152

You don't need "clang::" here and elsewhere.

156

Variable names should be LLVM style.

157

Is this cast always safe?

169

nit: No braces around one-liners. Same below.

196

Comments.

196

I think this visitor deserves a file of its own.

368

Note this is not expected behavior for alias types which would always be skipped in this check.

466

Loc seems to be a bad name here. It is usually used for TypeLoc.

clang-rename/USRLocFinder.h

34

Comments.

[hokein]

Address review comments.

[hokein]

clang-rename/USRLocFinder.cpp

157

Yes, because we have checked the type of the TL is an elaborated type. I have changed to getAs which makes the indication more explicitly.

196

I'm not sure it is the right time to do it at the moment since it is in early stage. I'd keep it here. We can do it when needed.

368

Acked. Add a FIXME.

[ioeric]

clang-rename/USRFinder.cpp

200

But what is the nested name? Is it the nested name specifier? Of what?

clang-rename/USRLocFinder.cpp

195

I think this also does some renaming?

217

Could you be more specific in this FIXME? I don't quite get it. Maybe an example?

359

I think these are using shadows only?

clang-rename/USRLocFinder.h

35

Why use std::vector instead of tooling::Replacements?

[hokein]

Add comments and polish tests.

[hokein]

clang-rename/USRLocFinder.cpp

195

No, this class is only responsible for finding rename locations and other information which are used for renaming. The renaming stuff is done by USRSymbolRenamer.

217

You can also see the FIXME in the test.

359

These are interested UsingDecls which contain UsingShadowDecl of the symbol declarations being renamed.

clang-rename/USRLocFinder.h

35

Seems that we don't get many benefits from using tooling::Replacements here. This function could be called multiple times (for renaming multiple symbols), we need to merge/add all replacements in caller side. if using tooling::Replacements, we will merge twice (one is in the API implementation).

[ioeric]

clang-rename/USRLocFinder.cpp

195

Sure. I meant you should also document it.

359

Sure. But maybe also document it?

clang-rename/USRLocFinder.h

35

I think what we really want is AtomicChange. We shouldn't be using std::vector or std::set replacements anymore.

[hokein]

Use AtomicChange.

[hokein]

update comments.

clang-rename/USRLocFinder.cpp

359

I have documented it at the "UsingDecls" member definition.

clang-rename/USRLocFinder.h

35

Good idea. Done. I think we might still need to refine the interface in the future.

[ioeric]

Lg with a few nits.

clang-rename/RenamingAction.cpp

104

Maybe add a FIXME to fully replace this with AtomicChanges in the future?

clang-rename/USRLocFinder.h

36

I'd name this createRenameAtomicChanges for clarity.

[hokein]

Fix a few nits.

clang-rename/RenamingAction.h

 
 private:
   const std::vector<std::string> &NewNames, &PrevNames;
   const std::vector<std::vector<std::string>> &USRList;
   std::map<std::string, tooling::Replacements> &FileToReplaces;
   bool PrintLocations;
 };
 
+class QualifiedRenamingAction {
+public:
+  QualifiedRenamingAction(
+      const std::vector<std::string> &NewNames,
+      const std::vector<std::string> &OldNames,
+      const std::vector<std::vector<std::string>> &USRList,
+      std::map<std::string, tooling::Replacements> &FileToReplaces)
+      : NewNames(NewNames), OldNames(OldNames), USRList(USRList),
+        FileToReplaces(FileToReplaces) {}
+
+  std::unique_ptr<ASTConsumer> newASTConsumer();
+
+private:
+  const std::vector<std::string> &NewNames;
+  const std::vector<std::string> &OldNames;
+  const std::vector<std::vector<std::string>> &USRList;
+  std::map<std::string, tooling::Replacements> &FileToReplaces;
+};
+
 } // namespace rename
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H

clang-rename/RenamingAction.cpp

 
 private:
   const std::vector<std::string> &NewNames, &PrevNames;
   const std::vector<std::vector<std::string>> &USRList;
   std::map<std::string, tooling::Replacements> &FileToReplaces;
   bool PrintLocations;
 };
 
+class QualifiedRenamingASTConsumer : public ASTConsumer {
+public:
+  QualifiedRenamingASTConsumer(
+      const std::vector<std::string> &NewNames,
+      const std::vector<std::string> &OldNames,
+      const std::vector<std::vector<std::string>> &USRList,
+      std::map<std::string, tooling::Replacements> &FileToReplaces)
+      : NewNames(NewNames), OldNames(OldNames), USRList(USRList),
+        FileToReplaces(FileToReplaces) {}
+
+  void HandleTranslationUnit(ASTContext &Context) override {
+    for (unsigned I = 0; I < NewNames.size(); ++I)
+      HandleOneRename(Context, NewNames[I], OldNames[I], USRList[I]);
+  }
+
+  void HandleOneRename(ASTContext &Context, llvm::StringRef NewName,
+                       const std::string &OldName,
+                       const std::vector<std::string> &USRs) {
+    auto RenameLocs = getQualifiedRenameLocsOfUSRs(
+        USRs, OldName, NewName, Context.getTranslationUnitDecl());
+    for (const auto &Loc : RenameLocs) {
+      tooling::Replacement Replace(
+          Context.getSourceManager(),
+          CharSourceRange::getTokenRange(Loc.Begin, Loc.End), Loc.NewName);
+      llvm::Error Err = FileToReplaces[Replace.getFilePath()].add(Replace);
+      if (Err) {
+        llvm::errs() << "Renaming failed in " << Replace.getFilePath() << "! "
+                     << llvm::toString(std::move(Err)) << "\n";
+      }
+    }
+  }
+
+private:
+  const std::vector<std::string> &NewNames;
+  const std::vector<std::string> &OldNames;
+  const std::vector<std::vector<std::string>> &USRList;
+  std::map<std::string, tooling::Replacements> &FileToReplaces;
+};
+
 std::unique_ptr<ASTConsumer> RenamingAction::newASTConsumer() {
   return llvm::make_unique<RenamingASTConsumer>(NewNames, PrevNames, USRList,
                                                 FileToReplaces, PrintLocations);
 }
 
+std::unique_ptr<ASTConsumer> QualifiedRenamingAction::newASTConsumer() {
+  return llvm::make_unique<QualifiedRenamingASTConsumer>(
+      NewNames, OldNames, USRList, FileToReplaces);
+}
+
 } // namespace rename
 } // namespace clang

clang-rename/USRFinder.cpp

if (!Decl)
       return true;
     if (Name.empty()) {
       // Offset is used to find the declaration.
       if (!Start.isValid() || !Start.isFileID() || !End.isValid() ||
           !End.isFileID() || !isPointWithin(Start, End))
         return true;
     } else {
       // Fully qualified name is used to find the declaration.
-      if (Name != Decl->getQualifiedNameAsString())
+      if (Name != Decl->getQualifiedNameAsString() &&
+          Name != "::" + Decl->getQualifiedNameAsString()) {
         return true;
       }
+    }
     Result = Decl;
     return false;
   }
 
   // \brief Sets Result to Decl if Point is within Loc and Loc + Offset.
   // \returns false on success.
   bool setResult(const NamedDecl *Decl, SourceLocation Loc, unsigned Offset) {
     // FIXME: Add test for Offset == 0. Add test for Offset - 1 (vs -2 etc).
const NamedDecl *getNamedDeclAt(const ASTContext &Context,
   return Visitor.getNamedDecl();
 }
 
 const NamedDecl *getNamedDeclFor(const ASTContext &Context,
                                  const std::string &Name) {
   NamedDeclFindingASTVisitor Visitor(Name, Context);
   Visitor.TraverseDecl(Context.getTranslationUnitDecl());
 
+  // Also find all USRs of nested declarations.
+  NestedNameSpecifierLocFinder Finder(const_cast<ASTContext &>(Context));
+  for (const auto &Location : Finder.getNestedNameSpecifierLocations())
+    Visitor.handleNestedNameSpecifierLoc(Location);
+
   return Visitor.getNamedDecl();
 }
 
 std::string getUSRForDecl(const Decl *Decl) {
   llvm::SmallVector<char, 128> Buff;
 
   // FIXME: Add test for the nullptr case.
   if (Decl == nullptr || index::generateUSRForDecl(Decl, Buff))
     return "";
 
   return std::string(Buff.data(), Buff.size());
 }
 
 } // namespace rename
 } // namespace clang

clang-rename/USRFindingAction.cpp

for (const auto *PartialSpec : PartialSpecs) {
         addUSRsOfCtorDtors(PartialSpec);
     }
     addUSRsOfCtorDtors(TemplateDecl->getTemplatedDecl());
   }
 
   void addUSRsOfCtorDtors(const CXXRecordDecl *RecordDecl) {
     RecordDecl = RecordDecl->getDefinition();
 
+    // Skip if the CXXRecordDecl doesn't have definition.
+    if (!RecordDecl)
+      return;
+
     for (const auto *CtorDecl : RecordDecl->ctors())
       USRSet.insert(getUSRForDecl(CtorDecl));
 
     USRSet.insert(getUSRForDecl(RecordDecl->getDestructor()));
     USRSet.insert(getUSRForDecl(RecordDecl));
   }
 
   void addUSRsOfOverridenFunctions(const CXXMethodDecl *MethodDecl) {

clang-rename/USRLocFinder.h

 #include "clang/AST/AST.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace rename {
 
+struct NewNameReplacement {
+  SourceLocation Begin;
+  SourceLocation End;
+  std::string NewName;
+};
+
+std::vector<NewNameReplacement>
+getQualifiedRenameLocsOfUSRs(llvm::ArrayRef<std::string> USRs,
+                             llvm::StringRef OldName, llvm::StringRef NewName,
+                             Decl *TranslationUnitDecl);
+
 // FIXME: make this an AST matcher. Wouldn't that be awesome??? I agree!
 std::vector<SourceLocation>
 getLocationsOfUSRs(const std::vector<std::string> &USRs,
                    llvm::StringRef PrevName, Decl *Decl);
 
 } // namespace rename
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H

clang-rename/USRLocFinder.cpp

 #include "USRLocFinder.h"
 #include "USRFinder.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
+#include "clang/Tooling/Core/Lookup.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <cstddef>
 #include <set>
 #include <string>
 #include <vector>
 
 using namespace llvm;
private:
   }
 
   const std::set<std::string> USRSet;
   const std::string PrevName;
   std::vector<clang::SourceLocation> LocationsFound;
   const ASTContext &Context;
 };
 
+clang::SourceLocation StartLocationForType(clang::TypeLoc TL) {
+  // For elaborated types (e.g. `struct a::A`) we want the portion after the
+  // `struct` but including the namespace qualifier, `a::`.
+  if (TL.getTypeLocClass() == clang::TypeLoc::Elaborated) {
+    clang::NestedNameSpecifierLoc nested_name_specifier =
+        TL.castAs<clang::ElaboratedTypeLoc>().getQualifierLoc();
+    if (nested_name_specifier.getNestedNameSpecifier())
+      return nested_name_specifier.getBeginLoc();
+    TL = TL.getNextTypeLoc();
+  }
+  return TL.getLocStart();
+}
+
+clang::SourceLocation EndLocationForType(clang::TypeLoc TL) {
+  // Dig past any namespace or keyword qualifications.
+  while (TL.getTypeLocClass() == clang::TypeLoc::Elaborated ||
+         TL.getTypeLocClass() == clang::TypeLoc::Qualified) {
+    TL = TL.getNextTypeLoc();
+  }
+
+  // The location for template specializations (e.g. Foo<int>) includes the
+  // templated types in its location range.  We want to restrict this to just
+  // before the `<` character.
+  if (TL.getTypeLocClass() == clang::TypeLoc::TemplateSpecialization) {
+    return TL.castAs<clang::TemplateSpecializationTypeLoc>()
+        .getLAngleLoc()
+        .getLocWithOffset(-1);
+  }
+  return TL.getEndLoc();
+}
+
+clang::NestedNameSpecifier *GetNestedNameForType(clang::TypeLoc TL) {
+  // Dig past any keyword qualifications.
+  while (TL.getTypeLocClass() == clang::TypeLoc::Qualified) {
+    TL = TL.getNextTypeLoc();
+  }
+
+  // For elaborated types (e.g. `struct a::A`) we want the portion after the
+  // `struct` but including the namespace qualifier, `a::`.
+  if (auto ElaboratedTypeLoc = TL.getAs<clang::ElaboratedTypeLoc>())
+    return ElaboratedTypeLoc.getQualifierLoc().getNestedNameSpecifier();
+  return nullptr;
+}
+
+class RenameLocFindingASTVisitor
+    : public clang::RecursiveASTVisitor<RenameLocFindingASTVisitor> {
+public:
+  RenameLocFindingASTVisitor(llvm::ArrayRef<std::string> USRs,
+                             ASTContext &Context)
+      : USRSet(USRs.begin(), USRs.end()), Context(Context) {}
+
+  // A structure records all information of a symbol reference being renamed.
+  // We try to add as few prefix qualifiers as possible.
+  struct RenameInfo {
+    // The begin location of a symbol being renamed.
+    SourceLocation Begin;
+    // The end location of a symbol being renamed.
+    SourceLocation End;
+    // The declaration of a symbol being renamed (can be nullptr).
+    const NamedDecl *FromDecl;
+    // The declaration in which the nested name is contained (can be nullptr).
+    const Decl *Context;
+    // The nested name being replaced (can be nullptr).
+    const NestedNameSpecifier *Specifier;
+  };
+
+  // FIXME: For renaming declarations/definitions, prefix qualifiers should be
+  // filtered out.
+  bool VisitNamedDecl(const NamedDecl *Decl) {
+    // UsingDecl has been handled in other place.
+    if (llvm::isa<UsingDecl>(Decl))
+      return true;
+
+    // DestructorDecl has been handled in Typeloc.
+    if (llvm::isa<CXXDestructorDecl>(Decl))
+      return true;
+
+    if (Decl->isImplicit())
+      return true;
+
+    if (isInUSRSet(Decl)) {
+      RenameInfo Info = {Decl->getLocation(), Decl->getLocation(), nullptr,
+                         nullptr, nullptr};
+      RenameInfos.push_back(Info);
+    }
+    return true;
+  }
+
+  bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
+    const NamedDecl *Decl = Expr->getFoundDecl();
+    if (isInUSRSet(Decl)) {
+      RenameInfo Info = {Expr->getSourceRange().getBegin(),
+                         Expr->getSourceRange().getEnd(), Decl,
+                         getClosestAncestorDecl(*Expr), Expr->getQualifier()};
+      RenameInfos.push_back(Info);
+    }
+
+    return true;
+  }
+
+  bool VisitUsingDecl(const clang::UsingDecl *Using) {
+    for (const auto *UsingShadow : Using->shadows()) {
+      if (isInUSRSet(UsingShadow->getTargetDecl())) {
+        UsingDecls.push_back(Using);
+        break;
+      }
+    }
+    return true;
+  }
+
+  bool VisitNestedNameSpecifierLocations(NestedNameSpecifierLoc NestedLoc) {
+    if (!NestedLoc.getNestedNameSpecifier()->getAsType())
+      return true;
+    if (IsTypeAliasWhichWillBeRenamedElsewhere(NestedLoc.getTypeLoc()))
+      return true;
+
+    if (const auto *TargetDecl =
+            getSupportedDeclFromTypeLoc(NestedLoc.getTypeLoc())) {
+      if (isInUSRSet(TargetDecl)) {
+        RenameInfo Info = {NestedLoc.getBeginLoc(),
+                           EndLocationForType(NestedLoc.getTypeLoc()),
+                           TargetDecl, getClosestAncestorDecl(NestedLoc),
+                           NestedLoc.getNestedNameSpecifier()->getPrefix()};
+        RenameInfos.push_back(Info);
+      }
+    }
+    return true;
+  }
+
+  bool VisitTypeLoc(TypeLoc Loc) {
+    if (IsTypeAliasWhichWillBeRenamedElsewhere(Loc))
+      return true;
+
+    auto Parents = Context.getParents(Loc);
+    TypeLoc ParentTypeLoc;
+    if (!Parents.empty()) {
+      // Handle cases of nested name specificier locations.
+      //
+      // The VisitNestedNameSpecifierLoc interface is not impelmented in
+      // RecursiveASTVisitor, we have to handle it explicitly.
+      if (const auto *NSL = Parents[0].get<clang::NestedNameSpecifierLoc>()) {
+        VisitNestedNameSpecifierLocations(*NSL);
+        return true;
+      }
+
+      if (const auto *TL = Parents[0].get<clang::TypeLoc>()) {
+        ParentTypeLoc = *TL;
+      }
+    }
+
+    // Handle the outer most TypeLoc which is directly linked to the interesting
+    // declaration and don't handle nested name specifier locations.
+    if (const auto *TargetDecl = getSupportedDeclFromTypeLoc(Loc)) {
+      if (isInUSRSet(TargetDecl)) {
+        // Only handle the outmost typeLoc.
+        //
+        // For a type like "a::Foo", there will be two typeLocs for it.
+        // One ElaboratedType, the other is RecordType:
+        //
+        //   ElaboratedType 0x33b9390 'a::Foo' sugar
+        //   `-RecordType 0x338fef0 'class a::Foo'
+        //     `-CXXRecord 0x338fe58 'Foo'
+        //
+        // Skip if this is an inner typeLoc.
+        if (!ParentTypeLoc.isNull() &&
+            isInUSRSet(getSupportedDeclFromTypeLoc(ParentTypeLoc))) {
+          return true;
+        }
+        RenameInfo Info = {StartLocationForType(Loc), EndLocationForType(Loc),
+                           TargetDecl, getClosestAncestorDecl(Loc),
+                           GetNestedNameForType(Loc)};
+        RenameInfos.push_back(Info);
+        return true;
+      }
+    }
+
+    // Handle specific template class specialiation cases.
+    if (const auto *TemplateSpecType =
+            dyn_cast<TemplateSpecializationType>(Loc.getType())) {
+      TypeLoc TargetLoc = Loc;
+      if (!ParentTypeLoc.isNull()) {
+        if (llvm::isa<ElaboratedType>(ParentTypeLoc.getType()))
+          TargetLoc = ParentTypeLoc;
+      }
+
+      if (isInUSRSet(TemplateSpecType->getTemplateName().getAsTemplateDecl())) {
+        TypeLoc TargetLoc = Loc;
+        // FIXME: Find a better way to handle this case.
+        // For the qualified template class specification type like
+        // "ns::Foo<int>" in "ns::Foo<int>& f();", we want the parent typeLoc
+        // (ElaboratedType) of the TemplateSpecializationType in order to
+        // catch the prefix qualifiers "ns::".
+        if (!ParentTypeLoc.isNull() &&
+            llvm::isa<ElaboratedType>(ParentTypeLoc.getType()))
+          TargetLoc = ParentTypeLoc;
+        RenameInfo Info = {
+            StartLocationForType(TargetLoc), EndLocationForType(TargetLoc),
+            TemplateSpecType->getTemplateName().getAsTemplateDecl(),
+            getClosestAncestorDecl(
+                ast_type_traits::DynTypedNode::create(TargetLoc)),
+            GetNestedNameForType(TargetLoc)};
+        RenameInfos.push_back(Info);
+      }
+    }
+    return true;
+  }
+
+  // Returns a list of RenameInfo.
+  const std::vector<RenameInfo> &getRenameInfos() const { return RenameInfos; }
+
+  // Returns a list of using declarations which are needed to update.
+  const std::vector<const UsingDecl *> &getUsingDecls() const {
+    return UsingDecls;
+  }
+
+private:
+  bool IsTypeAliasWhichWillBeRenamedElsewhere(clang::TypeLoc TL) const {
+    while (!TL.isNull()) {
+      // SubstTemplateTypeParm is the TypeLocation class for a substituted type
+      // inside a template expansion so we ignore these.  For example:
+      //
+      // template<typename T> struct S {
+      //   T t;  // <-- this T becomes a TypeLoc(int) with class
+      //         //     SubstTemplateTypeParm when S<int> is instantiated
+      // }
+      if (TL.getTypeLocClass() == clang::TypeLoc::SubstTemplateTypeParm) {
+        return true;
+      }
+
+      // Typedef is the TypeLocation class for a type which is a typedef to the
+      // type we want to replace.  We ignore the use of the typedef as we will
+      // replace the definition of it.  For example:
+      //
+      // typedef int T;
+      // T a;  // <---  This T is a TypeLoc(int) with class Typedef.
+      if (TL.getTypeLocClass() == clang::TypeLoc::Typedef) {
+        return true;
+      }
+      TL = TL.getNextTypeLoc();
+    }
+    return false;
+  }
+
+  // Get the supported declaration from a given typeLoc. If the declaration type
+  // is not supported, returns nullptr.
+  //
+  // FIXME: support more types, e.g. enum, type alias.
+  const NamedDecl *getSupportedDeclFromTypeLoc(TypeLoc Loc) {
+    if (const auto *RD = Loc.getType()->getAsCXXRecordDecl())
+      return RD;
+    return nullptr;
+  }
+
+  // Get the closest ancester which is a declaration of a given AST node.
+  template <typename ASTNodeType>
+  const Decl *getClosestAncestorDecl(ASTNodeType Node) {
+    auto Parents = Context.getParents(Node);
+    // FIXME: figure out how to handle it when there are multiple parents.
+    if (Parents.size() != 1)
+      return nullptr;
+    if (ast_type_traits::ASTNodeKind::getFromNodeKind<Decl>().isBaseOf(
+            Parents[0].getNodeKind())) {
+      return Parents[0].template get<clang::Decl>();
+    }
+    return getClosestAncestorDecl(Parents[0]);
+  }
+
+  // Get the parent typeLoc of a given typeLoc. If there is no such parent,
+  // return nullptr.
+  const TypeLoc *getParentTypeLoc(TypeLoc Loc) const {
+    auto Parents = Context.getParents(Loc);
+    // FIXME: figure out how to handle it when there are multiple parents.
+    if (Parents.size() != 1)
+      return nullptr;
+    return Parents[0].get<clang::TypeLoc>();
+  }
+
+  // Check whether the USR of a given Decl is in the USRSet.
+  bool isInUSRSet(const Decl *Decl) const {
+    auto USR = getUSRForDecl(Decl);
+    if (USR.empty())
+      return false;
+    return llvm::is_contained(USRSet, USR);
+  }
+
+  const std::set<std::string> USRSet;
+  ASTContext &Context;
+  std::vector<RenameInfo> RenameInfos;
+  std::vector<const UsingDecl *> UsingDecls;
+};
+
 } // namespace
 
 std::vector<SourceLocation>
 getLocationsOfUSRs(const std::vector<std::string> &USRs, StringRef PrevName,
                    Decl *Decl) {
   USRLocFindingASTVisitor Visitor(USRs, PrevName, Decl->getASTContext());
   Visitor.TraverseDecl(Decl);
   NestedNameSpecifierLocFinder Finder(Decl->getASTContext());
 
   for (const auto &Location : Finder.getNestedNameSpecifierLocations())
     Visitor.handleNestedNameSpecifierLoc(Location);
 
   return Visitor.getLocationsFound();
 }
 
+std::vector<NewNameReplacement>
+getQualifiedRenameLocsOfUSRs(llvm::ArrayRef<std::string> USRs,
+                             llvm::StringRef OldName, llvm::StringRef NewName,
+                             Decl *TranslationUnitDecl) {
+  RenameLocFindingASTVisitor Finder(USRs, TranslationUnitDecl->getASTContext());
+  Finder.TraverseDecl(TranslationUnitDecl);
+  std::vector<NewNameReplacement> NewNameReplacements;
+
+  for (const auto &Loc : Finder.getRenameInfos()) {
+    std::string ReplacedName = NewName.str();
+    if (Loc.FromDecl && Loc.Context) {
+      if (!llvm::isa<clang::TranslationUnitDecl>(
+              Loc.Context->getDeclContext())) {
+        ReplacedName = clang::tooling::replaceNestedName(
+            Loc.Specifier, Loc.Context->getDeclContext(), Loc.FromDecl,
+            NewName.startswith("::") ? NewName.str() : ("::" + NewName).str());
+      }
+    }
+    // If the NewName contains leading "::", add it back.
+    if (NewName.startswith("::") && NewName.substr(2) == ReplacedName)
+      ReplacedName = NewName.str();
+    NewNameReplacements.push_back(
+        NewNameReplacement{Loc.Begin, Loc.End, ReplacedName});
+  }
+
+  // Hanlde using declarations explicitly.
+  for (const auto *Using : Finder.getUsingDecls()) {
+    NewNameReplacements.push_back(NewNameReplacement{
+        Using->getLocStart(), Using->getLocEnd(), "using " + NewName.str()});
+  }
+
+  return NewNameReplacements;
+}
+
 } // namespace rename
 } // namespace clang

unittests/clang-rename/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 get_filename_component(CLANG_RENAME_SOURCE_DIR
   ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-rename REALPATH)
 include_directories(
   ${CLANG_RENAME_SOURCE_DIR}
   )
 
 # We'd like clang/unittests/Tooling/RewriterTestContext.h in the test.
 include_directories(${CLANG_SOURCE_DIR})
 
 add_extra_unittest(ClangRenameTests
-  ClangRenameTests.cpp
+  RenameClassTest.cpp
   )
 
 target_link_libraries(ClangRenameTests
   clangAST
   clangASTMatchers
   clangBasic
   clangFormat
   clangFrontend
   clangRename
   clangRewrite
   clangTooling
   clangToolingCore
   )

unittests/clang-rename/ClangRenameTest.h

 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clang_rename {
-namespace {
+namespace test {
 
 struct Case {
   std::string Before;
   std::string After;
+  std::string OldName;
+  std::string NewName;
 };
 
 class ClangRenameTest : public testing::Test,
                         public testing::WithParamInterface<Case> {
 protected:
-  void AppendToHeader(StringRef Code) {
-    HeaderContent += Code.str();
-  }
+  void AppendToHeader(StringRef Code) { HeaderContent += Code.str(); }
 
   std::string runClangRenameOnCode(llvm::StringRef Code,
                                    llvm::StringRef OldName,
                                    llvm::StringRef NewName) {
     std::string NewCode;
     llvm::raw_string_ostream(NewCode) << llvm::format(
         "#include \"%s\"\n%s", HeaderName.c_str(), Code.str().c_str());
     tooling::FileContentMappings FileContents = {{HeaderName, HeaderContent},
if (!tooling::runToolOnCodeWithArgs(
             FileContents))
       return "";
 
     const std::vector<std::vector<std::string>> &USRList =
         FindingAction.getUSRList();
     const std::vector<std::string> &PrevNames = FindingAction.getUSRSpellings();
     std::vector<std::string> NewNames = {NewName};
     std::map<std::string, tooling::Replacements> FileToReplacements;
-    rename::RenamingAction RenameAction(NewNames, PrevNames, USRList,
+    rename::QualifiedRenamingAction RenameAction(NewNames, PrevNames, USRList,
                                                  FileToReplacements);
     auto RenameActionFactory = tooling::newFrontendActionFactory(&RenameAction);
     if (!tooling::runToolOnCodeWithArgs(
             RenameActionFactory->create(), NewCode, {"-std=c++11"}, CCName,
             "clang-rename", std::make_shared<PCHContainerOperations>(),
             FileContents))
       return "";
 
     formatAndApplyAllReplacements(FileToReplacements, Context.Rewrite, "llvm");
std::string format(llvm::StringRef Code) {
     return *ChangedCode;
   }
 
   std::string HeaderContent;
   std::string HeaderName = "header.h";
   std::string CCName = "input.cc";
 };
 
-class RenameClassTest : public ClangRenameTest {
- public:
-  RenameClassTest() {
-    AppendToHeader("\nclass Foo {};\n");
-  }
-};
-
-INSTANTIATE_TEST_CASE_P(
-    RenameTests, RenameClassTest,
-    testing::ValuesIn(std::vector<Case>({
-      {"Foo f;", "Bar f;"},
-      {"void f(Foo f) {}", "void f(Bar f) {}"},
-      {"void f(Foo *f) {}", "void f(Bar *f) {}"},
-      {"Foo f() { return Foo(); }", "Bar f() { return Bar(); }"},
-    })));
-
-TEST_P(RenameClassTest, RenameClasses) {
-  auto Param = GetParam();
-  std::string OldName = "Foo";
-  std::string NewName = "Bar";
-  std::string Actual = runClangRenameOnCode(Param.Before, OldName, NewName);
-  CompareSnippets(Param.After, Actual);
-}
-
-class RenameFunctionTest : public ClangRenameTest {};
-
-INSTANTIATE_TEST_CASE_P(
-    RenameTests, RenameFunctionTest,
-    testing::ValuesIn(std::vector<Case>({
-      {"void func1() {}", "void func2() {}"},
-    })));
-
-TEST_P(RenameFunctionTest, RenameFunctions) {
-  auto Param = GetParam();
-  std::string OldName = "func1";
-  std::string NewName = "func2";
-  std::string Actual = runClangRenameOnCode(Param.Before, OldName, NewName);
-  CompareSnippets(Param.After, Actual);
-}
-
-} // anonymous namespace
+} // namespace test
 } // namespace clang_rename
 } // namesdpace clang

unittests/clang-rename/RenameClassTest.cpp

+//===-- RenameClassesTests.cpp - unit tests for renaming classes ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangRenameTest.h"
+
+namespace clang {
+namespace clang_rename {
+namespace test {
+namespace {
+
+class RenameClassTest : public ClangRenameTest {
+public:
+  RenameClassTest() {
+    AppendToHeader(R"(
+      namespace a {
+        class Foo {
+          public:
+            struct Nested {
+              enum NestedEnum {E1, E2};
+            };
+            void func() {}
+        };
+        class Goo {
+          public:
+            struct Nested {
+              enum NestedEnum {E1, E2};
+            };
+        };
+      } // namespace a
+      namespace b {
+      class Foo {};
+      } // namespace b
+
+      #define MACRO(x) x
+
+      template<typename T> class ptr {};
+    )");
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(
+    RenameClassTests, RenameClassTest,
+    testing::ValuesIn(std::vector<Case>({
+        // basic classes
+        {"a::Foo f;", "b::Bar f;", "a::Foo", "b::Bar"},
+        {"void f(a::Foo f) {}", "void f(b::Bar f) {}", "a::Foo", "b::Bar"},
+        {"void f(a::Foo *f) {}", "void f(b::Bar *f) {}", "a::Foo", "b::Bar"},
+        {"a::Foo f() { return a::Foo(); }", "b::Bar f() { return b::Bar(); }",
+         "a::Foo", "b::Bar"},
+        {"namespace a {a::Foo f() { return Foo(); }}",
+         "namespace a {b::Bar f() { return b::Bar(); }}", "a::Foo", "b::Bar"},
+        {"void f(const a::Foo& a1) {}", "void f(const b::Bar& a1) {}", "a::Foo",
+         "b::Bar"},
+        {"void f(const a::Foo* a1) {}", "void f(const b::Bar* a1) {}", "a::Foo",
+         "b::Bar"},
+        {"namespace a { void f(Foo a1) {} }",
+         "namespace a { void f(b::Bar a1) {} }", "a::Foo", "b::Bar"},
+        {"void f(MACRO(a::Foo) a1) {}", "void f(MACRO(b::Bar) a1) {}", "a::Foo",
+         "b::Bar"},
+        {"void f(MACRO(a::Foo a1)) {}", "void f(MACRO(b::Bar a1)) {}", "a::Foo",
+         "b::Bar"},
+
+        // use namespace and typedefs
+        {"using a::Foo; Foo gA;", "using b::Bar; b::Bar gA;"},
+        {"using a::Foo; void f(Foo gA) {}", "using b::Bar; void f(Bar gA) {}"},
+        {"using a::Foo; namespace x { Foo gA; }",
+         "using b::Bar; namespace x { Bar gA; }"},
+        {"struct S { using T = a::Foo; T a_; };",
+         "struct S { using T = b::Bar; T a_; };"},
+        {"using T = a::Foo; T gA;", "using T = b::Bar; T gA;"},
+        {"typedef a::Foo T; T gA;", "typedef b::Bar T; T gA;"},
+        {"typedef MACRO(a::Foo) T; T gA;", "typedef MACRO(b::Bar) T; T gA;"},
+
+        // struct members and other oddities
+        {"struct S : public a::Foo {};", "struct S : public b::Bar {};"},
+        {"struct F { void f(a::Foo a1) {} };",
+         "struct F { void f(b::Bar a1) {} };"},
+        {"struct F { a::Foo a_; };", "struct F { b::Bar a_; };"},
+        {"struct F { ptr<a::Foo> a_; };", "struct F { ptr<b::Bar> a_; };"},
+
+        {"void f() { a::Foo::Nested ne; }", "void f() { b::Bar::Nested ne; }",
+         "a::Foo", "b::Bar"},
+        {"void f() { a::Goo::Nested ne; }", "void f() { a::Goo::Nested ne; }",
+         "a::Foo", "b::Bar"},
+        {"void f() { a::Foo::Nested::NestedEnum e; }",
+         "void f() { b::Bar::Nested::NestedEnum e; }", "a::Foo", "b::Bar"},
+        {"void f() { auto e = a::Foo::Nested::NestedEnum::E1; }",
+         "void f() { auto e = b::Bar::Nested::NestedEnum::E1; }", "a::Foo",
+         "b::Bar"},
+        {"void f() { auto e = a::Foo::Nested::E1; }",
+         "void f() { auto e = b::Bar::Nested::E1; }", "a::Foo", "b::Bar"},
+
+        // templates
+        {"template <typename T> struct Foo { T t; };\n"
+         "void f() { Foo<a::Foo> foo; }",
+         "template <typename T> struct Foo { T t; };\n"
+         "void f() { Foo<b::Bar> foo; }"},
+        {"template <typename T> struct Foo { a::Foo a; };",
+         "template <typename T> struct Foo { b::Bar a; };"},
+        {"template <typename T> void f(T t) {}\n"
+         "void g() { f<a::Foo>(a::Foo()); }",
+         "template <typename T> void f(T t) {}\n"
+         "void g() { f<b::Bar>(b::Bar()); }"},
+        {"template <typename T> int f() { return 1; }\n"
+         "template <> int f<a::Foo>() { return 2; }\n"
+         "int g() { return f<a::Foo>(); }",
+         "template <typename T> int f() { return 1; }\n"
+         "template <> int f<b::Bar>() { return 2; }\n"
+         "int g() { return f<b::Bar>(); }"},
+        {"struct Foo { template <typename T> T foo(); };\n"
+         "void g() { Foo f;  auto a = f.template foo<a::Foo>(); }",
+         "struct Foo { template <typename T> T foo(); };\n"
+         "void g() { Foo f;  auto a = f.template foo<b::Bar>(); }"},
+
+        // The following two templates are distilled from regressions found in
+        // unique_ptr<> and type_traits.h
+        {"template <typename T> struct outer {\n"
+         "     typedef T type;\n"
+         "     type Baz();\n"
+         "    };\n"
+         "    outer<a::Foo> g_A;",
+         "template <typename T> struct outer {\n"
+         "      typedef T type;\n"
+         "      type Baz();\n"
+         "    };\n"
+         "    outer<b::Bar> g_A;"},
+        {"template <typename T> struct nested { typedef T type; };\n"
+         "template <typename T> struct outer { typename nested<T>::type Foo(); "
+         "};\n"
+         "outer<a::Foo> g_A;",
+         "template <typename T> struct nested { typedef T type; };\n"
+         "template <typename T> struct outer { typename nested<T>::type Foo(); "
+         "};\n"
+         "outer<b::Bar> g_A;"},
+
+        // macros
+        {"#define FOO(T, t) T t\n"
+         "void f() { FOO(a::Foo, a1); FOO(a::Foo, a2); }",
+         "#define FOO(T, t) T t\n"
+         "void f() { FOO(b::Bar, a1); FOO(b::Bar, a2); }"},
+        {"#define FOO(n) a::Foo n\n"
+         " void f() { FOO(a1); FOO(a2); }",
+         "#define FOO(n) b::Bar n\n"
+         " void f() { FOO(a1); FOO(a2); }"},
+
+        // Pointer to member functions
+        {"auto gA = &a::Foo::func;", "auto gA = &b::Bar::func;"},
+        {"using a::Foo; auto gA = &Foo::func;",
+         "using b::Bar; auto gA = &b::Bar::func;"},
+        {"using a::Foo; namespace x { auto gA = &Foo::func; }",
+         "using b::Bar; namespace x { auto gA = &Bar::func; }"},
+        {"typedef a::Foo T; auto gA = &T::func;",
+         "typedef b::Bar T; auto gA = &T::func;"},
+        {"auto gA = &MACRO(a::Foo)::func;", "auto gA = &MACRO(b::Bar)::func;"},
+
+        // Short match inside a namespace
+        {"namespace a { void f(Foo a1) {} }",
+         "namespace a { void f(b::Bar a1) {} }"},
+
+        // Correct match.
+        {"using a::Foo; struct F { ptr<Foo> a_; };",
+         "using b::Bar; struct F { ptr<Bar> a_; };"},
+
+        // avoid false positives
+        {"void f(b::Foo a) {}", "void f(b::Foo a) {}"},
+        {"namespace b { void f(Foo a) {} }",
+         "namespace b { void f(Foo a) {} }"},
+
+        // friends, everyone needs friends.
+        {"class Foo { int i; friend class a::Foo; };",
+         "class Foo { int i; friend class b::Bar; };"},
+    })));
+
+TEST_P(RenameClassTest, RenameClasses) {
+  auto Param = GetParam();
+  std::string OldName = "a::Foo";
+  std::string NewName = "b::Bar";
+  std::string Actual = runClangRenameOnCode(Param.Before, OldName, NewName);
+  CompareSnippets(Param.After, Actual);
+}
+
+class NamespaceDetectionTest : public ClangRenameTest {
+protected:
+  NamespaceDetectionTest() {
+    AppendToHeader(R"(
+         class Old {};
+         namespace o1 {
+         class Old {};
+         namespace o2 {
+         class Old {};
+         namespace o3 {
+         class Old {};
+         }  // namespace o3
+         }  // namespace o2
+         }  // namespace o1
+     )");
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(
+    RenameClassTest, NamespaceDetectionTest,
+    ::testing::ValuesIn(std::vector<Case>({
+        // Test old and new namespace overlap.
+        {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
+         "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
+         "o1::o2::o3::Old", "o1::o2::o3::New"},
+        {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
+         "namespace o1 { namespace o2 { namespace o3 { n3::New moo; } } }",
+         "o1::o2::o3::Old", "o1::o2::n3::New"},
+        {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
+         "namespace o1 { namespace o2 { namespace o3 { n2::n3::New moo; } } }",
+         "o1::o2::o3::Old", "o1::n2::n3::New"},
+        {"namespace o1 { namespace o2 { Old moo; } }",
+         "namespace o1 { namespace o2 { New moo; } }", "::o1::o2::Old",
+         "::o1::o2::New"},
+        {"namespace o1 { namespace o2 { Old moo; } }",
+         "namespace o1 { namespace o2 { n2::New moo; } }", "::o1::o2::Old",
+         "::o1::n2::New"},
+        {"namespace o1 { namespace o2 { Old moo; } }",
+         "namespace o1 { namespace o2 { ::n1::n2::New moo; } }",
+         "::o1::o2::Old", "::n1::n2::New"},
+        {"namespace o1 { namespace o2 { Old moo; } }",
+         "namespace o1 { namespace o2 { n1::n2::New moo; } }", "::o1::o2::Old",
+         "n1::n2::New"},
+
+        // Test old and new namespace with differing depths.
+        {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
+         "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
+         "o1::o2::o3::Old", "::o1::New"},
+        {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
+         "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
+         "o1::o2::o3::Old", "::o1::o2::New"},
+        {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
+         "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
+         "o1::o2::o3::Old", "o1::New"},
+        {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
+         "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
+         "o1::o2::o3::Old", "o1::o2::New"},
+        {"Old moo;", "o1::New moo;", "::Old", "o1::New"},
+        {"Old moo;", "o1::New moo;", "Old", "o1::New"},
+        {"namespace o1 { ::Old moo; }", "namespace o1 { New moo; }", "Old",
+         "o1::New"},
+        {"namespace o1 { namespace o2 {  Old moo; } }",
+         "namespace o1 { namespace o2 {  ::New moo; } }", "::o1::o2::Old",
+         "::New"},
+        {"namespace o1 { namespace o2 {  Old moo; } }",
+         "namespace o1 { namespace o2 {  New moo; } }", "::o1::o2::Old", "New"},
+
+        // Test moving into the new namespace at different levels.
+        {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
+         "namespace n1 { namespace n2 { New moo; } }", "::o1::o2::Old",
+         "::n1::n2::New"},
+        {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
+         "namespace n1 { namespace n2 { New moo; } }", "::o1::o2::Old",
+         "n1::n2::New"},
+        {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
+         "namespace n1 { namespace n2 { o2::New moo; } }", "::o1::o2::Old",
+         "::n1::o2::New"},
+        {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
+         "namespace n1 { namespace n2 { o2::New moo; } }", "::o1::o2::Old",
+         "n1::o2::New"},
+        {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
+         "namespace n1 { namespace n2 { ::o1::o2::New moo; } }",
+         "::o1::o2::Old", "::o1::o2::New"},
+        {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
+         "namespace n1 { namespace n2 { o1::o2::New moo; } }", "::o1::o2::Old",
+         "o1::o2::New"},
+
+        // Test friends declarations.
+        {"class Foo { friend class o1::Old; };",
+         "class Foo { friend class o1::New; };", "o1::Old", "o1::New"},
+        {"class Foo { int i; friend class o1::Old; };",
+         "class Foo { int i; friend class ::o1::New; };", "::o1::Old",
+         "::o1::New"},
+        {"namespace o1 { class Foo { int i; friend class Old; }; }",
+         "namespace o1 { class Foo { int i; friend class New; }; }", "o1::Old",
+         "o1::New"},
+        {"namespace o1 { class Foo { int i; friend class Old; }; }",
+         "namespace o1 { class Foo { int i; friend class New; }; }",
+         "::o1::Old", "::o1::New"},
+    })));
+
+TEST_P(NamespaceDetectionTest, RenameClasses) {
+  auto Param = GetParam();
+  std::string Actual =
+      runClangRenameOnCode(Param.Before, Param.OldName, Param.NewName);
+  CompareSnippets(Param.After, Actual);
+}
+
+class TemplatedClassRenameTest : public ClangRenameTest {
+protected:
+  TemplatedClassRenameTest() {
+    AppendToHeader(R"(
+           template <typename T> struct Old {
+             T t_;
+             T f() { return T(); };
+             static T s(T t) { return t; }
+           };
+           namespace ns {
+           template <typename T> struct Old {
+             T t_;
+             T f() { return T(); };
+             static T s(T t) { return t; }
+           };
+           }  // namespace ns
+
+           namespace o1 {
+           namespace o2 {
+           namespace o3 {
+           template <typename T> struct Old {
+             T t_;
+             T f() { return T(); };
+             static T s(T t) { return t; }
+           };
+           }  // namespace o3
+           }  // namespace o2
+           }  // namespace o1
+       )");
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(
+    RenameClassTests, TemplatedClassRenameTest,
+    ::testing::ValuesIn(std::vector<Case>({
+        {"Old<int> gI; Old<bool> gB;", "New<int> gI; New<bool> gB;", "Old",
+         "New"},
+        {"ns::Old<int> gI; ns::Old<bool> gB;",
+         "ns::New<int> gI; ns::New<bool> gB;", "ns::Old", "ns::New"},
+        {"auto gI = &Old<int>::f; auto gB = &Old<bool>::f;",
+         "auto gI = &New<int>::f; auto gB = &New<bool>::f;", "Old", "New"},
+        {"auto gI = &ns::Old<int>::f;", "auto gI = &ns::New<int>::f;",
+         "ns::Old", "ns::New"},
+
+        {"int gI = Old<int>::s(0); bool gB = Old<bool>::s(false);",
+         "int gI = New<int>::s(0); bool gB = New<bool>::s(false);", "Old",
+         "New"},
+        {"int gI = ns::Old<int>::s(0); bool gB = ns::Old<bool>::s(false);",
+         "int gI = ns::New<int>::s(0); bool gB = ns::New<bool>::s(false);",
+         "ns::Old", "ns::New"},
+
+        {"struct S { Old<int*> o_; };", "struct S { New<int*> o_; };", "Old",
+         "New"},
+        {"struct S { ns::Old<int*> o_; };", "struct S { ns::New<int*> o_; };",
+         "ns::Old", "ns::New"},
+
+        {"auto a = reinterpret_cast<Old<int>*>(new Old<int>);",
+         "auto a = reinterpret_cast<New<int>*>(new New<int>);", "Old", "New"},
+        {"auto a = reinterpret_cast<ns::Old<int>*>(new ns::Old<int>);",
+         "auto a = reinterpret_cast<ns::New<int>*>(new ns::New<int>);",
+         "ns::Old", "ns::New"},
+        {"auto a = reinterpret_cast<const Old<int>*>(new Old<int>);",
+         "auto a = reinterpret_cast<const New<int>*>(new New<int>);", "Old",
+         "New"},
+        {"auto a = reinterpret_cast<const ns::Old<int>*>(new ns::Old<int>);",
+         "auto a = reinterpret_cast<const ns::New<int>*>(new ns::New<int>);",
+         "ns::Old", "ns::New"},
+
+        {"Old<bool>& foo();", "New<bool>& foo();", "Old", "New"},
+        {"ns::Old<bool>& foo();", "ns::New<bool>& foo();", "ns::Old",
+         "ns::New"},
+        {"o1::o2::o3::Old<bool>& foo();", "o1::o2::o3::New<bool>& foo();",
+         "o1::o2::o3::Old", "o1::o2::o3::New"},
+        {"namespace ns { Old<bool>& foo(); }",
+         "namespace ns { New<bool>& foo(); }", "ns::Old", "ns::New"},
+        {"const Old<bool>& foo();", "const New<bool>& foo();", "Old", "New"},
+        {"const ns::Old<bool>& foo();", "const ns::New<bool>& foo();",
+         "ns::Old", "ns::New"},
+
+        // FIXME: figure out why this only works when Moo gets
+        // specialized at some point.
+        {"template <typename T> struct Moo { Old<T> o_; }; Moo<int> m;",
+         "template <typename T> struct Moo { New<T> o_; }; Moo<int> m;", "Old",
+         "New"},
+        {"template <typename T> struct Moo { ns::Old<T> o_; }; Moo<int> m;",
+         "template <typename T> struct Moo { ns::New<T> o_; }; Moo<int> m;",
+         "ns::Old", "ns::New"},
+    })));
+
+TEST_P(TemplatedClassRenameTest, RenameTemplateClasses) {
+  auto Param = GetParam();
+  std::string Actual =
+      runClangRenameOnCode(Param.Before, Param.OldName, Param.NewName);
+  CompareSnippets(Param.After, Actual);
+}
+
+TEST_F(ClangRenameTest, RenameClassWithOutOfLineMembers) {
+  std::string Before = R"(
+      class Old {
+       public:
+        Old();
+        ~Old();
+
+        Old* next();
+
+       private:
+        Old* next_;
+      };
+
+      Old::Old() {}
+      Old::~Old() {}
+      Old* Old::next() { return next_; }
+    )";
+  std::string Expected = R"(
+      class New {
+       public:
+        New();
+        ~New();
+
+        New* next();
+
+       private:
+        New* next_;
+      };
+
+      New::New() {}
+      New::~New() {}
+      New* New::next() { return next_; }
+    )";
+  std::string After = runClangRenameOnCode(Before, "Old", "New");
+  CompareSnippets(Expected, After);
+}
+
+TEST_F(ClangRenameTest, RenameClassWithInlineMembers) {
+  std::string Before = R"(
+      class Old {
+       public:
+        Old() {}
+        ~Old() {}
+
+        Old* next() { return next_; }
+
+       private:
+        Old* next_;
+      };
+    )";
+  std::string Expected = R"(
+      class New {
+       public:
+        New() {}
+        ~New() {}
+
+        New* next() { return next_; }
+
+       private:
+        New* next_;
+      };
+    )";
+  std::string After = runClangRenameOnCode(Before, "Old", "New");
+  CompareSnippets(Expected, After);
+}
+
+// FIXME: no prefix qualifiers being added to the class definition and
+// constructor.
+TEST_F(ClangRenameTest, RenameClassWithNamespaceWithInlineMembers) {
+  std::string Before = R"(
+      namespace ns {
+      class Old {
+       public:
+        Old() {}
+        ~Old() {}
+
+        Old* next() { return next_; }
+
+       private:
+        Old* next_;
+      };
+      }  // namespace ns
+    )";
+  std::string Expected = R"(
+      namespace ns {
+      class ns::New {
+       public:
+        ns::New() {}
+        ~New() {}
+
+        New* next() { return next_; }
+
+       private:
+        New* next_;
+      };
+      }  // namespace ns
+    )";
+  std::string After = runClangRenameOnCode(Before, "ns::Old", "ns::New");
+  CompareSnippets(Expected, After);
+}
+
+// FIXME: no prefix qualifiers being added to the class definition and
+// constructor.
+TEST_F(ClangRenameTest, RenameClassWithNamespaceWithOutOfInlineMembers) {
+  std::string Before = R"(
+      namespace ns {
+      class Old {
+       public:
+        Old();
+        ~Old();
+
+        Old* next();
+
+       private:
+        Old* next_;
+      };
+
+      Old::Old() {}
+      Old::~Old() {}
+      Old* Old::next() { return next_; }
+      }  // namespace ns
+    )";
+  std::string Expected = R"(
+      namespace ns {
+      class ns::New {
+       public:
+        ns::New();
+        ~New();
+
+        New* next();
+
+       private:
+        New* next_;
+      };
+
+      New::ns::New() {}
+      New::~New() {}
+      New* New::next() { return next_; }
+      }  // namespace ns
+    )";
+  std::string After = runClangRenameOnCode(Before, "ns::Old", "ns::New");
+  CompareSnippets(Expected, After);
+}
+
+// FIXME: no prefix qualifiers being added to the definition.
+TEST_F(ClangRenameTest, RenameClassInInheritedConstructor) {
+  // `using Base::Base;` will generate an implicit constructor containing usage
+  // of `::ns::Old` which should not be matched.
+  std::string Before = R"(
+      namespace ns {
+      class Old {
+        int x;
+      };
+      class Base {
+       protected:
+        Old *moo_;
+       public:
+        Base(Old *moo) : moo_(moo) {}
+      };
+      class Derived : public Base {
+       public:
+         using Base::Base;
+      };
+      }  // namespace ns
+      int main() {
+        ::ns::Old foo;
+        ::ns::Derived d(&foo);
+        return 0;
+      })";
+  std::string Expected = R"(
+      namespace ns {
+      class ns::New {
+        int x;
+      };
+      class Base {
+       protected:
+        New *moo_;
+       public:
+        Base(New *moo) : moo_(moo) {}
+      };
+      class Derived : public Base {
+       public:
+         using Base::Base;
+      };
+      }  // namespace ns
+      int main() {
+        ::ns::New foo;
+        ::ns::Derived d(&foo);
+        return 0;
+      })";
+  std::string After = runClangRenameOnCode(Before, "ns::Old", "ns::New");
+  CompareSnippets(Expected, After);
+}
+
+TEST_F(ClangRenameTest, DontRenameReferencesInImplicitFunction) {
+  std::string Before = R"(
+      namespace ns {
+      class Old {
+      };
+      } // namespace ns
+      struct S {
+        int y;
+        ns::Old old;
+      };
+      void f() {
+        S s1, s2, s3;
+        // This causes an implicit assignment operator to be created.
+        s1 = s2 = s3;
+      }
+      )";
+  std::string Expected = R"(
+      namespace ns {
+      class ::new_ns::New {
+      };
+      } // namespace ns
+      struct S {
+        int y;
+        ::new_ns::New old;
+      };
+      void f() {
+        S s1, s2, s3;
+        // This causes an implicit assignment operator to be created.
+        s1 = s2 = s3;
+      }
+      )";
+  std::string After = runClangRenameOnCode(Before, "ns::Old", "::new_ns::New");
+  CompareSnippets(Expected, After);
+}
+
+// FIXME: no prefix qualifiers being adding to the definition.
+TEST_F(ClangRenameTest, ReferencesInLambdaFunctionParameters) {
+  std::string Before = R"(
+      template <class T>
+      class function;
+      template <class R, class... ArgTypes>
+      class function<R(ArgTypes...)> {
+      public:
+        template <typename Functor>
+        function(Functor f) {}
+
+        function() {}
+
+        R operator()(ArgTypes...) const {}
+      };
+
+      namespace ns {
+      class Old {};
+      void f() {
+        function<void(Old)> func;
+      }
+      }  // namespace ns)";
+  std::string Expected = R"(
+      template <class T>
+      class function;
+      template <class R, class... ArgTypes>
+      class function<R(ArgTypes...)> {
+      public:
+        template <typename Functor>
+        function(Functor f) {}
+
+        function() {}
+
+        R operator()(ArgTypes...) const {}
+      };
+
+      namespace ns {
+      class ::new_ns::New {};
+      void f() {
+        function<void(::new_ns::New)> func;
+      }
+      }  // namespace ns)";
+  std::string After = runClangRenameOnCode(Before, "ns::Old", "::new_ns::New");
+  CompareSnippets(Expected, After);
+}
+
+} // anonymous namespace
+} // namespace test
+} // namespace clang_rename
+} // namesdpace clang