xref: /llvm-project/clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp (revision aaadaee7b228d7010ff7076f5002ebb96b5e03dc) 
1 //===--- RenamerClangTidyCheck.cpp - clang-tidy ---------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "RenamerClangTidyCheck.h"
10 #include "ASTUtils.h"
11 #include "clang/AST/CXXInheritance.h"
12 #include "clang/AST/RecursiveASTVisitor.h"
13 #include "clang/ASTMatchers/ASTMatchFinder.h"
14 #include "clang/Basic/CharInfo.h"
15 #include "clang/Frontend/CompilerInstance.h"
16 #include "clang/Lex/PPCallbacks.h"
17 #include "clang/Lex/Preprocessor.h"
18 #include "llvm/ADT/DenseMapInfo.h"
19 #include "llvm/ADT/PointerIntPair.h"
20 #include <optional>
21 
22 #define DEBUG_TYPE "clang-tidy"
23 
24 using namespace clang::ast_matchers;
25 
26 namespace llvm {
27 
28 /// Specialization of DenseMapInfo to allow NamingCheckId objects in DenseMaps
29 template <>
30 struct DenseMapInfo<clang::tidy::RenamerClangTidyCheck::NamingCheckId> {
31   using NamingCheckId = clang::tidy::RenamerClangTidyCheck::NamingCheckId;
32 
33   static inline NamingCheckId getEmptyKey() {
34     return {DenseMapInfo<clang::SourceLocation>::getEmptyKey(), "EMPTY"};
35   }
36 
37   static inline NamingCheckId getTombstoneKey() {
38     return {DenseMapInfo<clang::SourceLocation>::getTombstoneKey(),
39             "TOMBSTONE"};
40   }
41 
42   static unsigned getHashValue(NamingCheckId Val) {
43     assert(Val != getEmptyKey() && "Cannot hash the empty key!");
44     assert(Val != getTombstoneKey() && "Cannot hash the tombstone key!");
45 
46     return DenseMapInfo<clang::SourceLocation>::getHashValue(Val.first) +
47            DenseMapInfo<StringRef>::getHashValue(Val.second);
48   }
49 
50   static bool isEqual(const NamingCheckId &LHS, const NamingCheckId &RHS) {
51     if (RHS == getEmptyKey())
52       return LHS == getEmptyKey();
53     if (RHS == getTombstoneKey())
54       return LHS == getTombstoneKey();
55     return LHS == RHS;
56   }
57 };
58 
59 } // namespace llvm
60 
61 namespace clang::tidy {
62 
63 namespace {
64 
65 class NameLookup {
66   llvm::PointerIntPair<const NamedDecl *, 1, bool> Data;
67 
68 public:
69   explicit NameLookup(const NamedDecl *ND) : Data(ND, false) {}
70   explicit NameLookup(std::nullopt_t) : Data(nullptr, true) {}
71   explicit NameLookup(std::nullptr_t) : Data(nullptr, false) {}
72   NameLookup() : NameLookup(nullptr) {}
73 
74   bool hasMultipleResolutions() const { return Data.getInt(); }
75   const NamedDecl *getDecl() const {
76     assert(!hasMultipleResolutions() && "Found multiple decls");
77     return Data.getPointer();
78   }
79   operator bool() const { return !hasMultipleResolutions(); }
80   const NamedDecl *operator*() const { return getDecl(); }
81 };
82 
83 } // namespace
84 
85 static const NamedDecl *findDecl(const RecordDecl &RecDecl,
86                                  StringRef DeclName) {
87   for (const Decl *D : RecDecl.decls()) {
88     if (const auto *ND = dyn_cast<NamedDecl>(D)) {
89       if (ND->getDeclName().isIdentifier() && ND->getName() == DeclName)
90         return ND;
91     }
92   }
93   return nullptr;
94 }
95 
96 /// Returns the function that \p Method is overridding. If There are none or
97 /// multiple overrides it returns nullptr. If the overridden function itself is
98 /// overridding then it will recurse up to find the first decl of the function.
99 static const CXXMethodDecl *getOverrideMethod(const CXXMethodDecl *Method) {
100   if (Method->size_overridden_methods() != 1)
101     return nullptr;
102 
103   while (true) {
104     Method = *Method->begin_overridden_methods();
105     assert(Method && "Overridden method shouldn't be null");
106     unsigned NumOverrides = Method->size_overridden_methods();
107     if (NumOverrides == 0)
108       return Method;
109     if (NumOverrides > 1)
110       return nullptr;
111   }
112 }
113 
114 static bool hasNoName(const NamedDecl *Decl) {
115   return !Decl->getIdentifier() || Decl->getName().empty();
116 }
117 
118 static const NamedDecl *getFailureForNamedDecl(const NamedDecl *ND) {
119   const auto *Canonical = cast<NamedDecl>(ND->getCanonicalDecl());
120   if (Canonical != ND)
121     return Canonical;
122 
123   if (const auto *Method = dyn_cast<CXXMethodDecl>(ND)) {
124     if (const CXXMethodDecl *Overridden = getOverrideMethod(Method))
125       Canonical = cast<NamedDecl>(Overridden->getCanonicalDecl());
126     else if (const FunctionTemplateDecl *Primary = Method->getPrimaryTemplate())
127       if (const FunctionDecl *TemplatedDecl = Primary->getTemplatedDecl())
128         Canonical = cast<NamedDecl>(TemplatedDecl->getCanonicalDecl());
129 
130     if (Canonical != ND)
131       return Canonical;
132   }
133 
134   return ND;
135 }
136 
137 /// Returns a decl matching the \p DeclName in \p Parent or one of its base
138 /// classes. If \p AggressiveTemplateLookup is `true` then it will check
139 /// template dependent base classes as well.
140 /// If a matching decl is found in multiple base classes then it will return a
141 /// flag indicating the multiple resolutions.
142 static NameLookup findDeclInBases(const CXXRecordDecl &Parent,
143                                   StringRef DeclName,
144                                   bool AggressiveTemplateLookup) {
145   if (!Parent.hasDefinition())
146     return NameLookup(nullptr);
147   if (const NamedDecl *InClassRef = findDecl(Parent, DeclName))
148     return NameLookup(InClassRef);
149   const NamedDecl *Found = nullptr;
150 
151   for (CXXBaseSpecifier Base : Parent.bases()) {
152     const auto *Record = Base.getType()->getAsCXXRecordDecl();
153     if (!Record && AggressiveTemplateLookup) {
154       if (const auto *TST =
155               Base.getType()->getAs<TemplateSpecializationType>()) {
156         if (const auto *TD = llvm::dyn_cast_or_null<ClassTemplateDecl>(
157                 TST->getTemplateName().getAsTemplateDecl()))
158           Record = TD->getTemplatedDecl();
159       }
160     }
161     if (!Record)
162       continue;
163     if (auto Search =
164             findDeclInBases(*Record, DeclName, AggressiveTemplateLookup)) {
165       if (*Search) {
166         if (Found)
167           return NameLookup(
168               std::nullopt); // Multiple decls found in different base classes.
169         Found = *Search;
170         continue;
171       }
172     } else
173       return NameLookup(std::nullopt); // Propagate multiple resolution back up.
174   }
175   return NameLookup(Found); // If nullptr, decl wasn't found.
176 }
177 
178 namespace {
179 
180 /// Callback supplies macros to RenamerClangTidyCheck::checkMacro
181 class RenamerClangTidyCheckPPCallbacks : public PPCallbacks {
182 public:
183   RenamerClangTidyCheckPPCallbacks(const SourceManager &SM,
184                                    RenamerClangTidyCheck *Check)
185       : SM(SM), Check(Check) {}
186 
187   /// MacroDefined calls checkMacro for macros in the main file
188   void MacroDefined(const Token &MacroNameTok,
189                     const MacroDirective *MD) override {
190     const MacroInfo *Info = MD->getMacroInfo();
191     if (Info->isBuiltinMacro())
192       return;
193     if (SM.isWrittenInBuiltinFile(MacroNameTok.getLocation()))
194       return;
195     if (SM.isWrittenInCommandLineFile(MacroNameTok.getLocation()))
196       return;
197     Check->checkMacro(MacroNameTok, Info, SM);
198   }
199 
200   /// MacroExpands calls expandMacro for macros in the main file
201   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
202                     SourceRange /*Range*/,
203                     const MacroArgs * /*Args*/) override {
204     Check->expandMacro(MacroNameTok, MD.getMacroInfo(), SM);
205   }
206 
207 private:
208   const SourceManager &SM;
209   RenamerClangTidyCheck *Check;
210 };
211 
212 class RenamerClangTidyVisitor
213     : public RecursiveASTVisitor<RenamerClangTidyVisitor> {
214 public:
215   RenamerClangTidyVisitor(RenamerClangTidyCheck *Check, const SourceManager &SM,
216                           bool AggressiveDependentMemberLookup)
217       : Check(Check), SM(SM),
218         AggressiveDependentMemberLookup(AggressiveDependentMemberLookup) {}
219 
220   bool shouldVisitTemplateInstantiations() const { return true; }
221 
222   bool shouldVisitImplicitCode() const { return false; }
223 
224   bool VisitCXXConstructorDecl(CXXConstructorDecl *Decl) {
225     if (Decl->isImplicit())
226       return true;
227     Check->addUsage(Decl->getParent(), Decl->getNameInfo().getSourceRange(),
228                     SM);
229 
230     for (const auto *Init : Decl->inits()) {
231       if (!Init->isWritten() || Init->isInClassMemberInitializer())
232         continue;
233       if (const FieldDecl *FD = Init->getAnyMember())
234         Check->addUsage(FD, SourceRange(Init->getMemberLocation()), SM);
235       // Note: delegating constructors and base class initializers are handled
236       // via the "typeLoc" matcher.
237     }
238 
239     return true;
240   }
241 
242   bool VisitCXXDestructorDecl(CXXDestructorDecl *Decl) {
243     if (Decl->isImplicit())
244       return true;
245     SourceRange Range = Decl->getNameInfo().getSourceRange();
246     if (Range.getBegin().isInvalid())
247       return true;
248 
249     // The first token that will be found is the ~ (or the equivalent trigraph),
250     // we want instead to replace the next token, that will be the identifier.
251     Range.setBegin(CharSourceRange::getTokenRange(Range).getEnd());
252     Check->addUsage(Decl->getParent(), Range, SM);
253     return true;
254   }
255 
256   bool VisitUsingDecl(UsingDecl *Decl) {
257     for (const auto *Shadow : Decl->shadows())
258       Check->addUsage(Shadow->getTargetDecl(),
259                       Decl->getNameInfo().getSourceRange(), SM);
260     return true;
261   }
262 
263   bool VisitUsingDirectiveDecl(UsingDirectiveDecl *Decl) {
264     Check->addUsage(Decl->getNominatedNamespaceAsWritten(),
265                     Decl->getIdentLocation(), SM);
266     return true;
267   }
268 
269   bool VisitNamedDecl(NamedDecl *Decl) {
270     SourceRange UsageRange =
271         DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
272             .getSourceRange();
273     Check->addUsage(Decl, UsageRange, SM);
274     return true;
275   }
276 
277   bool VisitDeclRefExpr(DeclRefExpr *DeclRef) {
278     SourceRange Range = DeclRef->getNameInfo().getSourceRange();
279     Check->addUsage(DeclRef->getDecl(), Range, SM);
280     return true;
281   }
282 
283   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc Loc) {
284     if (const NestedNameSpecifier *Spec = Loc.getNestedNameSpecifier()) {
285       if (const NamespaceDecl *Decl = Spec->getAsNamespace())
286         Check->addUsage(Decl, Loc.getLocalSourceRange(), SM);
287     }
288 
289     using Base = RecursiveASTVisitor<RenamerClangTidyVisitor>;
290     return Base::TraverseNestedNameSpecifierLoc(Loc);
291   }
292 
293   bool VisitMemberExpr(MemberExpr *MemberRef) {
294     SourceRange Range = MemberRef->getMemberNameInfo().getSourceRange();
295     Check->addUsage(MemberRef->getMemberDecl(), Range, SM);
296     return true;
297   }
298 
299   bool
300   VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *DepMemberRef) {
301     QualType BaseType = DepMemberRef->isArrow()
302                             ? DepMemberRef->getBaseType()->getPointeeType()
303                             : DepMemberRef->getBaseType();
304     if (BaseType.isNull())
305       return true;
306     const CXXRecordDecl *Base = BaseType.getTypePtr()->getAsCXXRecordDecl();
307     if (!Base)
308       return true;
309     DeclarationName DeclName = DepMemberRef->getMemberNameInfo().getName();
310     if (!DeclName.isIdentifier())
311       return true;
312     StringRef DependentName = DeclName.getAsIdentifierInfo()->getName();
313 
314     if (NameLookup Resolved = findDeclInBases(
315             *Base, DependentName, AggressiveDependentMemberLookup)) {
316       if (*Resolved)
317         Check->addUsage(*Resolved,
318                         DepMemberRef->getMemberNameInfo().getSourceRange(), SM);
319     }
320 
321     return true;
322   }
323 
324   bool VisitTypedefTypeLoc(const TypedefTypeLoc &Loc) {
325     Check->addUsage(Loc.getTypedefNameDecl(), Loc.getSourceRange(), SM);
326     return true;
327   }
328 
329   bool VisitTagTypeLoc(const TagTypeLoc &Loc) {
330     Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
331     return true;
332   }
333 
334   bool VisitInjectedClassNameTypeLoc(const InjectedClassNameTypeLoc &Loc) {
335     Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
336     return true;
337   }
338 
339   bool VisitUnresolvedUsingTypeLoc(const UnresolvedUsingTypeLoc &Loc) {
340     Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
341     return true;
342   }
343 
344   bool VisitTemplateTypeParmTypeLoc(const TemplateTypeParmTypeLoc &Loc) {
345     Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
346     return true;
347   }
348 
349   bool
350   VisitTemplateSpecializationTypeLoc(const TemplateSpecializationTypeLoc &Loc) {
351     const TemplateDecl *Decl =
352         Loc.getTypePtr()->getTemplateName().getAsTemplateDecl();
353 
354     SourceRange Range(Loc.getTemplateNameLoc(), Loc.getTemplateNameLoc());
355     if (const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
356       if (const NamedDecl *TemplDecl = ClassDecl->getTemplatedDecl())
357         Check->addUsage(TemplDecl, Range, SM);
358     }
359 
360     return true;
361   }
362 
363   bool VisitDependentTemplateSpecializationTypeLoc(
364       const DependentTemplateSpecializationTypeLoc &Loc) {
365     if (const TagDecl *Decl = Loc.getTypePtr()->getAsTagDecl())
366       Check->addUsage(Decl, Loc.getSourceRange(), SM);
367 
368     return true;
369   }
370 
371   bool VisitDesignatedInitExpr(DesignatedInitExpr *Expr) {
372     for (const DesignatedInitExpr::Designator &D : Expr->designators()) {
373       if (!D.isFieldDesignator())
374         continue;
375       const FieldDecl *FD = D.getFieldDecl();
376       if (!FD)
377         continue;
378       const IdentifierInfo *II = FD->getIdentifier();
379       if (!II)
380         continue;
381       SourceRange FixLocation{D.getFieldLoc(), D.getFieldLoc()};
382       Check->addUsage(FD, FixLocation, SM);
383     }
384 
385     return true;
386   }
387 
388 private:
389   RenamerClangTidyCheck *Check;
390   const SourceManager &SM;
391   const bool AggressiveDependentMemberLookup;
392 };
393 
394 } // namespace
395 
396 RenamerClangTidyCheck::RenamerClangTidyCheck(StringRef CheckName,
397                                              ClangTidyContext *Context)
398     : ClangTidyCheck(CheckName, Context),
399       AggressiveDependentMemberLookup(
400           Options.get("AggressiveDependentMemberLookup", false)) {}
401 RenamerClangTidyCheck::~RenamerClangTidyCheck() = default;
402 
403 void RenamerClangTidyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
404   Options.store(Opts, "AggressiveDependentMemberLookup",
405                 AggressiveDependentMemberLookup);
406 }
407 
408 void RenamerClangTidyCheck::registerMatchers(MatchFinder *Finder) {
409   Finder->addMatcher(translationUnitDecl(), this);
410 }
411 
412 void RenamerClangTidyCheck::registerPPCallbacks(
413     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
414   ModuleExpanderPP->addPPCallbacks(
415       std::make_unique<RenamerClangTidyCheckPPCallbacks>(SM, this));
416 }
417 
418 std::pair<RenamerClangTidyCheck::NamingCheckFailureMap::iterator, bool>
419 RenamerClangTidyCheck::addUsage(
420     const RenamerClangTidyCheck::NamingCheckId &FailureId,
421     SourceRange UsageRange, const SourceManager &SourceMgr) {
422   // Do nothing if the provided range is invalid.
423   if (UsageRange.isInvalid())
424     return {NamingCheckFailures.end(), false};
425 
426   // Get the spelling location for performing the fix. This is necessary because
427   // macros can map the same spelling location to different source locations,
428   // and we only want to fix the token once, before it is expanded by the macro.
429   SourceLocation FixLocation = UsageRange.getBegin();
430   FixLocation = SourceMgr.getSpellingLoc(FixLocation);
431   if (FixLocation.isInvalid())
432     return {NamingCheckFailures.end(), false};
433 
434   auto EmplaceResult = NamingCheckFailures.try_emplace(FailureId);
435   NamingCheckFailure &Failure = EmplaceResult.first->second;
436 
437   // Try to insert the identifier location in the Usages map, and bail out if it
438   // is already in there
439   if (!Failure.RawUsageLocs.insert(FixLocation).second)
440     return EmplaceResult;
441 
442   if (Failure.FixStatus != RenamerClangTidyCheck::ShouldFixStatus::ShouldFix)
443     return EmplaceResult;
444 
445   if (SourceMgr.isWrittenInScratchSpace(FixLocation))
446     Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
447 
448   if (!utils::rangeCanBeFixed(UsageRange, &SourceMgr))
449     Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
450 
451   return EmplaceResult;
452 }
453 
454 void RenamerClangTidyCheck::addUsage(const NamedDecl *Decl,
455                                      SourceRange UsageRange,
456                                      const SourceManager &SourceMgr) {
457   if (hasNoName(Decl))
458     return;
459 
460   // Ignore ClassTemplateSpecializationDecl which are creating duplicate
461   // replacements with CXXRecordDecl.
462   if (isa<ClassTemplateSpecializationDecl>(Decl))
463     return;
464 
465   // We don't want to create a failure for every NamedDecl we find. Ideally
466   // there is just one NamedDecl in every group of "related" NamedDecls that
467   // becomes the failure. This NamedDecl and all of its related NamedDecls
468   // become usages. E.g. Since NamedDecls are Redeclarable, only the canonical
469   // NamedDecl becomes the failure and all redeclarations become usages.
470   const NamedDecl *FailureDecl = getFailureForNamedDecl(Decl);
471 
472   std::optional<FailureInfo> MaybeFailure =
473       getDeclFailureInfo(FailureDecl, SourceMgr);
474   if (!MaybeFailure)
475     return;
476 
477   NamingCheckId FailureId(FailureDecl->getLocation(), FailureDecl->getName());
478 
479   auto [FailureIter, NewFailure] = addUsage(FailureId, UsageRange, SourceMgr);
480 
481   if (FailureIter == NamingCheckFailures.end()) {
482     // Nothing to do if the usage wasn't accepted.
483     return;
484   }
485   if (!NewFailure) {
486     // FailureInfo has already been provided.
487     return;
488   }
489 
490   // Update the stored failure with info regarding the FailureDecl.
491   NamingCheckFailure &Failure = FailureIter->second;
492   Failure.Info = std::move(*MaybeFailure);
493 
494   // Don't overwritte the failure status if it was already set.
495   if (!Failure.shouldFix()) {
496     return;
497   }
498   const IdentifierTable &Idents = FailureDecl->getASTContext().Idents;
499   auto CheckNewIdentifier = Idents.find(Failure.Info.Fixup);
500   if (CheckNewIdentifier != Idents.end()) {
501     const IdentifierInfo *Ident = CheckNewIdentifier->second;
502     if (Ident->isKeyword(getLangOpts()))
503       Failure.FixStatus = ShouldFixStatus::ConflictsWithKeyword;
504     else if (Ident->hasMacroDefinition())
505       Failure.FixStatus = ShouldFixStatus::ConflictsWithMacroDefinition;
506   } else if (!isValidAsciiIdentifier(Failure.Info.Fixup)) {
507     Failure.FixStatus = ShouldFixStatus::FixInvalidIdentifier;
508   }
509 }
510 
511 void RenamerClangTidyCheck::check(const MatchFinder::MatchResult &Result) {
512   if (!Result.SourceManager) {
513     // In principle SourceManager is not null but going only by the definition
514     // of MatchResult it must be handled. Cannot rename anything without a
515     // SourceManager.
516     return;
517   }
518   RenamerClangTidyVisitor Visitor(this, *Result.SourceManager,
519                                   AggressiveDependentMemberLookup);
520   Visitor.TraverseAST(*Result.Context);
521 }
522 
523 void RenamerClangTidyCheck::checkMacro(const Token &MacroNameTok,
524                                        const MacroInfo *MI,
525                                        const SourceManager &SourceMgr) {
526   std::optional<FailureInfo> MaybeFailure =
527       getMacroFailureInfo(MacroNameTok, SourceMgr);
528   if (!MaybeFailure)
529     return;
530   FailureInfo &Info = *MaybeFailure;
531   StringRef Name = MacroNameTok.getIdentifierInfo()->getName();
532   NamingCheckId ID(MI->getDefinitionLoc(), Name);
533   NamingCheckFailure &Failure = NamingCheckFailures[ID];
534   SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
535 
536   if (!isValidAsciiIdentifier(Info.Fixup))
537     Failure.FixStatus = ShouldFixStatus::FixInvalidIdentifier;
538 
539   Failure.Info = std::move(Info);
540   addUsage(ID, Range, SourceMgr);
541 }
542 
543 void RenamerClangTidyCheck::expandMacro(const Token &MacroNameTok,
544                                         const MacroInfo *MI,
545                                         const SourceManager &SourceMgr) {
546   StringRef Name = MacroNameTok.getIdentifierInfo()->getName();
547   NamingCheckId ID(MI->getDefinitionLoc(), Name);
548 
549   auto Failure = NamingCheckFailures.find(ID);
550   if (Failure == NamingCheckFailures.end())
551     return;
552 
553   SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
554   addUsage(ID, Range, SourceMgr);
555 }
556 
557 static std::string
558 getDiagnosticSuffix(const RenamerClangTidyCheck::ShouldFixStatus FixStatus,
559                     const std::string &Fixup) {
560   if (Fixup.empty() ||
561       FixStatus == RenamerClangTidyCheck::ShouldFixStatus::FixInvalidIdentifier)
562     return "; cannot be fixed automatically";
563   if (FixStatus == RenamerClangTidyCheck::ShouldFixStatus::ShouldFix)
564     return {};
565   if (FixStatus >=
566       RenamerClangTidyCheck::ShouldFixStatus::IgnoreFailureThreshold)
567     return {};
568   if (FixStatus == RenamerClangTidyCheck::ShouldFixStatus::ConflictsWithKeyword)
569     return "; cannot be fixed because '" + Fixup +
570            "' would conflict with a keyword";
571   if (FixStatus ==
572       RenamerClangTidyCheck::ShouldFixStatus::ConflictsWithMacroDefinition)
573     return "; cannot be fixed because '" + Fixup +
574            "' would conflict with a macro definition";
575   llvm_unreachable("invalid ShouldFixStatus");
576 }
577 
578 void RenamerClangTidyCheck::onEndOfTranslationUnit() {
579   for (const auto &Pair : NamingCheckFailures) {
580     const NamingCheckId &Decl = Pair.first;
581     const NamingCheckFailure &Failure = Pair.second;
582 
583     if (Failure.Info.KindName.empty())
584       continue;
585 
586     if (Failure.shouldNotify()) {
587       auto DiagInfo = getDiagInfo(Decl, Failure);
588       auto Diag = diag(Decl.first,
589                        DiagInfo.Text + getDiagnosticSuffix(Failure.FixStatus,
590                                                            Failure.Info.Fixup));
591       DiagInfo.ApplyArgs(Diag);
592 
593       if (Failure.shouldFix()) {
594         for (const auto &Loc : Failure.RawUsageLocs) {
595           // We assume that the identifier name is made of one token only. This
596           // is always the case as we ignore usages in macros that could build
597           // identifier names by combining multiple tokens.
598           //
599           // For destructors, we already take care of it by remembering the
600           // location of the start of the identifier and not the start of the
601           // tilde.
602           //
603           // Other multi-token identifiers, such as operators are not checked at
604           // all.
605           Diag << FixItHint::CreateReplacement(SourceRange(Loc),
606                                                Failure.Info.Fixup);
607         }
608       }
609     }
610   }
611 }
612 
613 } // namespace clang::tidy
614