Set traversal explicitly where needed in tests

[steveire]

Fix case

[steveire]

Rebase

[shafik]

I was looking at the changes to ASTImporterTest.cpp and it not obvious to me how you determined where it was needed.

[steveire]

Update

[aaron.ballman]

In D72531#1845686, @shafik wrote:

I was looking at the changes to ASTImporterTest.cpp and it not obvious to me how you determined where it was needed.

Some of the changes were reasonably obvious to me because they involved matching implicit nodes that require the as-is traversal. However, other changes did seem to come from out of nowhere (I commented on one such), and hopefully @steveire will explain.

clang/unittests/Tooling/StencilTest.cpp

63

Was this change made because you didn't want to accept the traversal mode as a parameter to matchStmt and force each caller to decide which mode they use? Or is there some other reason why this change was needed?

[steveire]

clang/unittests/Tooling/StencilTest.cpp

63

Yes, the test currently expects AsIs. If someone wanted to change that in the future, that is an issue for future work.

[aaron.ballman]

clang/unittests/Tooling/StencilTest.cpp

63

You say "the test" as though there's only one. There are numerous tests which use matchStmt. Do *all* of the tests require AsIs? (I think that's an example of what's causing some of the confusion @shafik and I had and I'm trying to ensure his question gets answered and that I'm fully understanding your changes.) From spot-checking, it looks like there are tests using matchStmt that don't need AsIs traversal and that this sort of cleanup work could happen in the future, but for now you're going with the easiest approach instead of expanding the test coverage for ignoring implicit nodes; is that correct?

[steveire]

clang/unittests/Tooling/StencilTest.cpp

63

I said "the" test because there is one StencilTest class inside one StencilTest.cpp. Perhaps not a word you would use, but that's not something to get stuck on hopefully.

Yes, it is possible that someone could make matchStmt take an explicit TraversalKind, but I didn't see the need to do that in this patch. This patch maintains the status quo as much as possible while also making it possible to change the default.

[aaron.ballman]

LGTM!

clang/unittests/Tooling/StencilTest.cpp

63

I said "the" test because there is one StencilTest class inside one StencilTest.cpp. Perhaps not a word you would use, but that's not something to get stuck on hopefully.

Nope, just making sure I understood.

Yes, it is possible that someone could make matchStmt take an explicit TraversalKind, but I didn't see the need to do that in this patch.

Good to know! FWIW, it would be reasonable to do some of that work in this patch, but I don't insist. As with one of the other patches in the set, making the changes to handle either traversal kind as appropriate for the situation improves the test coverage for your changes and it helps demonstrate why this default is more simple (as opposed to making everything look more complex because the patch only adds code, doesn't remove any).

This patch maintains the status quo as much as possible while also making it possible to change the default.

That's good enough for me, thanks.

clang/unittests/AST/ASTImporterTest.cpp

testImport(
       Lang_C, "", Lang_C, Verifier,
       functionDecl(hasDescendant(
           switchStmt(has(compoundStmt(has(caseStmt())))))));
 }
 
 TEST_P(ImportExpr, ImportStmtExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
       Lang_C, "", Lang_C, Verifier,
-    functionDecl(hasDescendant(
-        varDecl(
-            hasName("C"),
-            hasType(asString("int")),
-            hasInitializer(
-                stmtExpr(
-                    hasAnySubstatement(declStmt(hasSingleDecl(
-                        varDecl(
-                            hasName("X"),
-                            hasType(asString("int")),
-                            hasInitializer(
-                                integerLiteral(equals(4))))))),
-                    hasDescendant(
-                        implicitCastExpr())))))));
+      traverse(ast_type_traits::TK_AsIs,
+               functionDecl(hasDescendant(varDecl(
+                   hasName("C"), hasType(asString("int")),
+                   hasInitializer(stmtExpr(
+                       hasAnySubstatement(declStmt(hasSingleDecl(varDecl(
+                           hasName("X"), hasType(asString("int")),
+                           hasInitializer(integerLiteral(equals(4))))))),
+                       hasDescendant(implicitCastExpr()))))))));
 }
 
 TEST_P(ImportExpr, ImportConditionalOperator) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { (void)(true ? 1 : -5); }",
       Lang_CXX, "", Lang_CXX, Verifier,
       functionDecl(hasDescendant(
           conditionalOperator(
               hasCondition(cxxBoolLiteral(equals(true))),
               hasTrueExpression(integerLiteral(equals(1))),
               hasFalseExpression(
                   unaryOperator(hasUnaryOperand(integerLiteral(equals(5))))))
           )));
 }
 
 TEST_P(ImportExpr, ImportBinaryConditionalOperator) {
   MatchVerifier<Decl> Verifier;
   testImport(
-      "void declToImport() { (void)(1 ?: -5); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
-          binaryConditionalOperator(
-              hasCondition(
-                  implicitCastExpr(
+      "void declToImport() { (void)(1 ?: -5); }", Lang_CXX, "", Lang_CXX,
+      Verifier,
+      traverse(ast_type_traits::TK_AsIs,
+               functionDecl(hasDescendant(binaryConditionalOperator(
+                   hasCondition(implicitCastExpr(
                        hasSourceExpression(opaqueValueExpr(
                            hasSourceExpression(integerLiteral(equals(1))))),
                        hasType(booleanType()))),
-              hasTrueExpression(
-                  opaqueValueExpr(
+                   hasTrueExpression(opaqueValueExpr(
                        hasSourceExpression(integerLiteral(equals(1))))),
-              hasFalseExpression(
-                  unaryOperator(
+                   hasFalseExpression(unaryOperator(
                        hasOperatorName("-"),
-                      hasUnaryOperand(integerLiteral(equals(5)))))))));
+                       hasUnaryOperand(integerLiteral(equals(5))))))))));
 }
 
 TEST_P(ImportExpr, ImportDesignatedInitExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() {"
       "  struct point { double x; double y; };"
       "  struct point ptarray[10] = "

 }
 
 TEST_P(ImportExpr, CXXTemporaryObjectExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "struct C {};"
       "void declToImport() { C c = C(); }",
       Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
-          exprWithCleanups(has(cxxConstructExpr(
+      traverse(ast_type_traits::TK_AsIs,
+               functionDecl(hasDescendant(exprWithCleanups(has(cxxConstructExpr(
                    has(materializeTemporaryExpr(has(implicitCastExpr(
-                  has(cxxTemporaryObjectExpr())))))))))));
+                       has(cxxTemporaryObjectExpr()))))))))))));
 }
 
 TEST_P(ImportType, ImportAtomicType) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { typedef _Atomic(int) a_int; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(hasDescendant(typedefDecl(has(atomicType())))));

 TEST_P(ImportType, ImportTypeAliasTemplate) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template <int K>"
       "struct dummy { static const int i = K; };"
       "template <int K> using dummy2 = dummy<K>;"
       "int declToImport() { return dummy2<3>::i; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
-      functionDecl(
-          hasDescendant(implicitCastExpr(has(declRefExpr()))),
-          unless(hasAncestor(translationUnitDecl(has(typeAliasDecl()))))));
+      traverse(ast_type_traits::TK_AsIs,
+               functionDecl(hasDescendant(implicitCastExpr(has(declRefExpr()))),
+                            unless(hasAncestor(
+                                translationUnitDecl(has(typeAliasDecl())))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateSpecializationDecl>
     varTemplateSpecializationDecl;
 
 TEST_P(ImportDecl, ImportVarTemplate) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template <typename T>"
       "T pi = T(3.1415926535897932385L);"
       "void declToImport() { (void)pi<int>; }",
       Lang_CXX14, "", Lang_CXX14, Verifier,
       functionDecl(
           hasDescendant(declRefExpr(to(varTemplateSpecializationDecl()))),
           unless(hasAncestor(translationUnitDecl(has(varDecl(
               hasName("pi"), unless(varTemplateSpecializationDecl()))))))));
 }
 
 TEST_P(ImportType, ImportPackExpansion) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "template <typename... Args>"
+  testImport("template <typename... Args>"
              "struct dummy {"
              "  dummy(Args... args) {}"
              "  static const int i = 4;"
              "};"
              "int declToImport() { return dummy<int>::i; }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
-      functionDecl(hasDescendant(
-          returnStmt(has(implicitCastExpr(has(declRefExpr())))))));
+             traverse(ast_type_traits::TK_AsIs,
+                      functionDecl(hasDescendant(returnStmt(
+                          has(implicitCastExpr(has(declRefExpr()))))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Type,
                                             DependentTemplateSpecializationType>
     dependentTemplateSpecializationType;
 
 TEST_P(ImportType, ImportDependentTemplateSpecialization) {
   MatchVerifier<Decl> Verifier;
TEST_P(ImportExpr, ImportCXXTypeidExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "namespace std { class type_info {}; }"
       "void declToImport() {"
       "  int x;"
       "  auto a = typeid(int); auto b = typeid(x);"
       "}",
       Lang_CXX11, "", Lang_CXX11, Verifier,
+      traverse(
+          ast_type_traits::TK_AsIs,
           functionDecl(
-          hasDescendant(varDecl(
-              hasName("a"), hasInitializer(hasDescendant(cxxTypeidExpr())))),
-          hasDescendant(varDecl(
-              hasName("b"), hasInitializer(hasDescendant(cxxTypeidExpr()))))));
+              hasDescendant(varDecl(hasName("a"), hasInitializer(hasDescendant(
+                                                      cxxTypeidExpr())))),
+              hasDescendant(varDecl(hasName("b"), hasInitializer(hasDescendant(
+                                                      cxxTypeidExpr())))))));
 }
 
 TEST_P(ImportExpr, ImportTypeTraitExprValDep) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template<typename T> struct declToImport {"
       "  void m() { (void)__is_pod(T); }"
       "};"

clang/unittests/AST/SourceLocationTest.cpp

EXPECT_TRUE(Verifier.match(
       "template<class T> void operator+(S<T> x);\n"
       "template<class T> struct S {\n"
       "  friend void operator+<>(S<T> src);\n"
       "};\n"
       "void test(S<double> s) { +s; }",
       friendDecl(hasParent(cxxRecordDecl(isTemplateInstantiation())))));
 }
 
-TEST(ObjCMessageExpr, CXXConstructExprRange) {
-  RangeVerifier<CXXConstructExpr> Verifier;
+TEST(ObjCMessageExpr, ParenExprRange) {
+  RangeVerifier<ParenExpr> Verifier;
   Verifier.expectRange(5, 25, 5, 27);
-  EXPECT_TRUE(Verifier.match(
-      "struct A { int a; };\n"
+  EXPECT_TRUE(Verifier.match("struct A { int a; };\n"
                              "@interface B {}\n"
                              "+ (void) f1: (A)arg;\n"
                              "@end\n"
                              "void f2() { A a; [B f1: (a)]; }\n",
-      cxxConstructExpr(), Lang_OBJCXX));
+                             traverse(ast_type_traits::TK_AsIs, parenExpr()),
+                             Lang_OBJCXX));
 }
 
 TEST(FunctionDecl, FunctionDeclWithThrowSpecification) {
   RangeVerifier<FunctionDecl> Verifier;
   Verifier.expectRange(1, 1, 1, 16);
   EXPECT_TRUE(Verifier.match(
       "void f() throw();\n",
       functionDecl()));

clang/unittests/AST/StmtPrinterTest.cpp

TEST(StmtPrinter, TestFloatingPointLiteral) {
   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX98,
     "void A() { 1.0f, -1.0f, 1.0, -1.0, 1.0l, -1.0l; }",
     FunctionBodyMatcher("A"),
     "1.F , -1.F , 1. , -1. , 1.L , -1.L"));
     // Should be: with semicolon
 }
 
 TEST(StmtPrinter, TestCXXConversionDeclImplicit) {
-  ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX98,
+  ASSERT_TRUE(
+      PrintedStmtCXXMatches(StdVer::CXX98,
                             "struct A {"
                             "operator void *();"
                             "A operator&(A);"
                             "};"
                             "void bar(void *);"
                             "void foo(A a, A b) {"
                             "  bar(a & b);"
                             "}",
-    cxxMemberCallExpr(anything()).bind("id"),
+                            traverse(ast_type_traits::TK_AsIs,
+                                     cxxMemberCallExpr(anything()).bind("id")),
                             "a & b"));
 }
 
 TEST(StmtPrinter, TestCXXConversionDeclExplicit) {
   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11,
     "struct A {"
       "operator void *();"
       "A operator&(A);"
     "};"

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

TEST(DeclarationMatcher, MatchNot) {
 
   DeclarationMatcher NamedNotRecord =
     namedDecl(hasName("Foo"), unless(recordDecl()));
   EXPECT_TRUE(matches("void Foo(){}", NamedNotRecord));
   EXPECT_TRUE(notMatches("struct Foo {};", NamedNotRecord));
 }
 
 TEST(CastExpression, HasCastKind) {
-  EXPECT_TRUE(matches("char *p = 0;",
-              castExpr(hasCastKind(CK_NullToPointer))));
-  EXPECT_TRUE(notMatches("char *p = 0;",
-              castExpr(hasCastKind(CK_DerivedToBase))));
-  EXPECT_TRUE(matches("char *p = 0;",
-              implicitCastExpr(hasCastKind(CK_NullToPointer))));
+  EXPECT_TRUE(
+      matches("char *p = 0;",
+              traverse(ast_type_traits::TK_AsIs,
+                       varDecl(has(castExpr(hasCastKind(CK_NullToPointer)))))));
+  EXPECT_TRUE(notMatches(
+      "char *p = 0;",
+      traverse(ast_type_traits::TK_AsIs,
+               varDecl(has(castExpr(hasCastKind(CK_DerivedToBase)))))));
+  EXPECT_TRUE(matches(
+      "char *p = 0;",
+      traverse(ast_type_traits::TK_AsIs,
+               varDecl(has(implicitCastExpr(hasCastKind(CK_NullToPointer)))))));
 }
 
 TEST(DeclarationMatcher, HasDescendant) {
   DeclarationMatcher ZDescendantClassX =
     recordDecl(
       hasDescendant(recordDecl(hasName("X"))),
       hasName("Z"));
   EXPECT_TRUE(matches("class Z { class X {}; };", ZDescendantClassX));
TEST(Matcher, MatchesOverridingMethod) {
   EXPECT_TRUE(notMatches("class X { int f(); int f(int); }; ",
                          cxxMethodDecl(isOverride())));
   EXPECT_TRUE(
     matches("template <typename Base> struct Y : Base { void f() override;};",
             cxxMethodDecl(isOverride(), hasName("::Y::f"))));
 }
 
 TEST(Matcher, ConstructorArgument) {
-  StatementMatcher Constructor = cxxConstructExpr(
-    hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
+  auto Constructor = traverse(
+      ast_type_traits::TK_AsIs,
+      cxxConstructExpr(hasArgument(0, declRefExpr(to(varDecl(hasName("y")))))));
 
   EXPECT_TRUE(
     matches("class X { public: X(int); }; void x() { int y; X x(y); }",
             Constructor));
   EXPECT_TRUE(
     matches("class X { public: X(int); }; void x() { int y; X x = X(y); }",
             Constructor));
   EXPECT_TRUE(
     matches("class X { public: X(int); }; void x() { int y; X x = y; }",
             Constructor));
   EXPECT_TRUE(
     notMatches("class X { public: X(int); }; void x() { int z; X x(z); }",
                Constructor));
 
-  StatementMatcher WrongIndex = cxxConstructExpr(
-    hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
+  StatementMatcher WrongIndex =
+      traverse(ast_type_traits::TK_AsIs,
+               cxxConstructExpr(
+                   hasArgument(42, declRefExpr(to(varDecl(hasName("y")))))));
   EXPECT_TRUE(
     notMatches("class X { public: X(int); }; void x() { int y; X x(y); }",
                WrongIndex));
 }
 
 TEST(Matcher, ConstructorArgumentCount) {
-  StatementMatcher Constructor1Arg = cxxConstructExpr(argumentCountIs(1));
+  auto Constructor1Arg =
+      traverse(ast_type_traits::TK_AsIs, cxxConstructExpr(argumentCountIs(1)));
 
   EXPECT_TRUE(
     matches("class X { public: X(int); }; void x() { X x(0); }",
             Constructor1Arg));
   EXPECT_TRUE(
     matches("class X { public: X(int); }; void x() { X x = X(0); }",
             Constructor1Arg));
   EXPECT_TRUE(
     matches("class X { public: X(int); }; void x() { X x = 0; }",
             Constructor1Arg));
   EXPECT_TRUE(
     notMatches("class X { public: X(int, int); }; void x() { X x(0, 0); }",
                Constructor1Arg));
 }
 
 TEST(Matcher, ConstructorListInitialization) {
-  StatementMatcher ConstructorListInit =
-    cxxConstructExpr(isListInitialization());
+  auto ConstructorListInit =
+      traverse(ast_type_traits::TK_AsIs,
+               varDecl(has(cxxConstructExpr(isListInitialization()))));
 
   EXPECT_TRUE(
     matches("class X { public: X(int); }; void x() { X x{0}; }",
             ConstructorListInit));
   EXPECT_FALSE(
     matches("class X { public: X(int); }; void x() { X x(0); }",
             ConstructorListInit));
 }

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

EXPECT_TRUE(matches("class Y { }; "
                       OpCall));
   // No match -- normal operator, not an overloaded one.
   EXPECT_TRUE(notMatches("bool x = true, y = true; bool t = x && y;", OpCall));
   EXPECT_TRUE(notMatches("int t = 5 << 2;", OpCall));
 }
 
 TEST(Matcher, ThisPointerType) {
   StatementMatcher MethodOnY =
-    cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y"))));
+      traverse(ast_type_traits::TK_AsIs,
+               cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y")))));
 
   EXPECT_TRUE(
     matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
             MethodOnY));
   EXPECT_TRUE(
     matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
             MethodOnY));
   EXPECT_TRUE(

 }
 
 TEST(ParmVarDecl, MatchesParmVars) {
   EXPECT_TRUE(matches("void f(int x);", parmVarDecl()));
   EXPECT_TRUE(notMatches("void f();", parmVarDecl()));
 }
 
 TEST(Matcher, ConstructorCall) {
-  StatementMatcher Constructor = cxxConstructExpr();
+  StatementMatcher Constructor =
+      traverse(ast_type_traits::TK_AsIs, cxxConstructExpr());
 
   EXPECT_TRUE(
     matches("class X { public: X(); }; void x() { X x; }", Constructor));
   EXPECT_TRUE(
     matches("class X { public: X(); }; void x() { X x = X(); }",
             Constructor));
   EXPECT_TRUE(
     matches("class X { public: X(int); }; void x() { X x = 0; }",

 TEST(Matcher, ThisExpr) {
   EXPECT_TRUE(
     matches("struct X { int a; int f () { return a; } };", cxxThisExpr()));
   EXPECT_TRUE(
     notMatches("struct X { int f () { int a; return a; } };", cxxThisExpr()));
 }
 
 TEST(Matcher, BindTemporaryExpression) {
-  StatementMatcher TempExpression = cxxBindTemporaryExpr();
+  StatementMatcher TempExpression =
+      traverse(ast_type_traits::TK_AsIs, cxxBindTemporaryExpr());
 
   std::string ClassString = "class string { public: string(); ~string(); }; ";
 
   EXPECT_TRUE(
     matches(ClassString +
               "string GetStringByValue();"
                 "void FunctionTakesString(string s);"
                 "void run() { FunctionTakesString(GetStringByValue()); }",
notMatches("class no_dtor {};"
                  "void ConsumeObj(no_dtor param);"
                  "void run() { ConsumeObj(GetObjByValue()); }",
                TempExpression));
 }
 
 TEST(MaterializeTemporaryExpr, MatchesTemporary) {
   std::string ClassString =
     "class string { public: string(); int length(); }; ";
+  StatementMatcher TempExpression =
+      traverse(ast_type_traits::TK_AsIs, materializeTemporaryExpr());
 
-  EXPECT_TRUE(
-    matches(ClassString +
-              "string GetStringByValue();"
+  EXPECT_TRUE(matches(
+      ClassString + "string GetStringByValue();"
                     "void FunctionTakesString(string s);"
                     "void run() { FunctionTakesString(GetStringByValue()); }",
-            materializeTemporaryExpr()));
+      TempExpression));
 
-  EXPECT_TRUE(
-    notMatches(ClassString +
+  EXPECT_TRUE(notMatches(ClassString +
                              "string* GetStringPointer(); "
                              "void FunctionTakesStringPtr(string* s);"
                              "void run() {"
                              "  string* s = GetStringPointer();"
                              "  FunctionTakesStringPtr(GetStringPointer());"
                              "  FunctionTakesStringPtr(s);"
                              "}",
-               materializeTemporaryExpr()));
+                         TempExpression));
 
-  EXPECT_TRUE(
-    matches(ClassString +
+  EXPECT_TRUE(matches(ClassString +
                           "string GetStringByValue();"
                           "void run() { int k = GetStringByValue().length(); }",
-               materializeTemporaryExpr()));
+                      TempExpression));
 
-  EXPECT_TRUE(
-    notMatches(ClassString +
-                 "string GetStringByValue();"
+  EXPECT_TRUE(notMatches(ClassString + "string GetStringByValue();"
                                        "void run() { GetStringByValue(); }",
-               materializeTemporaryExpr()));
+                         TempExpression));
 }
 
 TEST(Matcher, NewExpression) {
   StatementMatcher New = cxxNewExpr();
 
   EXPECT_TRUE(matches("class X { public: X(); }; void x() { new X; }", New));
   EXPECT_TRUE(
     matches("class X { public: X(); }; void x() { new X(); }", New));
EXPECT_TRUE(
     notMatches("void x() { true ? false : true; }", ConditionalFalse));
 
   EXPECT_TRUE(matches("void x() { true ? true : false; }", ConditionalFalse));
   EXPECT_TRUE(
     notMatches("void x() { true ? false : true; }", ConditionalFalse));
 }
 
 TEST(Matcher, BinaryConditionalOperator) {
-  StatementMatcher AlwaysOne = binaryConditionalOperator(
-    hasCondition(implicitCastExpr(
-      has(
-        opaqueValueExpr(
+  StatementMatcher AlwaysOne =
+      traverse(ast_type_traits::TK_AsIs,
+               binaryConditionalOperator(
+                   hasCondition(implicitCastExpr(has(opaqueValueExpr(
                        hasSourceExpression((integerLiteral(equals(1)))))))),
-    hasFalseExpression(integerLiteral(equals(0))));
+                   hasFalseExpression(integerLiteral(equals(0)))));
 
   EXPECT_TRUE(matches("void x() { 1 ?: 0; }", AlwaysOne));
 
   StatementMatcher FourNotFive = binaryConditionalOperator(
     hasTrueExpression(opaqueValueExpr(
       hasSourceExpression((integerLiteral(equals(4)))))),
     hasFalseExpression(integerLiteral(equals(5))));
 

 TEST(CastExpression, MatchesExplicitCasts) {
   EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);",castExpr()));
   EXPECT_TRUE(matches("void *p = (void *)(&p);", castExpr()));
   EXPECT_TRUE(matches("char q, *p = const_cast<char *>(&q);", castExpr()));
   EXPECT_TRUE(matches("char c = char(0);", castExpr()));
 }
 TEST(CastExpression, MatchesImplicitCasts) {
   // This test creates an implicit cast from int to char.
-  EXPECT_TRUE(matches("char c = 0;", castExpr()));
+  EXPECT_TRUE(
+      matches("char c = 0;", traverse(ast_type_traits::TK_AsIs, castExpr())));
   // This test creates an implicit cast from lvalue to rvalue.
-  EXPECT_TRUE(matches("char c = 0, d = c;", castExpr()));
+  EXPECT_TRUE(matches("char c = 0, d = c;",
+                      traverse(ast_type_traits::TK_AsIs, castExpr())));
 }
 
 TEST(CastExpression, DoesNotMatchNonCasts) {
   EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
   EXPECT_TRUE(notMatches("char c, &q = c;", castExpr()));
   EXPECT_TRUE(notMatches("int i = (0);", castExpr()));
   EXPECT_TRUE(notMatches("int i = 0;", castExpr()));
 }
EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);"
                            "B b;"
                            "D* t = dynamic_cast<D*>(&b);",
                          cStyleCastExpr()));
 }
 
 TEST(ImplicitCast, MatchesSimpleCase) {
   // This test creates an implicit const cast.
   EXPECT_TRUE(matches("int x = 0; const int y = x;",
-                      varDecl(hasInitializer(implicitCastExpr()))));
+                      traverse(ast_type_traits::TK_AsIs,
+                               varDecl(hasInitializer(implicitCastExpr())))));
   // This test creates an implicit cast from int to char.
   EXPECT_TRUE(matches("char c = 0;",
-                      varDecl(hasInitializer(implicitCastExpr()))));
+                      traverse(ast_type_traits::TK_AsIs,
+                               varDecl(hasInitializer(implicitCastExpr())))));
   // This test creates an implicit array-to-pointer cast.
   EXPECT_TRUE(matches("int arr[6]; int *p = arr;",
-                      varDecl(hasInitializer(implicitCastExpr()))));
+                      traverse(ast_type_traits::TK_AsIs,
+                               varDecl(hasInitializer(implicitCastExpr())))));
 }
 
 TEST(ImplicitCast, DoesNotMatchIncorrectly) {
   // This test verifies that implicitCastExpr() matches exactly when implicit casts
   // are present, and that it ignores explicit and paren casts.
 
   // These two test cases have no casts.
   EXPECT_TRUE(notMatches("int x = 0;",

 }
 
 TEST(DeclarationStatement, MatchesVariableDeclarationStatements) {
   EXPECT_TRUE(matches("void x() { int a; }", declStmt()));
 }
 
 TEST(ExprWithCleanups, MatchesExprWithCleanups) {
   EXPECT_TRUE(matches("struct Foo { ~Foo(); };"
-                        "const Foo f = Foo();",
-                      varDecl(hasInitializer(exprWithCleanups()))));
+                      traverse(ast_type_traits::TK_AsIs,
+                               varDecl(hasInitializer(exprWithCleanups())))));
   EXPECT_FALSE(matches("struct Foo { }; Foo a;"
                        "const Foo f = a;",
-                       varDecl(hasInitializer(exprWithCleanups()))));
+                       traverse(ast_type_traits::TK_AsIs,
+                                varDecl(hasInitializer(exprWithCleanups())))));
 }
 
 TEST(InitListExpression, MatchesInitListExpression) {
   EXPECT_TRUE(matches("int a[] = { 1, 2 };",
                       initListExpr(hasType(asString("int [2]")))));
   EXPECT_TRUE(matches("struct B { int x, y; }; B b = { 5, 6 };",
                       initListExpr(hasType(recordDecl(hasName("B"))))));
   EXPECT_TRUE(matches("struct S { S(void (*a)()); };"
                         "void f();"
                         "S s[1] = { &f };",
                       declRefExpr(to(functionDecl(hasName("f"))))));
   EXPECT_TRUE(
     matches("int i[1] = {42, [0] = 43};", integerLiteral(equals(42))));
 }
 
 TEST(CXXStdInitializerListExpression, MatchesCXXStdInitializerListExpression) {
   const std::string code = "namespace std {"
                            "template <typename> class initializer_list {"
                            "  public: initializer_list() noexcept {}"
                            "};"
                            "}"
                            "struct A {"
                            "  A(std::initializer_list<int>) {}"
                            "};";
-  EXPECT_TRUE(matches(code + "A a{0};",
+  EXPECT_TRUE(
+      matches(code + "A a{0};",
+              traverse(ast_type_traits::TK_AsIs,
                        cxxConstructExpr(has(cxxStdInitializerListExpr()),
                                         hasDeclaration(cxxConstructorDecl(
-                                           ofClass(hasName("A")))))));
-  EXPECT_TRUE(matches(code + "A a = {0};",
+                                            ofClass(hasName("A"))))))));
+  EXPECT_TRUE(
+      matches(code + "A a = {0};",
+              traverse(ast_type_traits::TK_AsIs,
                        cxxConstructExpr(has(cxxStdInitializerListExpr()),
                                         hasDeclaration(cxxConstructorDecl(
-                                           ofClass(hasName("A")))))));
+                                            ofClass(hasName("A"))))))));
 
   EXPECT_TRUE(notMatches("int a[] = { 1, 2 };", cxxStdInitializerListExpr()));
   EXPECT_TRUE(notMatches("struct B { int x, y; }; B b = { 5, 6 };",
                          cxxStdInitializerListExpr()));
 }
 
 TEST(UsingDeclaration, MatchesUsingDeclarations) {
   EXPECT_TRUE(matches("namespace X { int x; } using X::x;",
EXPECT_TRUE(notMatches("void foo() try { throw; } catch(int) { }",
                          cxxCatchStmt(isCatchAll())));
   EXPECT_TRUE(matches("void foo() try {} catch(int X) { }",
                       varDecl(isExceptionVariable())));
   EXPECT_TRUE(notMatches("void foo() try { int X; } catch (...) { }",
                          varDecl(isExceptionVariable())));
 }
 
 TEST(ParenExpression, SimpleCases) {
-  EXPECT_TRUE(matches("int i = (3);", parenExpr()));
-  EXPECT_TRUE(matches("int i = (3 + 7);", parenExpr()));
-  EXPECT_TRUE(notMatches("int i = 3;", parenExpr()));
+  EXPECT_TRUE(
+      matches("int i = (3);", traverse(ast_type_traits::TK_AsIs, parenExpr())));
+  EXPECT_TRUE(matches("int i = (3 + 7);",
+                      traverse(ast_type_traits::TK_AsIs, parenExpr())));
+  EXPECT_TRUE(notMatches("int i = 3;",
+                         traverse(ast_type_traits::TK_AsIs, parenExpr())));
   EXPECT_TRUE(notMatches("int foo() { return 1; }; int a = foo();",
-                         parenExpr()));
+                         traverse(ast_type_traits::TK_AsIs, parenExpr())));
 }
 
 TEST(ParenExpression, IgnoringParens) {
-  EXPECT_FALSE(matches("const char* str = (\"my-string\");",
-                       implicitCastExpr(hasSourceExpression(stringLiteral()))));
-  EXPECT_TRUE(matches(
+  EXPECT_FALSE(matches(
       "const char* str = (\"my-string\");",
-      implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral())))));
+      traverse(ast_type_traits::TK_AsIs,
+               implicitCastExpr(hasSourceExpression(stringLiteral())))));
+  EXPECT_TRUE(matches("const char* str = (\"my-string\");",
+                      traverse(ast_type_traits::TK_AsIs,
+                               implicitCastExpr(hasSourceExpression(
+                                   ignoringParens(stringLiteral()))))));
 }
 
 TEST(TypeMatching, MatchesTypes) {
   EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
 }
 
 TEST(TypeMatching, MatchesConstantArrayTypes) {
   EXPECT_TRUE(matches("int a[2];", constantArrayType()));

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

 
 
 TEST(Callee, MatchesDeclarations) {
   StatementMatcher CallMethodX = callExpr(callee(cxxMethodDecl(hasName("x"))));
 
   EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
   EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
 
-  CallMethodX = callExpr(callee(cxxConversionDecl()));
+  CallMethodX =
+      traverse(ast_type_traits::TK_AsIs, callExpr(callee(cxxConversionDecl())));
   EXPECT_TRUE(
     matches("struct Y { operator int() const; }; int i = Y();", CallMethodX));
   EXPECT_TRUE(notMatches("struct Y { operator int() const; }; Y y = Y();",
                          CallMethodX));
 }
 
 TEST(Callee, MatchesMemberExpressions) {
   EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
TEST(Matcher, AnyArgument) {
   EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
   EXPECT_TRUE(notMatches("struct Y { Y(int, int); };"
                          "void x() { int y; (void)Y(1, 2); }",
                          CtorArgumentY));
   EXPECT_TRUE(notMatches("template <class Y>"
                          "void x() { int y; (void)Y(1, 2); }",
                          UnresolvedCtorArgumentY));
 
-  StatementMatcher ImplicitCastedArgument = callExpr(
-    hasAnyArgument(implicitCastExpr()));
+  StatementMatcher ImplicitCastedArgument = traverse(
+      ast_type_traits::TK_AsIs, callExpr(hasAnyArgument(implicitCastExpr())));
   EXPECT_TRUE(matches("void x(long) { int y; x(y); }", ImplicitCastedArgument));
 }
 
 TEST(Matcher, HasReceiver) {
   EXPECT_TRUE(matchesObjC(
       "@interface NSString @end "
       "void f(NSString *x) {"
       "[x containsString];"
TEST(MatcherCXXMemberCallExpr, OnImplicitObjectArgument) {
   )cc";
   auto Snippet2 = R"cc(
     struct Y {
       void m();
     };
     struct X : public Y {};
     void z(X x) { x.m(); }
   )cc";
-  auto MatchesY = cxxMemberCallExpr(
-      onImplicitObjectArgument(hasType(cxxRecordDecl(hasName("Y")))));
+  auto MatchesY = traverse(ast_type_traits::TK_AsIs,
+                           cxxMemberCallExpr(onImplicitObjectArgument(
+                               hasType(cxxRecordDecl(hasName("Y"))))));
   EXPECT_TRUE(matches(Snippet1, MatchesY));
   EXPECT_TRUE(matches(Snippet2, MatchesY));
 
-  auto MatchesX = cxxMemberCallExpr(
-      onImplicitObjectArgument(hasType(cxxRecordDecl(hasName("X")))));
+  auto MatchesX = traverse(ast_type_traits::TK_AsIs,
+                           cxxMemberCallExpr(onImplicitObjectArgument(
+                               hasType(cxxRecordDecl(hasName("X"))))));
   EXPECT_TRUE(notMatches(Snippet2, MatchesX));
 
   // Parens are not ignored.
   auto Snippet3 = R"cc(
     struct Y {
       void m();
     };
     Y g();
     void z(Y y) { (g()).m(); }
   )cc";
-  auto MatchesCall = cxxMemberCallExpr(onImplicitObjectArgument(callExpr()));
+  auto MatchesCall =
+      traverse(ast_type_traits::TK_AsIs,
+               cxxMemberCallExpr(onImplicitObjectArgument(callExpr())));
   EXPECT_TRUE(notMatches(Snippet3, MatchesCall));
 }
 
 TEST(Matcher, HasObjectExpr) {
   auto Snippet1 = R"cc(
         struct X {
           int m;
           int f(X x) { return x.m; }
EXPECT_TRUE(matchAndVerifyResultTrue(
     std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2)));
 }
 
 TEST(ForEachArgumentWithParam, MatchesConstructExpr) {
   StatementMatcher ArgumentY =
     declRefExpr(to(varDecl(hasName("y")))).bind("arg");
   DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
   StatementMatcher ConstructExpr =
-    cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam));
+      traverse(ast_type_traits::TK_AsIs,
+               cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam)));
 
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "struct C {"
       "  C(int i) {}"
       "};"
       "int y = 0;"
       "C Obj(y);",
     ConstructExpr,
TEST(MatchBinaryOperator, HasLHSAndHasRHS) {
   StatementMatcher OperatorTrueFalse =
     binaryOperator(hasLHS(cxxBoolLiteral(equals(true))),
                    hasRHS(cxxBoolLiteral(equals(false))));
 
   EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse));
   EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
   EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
 
-  StatementMatcher OperatorIntPointer = arraySubscriptExpr(
-    hasLHS(hasType(isInteger())), hasRHS(hasType(pointsTo(qualType()))));
+  StatementMatcher OperatorIntPointer =
+      arraySubscriptExpr(hasLHS(hasType(isInteger())),
+                         traverse(ast_type_traits::TK_AsIs,
+                                  hasRHS(hasType(pointsTo(qualType())))));
   EXPECT_TRUE(matches("void x() { 1[\"abc\"]; }", OperatorIntPointer));
   EXPECT_TRUE(notMatches("void x() { \"abc\"[1]; }", OperatorIntPointer));
 }
 
 TEST(MatchBinaryOperator, HasEitherOperand) {
   StatementMatcher HasOperand =
     binaryOperator(hasEitherOperand(cxxBoolLiteral(equals(false))));
 
EXPECT_TRUE(matches(
     "int i[2]; void f() { 1[i] = 1; }",
     arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
   EXPECT_TRUE(notMatches(
     "int i[2]; void f() { i[1] = 1; }",
     arraySubscriptExpr(hasIndex(integerLiteral(equals(0))))));
 }
 
 TEST(ArraySubscriptMatchers, MatchesArrayBase) {
-  EXPECT_TRUE(matches(
-    "int i[2]; void f() { i[1] = 2; }",
+  EXPECT_TRUE(matches("int i[2]; void f() { i[1] = 2; }",
+                      traverse(ast_type_traits::TK_AsIs,
                                arraySubscriptExpr(hasBase(implicitCastExpr(
-      hasSourceExpression(declRefExpr()))))));
+                                   hasSourceExpression(declRefExpr())))))));
 }
 
 TEST(Matcher, OfClass) {
   StatementMatcher Constructor = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
     ofClass(hasName("X")))));
 
   EXPECT_TRUE(
     matches("class X { public: X(); }; void x(int) { X x; }", Constructor));

 TEST(HasDestinationType, MatchesSimpleCase) {
   EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
                       cxxStaticCastExpr(hasDestinationType(
                         pointsTo(TypeMatcher(anything()))))));
 }
 
 TEST(HasImplicitDestinationType, MatchesSimpleCase) {
   // This test creates an implicit const cast.
-  EXPECT_TRUE(matches("int x; const int i = x;",
-                      implicitCastExpr(
-                        hasImplicitDestinationType(isInteger()))));
+  EXPECT_TRUE(matches(
+      "int x; const int i = x;",
+      traverse(ast_type_traits::TK_AsIs,
+               implicitCastExpr(hasImplicitDestinationType(isInteger())))));
   // This test creates an implicit array-to-pointer cast.
   EXPECT_TRUE(matches("int arr[3]; int *p = arr;",
+                      traverse(ast_type_traits::TK_AsIs,
                                implicitCastExpr(hasImplicitDestinationType(
-                        pointsTo(TypeMatcher(anything()))))));
+                                   pointsTo(TypeMatcher(anything())))))));
 }
 
 TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
   // This test creates an implicit cast from int to char.
   EXPECT_TRUE(notMatches("char c = 0;",
                          implicitCastExpr(hasImplicitDestinationType(
                            unless(anything())))));
   // This test creates an implicit array-to-pointer cast.
OtherType something()
     return {};
 }
 
 int main()
 {
     SomeType i = something();
 }
 )";
-  EXPECT_TRUE(matches(Code, varDecl(
-      hasName("i"),
-      hasInitializer(exprWithCleanups(has(
-        cxxConstructExpr(has(expr(ignoringImplicit(cxxConstructExpr(
-          has(expr(ignoringImplicit(callExpr())))
-          )))))
-        )))
-      )
-  ));
+  EXPECT_TRUE(matches(
+      Code,
+      traverse(ast_type_traits::TK_AsIs,
+               varDecl(hasName("i"),
+                       hasInitializer(exprWithCleanups(has(cxxConstructExpr(
+                           has(expr(ignoringImplicit(cxxConstructExpr(has(
+                               expr(ignoringImplicit(callExpr())))))))))))))));
 }
 
 TEST(IgnoringImplicit, DoesNotMatchIncorrectly) {
-  EXPECT_TRUE(
-      notMatches("class C {}; C a = C();", varDecl(has(cxxConstructExpr()))));
+  EXPECT_TRUE(notMatches(
+      "class C {}; C a = C();",
+      traverse(ast_type_traits::TK_AsIs, varDecl(has(cxxConstructExpr())))));
 }
 
 TEST(Traversal, traverseMatcher) {
 
   const char *VarDeclCode = R"cpp(
 void foo()
 {
   int i = 3.0;
EXPECT_TRUE(notMatches("int x; int y = x;",
                          varDecl(hasInitializer(ignoringImpCasts(
                            unless(anything()))))));
 
   // These tests verify that ignoringImplictCasts does not look through explicit
   // casts or parentheses.
   EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
                          varDecl(hasInitializer(ignoringImpCasts(
                            integerLiteral())))));
-  EXPECT_TRUE(notMatches("int i = (0);",
-                         varDecl(hasInitializer(ignoringImpCasts(
-                           integerLiteral())))));
+  EXPECT_TRUE(notMatches(
+      "int i = (0);",
+      traverse(ast_type_traits::TK_AsIs,
+               varDecl(hasInitializer(ignoringImpCasts(integerLiteral()))))));
   EXPECT_TRUE(notMatches("float i = (float)0;",
                          varDecl(hasInitializer(ignoringImpCasts(
                            integerLiteral())))));
   EXPECT_TRUE(notMatches("float i = float(0);",
                          varDecl(hasInitializer(ignoringImpCasts(
                            integerLiteral())))));
 }
 
EXPECT_TRUE(notMatches("float y = (float)0;",
                          varDecl(hasInitializer(ignoringParenImpCasts(
                            integerLiteral())))));
   EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
                          varDecl(hasInitializer(ignoringParenImpCasts(
                            integerLiteral())))));
 }
 
 TEST(HasSourceExpression, MatchesImplicitCasts) {
-  EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
-                        "void r() {string a_string; URL url = a_string; }",
-                      implicitCastExpr(
-                        hasSourceExpression(cxxConstructExpr()))));
+  EXPECT_TRUE(matches(
+      "class string {}; class URL { public: URL(string s); };"
+      traverse(ast_type_traits::TK_AsIs,
+               implicitCastExpr(hasSourceExpression(cxxConstructExpr())))));
 }
 
 TEST(HasSourceExpression, MatchesExplicitCasts) {
   EXPECT_TRUE(matches("float x = static_cast<float>(42);",
-                      explicitCastExpr(
-                        hasSourceExpression(hasDescendant(
-                          expr(integerLiteral()))))));
+                      traverse(ast_type_traits::TK_AsIs,
+                               explicitCastExpr(hasSourceExpression(
+                                   hasDescendant(expr(integerLiteral())))))));
 }
 
 TEST(UsingDeclaration, MatchesSpecificTarget) {
   EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;",
                       usingDecl(hasAnyUsingShadowDecl(
                         hasTargetDecl(functionDecl())))));
   EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;",
                          usingDecl(hasAnyUsingShadowDecl(
EXPECT_TRUE(notMatches("void x() { switch(42); }",
                          switchStmt(forEachSwitchCase(caseStmt()))));
   EXPECT_TRUE(matches("void x() { switch(42) case 42:; }",
                       switchStmt(forEachSwitchCase(caseStmt()))));
   EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }",
                       switchStmt(forEachSwitchCase(caseStmt()))));
   EXPECT_TRUE(notMatches(
     "void x() { if (1) switch(42) { case 42: switch (42) { default:; } } }",
     ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt()))))));
-  EXPECT_TRUE(matches("void x() { switch(42) { case 1+1: case 4:; } }",
-                      switchStmt(forEachSwitchCase(
-                        caseStmt(hasCaseConstant(
-                            constantExpr(has(integerLiteral()))))))));
-  EXPECT_TRUE(notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
-                         switchStmt(forEachSwitchCase(
-                           caseStmt(hasCaseConstant(
-                               constantExpr(has(integerLiteral()))))))));
-  EXPECT_TRUE(notMatches("void x() { switch(42) { case 1 ... 2:; } }",
-                         switchStmt(forEachSwitchCase(
-                           caseStmt(hasCaseConstant(
-                               constantExpr(has(integerLiteral()))))))));
+  EXPECT_TRUE(
+      matches("void x() { switch(42) { case 1+1: case 4:; } }",
+              traverse(ast_type_traits::TK_AsIs,
+                       switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
+                           constantExpr(has(integerLiteral())))))))));
+  EXPECT_TRUE(
+      notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
+                 traverse(ast_type_traits::TK_AsIs,
+                          switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
+                              constantExpr(has(integerLiteral())))))))));
+  EXPECT_TRUE(
+      notMatches("void x() { switch(42) { case 1 ... 2:; } }",
+                 traverse(ast_type_traits::TK_AsIs,
+                          switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
+                              constantExpr(has(integerLiteral())))))))));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
     switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
     std::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3)));
 }
 
 TEST(Declaration, HasExplicitSpecifier) {
+
   EXPECT_TRUE(matchesConditionally(
       "void f();", functionDecl(hasExplicitSpecifier(constantExpr())), false,
       "-std=c++2a"));
   EXPECT_TRUE(matchesConditionally(
       "template<bool b> struct S { explicit operator int(); };",
       cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
       false, "-std=c++2a"));
   EXPECT_TRUE(matchesConditionally(
       "template<bool b> struct S { explicit(b) operator int(); };",
       cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
       false, "-std=c++2a"));
-  EXPECT_TRUE(matchesConditionally(
-      "struct S { explicit(true) operator int(); };",
-      cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+  EXPECT_TRUE(
+      matchesConditionally("struct S { explicit(true) operator int(); };",
+                           traverse(ast_type_traits::TK_AsIs,
+                                    cxxConversionDecl(hasExplicitSpecifier(
+                                        constantExpr(has(cxxBoolLiteral()))))),
                            true, "-std=c++2a"));
-  EXPECT_TRUE(matchesConditionally(
-      "struct S { explicit(false) operator int(); };",
-      cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+  EXPECT_TRUE(
+      matchesConditionally("struct S { explicit(false) operator int(); };",
+                           traverse(ast_type_traits::TK_AsIs,
+                                    cxxConversionDecl(hasExplicitSpecifier(
+                                        constantExpr(has(cxxBoolLiteral()))))),
                            true, "-std=c++2a"));
-  EXPECT_TRUE(matchesConditionally(
-      "template<bool b> struct S { explicit(b) S(int); };",
-      cxxConstructorDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+  EXPECT_TRUE(
+      matchesConditionally("template<bool b> struct S { explicit(b) S(int); };",
+                           traverse(ast_type_traits::TK_AsIs,
+                                    cxxConstructorDecl(hasExplicitSpecifier(
+                                        constantExpr(has(cxxBoolLiteral()))))),
                            false, "-std=c++2a"));
-  EXPECT_TRUE(matchesConditionally(
-      "struct S { explicit(true) S(int); };",
-      cxxConstructorDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+  EXPECT_TRUE(
+      matchesConditionally("struct S { explicit(true) S(int); };",
+                           traverse(ast_type_traits::TK_AsIs,
+                                    cxxConstructorDecl(hasExplicitSpecifier(
+                                        constantExpr(has(cxxBoolLiteral()))))),
                            true, "-std=c++2a"));
-  EXPECT_TRUE(matchesConditionally(
-      "struct S { explicit(false) S(int); };",
-      cxxConstructorDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+  EXPECT_TRUE(
+      matchesConditionally("struct S { explicit(false) S(int); };",
+                           traverse(ast_type_traits::TK_AsIs,
+                                    cxxConstructorDecl(hasExplicitSpecifier(
+                                        constantExpr(has(cxxBoolLiteral()))))),
                            true, "-std=c++2a"));
   EXPECT_TRUE(matchesConditionally(
       "template<typename T> struct S { S(int); };"
       "template<bool b = true> explicit(b) S(int) -> S<int>;",
+      traverse(ast_type_traits::TK_AsIs,
                cxxDeductionGuideDecl(
-          hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+                   hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral()))))),
       false, "-std=c++2a"));
-  EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int); };"
-                                   "explicit(true) S(int) -> S<int>;",
+  EXPECT_TRUE(
+      matchesConditionally("template<typename T> struct S { S(int); };"
+                           traverse(ast_type_traits::TK_AsIs,
                                     cxxDeductionGuideDecl(hasExplicitSpecifier(
-                                       constantExpr(has(cxxBoolLiteral())))),
-                                   true, "-std=c++2a"));
-  EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int); };"
-                                   "explicit(false) S(int) -> S<int>;",
+                                        constantExpr(has(cxxBoolLiteral()))))),
+  EXPECT_TRUE(
+      matchesConditionally("template<typename T> struct S { S(int); };"
+                           traverse(ast_type_traits::TK_AsIs,
                                     cxxDeductionGuideDecl(hasExplicitSpecifier(
-                                       constantExpr(has(cxxBoolLiteral())))),
-                                   true, "-std=c++2a"));
+                                        constantExpr(has(cxxBoolLiteral()))))),
 }
 
 TEST(ForEachConstructorInitializer, MatchesInitializers) {
   EXPECT_TRUE(matches(
     "struct X { X() : i(42), j(42) {} int i, j; };",
     cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer()))));
 }
 

clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp

Matcher<Decl> Value = constructMatcher(
       "decl", constructMatcher("hasAttr", StringRef("attr::WarnUnused")))
       .getTypedMatcher<Decl>();
   EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};", Value));
   EXPECT_FALSE(matches("struct X {};", Value));
 }
 
 TEST_F(RegistryTest, ParenExpr) {
   Matcher<Stmt> Value = constructMatcher("parenExpr").getTypedMatcher<Stmt>();
-  EXPECT_TRUE(matches("int i = (1);", Value));
-  EXPECT_FALSE(matches("int i = 1;", Value));
+  EXPECT_TRUE(
+      matches("int i = (1);", traverse(ast_type_traits::TK_AsIs, Value)));
+  EXPECT_FALSE(
+      matches("int i = 1;", traverse(ast_type_traits::TK_AsIs, Value)));
 }
 
 TEST_F(RegistryTest, EqualsMatcher) {
   Matcher<Stmt> BooleanStmt = constructMatcher(
       "cxxBoolLiteral", constructMatcher("equals", VariantValue(true)))
       .getTypedMatcher<Stmt>();
   EXPECT_TRUE(matches("bool x = true;", BooleanStmt));
   EXPECT_FALSE(matches("bool x = false;", BooleanStmt));

clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp

 
 StmtMatcher withEnclosingCompound(ExprMatcher Matcher) {
   return expr(Matcher, hasAncestor(compoundStmt().bind("stmt"))).bind("expr");
 }
 
 bool isMutated(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
   const auto *const S = selectFirst<Stmt>("stmt", Results);
   const auto *const E = selectFirst<Expr>("expr", Results);
+  TraversalKindScope RAII(AST->getASTContext(), ast_type_traits::TK_AsIs);
   return ExprMutationAnalyzer(*S, AST->getASTContext()).isMutated(E);
 }
 
 SmallVector<std::string, 1>
 mutatedBy(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
   const auto *const S = selectFirst<Stmt>("stmt", Results);
   SmallVector<std::string, 1> Chain;
   ExprMutationAnalyzer Analyzer(*S, AST->getASTContext());

clang/unittests/Tooling/RangeSelectorTest.cpp

 
 template <typename M> TestMatch matchCode(StringRef Code, M Matcher) {
   auto ASTUnit = tooling::buildASTFromCode(Code);
   assert(ASTUnit != nullptr && "AST construction failed");
 
   ASTContext &Context = ASTUnit->getASTContext();
   assert(!Context.getDiagnostics().hasErrorOccurred() && "Compilation error");
 
+  TraversalKindScope RAII(Context, ast_type_traits::TK_AsIs);
   auto Matches = ast_matchers::match(Matcher, Context);
   // We expect a single, exact match.
   assert(Matches.size() != 0 && "no matches found");
   assert(Matches.size() == 1 && "too many matches");
 
   return TestMatch{std::move(ASTUnit), MatchResult(Matches[0], &Context)};
 }
 

clang/unittests/Tooling/RefactoringCallbacksTest.cpp

 
 using namespace ast_matchers;
 
 template <typename T>
 void expectRewritten(const std::string &Code, const std::string &Expected,
                      const T &AMatcher, RefactoringCallback &Callback) {
   std::map<std::string, Replacements> FileToReplace;
   ASTMatchRefactorer Finder(FileToReplace);
-  Finder.addMatcher(AMatcher, &Callback);
+  Finder.addMatcher(traverse(ast_type_traits::TK_AsIs, AMatcher), &Callback);
   std::unique_ptr<tooling::FrontendActionFactory> Factory(
       tooling::newFrontendActionFactory(&Finder));
   ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), Code))
       << "Parsing error in \"" << Code << "\"";
   RewriterTestContext Context;
   FileID ID = Context.createInMemoryFile("input.cc", Code);
   EXPECT_TRUE(tooling::applyAllReplacements(FileToReplace["input.cc"],
                                             Context.Rewrite));

clang/unittests/Tooling/StencilTest.cpp

 static llvm::Optional<TestMatch> matchStmt(StringRef StatementCode,
                                            StatementMatcher Matcher) {
   auto AstUnit = tooling::buildASTFromCode(wrapSnippet(StatementCode));
   if (AstUnit == nullptr) {
     ADD_FAILURE() << "AST construction failed";
     return llvm::None;
   }
   ASTContext &Context = AstUnit->getASTContext();
-  auto Matches = ast_matchers::match(wrapMatcher(Matcher), Context);
+  auto Matches = ast_matchers::match(
+      traverse(ast_type_traits::TK_AsIs, wrapMatcher(Matcher)), Context);
   // We expect a single, exact match for the statement.
   if (Matches.size() != 1) {
     ADD_FAILURE() << "Wrong number of matches: " << Matches.size();
     return llvm::None;
   }
   return TestMatch{std::move(AstUnit), MatchResult(Matches[0], &Context)};
 }
 
TEST_F(StencilTest, AccessOpExplicitThis) {
   // Set up the code so we can bind to a use of this.
   StringRef Snippet = R"cc(
     class C {
      public:
       int x;
       int foo() { return this->x; }
     };
   )cc";
-  auto StmtMatch =
-      matchStmt(Snippet, returnStmt(hasReturnValue(ignoringImplicit(memberExpr(
-                             hasObjectExpression(expr().bind("obj")))))));
+  auto StmtMatch = matchStmt(
+      Snippet, traverse(ast_type_traits::TK_AsIs,
+                        returnStmt(hasReturnValue(ignoringImplicit(memberExpr(
+                            hasObjectExpression(expr().bind("obj"))))))));
   ASSERT_TRUE(StmtMatch);
   const Stencil Stencil = access("obj", "field");
   EXPECT_THAT_EXPECTED(Stencil->eval(StmtMatch->Result),
                        HasValue("this->field"));
 }
 
 TEST_F(StencilTest, AccessOpImplicitThis) {
   using clang::ast_matchers::hasObjectExpression;