1 //===--- USRFindingAction.cpp - Clang refactoring library -----------------===//
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 /// \file
10 /// Provides an action to find USR for the symbol at <offset>, as well as
11 /// all additional USRs.
12 ///
13 //===----------------------------------------------------------------------===//
14
15 #include "clang/Tooling/Refactoring/Rename/USRFindingAction.h"
16 #include "clang/AST/AST.h"
17 #include "clang/AST/ASTConsumer.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/RecursiveASTVisitor.h"
21 #include "clang/Basic/FileManager.h"
22 #include "clang/Frontend/CompilerInstance.h"
23 #include "clang/Frontend/FrontendAction.h"
24 #include "clang/Lex/Lexer.h"
25 #include "clang/Lex/Preprocessor.h"
26 #include "clang/Tooling/CommonOptionsParser.h"
27 #include "clang/Tooling/Refactoring.h"
28 #include "clang/Tooling/Refactoring/Rename/USRFinder.h"
29 #include "clang/Tooling/Tooling.h"
30
31 #include <algorithm>
32 #include <set>
33 #include <string>
34 #include <vector>
35
36 using namespace llvm;
37
38 namespace clang {
39 namespace tooling {
40
getCanonicalSymbolDeclaration(const NamedDecl * FoundDecl)41 const NamedDecl *getCanonicalSymbolDeclaration(const NamedDecl *FoundDecl) {
42 if (!FoundDecl)
43 return nullptr;
44 // If FoundDecl is a constructor or destructor, we want to instead take
45 // the Decl of the corresponding class.
46 if (const auto *CtorDecl = dyn_cast<CXXConstructorDecl>(FoundDecl))
47 FoundDecl = CtorDecl->getParent();
48 else if (const auto *DtorDecl = dyn_cast<CXXDestructorDecl>(FoundDecl))
49 FoundDecl = DtorDecl->getParent();
50 // FIXME: (Alex L): Canonicalize implicit template instantions, just like
51 // the indexer does it.
52
53 // Note: please update the declaration's doc comment every time the
54 // canonicalization rules are changed.
55 return FoundDecl;
56 }
57
58 namespace {
59 // NamedDeclFindingConsumer should delegate finding USRs of given Decl to
60 // AdditionalUSRFinder. AdditionalUSRFinder adds USRs of ctor and dtor if given
61 // Decl refers to class and adds USRs of all overridden methods if Decl refers
62 // to virtual method.
63 class AdditionalUSRFinder : public RecursiveASTVisitor<AdditionalUSRFinder> {
64 public:
AdditionalUSRFinder(const Decl * FoundDecl,ASTContext & Context)65 AdditionalUSRFinder(const Decl *FoundDecl, ASTContext &Context)
66 : FoundDecl(FoundDecl), Context(Context) {}
67
Find()68 std::vector<std::string> Find() {
69 // Fill OverriddenMethods and PartialSpecs storages.
70 TraverseAST(Context);
71 if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(FoundDecl)) {
72 addUSRsOfOverridenFunctions(MethodDecl);
73 for (const auto &OverriddenMethod : OverriddenMethods) {
74 if (checkIfOverriddenFunctionAscends(OverriddenMethod))
75 USRSet.insert(getUSRForDecl(OverriddenMethod));
76 }
77 addUSRsOfInstantiatedMethods(MethodDecl);
78 } else if (const auto *RecordDecl = dyn_cast<CXXRecordDecl>(FoundDecl)) {
79 handleCXXRecordDecl(RecordDecl);
80 } else if (const auto *TemplateDecl =
81 dyn_cast<ClassTemplateDecl>(FoundDecl)) {
82 handleClassTemplateDecl(TemplateDecl);
83 } else if (const auto *FD = dyn_cast<FunctionDecl>(FoundDecl)) {
84 USRSet.insert(getUSRForDecl(FD));
85 if (const auto *FTD = FD->getPrimaryTemplate())
86 handleFunctionTemplateDecl(FTD);
87 } else if (const auto *FD = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
88 handleFunctionTemplateDecl(FD);
89 } else if (const auto *VTD = dyn_cast<VarTemplateDecl>(FoundDecl)) {
90 handleVarTemplateDecl(VTD);
91 } else if (const auto *VD =
92 dyn_cast<VarTemplateSpecializationDecl>(FoundDecl)) {
93 // FIXME: figure out why FoundDecl can be a VarTemplateSpecializationDecl.
94 handleVarTemplateDecl(VD->getSpecializedTemplate());
95 } else if (const auto *VD = dyn_cast<VarDecl>(FoundDecl)) {
96 USRSet.insert(getUSRForDecl(VD));
97 if (const auto *VTD = VD->getDescribedVarTemplate())
98 handleVarTemplateDecl(VTD);
99 } else {
100 USRSet.insert(getUSRForDecl(FoundDecl));
101 }
102 return std::vector<std::string>(USRSet.begin(), USRSet.end());
103 }
104
shouldVisitTemplateInstantiations() const105 bool shouldVisitTemplateInstantiations() const { return true; }
106
VisitCXXMethodDecl(const CXXMethodDecl * MethodDecl)107 bool VisitCXXMethodDecl(const CXXMethodDecl *MethodDecl) {
108 if (MethodDecl->isVirtual())
109 OverriddenMethods.push_back(MethodDecl);
110 if (MethodDecl->getInstantiatedFromMemberFunction())
111 InstantiatedMethods.push_back(MethodDecl);
112 return true;
113 }
114
115 private:
handleCXXRecordDecl(const CXXRecordDecl * RecordDecl)116 void handleCXXRecordDecl(const CXXRecordDecl *RecordDecl) {
117 if (!RecordDecl->getDefinition()) {
118 USRSet.insert(getUSRForDecl(RecordDecl));
119 return;
120 }
121 RecordDecl = RecordDecl->getDefinition();
122 if (const auto *ClassTemplateSpecDecl =
123 dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl))
124 handleClassTemplateDecl(ClassTemplateSpecDecl->getSpecializedTemplate());
125 addUSRsOfCtorDtors(RecordDecl);
126 }
127
handleClassTemplateDecl(const ClassTemplateDecl * TemplateDecl)128 void handleClassTemplateDecl(const ClassTemplateDecl *TemplateDecl) {
129 for (const auto *Specialization : TemplateDecl->specializations())
130 addUSRsOfCtorDtors(Specialization);
131 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
132 TemplateDecl->getPartialSpecializations(PartialSpecs);
133 for (const auto *Spec : PartialSpecs)
134 addUSRsOfCtorDtors(Spec);
135 addUSRsOfCtorDtors(TemplateDecl->getTemplatedDecl());
136 }
137
handleFunctionTemplateDecl(const FunctionTemplateDecl * FTD)138 void handleFunctionTemplateDecl(const FunctionTemplateDecl *FTD) {
139 USRSet.insert(getUSRForDecl(FTD));
140 USRSet.insert(getUSRForDecl(FTD->getTemplatedDecl()));
141 for (const auto *S : FTD->specializations())
142 USRSet.insert(getUSRForDecl(S));
143 }
144
handleVarTemplateDecl(const VarTemplateDecl * VTD)145 void handleVarTemplateDecl(const VarTemplateDecl *VTD) {
146 USRSet.insert(getUSRForDecl(VTD));
147 USRSet.insert(getUSRForDecl(VTD->getTemplatedDecl()));
148 llvm::for_each(VTD->specializations(), [&](const auto *Spec) {
149 USRSet.insert(getUSRForDecl(Spec));
150 });
151 SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
152 VTD->getPartialSpecializations(PartialSpecs);
153 llvm::for_each(PartialSpecs, [&](const auto *Spec) {
154 USRSet.insert(getUSRForDecl(Spec));
155 });
156 }
157
addUSRsOfCtorDtors(const CXXRecordDecl * RD)158 void addUSRsOfCtorDtors(const CXXRecordDecl *RD) {
159 const auto* RecordDecl = RD->getDefinition();
160
161 // Skip if the CXXRecordDecl doesn't have definition.
162 if (!RecordDecl) {
163 USRSet.insert(getUSRForDecl(RD));
164 return;
165 }
166
167 for (const auto *CtorDecl : RecordDecl->ctors())
168 USRSet.insert(getUSRForDecl(CtorDecl));
169 // Add template constructor decls, they are not in ctors() unfortunately.
170 if (RecordDecl->hasUserDeclaredConstructor())
171 for (const auto *D : RecordDecl->decls())
172 if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(D))
173 if (const auto *Ctor =
174 dyn_cast<CXXConstructorDecl>(FTD->getTemplatedDecl()))
175 USRSet.insert(getUSRForDecl(Ctor));
176
177 USRSet.insert(getUSRForDecl(RecordDecl->getDestructor()));
178 USRSet.insert(getUSRForDecl(RecordDecl));
179 }
180
addUSRsOfOverridenFunctions(const CXXMethodDecl * MethodDecl)181 void addUSRsOfOverridenFunctions(const CXXMethodDecl *MethodDecl) {
182 USRSet.insert(getUSRForDecl(MethodDecl));
183 // Recursively visit each OverridenMethod.
184 for (const auto &OverriddenMethod : MethodDecl->overridden_methods())
185 addUSRsOfOverridenFunctions(OverriddenMethod);
186 }
187
addUSRsOfInstantiatedMethods(const CXXMethodDecl * MethodDecl)188 void addUSRsOfInstantiatedMethods(const CXXMethodDecl *MethodDecl) {
189 // For renaming a class template method, all references of the instantiated
190 // member methods should be renamed too, so add USRs of the instantiated
191 // methods to the USR set.
192 USRSet.insert(getUSRForDecl(MethodDecl));
193 if (const auto *FT = MethodDecl->getInstantiatedFromMemberFunction())
194 USRSet.insert(getUSRForDecl(FT));
195 for (const auto *Method : InstantiatedMethods) {
196 if (USRSet.find(getUSRForDecl(
197 Method->getInstantiatedFromMemberFunction())) != USRSet.end())
198 USRSet.insert(getUSRForDecl(Method));
199 }
200 }
201
checkIfOverriddenFunctionAscends(const CXXMethodDecl * MethodDecl)202 bool checkIfOverriddenFunctionAscends(const CXXMethodDecl *MethodDecl) {
203 for (const auto &OverriddenMethod : MethodDecl->overridden_methods()) {
204 if (USRSet.find(getUSRForDecl(OverriddenMethod)) != USRSet.end())
205 return true;
206 return checkIfOverriddenFunctionAscends(OverriddenMethod);
207 }
208 return false;
209 }
210
211 const Decl *FoundDecl;
212 ASTContext &Context;
213 std::set<std::string> USRSet;
214 std::vector<const CXXMethodDecl *> OverriddenMethods;
215 std::vector<const CXXMethodDecl *> InstantiatedMethods;
216 };
217 } // namespace
218
getUSRsForDeclaration(const NamedDecl * ND,ASTContext & Context)219 std::vector<std::string> getUSRsForDeclaration(const NamedDecl *ND,
220 ASTContext &Context) {
221 AdditionalUSRFinder Finder(ND, Context);
222 return Finder.Find();
223 }
224
225 class NamedDeclFindingConsumer : public ASTConsumer {
226 public:
NamedDeclFindingConsumer(ArrayRef<unsigned> SymbolOffsets,ArrayRef<std::string> QualifiedNames,std::vector<std::string> & SpellingNames,std::vector<std::vector<std::string>> & USRList,bool Force,bool & ErrorOccurred)227 NamedDeclFindingConsumer(ArrayRef<unsigned> SymbolOffsets,
228 ArrayRef<std::string> QualifiedNames,
229 std::vector<std::string> &SpellingNames,
230 std::vector<std::vector<std::string>> &USRList,
231 bool Force, bool &ErrorOccurred)
232 : SymbolOffsets(SymbolOffsets), QualifiedNames(QualifiedNames),
233 SpellingNames(SpellingNames), USRList(USRList), Force(Force),
234 ErrorOccurred(ErrorOccurred) {}
235
236 private:
FindSymbol(ASTContext & Context,const SourceManager & SourceMgr,unsigned SymbolOffset,const std::string & QualifiedName)237 bool FindSymbol(ASTContext &Context, const SourceManager &SourceMgr,
238 unsigned SymbolOffset, const std::string &QualifiedName) {
239 DiagnosticsEngine &Engine = Context.getDiagnostics();
240 const FileID MainFileID = SourceMgr.getMainFileID();
241
242 if (SymbolOffset >= SourceMgr.getFileIDSize(MainFileID)) {
243 ErrorOccurred = true;
244 unsigned InvalidOffset = Engine.getCustomDiagID(
245 DiagnosticsEngine::Error,
246 "SourceLocation in file %0 at offset %1 is invalid");
247 Engine.Report(SourceLocation(), InvalidOffset)
248 << SourceMgr.getFileEntryForID(MainFileID)->getName() << SymbolOffset;
249 return false;
250 }
251
252 const SourceLocation Point = SourceMgr.getLocForStartOfFile(MainFileID)
253 .getLocWithOffset(SymbolOffset);
254 const NamedDecl *FoundDecl = QualifiedName.empty()
255 ? getNamedDeclAt(Context, Point)
256 : getNamedDeclFor(Context, QualifiedName);
257
258 if (FoundDecl == nullptr) {
259 if (QualifiedName.empty()) {
260 FullSourceLoc FullLoc(Point, SourceMgr);
261 unsigned CouldNotFindSymbolAt = Engine.getCustomDiagID(
262 DiagnosticsEngine::Error,
263 "clang-rename could not find symbol (offset %0)");
264 Engine.Report(Point, CouldNotFindSymbolAt) << SymbolOffset;
265 ErrorOccurred = true;
266 return false;
267 }
268
269 if (Force) {
270 SpellingNames.push_back(std::string());
271 USRList.push_back(std::vector<std::string>());
272 return true;
273 }
274
275 unsigned CouldNotFindSymbolNamed = Engine.getCustomDiagID(
276 DiagnosticsEngine::Error, "clang-rename could not find symbol %0");
277 Engine.Report(CouldNotFindSymbolNamed) << QualifiedName;
278 ErrorOccurred = true;
279 return false;
280 }
281
282 FoundDecl = getCanonicalSymbolDeclaration(FoundDecl);
283 SpellingNames.push_back(FoundDecl->getNameAsString());
284 AdditionalUSRFinder Finder(FoundDecl, Context);
285 USRList.push_back(Finder.Find());
286 return true;
287 }
288
HandleTranslationUnit(ASTContext & Context)289 void HandleTranslationUnit(ASTContext &Context) override {
290 const SourceManager &SourceMgr = Context.getSourceManager();
291 for (unsigned Offset : SymbolOffsets) {
292 if (!FindSymbol(Context, SourceMgr, Offset, ""))
293 return;
294 }
295 for (const std::string &QualifiedName : QualifiedNames) {
296 if (!FindSymbol(Context, SourceMgr, 0, QualifiedName))
297 return;
298 }
299 }
300
301 ArrayRef<unsigned> SymbolOffsets;
302 ArrayRef<std::string> QualifiedNames;
303 std::vector<std::string> &SpellingNames;
304 std::vector<std::vector<std::string>> &USRList;
305 bool Force;
306 bool &ErrorOccurred;
307 };
308
newASTConsumer()309 std::unique_ptr<ASTConsumer> USRFindingAction::newASTConsumer() {
310 return std::make_unique<NamedDeclFindingConsumer>(
311 SymbolOffsets, QualifiedNames, SpellingNames, USRList, Force,
312 ErrorOccurred);
313 }
314
315 } // end namespace tooling
316 } // end namespace clang
317