[clang-tidy] Optimize performance of RenamerClangTidyCheck

[PiotrZSL]

Summary

Refactor RenamerClangTidyCheck to achieve better performance
by removing object copies, duplicated function calls and by
using RecursiveASTVisitor.

Measured -72% execution time on bugprone-reserved-identifier.

[njames93]

Mostly looks good, just a few small nits

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

48

What's the purpose of using hash_combine instead of just adding the 2 hashes together, there is enough entropy in the hashes that a simple operation makes more sense?

200–208

What is the reason for visiting template instantiations?

494

Instead of this nasty const cast, you can just use Visitor.TraverseAST(*Result.Context);

[PiotrZSL]

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

48

Habit, hash_combine sounded better here, I can change this to +.

200–208

Tests were failing, some method overrides are known only when we visit template instances. Without this code related to "Fix overridden methods" (line 281) were not executed properly.
And as an result overridden virtual methods in template classes were not "fixed". Previously it worked in same way.

494

Yes I know, but it looked strange when we register matcher for something, and then in check we don't use that something.
I can change this.

[PiotrZSL]

Use operator + instead of hash_combine.
Use TraverseAST.

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.h

struct NamingCheckFailure {
     ShouldFixStatus FixStatus = ShouldFixStatus::ShouldFix;
 
     /// A set of all the identifier usages starting SourceLocation.
     llvm::DenseSet<SourceLocation> RawUsageLocs;
 
     NamingCheckFailure() = default;
   };
 
-  using NamingCheckId = std::pair<SourceLocation, std::string>;
+  using NamingCheckId = std::pair<SourceLocation, StringRef>;
 
   using NamingCheckFailureMap =
       llvm::DenseMap<NamingCheckId, NamingCheckFailure>;
 
   /// Check Macros for style violations.
-  void checkMacro(SourceManager &SourceMgr, const Token &MacroNameTok,
+  void checkMacro(const SourceManager &SourceMgr, const Token &MacroNameTok,
                   const MacroInfo *MI);
 
   /// Add a usage of a macro if it already has a violation.
   void expandMacro(const Token &MacroNameTok, const MacroInfo *MI);
 
   void addUsage(const RenamerClangTidyCheck::NamingCheckId &Decl,
-                SourceRange Range, SourceManager *SourceMgr = nullptr);
+                SourceRange Range, const SourceManager *SourceMgr = nullptr);
 
   /// Convenience method when the usage to be added is a NamedDecl.
   void addUsage(const NamedDecl *Decl, SourceRange Range,
-                SourceManager *SourceMgr = nullptr);
+                const SourceManager *SourceMgr = nullptr);
+
+  void checkNamedDecl(const NamedDecl *Decl, const SourceManager &SourceMgr);
 
 protected:
   /// Overridden by derived classes, returns information about if and how a Decl
   /// failed the check. A 'std::nullopt' result means the Decl did not fail the
   /// check.
   virtual std::optional<FailureInfo>
   getDeclFailureInfo(const NamedDecl *Decl, const SourceManager &SM) const = 0;
 

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

 //===--- RenamerClangTidyCheck.cpp - clang-tidy ---------------------------===//
 //
 // 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 "RenamerClangTidyCheck.h"
 #include "ASTUtils.h"
 #include "clang/AST/CXXInheritance.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include <optional>
static inline NamingCheckId getTombstoneKey() {
     return NamingCheckId(DenseMapInfo<clang::SourceLocation>::getTombstoneKey(),
                          "TOMBSTONE");
   }
 
   static unsigned getHashValue(NamingCheckId Val) {
     assert(Val != getEmptyKey() && "Cannot hash the empty key!");
     assert(Val != getTombstoneKey() && "Cannot hash the tombstone key!");
 
-    std::hash<NamingCheckId::second_type> SecondHash;
     return DenseMapInfo<clang::SourceLocation>::getHashValue(Val.first) +
-           SecondHash(Val.second);
+           DenseMapInfo<StringRef>::getHashValue(Val.second);
   }
 
   static bool isEqual(const NamingCheckId &LHS, const NamingCheckId &RHS) {
     if (RHS == getEmptyKey())
       return LHS == getEmptyKey();
     if (RHS == getTombstoneKey())
       return LHS == getTombstoneKey();
     return LHS == RHS;
   }
 };
 
 } // namespace llvm
 
 namespace clang::tidy {
 
 namespace {
-
-/// Callback supplies macros to RenamerClangTidyCheck::checkMacro
-class RenamerClangTidyCheckPPCallbacks : public PPCallbacks {
-public:
-  RenamerClangTidyCheckPPCallbacks(Preprocessor *PP,
-                                   RenamerClangTidyCheck *Check)
-      : PP(PP), Check(Check) {}
-
-  /// MacroDefined calls checkMacro for macros in the main file
-  void MacroDefined(const Token &MacroNameTok,
-                    const MacroDirective *MD) override {
-    if (MD->getMacroInfo()->isBuiltinMacro())
-      return;
-    if (PP->getSourceManager().isWrittenInBuiltinFile(
-            MacroNameTok.getLocation()))
-      return;
-    if (PP->getSourceManager().isWrittenInCommandLineFile(
-            MacroNameTok.getLocation()))
-      return;
-    Check->checkMacro(PP->getSourceManager(), MacroNameTok, MD->getMacroInfo());
-  }
-
-  /// MacroExpands calls expandMacro for macros in the main file
-  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
-                    SourceRange /*Range*/,
-                    const MacroArgs * /*Args*/) override {
-    Check->expandMacro(MacroNameTok, MD.getMacroInfo());
-  }
-
-private:
-  Preprocessor *PP;
-  RenamerClangTidyCheck *Check;
-};
-
-} // namespace
-
-RenamerClangTidyCheck::RenamerClangTidyCheck(StringRef CheckName,
-                                             ClangTidyContext *Context)
-    : ClangTidyCheck(CheckName, Context),
-      AggressiveDependentMemberLookup(
-          Options.getLocalOrGlobal("AggressiveDependentMemberLookup", false)) {}
-RenamerClangTidyCheck::~RenamerClangTidyCheck() = default;
-
-void RenamerClangTidyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "AggressiveDependentMemberLookup",
-                AggressiveDependentMemberLookup);
-}
-
-void RenamerClangTidyCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(namedDecl().bind("decl"), this);
-  Finder->addMatcher(usingDecl().bind("using"), this);
-  Finder->addMatcher(declRefExpr().bind("declRef"), this);
-  Finder->addMatcher(cxxConstructorDecl(unless(isImplicit())).bind("classRef"),
-                     this);
-  Finder->addMatcher(cxxDestructorDecl(unless(isImplicit())).bind("classRef"),
-                     this);
-  Finder->addMatcher(typeLoc().bind("typeLoc"), this);
-  Finder->addMatcher(nestedNameSpecifierLoc().bind("nestedNameLoc"), this);
-  auto MemberRestrictions =
-      unless(forFunction(anyOf(isDefaulted(), isImplicit())));
-  Finder->addMatcher(memberExpr(MemberRestrictions).bind("memberExpr"), this);
-  Finder->addMatcher(
-      cxxDependentScopeMemberExpr(MemberRestrictions).bind("depMemberExpr"),
-      this);
-}
-
-void RenamerClangTidyCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  ModuleExpanderPP->addPPCallbacks(
-      std::make_unique<RenamerClangTidyCheckPPCallbacks>(ModuleExpanderPP,
-                                                         this));
-}
-
-/// Returns the function that \p Method is overridding. If There are none or
-/// multiple overrides it returns nullptr. If the overridden function itself is
-/// overridding then it will recurse up to find the first decl of the function.
-static const CXXMethodDecl *getOverrideMethod(const CXXMethodDecl *Method) {
-  if (Method->size_overridden_methods() != 1)
-    return nullptr;
-  while (true) {
-    Method = *Method->begin_overridden_methods();
-    assert(Method && "Overridden method shouldn't be null");
-    unsigned NumOverrides = Method->size_overridden_methods();
-    if (NumOverrides == 0)
-      return Method;
-    if (NumOverrides > 1)
-      return nullptr;
-  }
-}
-
-void RenamerClangTidyCheck::addUsage(
-    const RenamerClangTidyCheck::NamingCheckId &Decl, SourceRange Range,
-    SourceManager *SourceMgr) {
-  // Do nothing if the provided range is invalid.
-  if (Range.isInvalid())
-    return;
-
-  // If we have a source manager, use it to convert to the spelling location for
-  // performing the fix. This is necessary because macros can map the same
-  // spelling location to different source locations, and we only want to fix
-  // the token once, before it is expanded by the macro.
-  SourceLocation FixLocation = Range.getBegin();
-  if (SourceMgr)
-    FixLocation = SourceMgr->getSpellingLoc(FixLocation);
-  if (FixLocation.isInvalid())
-    return;
-
-  // Try to insert the identifier location in the Usages map, and bail out if it
-  // is already in there
-  RenamerClangTidyCheck::NamingCheckFailure &Failure =
-      NamingCheckFailures[Decl];
-  if (!Failure.RawUsageLocs.insert(FixLocation).second)
-    return;
-
-  if (!Failure.shouldFix())
-    return;
-
-  if (SourceMgr && SourceMgr->isWrittenInScratchSpace(FixLocation))
-    Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
-
-  if (!utils::rangeCanBeFixed(Range, SourceMgr))
-    Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
-}
-
-void RenamerClangTidyCheck::addUsage(const NamedDecl *Decl, SourceRange Range,
-                                     SourceManager *SourceMgr) {
-  if (const auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
-    if (const CXXMethodDecl *Overridden = getOverrideMethod(Method))
-      Decl = Overridden;
-  }
-  Decl = cast<NamedDecl>(Decl->getCanonicalDecl());
-  return addUsage(RenamerClangTidyCheck::NamingCheckId(Decl->getLocation(),
-                                                       Decl->getNameAsString()),
-                  Range, SourceMgr);
-}
-
-const NamedDecl *findDecl(const RecordDecl &RecDecl, StringRef DeclName) {
-  for (const Decl *D : RecDecl.decls()) {
-    if (const auto *ND = dyn_cast<NamedDecl>(D)) {
-      if (ND->getDeclName().isIdentifier() && ND->getName().equals(DeclName))
-        return ND;
-    }
-  }
-  return nullptr;
-}
-
-namespace {
 class NameLookup {
   llvm::PointerIntPair<const NamedDecl *, 1, bool> Data;
 
 public:
   explicit NameLookup(const NamedDecl *ND) : Data(ND, false) {}
   explicit NameLookup(std::nullopt_t) : Data(nullptr, true) {}
   explicit NameLookup(std::nullptr_t) : Data(nullptr, false) {}
   NameLookup() : NameLookup(nullptr) {}
 
   bool hasMultipleResolutions() const { return Data.getInt(); }
   const NamedDecl *getDecl() const {
     assert(!hasMultipleResolutions() && "Found multiple decls");
     return Data.getPointer();
   }
   operator bool() const { return !hasMultipleResolutions(); }
   const NamedDecl *operator*() const { return getDecl(); }
 };
 } // namespace
 
+static const NamedDecl *findDecl(const RecordDecl &RecDecl,
+                                 StringRef DeclName) {
+  for (const Decl *D : RecDecl.decls()) {
+    if (const auto *ND = dyn_cast<NamedDecl>(D)) {
+      if (ND->getDeclName().isIdentifier() && ND->getName().equals(DeclName))
+        return ND;
+    }
+  }
+  return nullptr;
+}
+
 /// Returns a decl matching the \p DeclName in \p Parent or one of its base
 /// classes. If \p AggressiveTemplateLookup is `true` then it will check
 /// template dependent base classes as well.
 /// If a matching decl is found in multiple base classes then it will return a
 /// flag indicating the multiple resolutions.
-NameLookup findDeclInBases(const CXXRecordDecl &Parent, StringRef DeclName,
+static NameLookup findDeclInBases(const CXXRecordDecl &Parent,
+                                  StringRef DeclName,
                                   bool AggressiveTemplateLookup) {
   if (!Parent.hasDefinition())
     return NameLookup(nullptr);
   if (const NamedDecl *InClassRef = findDecl(Parent, DeclName))
     return NameLookup(InClassRef);
   const NamedDecl *Found = nullptr;
 
   for (CXXBaseSpecifier Base : Parent.bases()) {
     const auto *Record = Base.getType()->getAsCXXRecordDecl();
if (auto Search =
         continue;
       }
     } else
       return NameLookup(std::nullopt); // Propagate multiple resolution back up.
   }
   return NameLookup(Found); // If nullptr, decl wasn't found.
 }
 
-void RenamerClangTidyCheck::check(const MatchFinder::MatchResult &Result) {
-  if (const auto *Decl =
-          Result.Nodes.getNodeAs<CXXConstructorDecl>("classRef")) {
+/// Returns the function that \p Method is overridding. If There are none or
+/// multiple overrides it returns nullptr. If the overridden function itself is
+/// overridding then it will recurse up to find the first decl of the function.
+static const CXXMethodDecl *getOverrideMethod(const CXXMethodDecl *Method) {
+  if (Method->size_overridden_methods() != 1)
+    return nullptr;
+
+  while (true) {
+    Method = *Method->begin_overridden_methods();
+    assert(Method && "Overridden method shouldn't be null");
+    unsigned NumOverrides = Method->size_overridden_methods();
+    if (NumOverrides == 0)
+      return Method;
+    if (NumOverrides > 1)
+      return nullptr;
+  }
+}
+
+namespace {
+
+/// Callback supplies macros to RenamerClangTidyCheck::checkMacro
+class RenamerClangTidyCheckPPCallbacks : public PPCallbacks {
+public:
+  RenamerClangTidyCheckPPCallbacks(const SourceManager &SM,
+                                   RenamerClangTidyCheck *Check)
+      : SM(SM), Check(Check) {}
+
+  /// MacroDefined calls checkMacro for macros in the main file
+  void MacroDefined(const Token &MacroNameTok,
+                    const MacroDirective *MD) override {
+    const MacroInfo *Info = MD->getMacroInfo();
+    if (Info->isBuiltinMacro())
+      return;
+    if (SM.isWrittenInBuiltinFile(MacroNameTok.getLocation()))
+      return;
+    if (SM.isWrittenInCommandLineFile(MacroNameTok.getLocation()))
+      return;
+    Check->checkMacro(SM, MacroNameTok, Info);
+  }
+
+  /// MacroExpands calls expandMacro for macros in the main file
+  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
+                    SourceRange /*Range*/,
+                    const MacroArgs * /*Args*/) override {
+    Check->expandMacro(MacroNameTok, MD.getMacroInfo());
+  }
 
-    addUsage(Decl->getParent(), Decl->getNameInfo().getSourceRange(),
-             Result.SourceManager);
+private:
+  const SourceManager &SM;
+  RenamerClangTidyCheck *Check;
+};
+
+class RenamerClangTidyVisitor
+    : public RecursiveASTVisitor<RenamerClangTidyVisitor> {
+public:
+  RenamerClangTidyVisitor(RenamerClangTidyCheck *Check, const SourceManager *SM,
+                          bool AggressiveDependentMemberLookup)
+      : Check(Check), SM(SM),
+        AggressiveDependentMemberLookup(AggressiveDependentMemberLookup) {}
+
+  static bool hasNoName(const NamedDecl *Decl) {
+    return !Decl->getIdentifier() || Decl->getName().empty();
+  }
+
+  bool shouldVisitTemplateInstantiations() const { return true; }
+
+  bool shouldVisitImplicitCode() const { return false; }
+
+  bool VisitCXXConstructorDecl(CXXConstructorDecl *Decl) {
+    if (Decl->isImplicit())
+      return true;
+    Check->addUsage(Decl->getParent(), Decl->getNameInfo().getSourceRange(),
+                    SM);
 
     for (const auto *Init : Decl->inits()) {
       if (!Init->isWritten() || Init->isInClassMemberInitializer())
         continue;
       if (const FieldDecl *FD = Init->getAnyMember())
-        addUsage(FD, SourceRange(Init->getMemberLocation()),
-                 Result.SourceManager);
+        Check->addUsage(FD, SourceRange(Init->getMemberLocation()), SM);
       // Note: delegating constructors and base class initializers are handled
       // via the "typeLoc" matcher.
     }
-    return;
-  }
 
-  if (const auto *Decl =
-          Result.Nodes.getNodeAs<CXXDestructorDecl>("classRef")) {
+    return true;
+  }
 
+  bool VisitCXXDestructorDecl(CXXDestructorDecl *Decl) {
+    if (Decl->isImplicit())
+      return true;
     SourceRange Range = Decl->getNameInfo().getSourceRange();
     if (Range.getBegin().isInvalid())
-      return;
+      return true;
+
     // The first token that will be found is the ~ (or the equivalent trigraph),
     // we want instead to replace the next token, that will be the identifier.
     Range.setBegin(CharSourceRange::getTokenRange(Range).getEnd());
-
-    addUsage(Decl->getParent(), Range, Result.SourceManager);
-    return;
+    Check->addUsage(Decl->getParent(), Range, SM);
+    return true;
   }
 
-  if (const auto *Loc = Result.Nodes.getNodeAs<TypeLoc>("typeLoc")) {
-    UnqualTypeLoc Unqual = Loc->getUnqualifiedLoc();
-    NamedDecl *Decl = nullptr;
-    if (const auto &Ref = Unqual.getAs<TagTypeLoc>())
-      Decl = Ref.getDecl();
-    else if (const auto &Ref = Unqual.getAs<InjectedClassNameTypeLoc>())
-      Decl = Ref.getDecl();
-    else if (const auto &Ref = Unqual.getAs<UnresolvedUsingTypeLoc>())
-      Decl = Ref.getDecl();
-    else if (const auto &Ref = Unqual.getAs<TemplateTypeParmTypeLoc>())
-      Decl = Ref.getDecl();
-    // further TypeLocs handled below
+  bool VisitUsingDecl(UsingDecl *Decl) {
+    for (const auto *Shadow : Decl->shadows())
+      Check->addUsage(Shadow->getTargetDecl(),
+                      Decl->getNameInfo().getSourceRange(), SM);
+    return true;
+  }
 
-    if (Decl) {
-      addUsage(Decl, Loc->getSourceRange(), Result.SourceManager);
-      return;
-    }
+  bool VisitUsingDirectiveDecl(UsingDirectiveDecl *Decl) {
+    Check->addUsage(Decl->getNominatedNamespaceAsWritten(),
+                    Decl->getIdentLocation(), SM);
+    return true;
 
-    if (const auto &Ref = Loc->getAs<TemplateSpecializationTypeLoc>()) {
-      const TemplateDecl *Decl =
-          Ref.getTypePtr()->getTemplateName().getAsTemplateDecl();
+  bool VisitNamedDecl(NamedDecl *Decl) {
+    if (hasNoName(Decl))
+      return true;
 
-      SourceRange Range(Ref.getTemplateNameLoc(), Ref.getTemplateNameLoc());
-      if (const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
-        if (const NamedDecl *TemplDecl = ClassDecl->getTemplatedDecl())
-          addUsage(TemplDecl, Range, Result.SourceManager);
-        return;
-      }
+    const auto *Canonical = cast<NamedDecl>(Decl->getCanonicalDecl());
+    if (Canonical != Decl) {
+      Check->addUsage(Canonical, Decl->getLocation(), SM);
+      return true;
     }
 
-    if (const auto &Ref =
-            Loc->getAs<DependentTemplateSpecializationTypeLoc>()) {
-      if (const TagDecl *Decl = Ref.getTypePtr()->getAsTagDecl())
-        addUsage(Decl, Loc->getSourceRange(), Result.SourceManager);
-      return;
+    // Fix type aliases in value declarations.
+    if (const auto *Value = dyn_cast<ValueDecl>(Decl)) {
+      if (const Type *TypePtr = Value->getType().getTypePtrOrNull()) {
+        if (const auto *Typedef = TypePtr->getAs<TypedefType>())
+          Check->addUsage(Typedef->getDecl(), Value->getSourceRange(), SM);
       }
     }
 
-  if (const auto *Loc =
-          Result.Nodes.getNodeAs<NestedNameSpecifierLoc>("nestedNameLoc")) {
-    if (const NestedNameSpecifier *Spec = Loc->getNestedNameSpecifier()) {
-      if (const NamespaceDecl *Decl = Spec->getAsNamespace()) {
-        addUsage(Decl, Loc->getLocalSourceRange(), Result.SourceManager);
-        return;
-      }
+    // Fix type aliases in function declarations.
+    if (const auto *Value = dyn_cast<FunctionDecl>(Decl)) {
+      if (const auto *Typedef =
+              Value->getReturnType().getTypePtr()->getAs<TypedefType>())
+        Check->addUsage(Typedef->getDecl(), Value->getSourceRange(), SM);
+      for (const ParmVarDecl *Param : Value->parameters()) {
+        if (const TypedefType *Typedef =
+                Param->getType().getTypePtr()->getAs<TypedefType>())
+          Check->addUsage(Typedef->getDecl(), Value->getSourceRange(), SM);
+      }
+
+    // Fix overridden methods
+    if (const auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
+      if (const CXXMethodDecl *Overridden = getOverrideMethod(Method)) {
+        Check->addUsage(Overridden, Method->getLocation());
+        return true; // Don't try to add the actual decl as a Failure.
       }
     }
 
-  if (const auto *Decl = Result.Nodes.getNodeAs<UsingDecl>("using")) {
-    for (const auto *Shadow : Decl->shadows())
-      addUsage(Shadow->getTargetDecl(), Decl->getNameInfo().getSourceRange(),
-               Result.SourceManager);
-    return;
+    // Ignore ClassTemplateSpecializationDecl which are creating duplicate
+    // replacements with CXXRecordDecl.
+    if (isa<ClassTemplateSpecializationDecl>(Decl))
+      return true;
+
+    Check->checkNamedDecl(Decl, *SM);
+    return true;
   }
 
-  if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declRef")) {
+  bool VisitDeclRefExpr(DeclRefExpr *DeclRef) {
     SourceRange Range = DeclRef->getNameInfo().getSourceRange();
-    addUsage(DeclRef->getDecl(), Range, Result.SourceManager);
-    return;
+    Check->addUsage(DeclRef->getDecl(), Range, SM);
+    return true;
+  }
+
+  bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc Loc) {
+    if (const NestedNameSpecifier *Spec = Loc.getNestedNameSpecifier()) {
+      if (const NamespaceDecl *Decl = Spec->getAsNamespace())
+        Check->addUsage(Decl, Loc.getLocalSourceRange(), SM);
+    }
+
+    using Base = RecursiveASTVisitor<RenamerClangTidyVisitor>;
+    return Base::TraverseNestedNameSpecifierLoc(Loc);
   }
 
-  if (const auto *MemberRef =
-          Result.Nodes.getNodeAs<MemberExpr>("memberExpr")) {
+  bool VisitMemberExpr(MemberExpr *MemberRef) {
     SourceRange Range = MemberRef->getMemberNameInfo().getSourceRange();
-    addUsage(MemberRef->getMemberDecl(), Range, Result.SourceManager);
-    return;
+    Check->addUsage(MemberRef->getMemberDecl(), Range, SM);
+    return true;
   }
 
-  if (const auto *DepMemberRef =
-          Result.Nodes.getNodeAs<CXXDependentScopeMemberExpr>(
-              "depMemberExpr")) {
+  bool
+  VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *DepMemberRef) {
     QualType BaseType = DepMemberRef->isArrow()
                             ? DepMemberRef->getBaseType()->getPointeeType()
                             : DepMemberRef->getBaseType();
     if (BaseType.isNull())
-      return;
+      return true;
     const CXXRecordDecl *Base = BaseType.getTypePtr()->getAsCXXRecordDecl();
     if (!Base)
-      return;
+      return true;
     DeclarationName DeclName = DepMemberRef->getMemberNameInfo().getName();
     if (!DeclName.isIdentifier())
-      return;
+      return true;
     StringRef DependentName = DeclName.getAsIdentifierInfo()->getName();
 
     if (NameLookup Resolved = findDeclInBases(
             *Base, DependentName, AggressiveDependentMemberLookup)) {
       if (*Resolved)
-        addUsage(*Resolved, DepMemberRef->getMemberNameInfo().getSourceRange(),
-                 Result.SourceManager);
+        Check->addUsage(*Resolved,
+                        DepMemberRef->getMemberNameInfo().getSourceRange(), SM);
     }
-    return;
+
+    return true;
   }
 
-  if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
-    // Fix using namespace declarations.
-    if (const auto *UsingNS = dyn_cast<UsingDirectiveDecl>(Decl))
-      addUsage(UsingNS->getNominatedNamespaceAsWritten(),
-               UsingNS->getIdentLocation(), Result.SourceManager);
+  bool VisitTagTypeLoc(const TagTypeLoc &Loc) {
+    Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
+    return true;
+  }
 
-    if (!Decl->getIdentifier() || Decl->getName().empty() || Decl->isImplicit())
-      return;
+  bool VisitInjectedClassNameTypeLoc(const InjectedClassNameTypeLoc &Loc) {
+    Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
+    return true;
+  }
 
-    const auto *Canonical = cast<NamedDecl>(Decl->getCanonicalDecl());
-    if (Canonical != Decl) {
-      addUsage(Canonical, Decl->getLocation(), Result.SourceManager);
-      return;
-    }
+  bool VisitUnresolvedUsingTypeLoc(const UnresolvedUsingTypeLoc &Loc) {
+    Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
+    return true;
 
-    // Fix type aliases in value declarations.
-    if (const auto *Value = Result.Nodes.getNodeAs<ValueDecl>("decl")) {
-      if (const Type *TypePtr = Value->getType().getTypePtrOrNull()) {
-        if (const auto *Typedef = TypePtr->getAs<TypedefType>())
-          addUsage(Typedef->getDecl(), Value->getSourceRange(),
-                   Result.SourceManager);
-      }
+  bool VisitTemplateTypeParmTypeLoc(const TemplateTypeParmTypeLoc &Loc) {
+    Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
+    return true;
+
+  bool
+  VisitTemplateSpecializationTypeLoc(const TemplateSpecializationTypeLoc &Loc) {
+    const TemplateDecl *Decl =
+        Loc.getTypePtr()->getTemplateName().getAsTemplateDecl();
+
+    SourceRange Range(Loc.getTemplateNameLoc(), Loc.getTemplateNameLoc());
+    if (const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
+      if (const NamedDecl *TemplDecl = ClassDecl->getTemplatedDecl())
+        Check->addUsage(TemplDecl, Range, SM);
     }
 
-    // Fix type aliases in function declarations.
-    if (const auto *Value = Result.Nodes.getNodeAs<FunctionDecl>("decl")) {
-      if (const auto *Typedef =
-              Value->getReturnType().getTypePtr()->getAs<TypedefType>())
-        addUsage(Typedef->getDecl(), Value->getSourceRange(),
-                 Result.SourceManager);
-      for (const ParmVarDecl *Param : Value->parameters()) {
-        if (const TypedefType *Typedef =
-                Param->getType().getTypePtr()->getAs<TypedefType>())
-          addUsage(Typedef->getDecl(), Value->getSourceRange(),
-                   Result.SourceManager);
-      }
-    }
+    return true;
+
+  bool VisitDependentTemplateSpecializationTypeLoc(
+      const DependentTemplateSpecializationTypeLoc &Loc) {
+    if (const TagDecl *Decl = Loc.getTypePtr()->getAsTagDecl())
+      Check->addUsage(Decl, Loc.getSourceRange(), SM);
+
+    return true;
 
-    // Fix overridden methods
-    if (const auto *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("decl")) {
-      if (const CXXMethodDecl *Overridden = getOverrideMethod(Method)) {
-        addUsage(Overridden, Method->getLocation());
-        return; // Don't try to add the actual decl as a Failure.
-      }
-    }
+private:
+  RenamerClangTidyCheck *Check;
+  const SourceManager *SM;
+  const bool AggressiveDependentMemberLookup;
+};
+
+} // namespace
+
+RenamerClangTidyCheck::RenamerClangTidyCheck(StringRef CheckName,
+                                             ClangTidyContext *Context)
+    : ClangTidyCheck(CheckName, Context),
+      AggressiveDependentMemberLookup(
+          Options.getLocalOrGlobal("AggressiveDependentMemberLookup", false)) {}
+RenamerClangTidyCheck::~RenamerClangTidyCheck() = default;
+
+void RenamerClangTidyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "AggressiveDependentMemberLookup",
+                AggressiveDependentMemberLookup);
+
+void RenamerClangTidyCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(translationUnitDecl(), this);
 
-    // Ignore ClassTemplateSpecializationDecl which are creating duplicate
-    // replacements with CXXRecordDecl.
-    if (isa<ClassTemplateSpecializationDecl>(Decl))
-      return;
+void RenamerClangTidyCheck::registerPPCallbacks(
+    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
+  ModuleExpanderPP->addPPCallbacks(
+      std::make_unique<RenamerClangTidyCheckPPCallbacks>(SM, this));
+}
+
+void RenamerClangTidyCheck::addUsage(
+    const RenamerClangTidyCheck::NamingCheckId &Decl, SourceRange Range,
+    const SourceManager *SourceMgr) {
+  // Do nothing if the provided range is invalid.
+  if (Range.isInvalid())
 
-    std::optional<FailureInfo> MaybeFailure =
-        getDeclFailureInfo(Decl, *Result.SourceManager);
-    if (!MaybeFailure)
-      return;
-    FailureInfo &Info = *MaybeFailure;
-    NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(
-        Decl->getLocation(), Decl->getNameAsString())];
-    SourceRange Range =
-        DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
-            .getSourceRange();
+  // If we have a source manager, use it to convert to the spelling location for
+  // performing the fix. This is necessary because macros can map the same
+  // spelling location to different source locations, and we only want to fix
+  // the token once, before it is expanded by the macro.
+  SourceLocation FixLocation = Range.getBegin();
+  if (SourceMgr)
+    FixLocation = SourceMgr->getSpellingLoc(FixLocation);
+  if (FixLocation.isInvalid())
+    return;
+
+  // Try to insert the identifier location in the Usages map, and bail out if it
+  // is already in there
+  RenamerClangTidyCheck::NamingCheckFailure &Failure =
+      NamingCheckFailures[Decl];
+  if (!Failure.RawUsageLocs.insert(FixLocation).second)
+    return;
+
+  if (!Failure.shouldFix())
+    return;
+
+  if (SourceMgr && SourceMgr->isWrittenInScratchSpace(FixLocation))
+    Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
+
+  if (!utils::rangeCanBeFixed(Range, SourceMgr))
+    Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
+}
+
+void RenamerClangTidyCheck::addUsage(const NamedDecl *Decl, SourceRange Range,
+                                     const SourceManager *SourceMgr) {
+  if (const auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
+    if (const CXXMethodDecl *Overridden = getOverrideMethod(Method))
+      Decl = Overridden;
+  }
+  Decl = cast<NamedDecl>(Decl->getCanonicalDecl());
+  return addUsage(RenamerClangTidyCheck::NamingCheckId(Decl->getLocation(),
+                                                       Decl->getName()),
+                  Range, SourceMgr);
+}
+
+void RenamerClangTidyCheck::checkNamedDecl(const NamedDecl *Decl,
+                                           const SourceManager &SourceMgr) {
+  std::optional<FailureInfo> MaybeFailure = getDeclFailureInfo(Decl, SourceMgr);
+
+  NamingCheckFailure &Failure =
+      NamingCheckFailures[NamingCheckId(Decl->getLocation(), Decl->getName())];
 
-    const IdentifierTable &Idents = Decl->getASTContext().Idents;
-    auto CheckNewIdentifier = Idents.find(Info.Fixup);
-    if (CheckNewIdentifier != Idents.end()) {
-      const IdentifierInfo *Ident = CheckNewIdentifier->second;
-      if (Ident->isKeyword(getLangOpts()))
-        Failure.FixStatus = ShouldFixStatus::ConflictsWithKeyword;
-      else if (Ident->hasMacroDefinition())
-        Failure.FixStatus = ShouldFixStatus::ConflictsWithMacroDefinition;
-    } else if (!isValidAsciiIdentifier(Info.Fixup)) {
-      Failure.FixStatus = ShouldFixStatus::FixInvalidIdentifier;
-    }
 
-    Failure.Info = std::move(Info);
-    addUsage(Decl, Range);
-  }
+
+void RenamerClangTidyCheck::check(const MatchFinder::MatchResult &Result) {
+  RenamerClangTidyVisitor Visitor(this, Result.SourceManager,
+                                  AggressiveDependentMemberLookup);
+  Visitor.TraverseAST(*Result.Context);
 }
 
-void RenamerClangTidyCheck::checkMacro(SourceManager &SourceMgr,
+void RenamerClangTidyCheck::checkMacro(const SourceManager &SourceMgr,
                                        const Token &MacroNameTok,
                                        const MacroInfo *MI) {
   std::optional<FailureInfo> MaybeFailure =
       getMacroFailureInfo(MacroNameTok, SourceMgr);
   if (!MaybeFailure)
     return;
   FailureInfo &Info = *MaybeFailure;
   StringRef Name = MacroNameTok.getIdentifierInfo()->getName();
-  NamingCheckId ID(MI->getDefinitionLoc(), std::string(Name));
+  NamingCheckId ID(MI->getDefinitionLoc(), Name);
   NamingCheckFailure &Failure = NamingCheckFailures[ID];
   SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
 
   if (!isValidAsciiIdentifier(Info.Fixup))
     Failure.FixStatus = ShouldFixStatus::FixInvalidIdentifier;
 
   Failure.Info = std::move(Info);
   addUsage(ID, Range);
 }
 
 void RenamerClangTidyCheck::expandMacro(const Token &MacroNameTok,
                                         const MacroInfo *MI) {
   StringRef Name = MacroNameTok.getIdentifierInfo()->getName();
-  NamingCheckId ID(MI->getDefinitionLoc(), std::string(Name));
+  NamingCheckId ID(MI->getDefinitionLoc(), Name);
 
   auto Failure = NamingCheckFailures.find(ID);
   if (Failure == NamingCheckFailures.end())
     return;
 
   SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
   addUsage(ID, Range);
 }