[libTooling] Introduce general combinator for fixed-value `MatchConsumer`s.

[ymandel]

Summary

This revision generalizes the (deprecated) clang::tooling::text combinator to
a value combinator, which works for any type. Aside from being more general,
it resolves the naming confict between clang::tooling::text and
clang::transformer::text, which has a subtly different meaning.

[gribozavr]

What are the use cases for non-text values?

I like the name text much better... If the name conflict is the issue, I think you could rename it to toText -- it would even read more fluently change(toText("abc")), also making it obvious that we are not changing *the text abc*, but we are changing the code to say "abc".

[ymandel]

In D69184#1715256, @gribozavr wrote:

What are the use cases for non-text values?

I like the name text much better... If the name conflict is the issue, I think you could rename it to toText -- it would even read more fluently change(toText("abc")), also making it obvious that we are not changing *the text abc*, but we are changing the code to say "abc".

Another example use is: https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Tooling/Transformer/RangeSelector.h#L29-L32, although I must admit that I hadn't thought of that before this patch. It's just the natural generalization (it's actually the K combinator form SKI fame). So, I haven't thought about other examples -- the primary motivation was just the naming.

That said, I'm not sure about toText because I consider the "to" as implicit in change. In fact, it might be a good idea to rename change to changeTo (WDYT?). What about any of asText, textMsg, textMessage? (I realize the unfortunate pun in the last two, but not sure that's worth caring about).

[ymandel]

In D69184#1718427, @ymandel wrote:

In D69184#1715256, @gribozavr wrote:

What are the use cases for non-text values?

I like the name text much better... If the name conflict is the issue, I think you could rename it to toText -- it would even read more fluently change(toText("abc")), also making it obvious that we are not changing *the text abc*, but we are changing the code to say "abc".

Another example use is: https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Tooling/Transformer/RangeSelector.h#L29-L32, although I must admit that I hadn't thought of that before this patch. It's just the natural generalization (it's actually the K combinator form SKI fame). So, I haven't thought about other examples -- the primary motivation was just the naming.

That said, I'm not sure about toText because I consider the "to" as implicit in change. In fact, it might be a good idea to rename change to changeTo (WDYT?). What about any of asText, textMsg, textMessage? (I realize the unfortunate pun in the last two, but not sure that's worth caring about).

An alternative, is not to introduce a new combinator at all, and just use Stencils:

change(cat("abc"))

Or, add operator() to StencilPart and use those directly:

change(text("abc"))

Given that Stencil and Transformer are bundled in the same library, is there any strong reason for a client to avoid a dependency on Stencil?

[gribozavr2]

In fact, it might be a good idea to rename change to changeTo (WDYT?).

I like it. It should combine well with all stencils, not just text.

An alternative, is not to introduce a new combinator at all, and just use Stencils:

I think we are converging on that in another review. Do you plan to pursue this patch still?

[ymandel]

In D69184#1730523, @gribozavr2 wrote:

In fact, it might be a good idea to rename change to changeTo (WDYT?).

I like it. It should combine well with all stencils, not just text.

Agreed. Will do.

An alternative, is not to introduce a new combinator at all, and just use Stencils:

I think we are converging on that in another review. Do you plan to pursue this patch still?

Agreed. Let's drop this one.

clang/include/clang/Tooling/Transformer/MatchConsumer.h

 #ifndef LLVM_CLANG_TOOLING_TRANSFORMER_MATCH_CONSUMER_H_
 #define LLVM_CLANG_TOOLING_TRANSFORMER_MATCH_CONSUMER_H_
 
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
+#include <type_traits>
 
 namespace clang {
 namespace transformer {
 /// A failable computation over nodes bound by AST matchers.
 ///
 /// The computation should report any errors though its return value (rather
 /// than terminating the program) to enable usage in interactive scenarios like
 /// clang-query.
 ///
 /// This is a central abstraction of the Transformer framework.
 template <typename T>
 using MatchConsumer =
     std::function<Expected<T>(const ast_matchers::MatchFinder::MatchResult &)>;
 
 /// Creates an error that signals that a `MatchConsumer` expected a certain node
 /// to be bound by AST matchers, but it was not actually bound.
 inline llvm::Error notBoundError(llvm::StringRef Id) {
   return llvm::make_error<llvm::StringError>(llvm::errc::invalid_argument,
                                              "Id not bound: " + Id);
 }
 
+/// Constructs a consumer that always returns the fixed value `V`.
+template <typename T> MatchConsumer<typename std::decay<T>::type> value(T V) {
+  return [V](const ast_matchers::MatchFinder::MatchResult &) {
+    return Expected<T>(V);
+  };
+}
+
 /// Chooses between the two consumers, based on whether \p ID is bound in the
 /// match.
 template <typename T>
 MatchConsumer<T> ifBound(std::string ID, MatchConsumer<T> TrueC,
                          MatchConsumer<T> FalseC) {
   return [=](const ast_matchers::MatchFinder::MatchResult &Result) {
     auto &Map = Result.Nodes.getMap();
     return (Map.find(ID) != Map.end() ? TrueC : FalseC)(Result);

clang/unittests/Tooling/TransformerTest.cpp

 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace tooling;
 using namespace ast_matchers;
 namespace {
 using ::testing::IsEmpty;
 using transformer::RewriteRule;
+using transformer::value;
 
 constexpr char KHeaderContents[] = R"cc(
   struct string {
     string(const char*);
     char* c_str();
     int size();
   };
   int strlen(const char*);
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."));
+      change(value("REPLACED")),
+      value("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")));
+      change(node(Flag), value("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()")));
+                              change(value("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()")));
+                              change(value("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")));
+                              change(name(Fun), value("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"))),
+                    change(name(Ref), value("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"))),
+                         change(name(Ref), value("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")));
+                              change(member(E), value("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), change(member(E), value("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"))),
+                    change(member(MemExpr), value("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), value("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), value("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 */ }"))}),
+                    {change(node(C), value("true")),
+                     change(statement(T), value("{ /* then */ }")),
+                     change(statement(E), value("{ /* 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")));
+      change(node(Flag), value("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")));
+               change(value("REPLACE_F1")));
   RewriteRule ReplaceF1OrF2 =
       makeRule(callExpr(callee(functionDecl(hasAnyName("f1", "f2")))),
-               change(text("REPLACE_F1_OR_F2")));
+               change(value("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")));
+               change(value("REPLACE_F1")));
   RewriteRule ReplaceF1OrF2 =
       makeRule(callExpr(callee(functionDecl(hasAnyName("f1", "f2")))),
-               change(text("REPLACE_F1_OR_F2")));
+               change(value("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")));
+               change(value("REPLACE_F1")));
   RewriteRule ReplaceF1OrF2 =
       makeRule(callExpr(callee(functionDecl(hasAnyName("f1", "f2")))),
-               change(text("REPLACE_F1_OR_F2")));
+               change(value("REPLACE_F1_OR_F2")));
   RewriteRule DeclRule = makeRule(functionDecl(hasName("f2")).bind("fun"),
-                                  change(name("fun"), text("DECL_RULE")));
+                                  change(name("fun"), value("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, 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"))}),
+                         {change(node(O), value("DELETE_OP")),
+                          change(node(L), value("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), change(node(E), value("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;"))),
+                         change(value("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")));
+                           change(node(zero), value("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(), change(value("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"))),
+                    change(node(E), value("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"))),
+                    change(node(E), value("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")));
+                           change(node(zero), value("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(), change(value("Q")));
   EXPECT_DEATH(transformer::detail::buildMatchers(QualTypeRule),
                "Matcher must be.*node matcher");
 
-  RewriteRule TypeRule = makeRule(arrayType(), change(text("T")));
+  RewriteRule TypeRule = makeRule(arrayType(), change(value("T")));
   EXPECT_DEATH(transformer::detail::buildMatchers(TypeRule),
                "Matcher must be.*node matcher");
 }
 #endif
 } // namespace