ymandel created this revision.
ymandel added a reviewer: gribozavr.
Herald added a project: clang.
ymandel requested review of this revision.
The new overloads apply directly to a node, like the
`clang::ast_matchers::match` functions, Rather than generating an
`EditGenerator` combinator.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D87031
Files:
clang/include/clang/Tooling/Transformer/RewriteRule.h
clang/lib/Tooling/Transformer/RewriteRule.cpp
clang/unittests/Tooling/TransformerTest.cpp
Index: clang/unittests/Tooling/TransformerTest.cpp
===================================================================
--- clang/unittests/Tooling/TransformerTest.cpp
+++ clang/unittests/Tooling/TransformerTest.cpp
@@ -568,6 +568,84 @@
EXPECT_EQ(ErrorCount, 1);
}
+//
+// We include one test per typed overload. We don't test extensively since that
+// is already covered by the tests above.
+//
+
+TEST_F(TransformerTest, RewriteDescendantsTypedStmt) {
+ // Add an unrelated definition to the header that also has a variable named
+ // "x", to test that the rewrite is limited to the scope we intend.
+ appendToHeader(R"cc(int g(int x) { return x; })cc");
+ std::string Input =
+ "int f(int x) { int y = x; { int z = x * x; } return x; }";
+ std::string Expected =
+ "int f(int x) { int y = 3; { int z = 3 * 3; } return 3; }";
+ auto InlineX =
+ makeRule(declRefExpr(to(varDecl(hasName("x")))), changeTo(cat("3")));
+ testRule(makeRule(functionDecl(hasName("f"), hasBody(stmt().bind("body"))),
+ [&InlineX](const MatchFinder::MatchResult &R) {
+ const auto *Node = R.Nodes.getNodeAs<Stmt>("body");
+ assert(Node != nullptr && "body must be bound");
+ return rewriteDescendants(*Node, InlineX, R);
+ }),
+ Input, Expected);
+}
+
+TEST_F(TransformerTest, RewriteDescendantsTypedDecl) {
+ std::string Input =
+ "int f(int x) { int y = x; { int z = x * x; } return x; }";
+ std::string Expected =
+ "int f(int x) { int y = 3; { int z = 3 * 3; } return 3; }";
+ auto InlineX =
+ makeRule(declRefExpr(to(varDecl(hasName("x")))), changeTo(cat("3")));
+ testRule(makeRule(functionDecl(hasName("f")).bind("fun"),
+ [&InlineX](const MatchFinder::MatchResult &R) {
+ const auto *Node = R.Nodes.getNodeAs<Decl>("fun");
+ assert(Node != nullptr && "fun must be bound");
+ return rewriteDescendants(*Node, InlineX, R);
+ }),
+ Input, Expected);
+}
+
+TEST_F(TransformerTest, RewriteDescendantsTypedTypeLoc) {
+ std::string Input = "int f(int *x) { return *x; }";
+ std::string Expected = "int f(char *x) { return *x; }";
+ auto IntToChar =
+ makeRule(typeLoc(loc(qualType(isInteger(), builtinType()))).bind("loc"),
+ changeTo(cat("char")));
+ testRule(
+ makeRule(functionDecl(hasName("f"),
+ hasParameter(0, varDecl(hasTypeLoc(
+ typeLoc().bind("parmType"))))),
+ [&IntToChar](const MatchFinder::MatchResult &R) {
+ const auto *Node = R.Nodes.getNodeAs<TypeLoc>("parmType");
+ assert(Node != nullptr && "parmType must be bound");
+ return rewriteDescendants(*Node, IntToChar, R);
+ }),
+ Input, Expected);
+}
+
+TEST_F(TransformerTest, RewriteDescendantsTypedDynTyped) {
+ // Add an unrelated definition to the header that also has a variable named
+ // "x", to test that the rewrite is limited to the scope we intend.
+ appendToHeader(R"cc(int g(int x) { return x; })cc");
+ std::string Input =
+ "int f(int x) { int y = x; { int z = x * x; } return x; }";
+ std::string Expected =
+ "int f(int x) { int y = 3; { int z = 3 * 3; } return 3; }";
+ auto InlineX =
+ makeRule(declRefExpr(to(varDecl(hasName("x")))), changeTo(cat("3")));
+ testRule(makeRule(functionDecl(hasName("f"), hasBody(stmt().bind("body"))),
+ [&InlineX](const MatchFinder::MatchResult &R) {
+ auto It = R.Nodes.getMap().find("body");
+ assert(It != R.Nodes.getMap().end() &&
+ "body must be bound");
+ return rewriteDescendants(It->second, InlineX, R);
+ }),
+ Input, Expected);
+}
+
TEST_F(TransformerTest, InsertBeforeEdit) {
std::string Input = R"cc(
int f() {
Index: clang/lib/Tooling/Transformer/RewriteRule.cpp
===================================================================
--- clang/lib/Tooling/Transformer/RewriteRule.cpp
+++ clang/lib/Tooling/Transformer/RewriteRule.cpp
@@ -242,7 +242,7 @@
} // namespace
template <typename T>
-static llvm::Expected<SmallVector<clang::transformer::Edit, 1>>
+llvm::Expected<SmallVector<clang::transformer::Edit, 1>>
rewriteDescendantsImpl(const T &Node, RewriteRule Rule,
const MatchResult &Result) {
ApplyRuleCallback Callback(std::move(Rule));
@@ -252,10 +252,42 @@
return std::move(Callback.Edits);
}
+llvm::Expected<SmallVector<clang::transformer::Edit, 1>>
+transformer::rewriteDescendants(const Decl &Node, RewriteRule Rule,
+ const MatchResult &Result) {
+ return rewriteDescendantsImpl(Node, std::move(Rule), Result);
+}
+
+llvm::Expected<SmallVector<clang::transformer::Edit, 1>>
+transformer::rewriteDescendants(const Stmt &Node, RewriteRule Rule,
+ const MatchResult &Result) {
+ return rewriteDescendantsImpl(Node, std::move(Rule), Result);
+}
+
+llvm::Expected<SmallVector<clang::transformer::Edit, 1>>
+transformer::rewriteDescendants(const TypeLoc &Node, RewriteRule Rule,
+ const MatchResult &Result) {
+ return rewriteDescendantsImpl(Node, std::move(Rule), Result);
+}
+
+llvm::Expected<SmallVector<clang::transformer::Edit, 1>>
+transformer::rewriteDescendants(const DynTypedNode &DNode, RewriteRule Rule,
+ const MatchResult &Result) {
+ if (auto *Node = DNode.get<Decl>())
+ return rewriteDescendantsImpl(*Node, std::move(Rule), Result);
+ if (auto *Node = DNode.get<Stmt>())
+ return rewriteDescendantsImpl(*Node, std::move(Rule), Result);
+ if (auto *Node = DNode.get<TypeLoc>())
+ return rewriteDescendantsImpl(*Node, std::move(Rule), Result);
+
+ return llvm::make_error<llvm::StringError>(
+ llvm::errc::invalid_argument,
+ "type unsupported for recursive rewriting, Kind=" +
+ DNode.getNodeKind().asStringRef());
+}
+
EditGenerator transformer::rewriteDescendants(std::string NodeId,
RewriteRule Rule) {
- // FIXME: warn or return error if `Rule` contains any `AddedIncludes`, since
- // these will be dropped.
return [NodeId = std::move(NodeId),
Rule = std::move(Rule)](const MatchResult &Result)
-> llvm::Expected<SmallVector<clang::transformer::Edit, 1>> {
@@ -265,17 +297,7 @@
if (It == NodesMap.end())
return llvm::make_error<llvm::StringError>(llvm::errc::invalid_argument,
"ID not bound: " + NodeId);
- if (auto *Node = It->second.get<Decl>())
- return rewriteDescendantsImpl(*Node, std::move(Rule), Result);
- if (auto *Node = It->second.get<Stmt>())
- return rewriteDescendantsImpl(*Node, std::move(Rule), Result);
- if (auto *Node = It->second.get<TypeLoc>())
- return rewriteDescendantsImpl(*Node, std::move(Rule), Result);
-
- return llvm::make_error<llvm::StringError>(
- llvm::errc::invalid_argument,
- "type unsupported for recursive rewriting, ID=\"" + NodeId +
- "\", Kind=" + It->second.getNodeKind().asStringRef());
+ return rewriteDescendants(It->second, std::move(Rule), Result);
};
}
Index: clang/include/clang/Tooling/Transformer/RewriteRule.h
===================================================================
--- clang/include/clang/Tooling/Transformer/RewriteRule.h
+++ clang/include/clang/Tooling/Transformer/RewriteRule.h
@@ -371,6 +371,36 @@
/// appearances of `x` in its body to `3`.
EditGenerator rewriteDescendants(std::string NodeId, RewriteRule Rule);
+/// Applies `Rule` to all descendants of `Node`. `Rule` can refer to nodes bound
+/// in `Result`. `Rule` is not applied to `Node` itself.
+///
+/// For example, assuming that "body" is bound to a function body in MatchResult
+/// `Results`, this will produce edits to change all appearances of `x` in that
+/// body to `3`.
+/// ```
+/// auto InlineX =
+/// makeRule(declRefExpr(to(varDecl(hasName("x")))), changeTo(cat("3")));
+/// const auto *Node = Results.Nodes.getNodeAs<Stmt>("body");
+/// auto Edits = rewriteDescendants(*Node, InlineX, Results);
+/// ```
+/// @{
+llvm::Expected<SmallVector<Edit, 1>>
+rewriteDescendants(const Decl &Node, RewriteRule Rule,
+ const ast_matchers::MatchFinder::MatchResult &Result);
+
+llvm::Expected<SmallVector<Edit, 1>>
+rewriteDescendants(const Stmt &Node, RewriteRule Rule,
+ const ast_matchers::MatchFinder::MatchResult &Result);
+
+llvm::Expected<SmallVector<Edit, 1>>
+rewriteDescendants(const TypeLoc &Node, RewriteRule Rule,
+ const ast_matchers::MatchFinder::MatchResult &Result);
+
+llvm::Expected<SmallVector<Edit, 1>>
+rewriteDescendants(const DynTypedNode &Node, RewriteRule Rule,
+ const ast_matchers::MatchFinder::MatchResult &Result);
+/// @}
+
/// The following three functions are a low-level part of the RewriteRule
/// API. We expose them for use in implementing the fixtures that interpret
/// RewriteRule, like Transformer and TransfomerTidy, or for more advanced
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
