16 #include "llvm/ADT/Optional.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/Support/Errc.h"
19 #include "llvm/Support/Error.h"
25 using namespace clang;
26 using namespace transformer;
29 using ast_matchers::internal::DynTypedMatcher;
38 for (
const auto &E : ASTEdits) {
41 return Range.takeError();
53 auto Replacement = E.Replacement->eval(Result);
55 return Replacement.takeError();
56 auto Metadata = E.Metadata(Result);
58 return Metadata.takeError();
64 Edits.push_back(std::move(T));
70 return [Edits = std::move(Edits)](
const MatchResult &Result) {
82 return [Anchor = std::move(Anchor)](
const MatchResult &Result)
86 return Range.takeError();
90 Result.SourceManager->getSpellingLoc(
Range->getBegin());
101 if (Generators.size() == 1)
102 return std::move(Generators[0]);
104 [Gs = std::move(Generators)](
107 for (
const auto &G : Gs) {
110 return Edits.takeError();
111 AllEdits.append(Edits->begin(), Edits->end());
130 SimpleTextGenerator(std::string S) : S(
std::move(S)) {}
132 std::string *Result)
const override {
134 return llvm::Error::success();
136 std::string
toString()
const override {
137 return (llvm::Twine(
"text(\"") + S +
"\")").str();
143 return std::make_shared<SimpleTextGenerator>(std::move(S));
155 return (
"<" + Header +
">").str();
157 llvm_unreachable(
"Unknown transformer::IncludeFormat enum");
172 std::move(Explanation)}}};
179 template <
typename T>
180 class BindingsMatcher :
public ast_matchers::internal::MatcherInterface<T> {
182 const ast_matchers::internal::Matcher<T> InnerMatcher;
186 ast_matchers::internal::Matcher<T> InnerMatcher)
190 const T &
Node, ast_matchers::internal::ASTMatchFinder *Finder,
191 ast_matchers::internal::BoundNodesTreeBuilder *Builder)
const override {
192 ast_matchers::internal::BoundNodesTreeBuilder Result(*Builder);
193 for (
const auto &N :
Nodes.getMap())
194 Result.setBinding(N.first, N.second);
195 if (InnerMatcher.matches(
Node, Finder, &Result)) {
196 *Builder = std::move(Result);
208 template <
typename T>
209 class DynamicForEachDescendantMatcher
210 :
public ast_matchers::internal::MatcherInterface<T> {
211 const DynTypedMatcher DescendantMatcher;
214 explicit DynamicForEachDescendantMatcher(DynTypedMatcher DescendantMatcher)
215 : DescendantMatcher(
std::move(DescendantMatcher)) {}
218 const T &
Node, ast_matchers::internal::ASTMatchFinder *Finder,
219 ast_matchers::internal::BoundNodesTreeBuilder *Builder)
const override {
220 return Finder->matchesDescendantOf(
221 Node, this->DescendantMatcher, Builder,
222 ast_matchers::internal::ASTMatchFinder::BK_All);
226 template <
typename T>
227 ast_matchers::internal::Matcher<T>
230 return ast_matchers::internal::makeMatcher(
new BindingsMatcher<T>(
232 ast_matchers::internal::makeMatcher(
233 new DynamicForEachDescendantMatcher<T>(std::move(M)))));
240 template <
typename T>
252 auto Transformations = Case.
Edits(Result);
253 if (!Transformations) {
254 Edits = Transformations.takeError();
257 Edits->append(Transformations->begin(), Transformations->end());
267 template <
typename T>
271 ApplyRuleCallback Callback(std::move(Rule));
273 Callback.registerMatchers<T>(Result.Nodes, &Finder);
274 Finder.match(
Node, *Result.Context);
275 return std::move(Callback.Edits);
307 return llvm::make_error<llvm::StringError>(
308 llvm::errc::invalid_argument,
309 "type unsupported for recursive rewriting, Kind=" +
315 return [NodeId = std::move(NodeId),
319 Result.Nodes.getMap();
320 auto It = NodesMap.find(NodeId);
321 if (It == NodesMap.end())
322 return llvm::make_error<llvm::StringError>(llvm::errc::invalid_argument,
323 "ID not bound: " + NodeId);
330 for (
auto &Case : Rule.
Cases)
351 std::vector<DynTypedMatcher> Matchers;
352 Matchers.reserve(Cases.size());
353 for (
const auto &Case : Cases) {
354 std::string Tag = (TagBase + Twine(Case.first)).str();
356 DynTypedMatcher BoundMatcher(Case.second.
Matcher);
357 BoundMatcher.setAllowBind(
true);
358 auto M = *BoundMatcher.tryBind(Tag);
359 Matchers.push_back(!M.getTraversalKind()
360 ? M.withTraversalKind(DefaultTraversalKind)
371 for (
auto &Rule : Rules)
376 std::vector<DynTypedMatcher>
382 std::map<ASTNodeKind, SmallVector<std::pair<size_t, RewriteRule::Case>, 1>>
385 for (
int I = 0, N = Cases.size(); I < N; ++I) {
387 "Matcher must be non-(Qual)Type node matcher");
388 Buckets[Cases[I].Matcher.getSupportedKind()].emplace_back(I, Cases[I]);
396 std::vector<DynTypedMatcher> Matchers;
397 for (
const auto &Bucket : Buckets) {
398 DynTypedMatcher M = DynTypedMatcher::constructVariadic(
399 DynTypedMatcher::VO_AnyOf, Bucket.first,
401 M.setAllowBind(
true);
403 Matchers.push_back(M.tryBind(
RootID)->withTraversalKind(
TK_AsIs));
410 assert(Ms.size() == 1 &&
"Cases must have compatible matchers.");
415 auto &NodesMap = Result.Nodes.getMap();
416 auto Root = NodesMap.find(
RootID);
417 assert(Root != NodesMap.end() &&
"Transformation failed: missing root node.");
422 return RootRange->getBegin();
425 return Result.SourceManager->getExpansionLoc(
426 Root->second.getSourceRange().getBegin());
434 if (Rule.
Cases.size() == 1)
435 return Rule.
Cases[0];
437 auto &NodesMap = Result.Nodes.getMap();
438 for (
size_t i = 0, N = Rule.
Cases.size(); i < N; ++i) {
439 std::string Tag = (
"Tag" + Twine(i)).str();
440 if (NodesMap.find(Tag) != NodesMap.end())
441 return Rule.
Cases[i];
443 llvm_unreachable(
"No tag found for this rule.");