[libTooling] Small changes in Transformer API.

[ymandel]

Summary

• Rename transformer::change to transformer::changeTo, make change forward to changeTo and mark it deprecated.

• Mark transformer::text and transformer::selection deprecated and migrate references to them in tests.

[ilya-biryukov]

LGTM

[ymandel]

Build breakage fixed in commit "6c683aa8d7d [libTooling] Fix breakage from change #84922"

clang/include/clang/Tooling/Transformer/RewriteRule.h

 //   for example, in clang-tidy diagnostics.  Use of notes should be rare --
 //   explanations of the entire rewrite should be set in the rule
 //   (`RewriteRule::Explanation`) instead.  Notes serve the rare cases wherein
 //   edit-specific diagnostics are required.
 //
 // `ASTEdit` should be built using the `change` convenience functions. For
 // example,
 // \code
-//   change(name(fun), text("Frodo"))
+//   changeTo(name(fun), cat("Frodo"))
 // \endcode
 // Or, if we use Stencil for the TextGenerator:
 // \code
 //   using stencil::cat;
-//   change(statement(thenNode), cat("{", thenNode, "}"))
-//   change(callArgs(call), cat(x, ",", y))
+//   changeTo(statement(thenNode), cat("{", thenNode, "}"))
+//   changeTo(callArgs(call), cat(x, ",", y))
 // \endcode
 // Or, if you are changing the node corresponding to the rule's matcher, you can
 // use the single-argument override of \c change:
 // \code
-//   change(cat("different_expr"))
+//   changeTo(cat("different_expr"))
 // \endcode
 struct ASTEdit {
   RangeSelector TargetRange;
   TextGenerator Replacement;
   TextGenerator Note;
 };
 
 /// Format of the path in an include directive -- angle brackets or quotes.

 }
 
 /// For every case in Rule, adds an include directive for the given header. The
 /// common use is assumed to be a rule with only one case. For example, to
 /// replace a function call and add headers corresponding to the new code, one
 /// could write:
 /// \code
 ///   auto R = makeRule(callExpr(callee(functionDecl(hasName("foo")))),
-///            change(text("bar()")));
+///            changeTo(cat("bar()")));
 ///   AddInclude(R, "path/to/bar_header.h");
 ///   AddInclude(R, "vector", IncludeFormat::Angled);
 /// \endcode
 void addInclude(RewriteRule &Rule, llvm::StringRef Header,
                 IncludeFormat Format = IncludeFormat::Quoted);
 
 /// Applies the first rule whose pattern matches; other rules are ignored.  If
 /// the matchers are independent then order doesn't matter. In that case,

 //
 // RewriteRule R = applyFirst({makeRule(two_calls, two_calls_action),
 //                             makeRule(left_call, left_call_action),
 //                             makeRule(right_call, right_call_action)});
 // ```
 RewriteRule applyFirst(ArrayRef<RewriteRule> Rules);
 
 /// Replaces a portion of the source text with \p Replacement.
-ASTEdit change(RangeSelector Target, TextGenerator Replacement);
+ASTEdit changeTo(RangeSelector Target, TextGenerator Replacement);
+/// DEPRECATED: use \c changeTo.
+inline ASTEdit change(RangeSelector Target, TextGenerator Replacement) {
+  return changeTo(std::move(Target), std::move(Replacement));
+}
 
 /// Replaces the entirety of a RewriteRule's match with \p Replacement.  For
 /// example, to replace a function call, one could write:
 /// \code
 ///   makeRule(callExpr(callee(functionDecl(hasName("foo")))),
-///            change(text("bar()")))
+///            changeTo(cat("bar()")))
 /// \endcode
+inline ASTEdit changeTo(TextGenerator Replacement) {
+  return changeTo(node(RewriteRule::RootID), std::move(Replacement));
+}
+/// DEPRECATED: use \c changeTo.
 inline ASTEdit change(TextGenerator Replacement) {
-  return change(node(RewriteRule::RootID), std::move(Replacement));
+  return changeTo(std::move(Replacement));
 }
 
 /// Inserts \p Replacement before \p S, leaving the source selected by \S
 /// unchanged.
 inline ASTEdit insertBefore(RangeSelector S, TextGenerator Replacement) {
-  return change(before(std::move(S)), std::move(Replacement));
+  return changeTo(before(std::move(S)), std::move(Replacement));
 }
 
 /// Inserts \p Replacement after \p S, leaving the source selected by \S
 /// unchanged.
 inline ASTEdit insertAfter(RangeSelector S, TextGenerator Replacement) {
-  return change(after(std::move(S)), std::move(Replacement));
+  return changeTo(after(std::move(S)), std::move(Replacement));
 }
 
 /// Removes the source selected by \p S.
 inline ASTEdit remove(RangeSelector S) {
   return change(std::move(S),
                 [](const ast_matchers::MatchFinder::MatchResult &)
                     -> Expected<std::string> { return ""; });
 }

clang/include/clang/Tooling/Transformer/Stencil.h

 template <typename... Ts> Stencil cat(Ts &&... Parts) {
   return catVector({detail::makeStencil(std::forward<Ts>(Parts))...});
 }
 
 //
 // Functions for conveniently building stencils.
 //
 
+/// DEPRECATED: Use `cat` instead.
 /// \returns exactly the text provided.
 Stencil text(llvm::StringRef Text);
 
+/// DEPRECATED: Use `cat` instead.
 /// \returns the source corresponding to the selected range.
 Stencil selection(RangeSelector Selector);
 
 /// Generates the source of the expression bound to \p Id, wrapping it in
 /// parentheses if it may parse differently depending on context. For example, a
 /// binary operation is always wrapped, while a variable reference is never
 /// wrapped.
 Stencil expression(llvm::StringRef Id);

clang/unittests/Tooling/TransformerTest.cpp

static RewriteRule ruleStrlenSize() {
   StringRef StringExpr = "strexpr";
   auto StringType = namedDecl(hasAnyName("::basic_string", "::string"));
   auto R = makeRule(
       callExpr(callee(functionDecl(hasName("strlen"))),
                hasArgument(0, cxxMemberCallExpr(
                                   on(expr(hasType(isOrPointsTo(StringType)))
                                          .bind(StringExpr)),
                                   callee(cxxMethodDecl(hasName("c_str")))))),
-      change(text("REPLACED")), text("Use size() method directly on string."));
+      changeTo(cat("REPLACED")), cat("Use size() method directly on string."));
   return R;
 }
 
 TEST_F(TransformerTest, StrlenSize) {
   std::string Input = "int f(string s) { return strlen(s.c_str()); }";
   std::string Expected = "int f(string s) { return REPLACED; }";
   testRule(ruleStrlenSize(), Input, Expected);
 }
 
 // Tests that no change is applied when a match is not expected.
 TEST_F(TransformerTest, NoMatch) {
   std::string Input = "int f(string s) { return s.size(); }";
   testRule(ruleStrlenSize(), Input, Input);
 }
 
 // Tests replacing an expression.
 TEST_F(TransformerTest, Flag) {
   StringRef Flag = "flag";
   RewriteRule Rule = makeRule(
       cxxMemberCallExpr(on(expr(hasType(cxxRecordDecl(
                                     hasName("proto::ProtoCommandLineFlag"))))
                                .bind(Flag)),
                         unless(callee(cxxMethodDecl(hasName("GetProto"))))),
-      change(node(Flag), text("EXPR")));
+      changeTo(node(Flag), cat("EXPR")));
 
   std::string Input = R"cc(
     proto::ProtoCommandLineFlag flag;
     int x = flag.foo();
     int y = flag.GetProto().foo();
   )cc";
   std::string Expected = R"cc(
     proto::ProtoCommandLineFlag flag;
     int x = EXPR.foo();
     int y = flag.GetProto().foo();
   )cc";
 
   testRule(std::move(Rule), Input, Expected);
 }
 
 TEST_F(TransformerTest, AddIncludeQuoted) {
   RewriteRule Rule = makeRule(callExpr(callee(functionDecl(hasName("f")))),
-                              change(text("other()")));
+                              changeTo(cat("other()")));
   addInclude(Rule, "clang/OtherLib.h");
 
   std::string Input = R"cc(
     int f(int x);
     int h(int x) { return f(x); }
   )cc";
   std::string Expected = R"cc(#include "clang/OtherLib.h"
 
     int f(int x);
     int h(int x) { return other(); }
   )cc";
 
   testRule(Rule, Input, Expected);
 }
 
 TEST_F(TransformerTest, AddIncludeAngled) {
   RewriteRule Rule = makeRule(callExpr(callee(functionDecl(hasName("f")))),
-                              change(text("other()")));
+                              changeTo(cat("other()")));
   addInclude(Rule, "clang/OtherLib.h", transformer::IncludeFormat::Angled);
 
   std::string Input = R"cc(
     int f(int x);
     int h(int x) { return f(x); }
   )cc";
   std::string Expected = R"cc(#include <clang/OtherLib.h>
 
     int f(int x);
     int h(int x) { return other(); }
   )cc";
 
   testRule(Rule, Input, Expected);
 }
 
 TEST_F(TransformerTest, NodePartNameNamedDecl) {
   StringRef Fun = "fun";
   RewriteRule Rule = makeRule(functionDecl(hasName("bad")).bind(Fun),
-                              change(name(Fun), text("good")));
+                              changeTo(name(Fun), cat("good")));
 
   std::string Input = R"cc(
     int bad(int x);
     int bad(int x) { return x * x; }
   )cc";
   std::string Expected = R"cc(
     int good(int x);
     int good(int x) { return x * x; }
std::string Expected = R"cc(
     T bad(T x) {
       return x;
     }
     int neutral(int x) { return good<int>(x) * x; }
   )cc";
 
   StringRef Ref = "ref";
   testRule(makeRule(declRefExpr(to(functionDecl(hasName("bad")))).bind(Ref),
-                    change(name(Ref), text("good"))),
+                    changeTo(name(Ref), cat("good"))),
            Input, Expected);
 }
 
 TEST_F(TransformerTest, NodePartNameDeclRefFailure) {
   std::string Input = R"cc(
     struct Y {
       int operator*();
     };
     int neutral(int x) {
       Y y;
       int (Y::*ptr)() = &Y::operator*;
       return *y + x;
     }
   )cc";
 
   StringRef Ref = "ref";
   Transformer T(makeRule(declRefExpr(to(functionDecl())).bind(Ref),
-                         change(name(Ref), text("good"))),
+                         changeTo(name(Ref), cat("good"))),
                 consumer());
   T.registerMatchers(&MatchFinder);
   EXPECT_FALSE(rewrite(Input));
 }
 
 TEST_F(TransformerTest, NodePartMember) {
   StringRef E = "expr";
   RewriteRule Rule = makeRule(memberExpr(member(hasName("bad"))).bind(E),
-                              change(member(E), text("good")));
+                              changeTo(member(E), cat("good")));
 
   std::string Input = R"cc(
     struct S {
       int bad;
     };
     int g() {
       S s;
       return s.bad;
std::string Expected = R"cc(
     };
     int g() {
       T t;
       return t.S::good;
     }
   )cc";
 
   StringRef E = "expr";
-  testRule(makeRule(memberExpr().bind(E), change(member(E), text("good"))),
+  testRule(makeRule(memberExpr().bind(E), changeTo(member(E), cat("good"))),
            Input, Expected);
 }
 
 TEST_F(TransformerTest, NodePartMemberMultiToken) {
   std::string Input = R"cc(
     struct Y {
       int operator*();
       int good();
int neutral(int x) {
       Y y;
       y.template good<int>(3);
       return y.good();
     }
   )cc";
 
   StringRef MemExpr = "member";
   testRule(makeRule(memberExpr().bind(MemExpr),
-                    change(member(MemExpr), text("good"))),
+                    changeTo(member(MemExpr), cat("good"))),
            Input, Expected);
 }
 
 TEST_F(TransformerTest, InsertBeforeEdit) {
   std::string Input = R"cc(
     int f() {
       return 7;
     }
   )cc";
   std::string Expected = R"cc(
     int f() {
       int y = 3;
       return 7;
     }
   )cc";
 
   StringRef Ret = "return";
   testRule(makeRule(returnStmt().bind(Ret),
-                    insertBefore(statement(Ret), text("int y = 3;"))),
+                    insertBefore(statement(Ret), cat("int y = 3;"))),
            Input, Expected);
 }
 
 TEST_F(TransformerTest, InsertAfterEdit) {
   std::string Input = R"cc(
     int f() {
       int x = 5;
       return 7;
     }
   )cc";
   std::string Expected = R"cc(
     int f() {
       int x = 5;
       int y = 3;
       return 7;
     }
   )cc";
 
   StringRef Decl = "decl";
   testRule(makeRule(declStmt().bind(Decl),
-                    insertAfter(statement(Decl), text("int y = 3;"))),
+                    insertAfter(statement(Decl), cat("int y = 3;"))),
            Input, Expected);
 }
 
 TEST_F(TransformerTest, RemoveEdit) {
   std::string Input = R"cc(
     int f() {
       int x = 5;
       return 7;
void foo() {
       if (true) { /* then */ }
       else { /* else */ }
     }
   )";
 
   StringRef C = "C", T = "T", E = "E";
   testRule(makeRule(ifStmt(hasCondition(expr().bind(C)),
                            hasThen(stmt().bind(T)), hasElse(stmt().bind(E))),
-                    {change(node(C), text("true")),
-                     change(statement(T), text("{ /* then */ }")),
-                     change(statement(E), text("{ /* else */ }"))}),
+                    {changeTo(node(C), cat("true")),
+                     changeTo(statement(T), cat("{ /* then */ }")),
+                     changeTo(statement(E), cat("{ /* else */ }"))}),
            Input, Expected);
 }
 
 TEST_F(TransformerTest, OrderedRuleUnrelated) {
   StringRef Flag = "flag";
   RewriteRule FlagRule = makeRule(
       cxxMemberCallExpr(on(expr(hasType(cxxRecordDecl(
                                     hasName("proto::ProtoCommandLineFlag"))))
                                .bind(Flag)),
                         unless(callee(cxxMethodDecl(hasName("GetProto"))))),
-      change(node(Flag), text("PROTO")));
+      changeTo(node(Flag), cat("PROTO")));
 
   std::string Input = R"cc(
     proto::ProtoCommandLineFlag flag;
     int x = flag.foo();
     int y = flag.GetProto().foo();
     int f(string s) { return strlen(s.c_str()); }
   )cc";
   std::string Expected = R"cc(
std::string Expected = R"cc(
     void f1();
     void f2();
     void call_f1() { REPLACE_F1; }
     void call_f2() { REPLACE_F1_OR_F2; }
   )cc";
 
   RewriteRule ReplaceF1 =
       makeRule(callExpr(callee(functionDecl(hasName("f1")))),
-               change(text("REPLACE_F1")));
+               changeTo(cat("REPLACE_F1")));
   RewriteRule ReplaceF1OrF2 =
       makeRule(callExpr(callee(functionDecl(hasAnyName("f1", "f2")))),
-               change(text("REPLACE_F1_OR_F2")));
+               changeTo(cat("REPLACE_F1_OR_F2")));
   testRule(applyFirst({ReplaceF1, ReplaceF1OrF2}), Input, Expected);
 }
 
 // Change the order of the rules to get a different result. When `ReplaceF1OrF2`
 // comes first, it applies for both uses, so `ReplaceF1` never applies.
 TEST_F(TransformerTest, OrderedRuleRelatedSwapped) {
   std::string Input = R"cc(
     void f1();
     void f2();
     void call_f1() { f1(); }
     void call_f2() { f2(); }
   )cc";
   std::string Expected = R"cc(
     void f1();
     void f2();
     void call_f1() { REPLACE_F1_OR_F2; }
     void call_f2() { REPLACE_F1_OR_F2; }
   )cc";
 
   RewriteRule ReplaceF1 =
       makeRule(callExpr(callee(functionDecl(hasName("f1")))),
-               change(text("REPLACE_F1")));
+               changeTo(cat("REPLACE_F1")));
   RewriteRule ReplaceF1OrF2 =
       makeRule(callExpr(callee(functionDecl(hasAnyName("f1", "f2")))),
-               change(text("REPLACE_F1_OR_F2")));
+               changeTo(cat("REPLACE_F1_OR_F2")));
   testRule(applyFirst({ReplaceF1OrF2, ReplaceF1}), Input, Expected);
 }
 
 // Verify that a set of rules whose matchers have different base kinds works
 // properly, including that `applyFirst` produces multiple matchers.  We test
 // two different kinds of rules: Expr and Decl. We place the Decl rule in the
 // middle to test that `buildMatchers` works even when the kinds aren't grouped
 // together.
 TEST_F(TransformerTest, OrderedRuleMultipleKinds) {
   std::string Input = R"cc(
     void f1();
     void f2();
     void call_f1() { f1(); }
     void call_f2() { f2(); }
   )cc";
   std::string Expected = R"cc(
     void f1();
     void DECL_RULE();
     void call_f1() { REPLACE_F1; }
     void call_f2() { REPLACE_F1_OR_F2; }
   )cc";
 
   RewriteRule ReplaceF1 =
       makeRule(callExpr(callee(functionDecl(hasName("f1")))),
-               change(text("REPLACE_F1")));
+               changeTo(cat("REPLACE_F1")));
   RewriteRule ReplaceF1OrF2 =
       makeRule(callExpr(callee(functionDecl(hasAnyName("f1", "f2")))),
-               change(text("REPLACE_F1_OR_F2")));
+               changeTo(cat("REPLACE_F1_OR_F2")));
   RewriteRule DeclRule = makeRule(functionDecl(hasName("f2")).bind("fun"),
-                                  change(name("fun"), text("DECL_RULE")));
+                                  changeTo(name("fun"), cat("DECL_RULE")));
 
   RewriteRule Rule = applyFirst({ReplaceF1, DeclRule, ReplaceF1OrF2});
   EXPECT_EQ(transformer::detail::buildMatchers(Rule).size(), 2UL);
   testRule(Rule, Input, Expected);
 }
 
 //
 // Negative tests (where we expect no transformation to occur).
 //
 
 // Tests for a conflict in edits from a single match for a rule.
 TEST_F(TransformerTest, TextGeneratorFailure) {
   std::string Input = "int conflictOneRule() { return 3 + 7; }";
   // Try to change the whole binary-operator expression AND one its operands:
   StringRef O = "O";
   auto AlwaysFail = [](const ast_matchers::MatchFinder::MatchResult &)
       -> llvm::Expected<std::string> {
     return llvm::createStringError(llvm::errc::invalid_argument, "ERROR");
   };
-  Transformer T(makeRule(binaryOperator().bind(O), change(node(O), AlwaysFail)),
-                consumer());
+  Transformer T(
+      makeRule(binaryOperator().bind(O), changeTo(node(O), AlwaysFail)),
   T.registerMatchers(&MatchFinder);
   EXPECT_FALSE(rewrite(Input));
   EXPECT_THAT(Changes, IsEmpty());
   EXPECT_EQ(ErrorCount, 1);
 }
 
 // Tests for a conflict in edits from a single match for a rule.
 TEST_F(TransformerTest, OverlappingEditsInRule) {
   std::string Input = "int conflictOneRule() { return 3 + 7; }";
   // Try to change the whole binary-operator expression AND one its operands:
   StringRef O = "O", L = "L";
   Transformer T(makeRule(binaryOperator(hasLHS(expr().bind(L))).bind(O),
-                         {change(node(O), text("DELETE_OP")),
-                          change(node(L), text("DELETE_LHS"))}),
+                         {changeTo(node(O), cat("DELETE_OP")),
+                          changeTo(node(L), cat("DELETE_LHS"))}),
                 consumer());
   T.registerMatchers(&MatchFinder);
   EXPECT_FALSE(rewrite(Input));
   EXPECT_THAT(Changes, IsEmpty());
   EXPECT_EQ(ErrorCount, 1);
 }
 
 // Tests for a conflict in edits across multiple matches (of the same rule).
 TEST_F(TransformerTest, OverlappingEditsMultipleMatches) {
   std::string Input = "int conflictOneRule() { return -7; }";
   // Try to change the whole binary-operator expression AND one its operands:
   StringRef E = "E";
-  Transformer T(makeRule(expr().bind(E), change(node(E), text("DELETE_EXPR"))),
+  Transformer T(makeRule(expr().bind(E), changeTo(node(E), cat("DELETE_EXPR"))),
                 consumer());
   T.registerMatchers(&MatchFinder);
   // The rewrite process fails because the changes conflict with each other...
   EXPECT_FALSE(rewrite(Input));
   // ... but two changes were produced.
   EXPECT_EQ(Changes.size(), 2u);
   EXPECT_EQ(ErrorCount, 0);
 }
 
 TEST_F(TransformerTest, ErrorOccurredMatchSkipped) {
   // Syntax error in the function body:
   std::string Input = "void errorOccurred() { 3 }";
   Transformer T(makeRule(functionDecl(hasName("errorOccurred")),
-                         change(text("DELETED;"))),
+                         changeTo(cat("DELETED;"))),
                 consumer());
   T.registerMatchers(&MatchFinder);
   // The rewrite process itself fails...
   EXPECT_FALSE(rewrite(Input));
   // ... and no changes or errors are produced in the process.
   EXPECT_THAT(Changes, IsEmpty());
   EXPECT_EQ(ErrorCount, 0);
 }
 
 // Transformation of macro source text when the change encompasses the entirety
 // of the expanded text.
 TEST_F(TransformerTest, SimpleMacro) {
   std::string Input = R"cc(
 #define ZERO 0
     int f(string s) { return ZERO; }
   )cc";
   std::string Expected = R"cc(
 #define ZERO 0
     int f(string s) { return 999; }
   )cc";
 
   StringRef zero = "zero";
   RewriteRule R = makeRule(integerLiteral(equals(0)).bind(zero),
-                           change(node(zero), text("999")));
+                           changeTo(node(zero), cat("999")));
   testRule(R, Input, Expected);
 }
 
 // Transformation of macro source text when the change encompasses the entirety
 // of the expanded text, for the case of function-style macros.
 TEST_F(TransformerTest, FunctionMacro) {
   std::string Input = R"cc(
 #define MACRO(str) strlen((str).c_str())

 #define PLUS(a,b) (a) + (b)
     int f() { return PLUS(3, 4); }
   )cc";
   std::string Expected = R"cc(
 #define PLUS(a,b) (a) + (b)
     int f() { return PLUS(LIT, LIT); }
   )cc";
 
-  testRule(makeRule(integerLiteral(), change(text("LIT"))), Input, Expected);
+  testRule(makeRule(integerLiteral(), changeTo(cat("LIT"))), Input, Expected);
 }
 
 // Tests case where the rule's match spans both source from the macro and its
 // arg, with the begin location (the "anchor") being the arg.
 TEST_F(TransformerTest, MatchSpansMacroTextButChangeDoesNot) {
   std::string Input = R"cc(
 #define PLUS_ONE(a) a + 1
     int f() { return PLUS_ONE(3); }
   )cc";
   std::string Expected = R"cc(
 #define PLUS_ONE(a) a + 1
     int f() { return PLUS_ONE(LIT); }
   )cc";
 
   StringRef E = "expr";
   testRule(makeRule(binaryOperator(hasLHS(expr().bind(E))),
-                    change(node(E), text("LIT"))),
+                    changeTo(node(E), cat("LIT"))),
            Input, Expected);
 }
 
 // Tests case where the rule's match spans both source from the macro and its
 // arg, with the begin location (the "anchor") being inside the macro.
 TEST_F(TransformerTest, MatchSpansMacroTextButChangeDoesNotAnchoredInMacro) {
   std::string Input = R"cc(
 #define PLUS_ONE(a) 1 + a
     int f() { return PLUS_ONE(3); }
   )cc";
   std::string Expected = R"cc(
 #define PLUS_ONE(a) 1 + a
     int f() { return PLUS_ONE(LIT); }
   )cc";
 
   StringRef E = "expr";
   testRule(makeRule(binaryOperator(hasRHS(expr().bind(E))),
-                    change(node(E), text("LIT"))),
+                    changeTo(node(E), cat("LIT"))),
            Input, Expected);
 }
 
 // No rewrite is applied when the changed text does not encompass the entirety
 // of the expanded text. That is, the edit would have to be applied to the
 // macro's definition to succeed and editing the expansion point would not
 // suffice.
 TEST_F(TransformerTest, NoPartialRewriteOMacroExpansion) {
   std::string Input = R"cc(
 #define ZERO_PLUS 0 + 3
     int f(string s) { return ZERO_PLUS; })cc";
 
   StringRef zero = "zero";
   RewriteRule R = makeRule(integerLiteral(equals(0)).bind(zero),
-                           change(node(zero), text("0")));
+                           changeTo(node(zero), cat("0")));
   testRule(R, Input, Input);
 }
 
 // This test handles the corner case where a macro expands within another macro
 // to matching code, but that code is an argument to the nested macro call.  A
 // simple check of isMacroArgExpansion() vs. isMacroBodyExpansion() will get
 // this wrong, and transform the code.
 TEST_F(TransformerTest, NoPartialRewriteOfMacroExpansionForMacroArgs) {
   std::string Input = R"cc(
 #define NESTED(e) e
 #define MACRO(str) 1 + NESTED(strlen((str).c_str()))
     int f(string s) { return MACRO(s); }
   )cc";
 
   testRule(ruleStrlenSize(), Input, Input);
 }
 
 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
 // Verifies that `Type` and `QualType` are not allowed as top-level matchers in
 // rules.
 TEST(TransformerDeathTest, OrderedRuleTypes) {
-  RewriteRule QualTypeRule = makeRule(qualType(), change(text("Q")));
+  RewriteRule QualTypeRule = makeRule(qualType(), changeTo(cat("Q")));
   EXPECT_DEATH(transformer::detail::buildMatchers(QualTypeRule),
                "Matcher must be.*node matcher");
 
-  RewriteRule TypeRule = makeRule(arrayType(), change(text("T")));
+  RewriteRule TypeRule = makeRule(arrayType(), changeTo(cat("T")));
   EXPECT_DEATH(transformer::detail::buildMatchers(TypeRule),
                "Matcher must be.*node matcher");
 }
 #endif
 } // namespace