1 //===--- RefactoringCallbacks.cpp - Structural query framework ------------===//
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 //
10 //===----------------------------------------------------------------------===//
11 #include "clang/Tooling/RefactoringCallbacks.h"
12 #include "clang/ASTMatchers/ASTMatchFinder.h"
13 #include "clang/Basic/SourceLocation.h"
14 #include "clang/Lex/Lexer.h"
15
16 using llvm::StringError;
17 using llvm::make_error;
18
19 namespace clang {
20 namespace tooling {
21
RefactoringCallback()22 RefactoringCallback::RefactoringCallback() {}
getReplacements()23 tooling::Replacements &RefactoringCallback::getReplacements() {
24 return Replace;
25 }
26
ASTMatchRefactorer(std::map<std::string,Replacements> & FileToReplaces)27 ASTMatchRefactorer::ASTMatchRefactorer(
28 std::map<std::string, Replacements> &FileToReplaces)
29 : FileToReplaces(FileToReplaces) {}
30
addDynamicMatcher(const ast_matchers::internal::DynTypedMatcher & Matcher,RefactoringCallback * Callback)31 void ASTMatchRefactorer::addDynamicMatcher(
32 const ast_matchers::internal::DynTypedMatcher &Matcher,
33 RefactoringCallback *Callback) {
34 MatchFinder.addDynamicMatcher(Matcher, Callback);
35 Callbacks.push_back(Callback);
36 }
37
38 class RefactoringASTConsumer : public ASTConsumer {
39 public:
RefactoringASTConsumer(ASTMatchRefactorer & Refactoring)40 explicit RefactoringASTConsumer(ASTMatchRefactorer &Refactoring)
41 : Refactoring(Refactoring) {}
42
HandleTranslationUnit(ASTContext & Context)43 void HandleTranslationUnit(ASTContext &Context) override {
44 // The ASTMatchRefactorer is re-used between translation units.
45 // Clear the matchers so that each Replacement is only emitted once.
46 for (const auto &Callback : Refactoring.Callbacks) {
47 Callback->getReplacements().clear();
48 }
49 Refactoring.MatchFinder.matchAST(Context);
50 for (const auto &Callback : Refactoring.Callbacks) {
51 for (const auto &Replacement : Callback->getReplacements()) {
52 llvm::Error Err =
53 Refactoring.FileToReplaces[std::string(Replacement.getFilePath())]
54 .add(Replacement);
55 if (Err) {
56 llvm::errs() << "Skipping replacement " << Replacement.toString()
57 << " due to this error:\n"
58 << toString(std::move(Err)) << "\n";
59 }
60 }
61 }
62 }
63
64 private:
65 ASTMatchRefactorer &Refactoring;
66 };
67
newASTConsumer()68 std::unique_ptr<ASTConsumer> ASTMatchRefactorer::newASTConsumer() {
69 return std::make_unique<RefactoringASTConsumer>(*this);
70 }
71
replaceStmtWithText(SourceManager & Sources,const Stmt & From,StringRef Text)72 static Replacement replaceStmtWithText(SourceManager &Sources, const Stmt &From,
73 StringRef Text) {
74 return tooling::Replacement(
75 Sources, CharSourceRange::getTokenRange(From.getSourceRange()), Text);
76 }
replaceStmtWithStmt(SourceManager & Sources,const Stmt & From,const Stmt & To)77 static Replacement replaceStmtWithStmt(SourceManager &Sources, const Stmt &From,
78 const Stmt &To) {
79 return replaceStmtWithText(
80 Sources, From,
81 Lexer::getSourceText(CharSourceRange::getTokenRange(To.getSourceRange()),
82 Sources, LangOptions()));
83 }
84
ReplaceStmtWithText(StringRef FromId,StringRef ToText)85 ReplaceStmtWithText::ReplaceStmtWithText(StringRef FromId, StringRef ToText)
86 : FromId(std::string(FromId)), ToText(std::string(ToText)) {}
87
run(const ast_matchers::MatchFinder::MatchResult & Result)88 void ReplaceStmtWithText::run(
89 const ast_matchers::MatchFinder::MatchResult &Result) {
90 if (const Stmt *FromMatch = Result.Nodes.getNodeAs<Stmt>(FromId)) {
91 auto Err = Replace.add(tooling::Replacement(
92 *Result.SourceManager,
93 CharSourceRange::getTokenRange(FromMatch->getSourceRange()), ToText));
94 // FIXME: better error handling. For now, just print error message in the
95 // release version.
96 if (Err) {
97 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
98 assert(false);
99 }
100 }
101 }
102
ReplaceStmtWithStmt(StringRef FromId,StringRef ToId)103 ReplaceStmtWithStmt::ReplaceStmtWithStmt(StringRef FromId, StringRef ToId)
104 : FromId(std::string(FromId)), ToId(std::string(ToId)) {}
105
run(const ast_matchers::MatchFinder::MatchResult & Result)106 void ReplaceStmtWithStmt::run(
107 const ast_matchers::MatchFinder::MatchResult &Result) {
108 const Stmt *FromMatch = Result.Nodes.getNodeAs<Stmt>(FromId);
109 const Stmt *ToMatch = Result.Nodes.getNodeAs<Stmt>(ToId);
110 if (FromMatch && ToMatch) {
111 auto Err = Replace.add(
112 replaceStmtWithStmt(*Result.SourceManager, *FromMatch, *ToMatch));
113 // FIXME: better error handling. For now, just print error message in the
114 // release version.
115 if (Err) {
116 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
117 assert(false);
118 }
119 }
120 }
121
ReplaceIfStmtWithItsBody(StringRef Id,bool PickTrueBranch)122 ReplaceIfStmtWithItsBody::ReplaceIfStmtWithItsBody(StringRef Id,
123 bool PickTrueBranch)
124 : Id(std::string(Id)), PickTrueBranch(PickTrueBranch) {}
125
run(const ast_matchers::MatchFinder::MatchResult & Result)126 void ReplaceIfStmtWithItsBody::run(
127 const ast_matchers::MatchFinder::MatchResult &Result) {
128 if (const IfStmt *Node = Result.Nodes.getNodeAs<IfStmt>(Id)) {
129 const Stmt *Body = PickTrueBranch ? Node->getThen() : Node->getElse();
130 if (Body) {
131 auto Err =
132 Replace.add(replaceStmtWithStmt(*Result.SourceManager, *Node, *Body));
133 // FIXME: better error handling. For now, just print error message in the
134 // release version.
135 if (Err) {
136 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
137 assert(false);
138 }
139 } else if (!PickTrueBranch) {
140 // If we want to use the 'else'-branch, but it doesn't exist, delete
141 // the whole 'if'.
142 auto Err =
143 Replace.add(replaceStmtWithText(*Result.SourceManager, *Node, ""));
144 // FIXME: better error handling. For now, just print error message in the
145 // release version.
146 if (Err) {
147 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
148 assert(false);
149 }
150 }
151 }
152 }
153
ReplaceNodeWithTemplate(llvm::StringRef FromId,std::vector<TemplateElement> Template)154 ReplaceNodeWithTemplate::ReplaceNodeWithTemplate(
155 llvm::StringRef FromId, std::vector<TemplateElement> Template)
156 : FromId(std::string(FromId)), Template(std::move(Template)) {}
157
158 llvm::Expected<std::unique_ptr<ReplaceNodeWithTemplate>>
create(StringRef FromId,StringRef ToTemplate)159 ReplaceNodeWithTemplate::create(StringRef FromId, StringRef ToTemplate) {
160 std::vector<TemplateElement> ParsedTemplate;
161 for (size_t Index = 0; Index < ToTemplate.size();) {
162 if (ToTemplate[Index] == '$') {
163 if (ToTemplate.substr(Index, 2) == "$$") {
164 Index += 2;
165 ParsedTemplate.push_back(
166 TemplateElement{TemplateElement::Literal, "$"});
167 } else if (ToTemplate.substr(Index, 2) == "${") {
168 size_t EndOfIdentifier = ToTemplate.find("}", Index);
169 if (EndOfIdentifier == std::string::npos) {
170 return make_error<StringError>(
171 "Unterminated ${...} in replacement template near " +
172 ToTemplate.substr(Index),
173 llvm::inconvertibleErrorCode());
174 }
175 std::string SourceNodeName = std::string(
176 ToTemplate.substr(Index + 2, EndOfIdentifier - Index - 2));
177 ParsedTemplate.push_back(
178 TemplateElement{TemplateElement::Identifier, SourceNodeName});
179 Index = EndOfIdentifier + 1;
180 } else {
181 return make_error<StringError>(
182 "Invalid $ in replacement template near " +
183 ToTemplate.substr(Index),
184 llvm::inconvertibleErrorCode());
185 }
186 } else {
187 size_t NextIndex = ToTemplate.find('$', Index + 1);
188 ParsedTemplate.push_back(TemplateElement{
189 TemplateElement::Literal,
190 std::string(ToTemplate.substr(Index, NextIndex - Index))});
191 Index = NextIndex;
192 }
193 }
194 return std::unique_ptr<ReplaceNodeWithTemplate>(
195 new ReplaceNodeWithTemplate(FromId, std::move(ParsedTemplate)));
196 }
197
run(const ast_matchers::MatchFinder::MatchResult & Result)198 void ReplaceNodeWithTemplate::run(
199 const ast_matchers::MatchFinder::MatchResult &Result) {
200 const auto &NodeMap = Result.Nodes.getMap();
201
202 std::string ToText;
203 for (const auto &Element : Template) {
204 switch (Element.Type) {
205 case TemplateElement::Literal:
206 ToText += Element.Value;
207 break;
208 case TemplateElement::Identifier: {
209 auto NodeIter = NodeMap.find(Element.Value);
210 if (NodeIter == NodeMap.end()) {
211 llvm::errs() << "Node " << Element.Value
212 << " used in replacement template not bound in Matcher \n";
213 llvm::report_fatal_error("Unbound node in replacement template.");
214 }
215 CharSourceRange Source =
216 CharSourceRange::getTokenRange(NodeIter->second.getSourceRange());
217 ToText += Lexer::getSourceText(Source, *Result.SourceManager,
218 Result.Context->getLangOpts());
219 break;
220 }
221 }
222 }
223 if (NodeMap.count(FromId) == 0) {
224 llvm::errs() << "Node to be replaced " << FromId
225 << " not bound in query.\n";
226 llvm::report_fatal_error("FromId node not bound in MatchResult");
227 }
228 auto Replacement =
229 tooling::Replacement(*Result.SourceManager, &NodeMap.at(FromId), ToText,
230 Result.Context->getLangOpts());
231 llvm::Error Err = Replace.add(Replacement);
232 if (Err) {
233 llvm::errs() << "Query and replace failed in " << Replacement.getFilePath()
234 << "! " << llvm::toString(std::move(Err)) << "\n";
235 llvm::report_fatal_error("Replacement failed");
236 }
237 }
238
239 } // end namespace tooling
240 } // end namespace clang
241