[ASTMatchers] Make tests explicit about mode-dependence

[aaron.ballman]

Could you give me a bit more background about why you want to make this change?

There are tests which I would expect to match in any traversal mode (e.g., EXPECT_TRUE(matches("class X {};", traverse(TK_AsIs, HasClassX)));) so there's a part of me that wonders if we should add helper functionality to test the various traversal modes as part of this change. e.g., we specify an explicit traversal mode for the situations where only one mode should be tested, and we specify a helper function that tests both traversal modes on the same code. WDYT?

[steveire]

In D93988#2477602, @aaron.ballman wrote:

Could you give me a bit more background about why you want to make this change?

This change makes it explicit so that we can see which tests work in only one mode, and if we want to change the default, this part is already compatible with the change.

But, this is not very important.

There are tests which I would expect to match in any traversal mode (e.g., EXPECT_TRUE(matches("class X {};", traverse(TK_AsIs, HasClassX)));)

Given that

HasClassX = recordDecl(has(recordDecl(hasName("X"))))

which matches the implicit RecordDecl within the RecordDecl, it shouldn't match in Ignore... mode.

[aaron.ballman]

In D93988#2477961, @steveire wrote:

In D93988#2477602, @aaron.ballman wrote:

Could you give me a bit more background about why you want to make this change?

This change makes it explicit so that we can see which tests work in only one mode, and if we want to change the default, this part is already compatible with the change.

But, this is not very important.

There are tests which I would expect to match in any traversal mode (e.g., EXPECT_TRUE(matches("class X {};", traverse(TK_AsIs, HasClassX)));)

Given that

HasClassX = recordDecl(has(recordDecl(hasName("X"))))

which matches the implicit RecordDecl within the RecordDecl, it shouldn't match in Ignore... mode.

My eyes managed to miss that this was grabbing the injected declaration and that was the root cause of my confusion in a few places. Thanks for the clarification. :-)

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

698

Are you planning to answer this as part of this patch?

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

3626

Rather than duplicate the code, it may be a bit cleaner to hoist the string literal into a local variable that's shared between the two test cases. Also, a comment pointing out how these tests differ wouldn't be amiss (it took me a bit to see that the second test is ensuring we ignore the injected class name).

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

 TEST_P(ASTMatchersTest, Has) {
   if (!GetParam().isCXX()) {
     // FIXME: Add a test for `has()` that does not depend on C++.
     return;
   }
 
   DeclarationMatcher HasClassX = recordDecl(has(recordDecl(hasName("X"))));
   EXPECT_TRUE(matches("class Y { class X {}; };", HasClassX));
-  EXPECT_TRUE(matches("class X {};", HasClassX));
+  EXPECT_TRUE(matches("class X {};", traverse(TK_AsIs, HasClassX)));
 
   DeclarationMatcher YHasClassX =
       recordDecl(hasName("Y"), has(recordDecl(hasName("X"))));
   EXPECT_TRUE(matches("class Y { class X {}; };", YHasClassX));
   EXPECT_TRUE(notMatches("class X {};", YHasClassX));
   EXPECT_TRUE(notMatches("class Y { class Z { class X {}; }; };", YHasClassX));
 }
 
EXPECT_TRUE(matches("class O1 {"
                       Recursive));
 }
 
 TEST_P(ASTMatchersTest, Has_RecursiveAnyOf) {
   if (!GetParam().isCXX()) {
     return;
   }
 
-  DeclarationMatcher Recursive = recordDecl(
-      anyOf(has(recordDecl(anyOf(has(recordDecl(hasName("X"))),
-                                 has(recordDecl(hasName("Y"))), hasName("Z")))),
-            has(recordDecl(anyOf(hasName("C"), has(recordDecl(hasName("A"))),
-                                 has(recordDecl(hasName("B")))))),
-            hasName("F")));
+  DeclarationMatcher Recursive = traverse(
+      TK_AsIs,
+      recordDecl(anyOf(
+          has(recordDecl(anyOf(has(recordDecl(hasName("X"))),
+          hasName("F"))));
 
   EXPECT_TRUE(matches("class F {};", Recursive));
   EXPECT_TRUE(matches("class Z {};", Recursive));
   EXPECT_TRUE(matches("class C {};", Recursive));
   EXPECT_TRUE(matches("class M { class N { class X {}; }; };", Recursive));
   EXPECT_TRUE(matches("class M { class N { class B {}; }; };", Recursive));
   EXPECT_TRUE(matches("class O1 { class O2 {"
                       "  class M { class N { class B {}; }; }; "
EXPECT_TRUE(matches("template<class T, class U=T> class X {}; "
                       "template<class T> class Z : public X<T> {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(
       notMatches("template<class X> class A { class Z : public X {}; };",
                  ZIsDerivedFromX));
   EXPECT_TRUE(
       matches("template<class X> class A { public: class Z : public X {}; }; "
               "class X{}; void y() { A<X>::Z z; }",
-              ZIsDerivedFromX));
+              traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(
       matches("template <class T> class X {}; "
               "template<class Y> class A { class Z : public X<Y> {}; };",
-              ZIsDerivedFromX));
+              traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(notMatches("template<template<class T> class X> class A { "
                          "  class Z : public X<int> {}; };",
-                         ZIsDerivedFromX));
+                         traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(matches("template<template<class T> class X> class A { "
                       "  public: class Z : public X<int> {}; }; "
                       "template<class T> class X {}; void y() { A<X>::Z z; }",
-                      ZIsDerivedFromX));
+                      traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(
       notMatches("template<class X> class A { class Z : public X::D {}; };",
-                 ZIsDerivedFromX));
+                 traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(matches("template<class X> class A { public: "
                       "  class Z : public X::D {}; }; "
                       "class Y { public: class X {}; typedef X D; }; "
                       "void y() { A<Y>::Z z; }",
-                      ZIsDerivedFromX));
+                      traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(matches("class X {}; typedef X Y; class Z : public Y {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(matches("template<class T> class Y { typedef typename T::U X; "
                       "  class Z : public X {}; };",
                       ZIsDerivedFromX));
   EXPECT_TRUE(matches("class X {}; class Z : public ::X {};", ZIsDerivedFromX));
   EXPECT_TRUE(
       notMatches("template<class T> class X {}; "
                  "template<class T> class A { class Z : public X<T>::D {}; };",
                  ZIsDerivedFromX));
   EXPECT_TRUE(
       matches("template<class T> class X { public: typedef X<T> D; }; "
               "template<class T> class A { public: "
               "  class Z : public X<T>::D {}; }; void y() { A<int>::Z z; }",
-              ZIsDerivedFromX));
+              traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(
       notMatches("template<class X> class A { class Z : public X::D::E {}; };",
-                 ZIsDerivedFromX));
+                 traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(
       matches("class X {}; typedef X V; typedef V W; class Z : public W {};",
               ZIsDerivedFromX));
   EXPECT_TRUE(matches("class X {}; class Y : public X {}; "
                       "typedef Y V; typedef V W; class Z : public W {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(notMatches("class X {}; class Y : public X {}; "
                          "typedef Y V; typedef V W; class Z : public W {};",
                          ZIsDirectlyDerivedFromX));
   EXPECT_TRUE(
       matches("template<class T, class U> class X {}; "
               "template<class T> class A { class Z : public X<T, int> {}; };",
-              ZIsDerivedFromX));
+              traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(
       notMatches("template<class X> class D { typedef X A; typedef A B; "
                  "  typedef B C; class Z : public C {}; };",
-                 ZIsDerivedFromX));
+                 traverse(TK_AsIs, ZIsDerivedFromX)));
   EXPECT_TRUE(matches("class X {}; typedef X A; typedef A B; "
                       "class Z : public B {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(matches("class X {}; typedef X A; typedef A B; typedef B C; "
                       "class Z : public C {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(matches("class U {}; typedef U X; typedef X V; "
                       "class Z : public V {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(matches("class Base {}; typedef Base X; "
                       "class Z : public Base {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(matches("class Base {}; typedef Base Base2; typedef Base2 X; "
                       "class Z : public Base {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(notMatches("class Base {}; class Base2 {}; typedef Base2 X; "
                          "class Z : public Base {};",
                          ZIsDerivedFromX));
   EXPECT_TRUE(matches("class A {}; typedef A X; typedef A Y; "
                       "class Z : public Y {};",
                       ZIsDerivedFromX));
   EXPECT_TRUE(notMatches("template <typename T> class Z;"
                          "template <> class Z<void> {};"
                          "template <typename T> class Z : public Z<void> {};",
-                         IsDerivedFromX));
+                         traverse(TK_AsIs, IsDerivedFromX)));
   EXPECT_TRUE(matches("template <typename T> class X;"
                       "template <> class X<void> {};"
                       "template <typename T> class X : public X<void> {};",
-                      IsDerivedFromX));
+                      traverse(TK_AsIs, IsDerivedFromX)));
   EXPECT_TRUE(
       matches("class X {};"
               "template <typename T> class Z;"
               "template <> class Z<void> {};"
               "template <typename T> class Z : public Z<void>, public X {};",
-              ZIsDerivedFromX));
-  EXPECT_TRUE(
-      notMatches("template<int> struct X;"
+              traverse(TK_AsIs, ZIsDerivedFromX)));
+  EXPECT_TRUE(notMatches("template<int> struct X;"
                          "template<int i> struct X : public X<i-1> {};",
-                 cxxRecordDecl(isDerivedFrom(recordDecl(hasName("Some"))))));
+                         traverse(TK_AsIs, cxxRecordDecl(isDerivedFrom(
+                                               recordDecl(hasName("Some")))))));
   EXPECT_TRUE(matches(
       "struct A {};"
       "template<int> struct X;"
       "template<int i> struct X : public X<i-1> {};"
       "template<> struct X<0> : public A {};"
       "struct B : public X<42> {};",
-      cxxRecordDecl(hasName("B"), isDerivedFrom(recordDecl(hasName("A"))))));
+      traverse(TK_AsIs, cxxRecordDecl(hasName("B"), isDerivedFrom(recordDecl(
+                                                        hasName("A")))))));
   EXPECT_TRUE(notMatches(
       "struct A {};"
       "template<int> struct X;"
       "template<int i> struct X : public X<i-1> {};"
       "template<> struct X<0> : public A {};"
       "struct B : public X<42> {};",
-      cxxRecordDecl(hasName("B"),
-                    isDirectlyDerivedFrom(recordDecl(hasName("A"))))));
+      traverse(TK_AsIs,
+               cxxRecordDecl(hasName("B"), isDirectlyDerivedFrom(
+                                               recordDecl(hasName("A")))))));
 
   // FIXME: Once we have better matchers for template type matching,
   // get rid of the Variable(...) matching and match the right template
   // declarations directly.
   const char *RecursiveTemplateOneParameter =
       "class Base1 {}; class Base2 {};"
       "template <typename T> class Z;"
       "template <> class Z<void> : public Base1 {};"
       "template <> class Z<int> : public Base2 {};"
       "template <> class Z<float> : public Z<void> {};"
       "template <> class Z<double> : public Z<int> {};"
       "template <typename T> class Z : public Z<float>, public Z<double> {};"
       "void f() { Z<float> z_float; Z<double> z_double; Z<char> z_char; }";
-  EXPECT_TRUE(matches(
-      RecursiveTemplateOneParameter,
-      varDecl(hasName("z_float"),
-              hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base1")))))));
-  EXPECT_TRUE(notMatches(
-      RecursiveTemplateOneParameter,
-      varDecl(hasName("z_float"),
-              hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base2")))))));
   EXPECT_TRUE(
       matches(RecursiveTemplateOneParameter,
-              varDecl(hasName("z_char"),
+              traverse(TK_AsIs, varDecl(hasName("z_float"),
                                         hasInitializer(hasType(cxxRecordDecl(
-                          isDerivedFrom("Base1"), isDerivedFrom("Base2")))))));
+                                            isDerivedFrom("Base1"))))))));
+  EXPECT_TRUE(
+      notMatches(RecursiveTemplateOneParameter,
+                 traverse(TK_AsIs, varDecl(hasName("z_float"),
+                                           hasInitializer(hasType(cxxRecordDecl(
+                                               isDerivedFrom("Base2"))))))));
+  EXPECT_TRUE(
+      matches(RecursiveTemplateOneParameter,
+              traverse(TK_AsIs, varDecl(hasName("z_char"),
+                                        hasInitializer(hasType(cxxRecordDecl(
+                                            isDerivedFrom("Base1"),
+                                            isDerivedFrom("Base2"))))))));
 
   const char *RecursiveTemplateTwoParameters =
       "class Base1 {}; class Base2 {};"
       "template <typename T1, typename T2> class Z;"
       "template <typename T> class Z<void, T> : public Base1 {};"
       "template <typename T> class Z<int, T> : public Base2 {};"
       "template <typename T> class Z<float, T> : public Z<void, T> {};"
       "template <typename T> class Z<double, T> : public Z<int, T> {};"
       "template <typename T1, typename T2> class Z : "
       "    public Z<float, T2>, public Z<double, T2> {};"
       "void f() { Z<float, void> z_float; Z<double, void> z_double; "
       "           Z<char, void> z_char; }";
+
+  // TODO: No change?
   EXPECT_TRUE(matches(
       RecursiveTemplateTwoParameters,
       varDecl(hasName("z_float"),
               hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base1")))))));
   EXPECT_TRUE(notMatches(
       RecursiveTemplateTwoParameters,
       varDecl(hasName("z_float"),
               hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base2")))))));
EXPECT_TRUE(
                   ZIsDirectlyDerivedFromX));
 }
 
 TEST_P(ASTMatchersTest, IsLambda) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
 
-  const auto IsLambda = cxxMethodDecl(ofClass(cxxRecordDecl(isLambda())));
+  const auto IsLambda =
+      traverse(TK_AsIs, cxxMethodDecl(ofClass(cxxRecordDecl(isLambda()))));
   EXPECT_TRUE(matches("auto x = []{};", IsLambda));
   EXPECT_TRUE(notMatches("struct S { void operator()() const; };", IsLambda));
 }
 
 TEST_P(ASTMatchersTest, Bind) {
   DeclarationMatcher ClassX = has(recordDecl(hasName("::X")).bind("x"));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
TEST_P(ASTMatchersTest, References) {
   DeclarationMatcher ReferenceClassX =
       varDecl(hasType(references(recordDecl(hasName("X")))));
   EXPECT_TRUE(
       matches("class X {}; void y(X y) { X &x = y; }", ReferenceClassX));
   EXPECT_TRUE(
       matches("class X {}; void y(X y) { const X &x = y; }", ReferenceClassX));
   // The match here is on the implicit copy constructor code for
   // class X, not on code 'X x = y'.
-  EXPECT_TRUE(matches("class X {}; void y(X y) { X x = y; }", ReferenceClassX));
-  EXPECT_TRUE(notMatches("class X {}; extern X x;", ReferenceClassX));
-  EXPECT_TRUE(
-      notMatches("class X {}; void y(X *y) { X *&x = y; }", ReferenceClassX));
+  EXPECT_TRUE(matches("class X {}; void y(X y) { X x = y; }",
+                      traverse(TK_AsIs, ReferenceClassX)));
+  EXPECT_TRUE(notMatches("class X {}; extern X x;",
+                         traverse(TK_AsIs, ReferenceClassX)));
+  EXPECT_TRUE(notMatches("class X {}; void y(X *y) { X *&x = y; }",
+                         traverse(TK_AsIs, ReferenceClassX)));
 }
 
 TEST_P(ASTMatchersTest, HasLocalQualifiers) {
   if (!GetParam().isCXX11OrLater()) {
     // FIXME: Add a test for `hasLocalQualifiers()` that does not depend on C++.
     return;
   }
 
EXPECT_TRUE(notMatches("void baz() {"
                          cxxForRangeStmt(hasInitStatement(anything()))));
 }
 
 TEST_P(ASTMatchersTest, TemplateArgumentCountIs) {
   if (!GetParam().isCXX()) {
     return;
   }
 
-  EXPECT_TRUE(
-      matches("template<typename T> struct C {}; C<int> c;",
-              classTemplateSpecializationDecl(templateArgumentCountIs(1))));
-  EXPECT_TRUE(
-      notMatches("template<typename T> struct C {}; C<int> c;",
-                 classTemplateSpecializationDecl(templateArgumentCountIs(2))));
+  EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
+                      traverse(TK_AsIs, classTemplateSpecializationDecl(
+                                            templateArgumentCountIs(1)))));
+  EXPECT_TRUE(notMatches("template<typename T> struct C {}; C<int> c;",
+                         traverse(TK_AsIs, classTemplateSpecializationDecl(
+                                               templateArgumentCountIs(2)))));
 
   EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
-                      templateSpecializationType(templateArgumentCountIs(1))));
-  EXPECT_TRUE(
-      notMatches("template<typename T> struct C {}; C<int> c;",
-                 templateSpecializationType(templateArgumentCountIs(2))));
+                      traverse(TK_AsIs, templateSpecializationType(
+                                            templateArgumentCountIs(1)))));
+  EXPECT_TRUE(notMatches("template<typename T> struct C {}; C<int> c;",
+                         traverse(TK_AsIs, templateSpecializationType(
+                                               templateArgumentCountIs(2)))));
 }
 
 TEST_P(ASTMatchersTest, IsIntegral) {
   if (!GetParam().isCXX()) {
     return;
   }
 
-  EXPECT_TRUE(matches(
-      "template<int T> struct C {}; C<42> c;",
-      classTemplateSpecializationDecl(hasAnyTemplateArgument(isIntegral()))));
-  EXPECT_TRUE(notMatches("template<typename T> struct C {}; C<int> c;",
-                         classTemplateSpecializationDecl(hasAnyTemplateArgument(
-                             templateArgument(isIntegral())))));
+  EXPECT_TRUE(
+      matches("template<int T> struct C {}; C<42> c;",
+              traverse(TK_AsIs, classTemplateSpecializationDecl(
+                                    hasAnyTemplateArgument(isIntegral())))));
+  EXPECT_TRUE(notMatches(
+      "template<typename T> struct C {}; C<int> c;",
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            templateArgument(isIntegral()))))));
 }
 
 TEST_P(ASTMatchersTest, EqualsIntegralValue) {
   if (!GetParam().isCXX()) {
     return;
   }
 
-  EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
-                      classTemplateSpecializationDecl(
-                          hasAnyTemplateArgument(equalsIntegralValue("42")))));
-  EXPECT_TRUE(matches("template<int T> struct C {}; C<-42> c;",
-                      classTemplateSpecializationDecl(
-                          hasAnyTemplateArgument(equalsIntegralValue("-42")))));
-  EXPECT_TRUE(matches("template<int T> struct C {}; C<-0042> c;",
-                      classTemplateSpecializationDecl(
-                          hasAnyTemplateArgument(equalsIntegralValue("-34")))));
-  EXPECT_TRUE(notMatches("template<int T> struct C {}; C<42> c;",
-                         classTemplateSpecializationDecl(hasAnyTemplateArgument(
-                             equalsIntegralValue("0042")))));
+  EXPECT_TRUE(matches(
+      "template<int T> struct C {}; C<42> c;",
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            equalsIntegralValue("42"))))));
+  EXPECT_TRUE(matches(
+      "template<int T> struct C {}; C<-42> c;",
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            equalsIntegralValue("-42"))))));
+  EXPECT_TRUE(matches(
+      "template<int T> struct C {}; C<-0042> c;",
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            equalsIntegralValue("-34"))))));
+  EXPECT_TRUE(notMatches(
+      "template<int T> struct C {}; C<42> c;",
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            equalsIntegralValue("0042"))))));
 }
 
 TEST_P(ASTMatchersTest, AccessSpecDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(matches("class C { public: int i; };", accessSpecDecl()));

 
 TEST_P(ASTMatchersTest, IsImplicit_CXXConstructorDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   // This one doesn't match because the constructor is not added by the
   // compiler (it is not needed).
-  EXPECT_TRUE(notMatches("class Foo { };", cxxConstructorDecl(isImplicit())));
+  EXPECT_TRUE(notMatches("class Foo { };",
+                         traverse(TK_AsIs, cxxConstructorDecl(isImplicit()))));
   // The compiler added the implicit default constructor.
   EXPECT_TRUE(matches("class Foo { }; Foo* f = new Foo();",
-                      cxxConstructorDecl(isImplicit())));
-  EXPECT_TRUE(matches("class Foo { Foo(){} };",
-                      cxxConstructorDecl(unless(isImplicit()))));
+                      traverse(TK_AsIs, cxxConstructorDecl(isImplicit()))));
+  EXPECT_TRUE(
+      matches("class Foo { Foo(){} };",
+              traverse(TK_AsIs, cxxConstructorDecl(unless(isImplicit())))));
   // The compiler added an implicit assignment operator.
-  EXPECT_TRUE(matches("struct A { int x; } a = {0}, b = a; void f() { a = b; }",
-                      cxxMethodDecl(isImplicit(), hasName("operator="))));
+  EXPECT_TRUE(matches(
+      "struct A { int x; } a = {0}, b = a; void f() { a = b; }",
+      traverse(TK_AsIs, cxxMethodDecl(isImplicit(), hasName("operator=")))));
 }
 
 TEST_P(ASTMatchersTest, IsExplicit_CXXConstructorDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(matches("struct S { explicit S(int); };",
if (!GetParam().isCXX()) {
     return;
   }
 
   // Make sure that we can both match the class by name (::X) and by the type
   // the template was instantiated with (via a field).
 
   EXPECT_TRUE(
       matches("template <typename T> class X {}; class A {}; X<A> x;",
-              cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));
+              traverse(TK_AsIs, cxxRecordDecl(hasName("::X"),
+                                              isTemplateInstantiation()))));
 
   EXPECT_TRUE(matches(
       "template <typename T> class X { T t; }; class A {}; X<A> x;",
-      cxxRecordDecl(
-          isTemplateInstantiation(),
-          hasDescendant(fieldDecl(hasType(recordDecl(hasName("A"))))))));
+      traverse(TK_AsIs, cxxRecordDecl(isTemplateInstantiation(),
+                                      hasDescendant(fieldDecl(hasType(
+                                          recordDecl(hasName("A")))))))));
 }
 
 TEST_P(ASTMatchersTest,
        IsTemplateInstantiation_MatchesImplicitFunctionTemplateInstantiation) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(matches(
       "template <typename T> void f(T t) {} class A {}; void g() { f(A()); }",
+      traverse(TK_AsIs,
                functionDecl(hasParameter(0, hasType(recordDecl(hasName("A")))),
-                   isTemplateInstantiation())));
+                            isTemplateInstantiation()))));
 }
 
 TEST_P(ASTMatchersTest,
        IsTemplateInstantiation_MatchesExplicitClassTemplateInstantiation) {
   if (!GetParam().isCXX()) {
     return;
   }
 
-  EXPECT_TRUE(matches("template <typename T> class X { T t; }; class A {};"
-                      "template class X<A>;",
-                      cxxRecordDecl(isTemplateInstantiation(),
-                                    hasDescendant(fieldDecl(
-                                        hasType(recordDecl(hasName("A"))))))));
+  EXPECT_TRUE(matches(
+      "template <typename T> class X { T t; }; class A {};"
+      traverse(TK_AsIs, cxxRecordDecl(isTemplateInstantiation(),
+                                      hasDescendant(fieldDecl(hasType(
+                                          recordDecl(hasName("A")))))))));
 
   // Make sure that we match the instantiation instead of the template
   // definition by checking whether the member function is present.
-  EXPECT_TRUE(
-      matches("template <typename T> class X { void f() { T t; } };"
-              "extern template class X<int>;",
+  EXPECT_TRUE(matches(
+      "template <typename T> class X { void f() { T t; } };"
+      traverse(TK_AsIs,
                cxxRecordDecl(isTemplateInstantiation(),
-                            unless(hasDescendant(varDecl(hasName("t")))))));
+                             unless(hasDescendant(varDecl(hasName("t"))))))));
 }
 
 TEST_P(
     ASTMatchersTest,
     IsTemplateInstantiation_MatchesInstantiationOfPartiallySpecializedClassTemplate) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(
       matches("template <typename T> class X {};"
               "template <typename T> class X<T*> {}; class A {}; X<A*> x;",
-              cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));
+              traverse(TK_AsIs, cxxRecordDecl(hasName("::X"),
+                                              isTemplateInstantiation()))));
 }
 
 TEST_P(
     ASTMatchersTest,
     IsTemplateInstantiation_MatchesInstantiationOfClassTemplateNestedInNonTemplate) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(
       matches("class A {};"
               "class X {"
               "  template <typename U> class Y { U u; };"
               "  Y<A> y;"
               "};",
-              cxxRecordDecl(hasName("::X::Y"), isTemplateInstantiation())));
+              traverse(TK_AsIs, cxxRecordDecl(hasName("::X::Y"),
+                                              isTemplateInstantiation()))));
 }
 
 TEST_P(
     ASTMatchersTest,
     IsTemplateInstantiation_DoesNotMatchInstantiationsInsideOfInstantiation) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   // FIXME: Figure out whether this makes sense. It doesn't affect the
   // normal use case as long as the uppermost instantiation always is marked
   // as template instantiation, but it might be confusing as a predicate.
   EXPECT_TRUE(matches(
       "class A {};"
       "template <typename T> class X {"
       "  template <typename U> class Y { U u; };"
       "  Y<T> y;"
       "}; X<A> x;",
-      cxxRecordDecl(hasName("::X<A>::Y"), unless(isTemplateInstantiation()))));
+      traverse(TK_AsIs, cxxRecordDecl(hasName("::X<A>::Y"),
+                                      unless(isTemplateInstantiation())))));
 }
 
 TEST_P(
     ASTMatchersTest,
     IsTemplateInstantiation_DoesNotMatchExplicitClassTemplateSpecialization) {
   if (!GetParam().isCXX()) {
     return;
   }

 
 TEST_P(ASTMatchersTest, IsInstantiated_MatchesInstantiation) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(
       matches("template<typename T> class A { T i; }; class Y { A<int> a; };",
-              cxxRecordDecl(isInstantiated())));
+              traverse(TK_AsIs, cxxRecordDecl(isInstantiated()))));
 }
 
 TEST_P(ASTMatchersTest, IsInstantiated_NotMatchesDefinition) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(notMatches("template<typename T> class A { T i; };",
                          cxxRecordDecl(isInstantiated())));
 }
 
 TEST_P(ASTMatchersTest, IsInTemplateInstantiation_MatchesInstantiationStmt) {
   if (!GetParam().isCXX()) {
     return;
   }
 
-  EXPECT_TRUE(matches("template<typename T> struct A { A() { T i; } };"
-                      "class Y { A<int> a; }; Y y;",
-                      declStmt(isInTemplateInstantiation())));
+  EXPECT_TRUE(
+      matches("template<typename T> struct A { A() { T i; } };"
+              traverse(TK_AsIs, declStmt(isInTemplateInstantiation()))));
 }
 
 TEST_P(ASTMatchersTest, IsInTemplateInstantiation_NotMatchesDefinitionStmt) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(notMatches("template<typename T> struct A { void x() { T i; } };",
                          declStmt(isInTemplateInstantiation())));
 }
 
 TEST_P(ASTMatchersTest, IsInstantiated_MatchesFunctionInstantiation) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(
       matches("template<typename T> void A(T t) { T i; } void x() { A(0); }",
-              functionDecl(isInstantiated())));
+              traverse(TK_AsIs, functionDecl(isInstantiated()))));
 }
 
 TEST_P(ASTMatchersTest, IsInstantiated_NotMatchesFunctionDefinition) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(notMatches("template<typename T> void A(T t) { T i; }",
                          varDecl(isInstantiated())));
 }
 
 TEST_P(ASTMatchersTest,
        IsInTemplateInstantiation_MatchesFunctionInstantiationStmt) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   EXPECT_TRUE(
       matches("template<typename T> void A(T t) { T i; } void x() { A(0); }",
-              declStmt(isInTemplateInstantiation())));
+              traverse(TK_AsIs, declStmt(isInTemplateInstantiation()))));
 }
 
 TEST_P(ASTMatchersTest,
        IsInTemplateInstantiation_NotMatchesFunctionDefinitionStmt) {
   if (!GetParam().isCXX()) {
     return;
   }
 

 
 TEST_P(ASTMatchersTest, HasTrailingReturn_MatchesLambdaTrailingReturn) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
 
   EXPECT_TRUE(matches(
       "auto lambda2 = [](double x, double y) -> double {return x + y;};",
-      functionDecl(hasTrailingReturn())));
+      traverse(TK_AsIs, functionDecl(hasTrailingReturn()))));
   EXPECT_TRUE(
       notMatches("auto lambda2 = [](double x, double y) {return x + y;};",
-                 functionDecl(hasTrailingReturn())));
+                 traverse(TK_AsIs, functionDecl(hasTrailingReturn()))));
 }
 
 TEST_P(ASTMatchersTest, IsAssignmentOperator) {
   if (!GetParam().isCXX()) {
     return;
   }
 
   StatementMatcher BinAsgmtOperator = binaryOperator(isAssignmentOperator());

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

 }
 
 TEST_P(ASTMatchersTest, ClassTemplateSpecializationDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(matches("template<typename T> struct A {};"
                       "template<> struct A<int> {};",
-                      classTemplateSpecializationDecl()));
+                      traverse(TK_AsIs, classTemplateSpecializationDecl())));
   EXPECT_TRUE(matches("template<typename T> struct A {}; A<int> a;",
-                      classTemplateSpecializationDecl()));
+                      traverse(TK_AsIs, classTemplateSpecializationDecl())));
   EXPECT_TRUE(notMatches("template<typename T> struct A {};",
-                         classTemplateSpecializationDecl()));
+                         traverse(TK_AsIs, classTemplateSpecializationDecl())));
 }
 
 TEST_P(ASTMatchersTest, DeclaratorDecl) {
   EXPECT_TRUE(matches("int x;", declaratorDecl()));
   EXPECT_TRUE(notMatches("struct A {};", declaratorDecl()));
 }
 
 TEST_P(ASTMatchersTest, DeclaratorDecl_CXX) {
TEST_P(ASTMatchersTest, Initializers_CXX) {
   if (GetParam().Language != Lang_CXX03) {
     // FIXME: Make this test pass with other C++ standard versions.
     return;
   }
   EXPECT_TRUE(matches(
       "void foo() { struct point { double x; double y; };"
       "  struct point ptarray[10] = "
       "      { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }",
-      initListExpr(
-          has(cxxConstructExpr(requiresZeroInitialization())),
-          has(initListExpr(
-              hasType(asString("struct point")), has(floatLiteral(equals(1.0))),
-              has(implicitValueInitExpr(hasType(asString("double")))))),
+      traverse(
+          TK_AsIs,
+          initListExpr(has(cxxConstructExpr(requiresZeroInitialization())),
+                       has(initListExpr(hasType(asString("struct point")),
+                                        has(floatLiteral(equals(1.0))),
+                                        has(implicitValueInitExpr(
+                                            hasType(asString("double")))))),
                        has(initListExpr(hasType(asString("struct point")),
                                         has(floatLiteral(equals(2.0))),
-                           has(floatLiteral(equals(1.0))))))));
+                                        has(floatLiteral(equals(1.0)))))))));
 }
 
 TEST_P(ASTMatchersTest, ParenListExpr) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(
       matches("template<typename T> class foo { void bar() { foo X(*this); } };"
TEST_P(ASTMatchersTest, CastExpression_MatchesImplicitCasts) {
   // This test creates an implicit cast from lvalue to rvalue.
   EXPECT_TRUE(matches("void f() { char c = 0, d = c; }",
                       traverse(TK_AsIs, castExpr())));
 }
 
 TEST_P(ASTMatchersTest, CastExpr_DoesNotMatchNonCasts) {
   if (GetParam().Language == Lang_C89 || GetParam().Language == Lang_C99) {
     // This does have a cast in C
-    EXPECT_TRUE(matches("char c = '0';", implicitCastExpr()));
+    EXPECT_TRUE(
+        matches("char c = '0';", traverse(TK_AsIs, implicitCastExpr())));
   } else {
-    EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
+    EXPECT_TRUE(notMatches("char c = '0';", traverse(TK_AsIs, castExpr())));
   }
-  EXPECT_TRUE(notMatches("int i = (0);", castExpr()));
-  EXPECT_TRUE(notMatches("int i = 0;", castExpr()));
+  EXPECT_TRUE(notMatches("int i = (0);", traverse(TK_AsIs, castExpr())));
+  EXPECT_TRUE(notMatches("int i = 0;", traverse(TK_AsIs, castExpr())));
 }
 
 TEST_P(ASTMatchersTest, CastExpr_DoesNotMatchNonCasts_CXX) {
   if (!GetParam().isCXX()) {
     return;
   }
-  EXPECT_TRUE(notMatches("char c, &q = c;", castExpr()));
+  EXPECT_TRUE(notMatches("char c, &q = c;", traverse(TK_AsIs, castExpr())));
 }
 
 TEST_P(ASTMatchersTest, CXXReinterpretCastExpr) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(matches("char* p = reinterpret_cast<char*>(&p);",
                       cxxReinterpretCastExpr()));

 }
 
 TEST_P(ASTMatchersTest, CXXFunctionalCastExpr_MatchesSimpleCase) {
   if (!GetParam().isCXX()) {
     return;
   }
   StringRef foo_class = "class Foo { public: Foo(const char*); };";
   EXPECT_TRUE(matches(foo_class + "void r() { Foo f = Foo(\"hello world\"); }",
-                      cxxFunctionalCastExpr()));
+                      traverse(TK_AsIs, cxxFunctionalCastExpr())));
 }
 
 TEST_P(ASTMatchersTest, CXXFunctionalCastExpr_DoesNotMatchOtherCasts) {
   if (!GetParam().isCXX()) {
     return;
   }
   StringRef FooClass = "class Foo { public: Foo(const char*); };";
   EXPECT_TRUE(
       notMatches(FooClass + "void r() { Foo f = (Foo) \"hello world\"; }",
-                 cxxFunctionalCastExpr()));
+                 traverse(TK_AsIs, cxxFunctionalCastExpr())));
   EXPECT_TRUE(notMatches(FooClass + "void r() { Foo f = \"hello world\"; }",
-                         cxxFunctionalCastExpr()));
+                         traverse(TK_AsIs, cxxFunctionalCastExpr())));
 }
 
 TEST_P(ASTMatchersTest, CXXDynamicCastExpr) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(matches("struct B { virtual ~B() {} }; struct D : B {};"
                       "B b;"
EXPECT_FALSE(matches("const char* str = (\"my-string\");",
                                              stringLiteral())))));
   EXPECT_TRUE(
       matches("const char* str = (\"my-string\");",
               traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
                                     ignoringParens(stringLiteral()))))));
 }
 
 TEST_P(ASTMatchersTest, QualType) {
-  EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
+  EXPECT_TRUE(
+      matches("struct S {};", traverse(TK_AsIs, qualType().bind("loc"))));
 }
 
 TEST_P(ASTMatchersTest, ConstantArrayType) {
   EXPECT_TRUE(matches("int a[2];", constantArrayType()));
   EXPECT_TRUE(notMatches("void f() { int a[] = { 2, 3 }; int b[a[0]]; }",
                          constantArrayType(hasElementType(builtinType()))));
 
   EXPECT_TRUE(matches("int a[42];", constantArrayType(hasSize(42))));

 }
 
 TEST_P(ASTMatchersTest, AutoType) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(matches("auto i = 2;", autoType()));
   EXPECT_TRUE(matches("int v[] = { 2, 3 }; void f() { for (int i : v) {} }",
-                      autoType()));
+                      traverse(TK_AsIs, autoType())));
 
   EXPECT_TRUE(matches("auto i = 2;", varDecl(hasType(isInteger()))));
   EXPECT_TRUE(matches("struct X{}; auto x = X{};",
                       varDecl(hasType(recordDecl(hasName("X"))))));
 
   // FIXME: Matching against the type-as-written can't work here, because the
   //        type as written was not deduced.
   // EXPECT_TRUE(matches("auto a = 1;",
TEST_P(ASTMatchersTest, SubstTemplateTypeParmType) {
   if (!GetParam().isCXX()) {
     return;
   }
   StringRef code = "template <typename T>"
                    "int F() {"
                    "  return 1 + T();"
                    "}"
                    "int i = F<int>();";
-  EXPECT_FALSE(matches(code, binaryOperator(hasLHS(
-                                 expr(hasType(substTemplateTypeParmType()))))));
-  EXPECT_TRUE(matches(code, binaryOperator(hasRHS(
-                                expr(hasType(substTemplateTypeParmType()))))));
+  EXPECT_FALSE(
+      matches(code, traverse(TK_AsIs, binaryOperator(hasLHS(expr(hasType(
+                                          substTemplateTypeParmType())))))));
+  EXPECT_TRUE(
+      matches(code, traverse(TK_AsIs, binaryOperator(hasRHS(expr(hasType(
+                                          substTemplateTypeParmType())))))));
 }
 
 TEST_P(ASTMatchersTest, NestedNameSpecifier) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(
       matches("namespace ns { struct A {}; } ns::A a;", nestedNameSpecifier()));

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

 TEST(DeclarationMatcher, hasMethod) {
   EXPECT_TRUE(matches("class A { void func(); };",
                       cxxRecordDecl(hasMethod(hasName("func")))));
   EXPECT_TRUE(notMatches("class A { void func(); };",
                          cxxRecordDecl(hasMethod(isPublic()))));
 }
 
 TEST(DeclarationMatcher, ClassDerivedFromDependentTemplateSpecialization) {
-  EXPECT_TRUE(matches(
-    "template <typename T> struct A {"
+  EXPECT_TRUE(
+      matches("template <typename T> struct A {"
               "  template <typename T2> struct F {};"
               "};"
               "template <typename T> struct B : A<T>::template F<T> {};"
               "B<int> b;",
-    cxxRecordDecl(hasName("B"), isDerivedFrom(recordDecl()))));
+              traverse(TK_AsIs, cxxRecordDecl(hasName("B"),
+                                              isDerivedFrom(recordDecl())))));
 }
 
 TEST(DeclarationMatcher, hasDeclContext) {
   EXPECT_TRUE(matches(
     "namespace N {"
       "  namespace M {"
       "    class D {};"
       "  }"
EXPECT_TRUE(matches("template <typename T> class A {};"
                       fieldDecl(hasType(templateSpecializationType(
                         hasDeclaration(namedDecl(hasName("A"))))))));
   EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
                       varDecl(hasType(templateSpecializationType(
                           hasDeclaration(cxxRecordDecl()))))));
 }
 
 TEST(HasDeclaration, HasDeclarationOfCXXNewExpr) {
-  EXPECT_TRUE(
-      matches("int *A = new int();",
-              cxxNewExpr(hasDeclaration(functionDecl(parameterCountIs(1))))));
+  EXPECT_TRUE(matches("int *A = new int();",
+                      traverse(TK_AsIs, cxxNewExpr(hasDeclaration(functionDecl(
+                                            parameterCountIs(1)))))));
 }
 
 TEST(HasDeclaration, HasDeclarationOfTypeAlias) {
   EXPECT_TRUE(matches("template <typename T> using C = T; C<int> c;",
                       varDecl(hasType(templateSpecializationType(
                           hasDeclaration(typeAliasTemplateDecl()))))));
 }
 
TEST(HasName, MatchesParameterVariableDeclarations) {
   EXPECT_TRUE(matches("class Y {}; class X { void x(int x) {} };",
                       cxxMethodDecl(hasAnyParameter(hasName("x")))));
   EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
                          cxxMethodDecl(hasAnyParameter(hasName("x")))));
 }
 
 TEST(Matcher, MatchesTypeTemplateArgument) {
   EXPECT_TRUE(matches(
       "template<typename T> struct B {};"
       "B<int> b;",
-    classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
-      asString("int"))))));
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            refersToType(asString("int")))))));
 }
 
 TEST(Matcher, MatchesTemplateTemplateArgument) {
-  EXPECT_TRUE(matches("template<template <typename> class S> class X {};"
-                      "template<typename T> class Y {};"
-                      "X<Y> xi;",
-                      classTemplateSpecializationDecl(hasAnyTemplateArgument(
-                          refersToTemplate(templateName())))));
+  EXPECT_TRUE(matches(
+      "template<template <typename> class S> class X {};"
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            refersToTemplate(templateName()))))));
 }
 
 TEST(Matcher, MatchesDeclarationReferenceTemplateArgument) {
-  EXPECT_TRUE(matches(
-    "struct B { int next; };"
+  EXPECT_TRUE(
+      matches("struct B { int next; };"
               "template<int(B::*next_ptr)> struct A {};"
               "A<&B::next> a;",
+              traverse(TK_AsIs,
                        classTemplateSpecializationDecl(hasAnyTemplateArgument(
-      refersToDeclaration(fieldDecl(hasName("next")))))));
+                           refersToDeclaration(fieldDecl(hasName("next"))))))));
 
   EXPECT_TRUE(notMatches(
       "template <typename T> struct A {};"
       "A<int> a;",
-    classTemplateSpecializationDecl(hasAnyTemplateArgument(
-      refersToDeclaration(decl())))));
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            refersToDeclaration(decl()))))));
 
   EXPECT_TRUE(matches(
       "struct B { int next; };"
       "template<int(B::*next_ptr)> struct A {};"
       "A<&B::next> a;",
-    templateSpecializationType(hasAnyTemplateArgument(isExpr(
-      hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))));
+      traverse(TK_AsIs, templateSpecializationType(hasAnyTemplateArgument(
+                            isExpr(hasDescendant(declRefExpr(
+                                to(fieldDecl(hasName("next")))))))))));
 
   EXPECT_TRUE(notMatches(
       "template <typename T> struct A {};"
       "A<int> a;",
-    templateSpecializationType(hasAnyTemplateArgument(
-      refersToDeclaration(decl())))));
+      traverse(TK_AsIs, templateSpecializationType(hasAnyTemplateArgument(
+                            refersToDeclaration(decl()))))));
 }
 
 
 TEST(Matcher, MatchesSpecificArgument) {
   EXPECT_TRUE(matches(
       "template<typename T, typename U> class A {};"
       "A<bool, int> a;",
-    classTemplateSpecializationDecl(hasTemplateArgument(
-      1, refersToType(asString("int"))))));
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasTemplateArgument(
+                            1, refersToType(asString("int")))))));
   EXPECT_TRUE(notMatches(
       "template<typename T, typename U> class A {};"
       "A<int, bool> a;",
-    classTemplateSpecializationDecl(hasTemplateArgument(
-      1, refersToType(asString("int"))))));
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasTemplateArgument(
+                            1, refersToType(asString("int")))))));
 
   EXPECT_TRUE(matches(
     "template<typename T, typename U> class A {};"
       "A<bool, int> a;",
     templateSpecializationType(hasTemplateArgument(
       1, refersToType(asString("int"))))));
   EXPECT_TRUE(notMatches(
     "template<typename T, typename U> class A {};"
       "A<int, bool> a;",
     templateSpecializationType(hasTemplateArgument(
       1, refersToType(asString("int"))))));
 
-  EXPECT_TRUE(matches(
-    "template<typename T> void f() {};"
+  EXPECT_TRUE(
+      matches("template<typename T> void f() {};"
               "void func() { f<int>(); }",
-    functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))));
-  EXPECT_TRUE(notMatches(
-    "template<typename T> void f() {};",
-    functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))));
+              traverse(TK_AsIs, functionDecl(hasTemplateArgument(
+                                    0, refersToType(asString("int")))))));
+  EXPECT_TRUE(
+      notMatches("template<typename T> void f() {};",
+                 traverse(TK_AsIs, functionDecl(hasTemplateArgument(
+                                       0, refersToType(asString("int")))))));
 }
 
 TEST(TemplateArgument, Matches) {
-  EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
-                      classTemplateSpecializationDecl(
-                        hasAnyTemplateArgument(templateArgument()))));
   EXPECT_TRUE(matches(
       "template<typename T> struct C {}; C<int> c;",
-    templateSpecializationType(hasAnyTemplateArgument(templateArgument()))));
-
+      traverse(TK_AsIs, classTemplateSpecializationDecl(
+                            hasAnyTemplateArgument(templateArgument())))));
   EXPECT_TRUE(matches(
-    "template<typename T> void f() {};"
+      "template<typename T> struct C {}; C<int> c;",
+      traverse(TK_AsIs, templateSpecializationType(
+                            hasAnyTemplateArgument(templateArgument())))));
+
+  EXPECT_TRUE(matches("template<typename T> void f() {};"
                       "void func() { f<int>(); }",
-    functionDecl(hasAnyTemplateArgument(templateArgument()))));
+                      traverse(TK_AsIs, functionDecl(hasAnyTemplateArgument(
+                                            templateArgument())))));
 }
 
 TEST(TemplateTypeParmDecl, CXXMethodDecl) {
   const char input[] =
       "template<typename T>\n"
       "class Class {\n"
       "  void method();\n"
       "};\n"
const char input[] =
       "struct Class<U>::Struct {\n"
       "  U field;\n"
       "};\n";
   EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
   EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
 }
 
 TEST(RefersToIntegralType, Matches) {
-  EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
-                      classTemplateSpecializationDecl(
-                        hasAnyTemplateArgument(refersToIntegralType(
-                          asString("int"))))));
-  EXPECT_TRUE(notMatches("template<unsigned T> struct C {}; C<42> c;",
-                         classTemplateSpecializationDecl(hasAnyTemplateArgument(
-                           refersToIntegralType(asString("int"))))));
+  EXPECT_TRUE(matches(
+      "template<int T> struct C {}; C<42> c;",
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            refersToIntegralType(asString("int")))))));
+  EXPECT_TRUE(notMatches(
+      "template<unsigned T> struct C {}; C<42> c;",
+      traverse(TK_AsIs, classTemplateSpecializationDecl(hasAnyTemplateArgument(
+                            refersToIntegralType(asString("int")))))));
 }
 
 TEST(ConstructorDeclaration, SimpleCase) {
   EXPECT_TRUE(matches("class Foo { Foo(int i); };",
                       cxxConstructorDecl(ofClass(hasName("Foo")))));
   EXPECT_TRUE(notMatches("class Foo { Foo(int i); };",
                          cxxConstructorDecl(ofClass(hasName("Bar")))));
 }
"struct Bar { Bar(){} };"
       "  Foo() : foo_() { }"
       "  Bar foo_;"
       "  Bar bar_;"
       "};";
   EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
     allOf(forField(hasName("foo_")), isWritten())))));
   EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
     allOf(forField(hasName("bar_")), isWritten())))));
-  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
-    allOf(forField(hasName("bar_")), unless(isWritten()))))));
+  EXPECT_TRUE(matches(
+      Code, traverse(TK_AsIs,
+                     cxxConstructorDecl(hasAnyConstructorInitializer(allOf(
+                         forField(hasName("bar_")), unless(isWritten())))))));
 }
 
 TEST(HasAnyConstructorInitializer, IsBaseInitializer) {
   static const char Code[] =
     "struct B {};"
       "struct D : B {"
       "  int I;"
       "  D(int i) : I(i) {}"
matches("class X { public: X(); }; void x(int) { X x = X(); }",
             Constructor));
   EXPECT_TRUE(
     notMatches("class Y { public: Y(); }; void x(int) { Y y; }",
                Constructor));
 }
 
 TEST(Matcher, VisitsTemplateInstantiations) {
   EXPECT_TRUE(matches(
       "class A { public: void x(); };"
       "template <typename T> class B { public: void y() { T t; t.x(); } };"
       "void f() { B<A> b; b.y(); }",
-    callExpr(callee(cxxMethodDecl(hasName("x"))))));
+      traverse(TK_AsIs, callExpr(callee(cxxMethodDecl(hasName("x")))))));
 
   EXPECT_TRUE(matches(
       "class A { public: void x(); };"
       "class C {"
       " public:"
       "  template <typename T> class B { public: void y() { T t; t.x(); } };"
       "};"
       "void f() {"
       "  C::B<A> b; b.y();"
       "}",
-    recordDecl(hasName("C"), hasDescendant(callExpr(
-      callee(cxxMethodDecl(hasName("x"))))))));
+      traverse(TK_AsIs,
+               recordDecl(hasName("C"), hasDescendant(callExpr(callee(
+                                            cxxMethodDecl(hasName("x")))))))));
 }
 
 TEST(Matcher, HasCondition) {
   StatementMatcher IfStmt =
     ifStmt(hasCondition(cxxBoolLiteral(equals(true))));
   EXPECT_TRUE(matches("void x() { if (true) {} }", IfStmt));
   EXPECT_TRUE(notMatches("void x() { if (false) {} }", IfStmt));
 

 void foo()
 {
     int i = 0;
     int b = 4;
     i < b;
 }
 )cpp";
   EXPECT_TRUE(matchAndVerifyResultFalse(
-      Code, binaryOperator(forEach(declRefExpr().bind("dre"))),
+      Code,
+      traverse(TK_AsIs, binaryOperator(forEach(declRefExpr().bind("dre")))),
       std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("dre", 0)));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       Code,
-      binaryOperator(forEach(
-          implicitCastExpr(hasSourceExpression(declRefExpr().bind("dre"))))),
+      traverse(TK_AsIs, binaryOperator(forEach(implicitCastExpr(
+                            hasSourceExpression(declRefExpr().bind("dre")))))),
       std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("dre", 2)));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       Code,
-      binaryOperator(
-          forEach(expr(ignoringImplicit(declRefExpr().bind("dre"))))),
+      traverse(TK_AsIs, binaryOperator(forEach(expr(
+                            ignoringImplicit(declRefExpr().bind("dre")))))),
       std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("dre", 2)));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
       Code,
       traverse(TK_IgnoreUnlessSpelledInSource,
                binaryOperator(forEach(declRefExpr().bind("dre")))),
       std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("dre", 2)));
 }
recordDecl(
       recordDecl().bind("x"), hasName("::X"),
       anyOf(forEachDescendant(recordDecl(hasName("Y"))), anything())),
     std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "class X {};", recordDecl(recordDecl().bind("x"), hasName("::X"),
                               anyOf(unless(anything()), anything())),
     std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "template<typename T1, typename T2> class X {}; X<float, int> x;",
+      traverse(TK_AsIs,
                classTemplateSpecializationDecl(
                    decl().bind("x"),
-      hasAnyTemplateArgument(refersToType(asString("int")))),
+                   hasAnyTemplateArgument(refersToType(asString("int"))))),
       std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "class X { void f(); void g(); };",
     cxxRecordDecl(decl().bind("x"), hasMethod(hasName("g"))),
     std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "class X { X() : a(1), b(2) {} double a; int b; };",
     recordDecl(decl().bind("x"),
                has(cxxConstructorDecl(
"class A{}; typedef A B; typedef A C; typedef A D;"
       "class E : A {};",
     cxxRecordDecl(decl().bind("x"), isDerivedFrom("C")),
     std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "class A { class B { void f() {} }; };",
     functionDecl(decl().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
     std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "template <typename T> struct A { struct B {"
       "  void f() { if(true) {} }"
       "}; };"
       "void t() { A<int>::B b; b.f(); }",
-    ifStmt(stmt().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
+      traverse(TK_AsIs, ifStmt(stmt().bind("x"),
+                               hasAncestor(recordDecl(hasName("::A"))))),
       std::make_unique<VerifyIdIsBoundTo<Stmt>>("x", 2)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
+      "template <typename T> struct A { struct B {"
+      "  void f() { if(true) {} }"
+      "}; };"
+      "void t() { A<int>::B b; b.f(); }",
+      traverse(
+          TK_IgnoreUnlessSpelledInSource,
+          ifStmt(stmt().bind("x"), hasAncestor(recordDecl(hasName("::A"))))),
+      std::make_unique<VerifyIdIsBoundTo<Stmt>>("x", 1)));
+  EXPECT_TRUE(matchAndVerifyResultTrue(
     "class A {};",
     recordDecl(hasName("::A"), decl().bind("x"), unless(hasName("fooble"))),
     std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "class A { A() : s(), i(42) {} const char *s; int i; };",
     cxxConstructorDecl(hasName("::A::A"), decl().bind("x"),
                        forEachConstructorInitializer(forField(hasName("i")))),
     std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
fieldDecl(hasAncestor(
                                  hasAncestor(recordDecl())))
       ).bind("d")
     )),
     std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("d", "E")));
 }
 
 TEST(HasAncestor, MatchesClosestAncestor) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "template <typename T> struct C {"
       "  void f(int) {"
       "    struct I { void g(T) { int x; } } i; i.g(42);"
       "  }"
       "};"
       "template struct C<int>;",
+      traverse(TK_AsIs,
                varDecl(hasName("x"),
-            hasAncestor(functionDecl(hasParameter(
-              0, varDecl(hasType(asString("int"))))).bind("f"))).bind("v"),
+                       hasAncestor(
+                           functionDecl(hasParameter(0, varDecl(hasType(
+                                                            asString("int")))))
+                               .bind("f")))
+                   .bind("v")),
       std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("f", "g", 2)));
 }
 
 TEST(HasAncestor, MatchesInTemplateInstantiations) {
   EXPECT_TRUE(matches(
       "template <typename T> struct A { struct B { struct C { T t; }; }; }; "
       "A<int>::B::C a;",
-    fieldDecl(hasType(asString("int")),
-              hasAncestor(recordDecl(hasName("A"))))));
+      traverse(TK_AsIs, fieldDecl(hasType(asString("int")),
+                                  hasAncestor(recordDecl(hasName("A")))))));
 }
 
 TEST(HasAncestor, MatchesInImplicitCode) {
   EXPECT_TRUE(matches(
       "struct X {}; struct A { A() {} X x; };",
-    cxxConstructorDecl(
-      hasAnyConstructorInitializer(withInitializer(expr(
-        hasAncestor(recordDecl(hasName("A")))))))));
+      traverse(TK_AsIs,
+               cxxConstructorDecl(hasAnyConstructorInitializer(withInitializer(
+                   expr(hasAncestor(recordDecl(hasName("A"))))))))));
 }
 
 TEST(HasParent, MatchesOnlyParent) {
   EXPECT_TRUE(matches(
     "void f() { if (true) { int x = 42; } }",
     compoundStmt(hasParent(ifStmt()))));
   EXPECT_TRUE(notMatches(
     "void f() { for (;;) { int x = 42; } }",
EXPECT_TRUE(matches(
     integerLiteral(
       equals(42),
       allOf(
         hasAncestor(cxxRecordDecl(isTemplateInstantiation())),
         hasAncestor(cxxRecordDecl(unless(isTemplateInstantiation())))))));
 }
 
 TEST(HasAncestor, ImplicitArrayCopyCtorDeclRefExpr) {
-  EXPECT_TRUE(matches("struct MyClass {\n"
-                        "  int c[1];\n"
-                        "  static MyClass Create() { return MyClass(); }\n"
-                        "};",
-                      declRefExpr(to(decl(hasAncestor(decl()))))));
+  EXPECT_TRUE(
+      matches("struct MyClass {\n"
+              traverse(TK_AsIs, declRefExpr(to(decl(hasAncestor(decl())))))));
 }
 
 TEST(HasAncestor, AnonymousUnionMemberExpr) {
   EXPECT_TRUE(matches("int F() {\n"
                         "  union { int i; };\n"
                         "  return i;\n"
                         "}\n",
                       memberExpr(member(hasAncestor(decl())))));
EXPECT_TRUE(notMatches(Fragment, unresolvedLookupExpr(hasAnyDeclaration(
                                        functionDecl(hasName("bar"))))));
 }
 
 TEST(SubstTemplateTypeParmType, HasReplacementType) {
   StringRef Fragment = "template<typename T>"
                        "double F(T t);"
                        "int i;"
                        "double j = F(i);";
-  EXPECT_TRUE(matches(Fragment, substTemplateTypeParmType(hasReplacementType(
-                                    qualType(asString("int"))))));
-  EXPECT_TRUE(notMatches(Fragment, substTemplateTypeParmType(hasReplacementType(
-                                       qualType(asString("double"))))));
-  EXPECT_TRUE(
-      notMatches("template<int N>"
-                 "double F();"
-                 "double j = F<5>();",
-                 substTemplateTypeParmType(hasReplacementType(qualType()))));
+  EXPECT_TRUE(matches(
+      Fragment, traverse(TK_AsIs, substTemplateTypeParmType(hasReplacementType(
+                                      qualType(asString("int")))))));
+  EXPECT_TRUE(notMatches(
+      Fragment, traverse(TK_AsIs, substTemplateTypeParmType(hasReplacementType(
+                                      qualType(asString("double")))))));
+  EXPECT_TRUE(notMatches(
+      "template<int N>"
+      traverse(TK_AsIs,
+               substTemplateTypeParmType(hasReplacementType(qualType())))));
 }
 
 TEST(ClassTemplateSpecializationDecl, HasSpecializedTemplate) {
-  auto Matcher = classTemplateSpecializationDecl(
-      hasSpecializedTemplate(classTemplateDecl()));
+  auto Matcher =
+      traverse(TK_AsIs, classTemplateSpecializationDecl(
+                            hasSpecializedTemplate(classTemplateDecl())));
   EXPECT_TRUE(
       matches("template<typename T> class A {}; typedef A<int> B;", Matcher));
   EXPECT_TRUE(notMatches("template<typename T> class A {};", Matcher));
 }
 
 TEST(CXXNewExpr, Array) {
   StatementMatcher NewArray = cxxNewExpr(isArray());