diff --git a/clang/unittests/AST/ASTImporterTest.cpp b/clang/unittests/AST/ASTImporterTest.cpp
--- a/clang/unittests/AST/ASTImporterTest.cpp
+++ b/clang/unittests/AST/ASTImporterTest.cpp
@@ -493,7 +493,7 @@
   testImport(
     "void declToImport() { (void)__builtin_choose_expr(1, 2, 3); }",
     Lang_C, "", Lang_C, Verifier,
-    functionDecl(hasDescendant(chooseExpr())));
+    traverse(ast_type_traits::TK_AsIs, functionDecl(hasDescendant(chooseExpr()))));
 }
 
 TEST_P(ImportExpr, ImportGNUNullExpr) {
@@ -630,7 +630,7 @@
   testImport(
     "void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
     Lang_C, "", Lang_C, Verifier,
-    functionDecl(hasDescendant(
+    traverse(ast_type_traits::TK_AsIs, functionDecl(hasDescendant(
         varDecl(
             hasName("C"),
             hasType(asString("int")),
@@ -643,7 +643,7 @@
                             hasInitializer(
                                 integerLiteral(equals(4))))))),
                     hasDescendant(
-                        implicitCastExpr())))))));
+                        implicitCastExpr()))))))));
 }
 
 TEST_P(ImportExpr, ImportConditionalOperator) {
@@ -665,7 +665,7 @@
   testImport(
       "void declToImport() { (void)(1 ?: -5); }",
       Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
+      traverse(ast_type_traits::TK_AsIs, functionDecl(hasDescendant(
           binaryConditionalOperator(
               hasCondition(
                   implicitCastExpr(
@@ -678,7 +678,7 @@
               hasFalseExpression(
                   unaryOperator(
                       hasOperatorName("-"),
-                      hasUnaryOperand(integerLiteral(equals(5)))))))));
+                      hasUnaryOperand(integerLiteral(equals(5))))))))));
 }
 
 TEST_P(ImportExpr, ImportDesignatedInitExpr) {
@@ -764,10 +764,10 @@
       "struct C {};"
       "void declToImport() { C c = C(); }",
       Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
+      traverse(ast_type_traits::TK_AsIs, functionDecl(hasDescendant(
           exprWithCleanups(has(cxxConstructExpr(
               has(materializeTemporaryExpr(has(implicitCastExpr(
-                  has(cxxTemporaryObjectExpr())))))))))));
+                  has(cxxTemporaryObjectExpr()))))))))))));
 }
 
 TEST_P(ImportType, ImportAtomicType) {
@@ -818,9 +818,9 @@
       "template <int K> using dummy2 = dummy<K>;"
       "int declToImport() { return dummy2<3>::i; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
-      functionDecl(
+      traverse(ast_type_traits::TK_AsIs, functionDecl(
           hasDescendant(implicitCastExpr(has(declRefExpr()))),
-          unless(hasAncestor(translationUnitDecl(has(typeAliasDecl()))))));
+          unless(hasAncestor(translationUnitDecl(has(typeAliasDecl())))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateSpecializationDecl>
@@ -849,8 +849,8 @@
       "};"
       "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,
@@ -927,11 +927,11 @@
       "  auto a = typeid(int); auto b = typeid(x);"
       "}",
       Lang_CXX11, "", Lang_CXX11, Verifier,
-      functionDecl(
+      traverse(ast_type_traits::TK_AsIs, functionDecl(
           hasDescendant(varDecl(
               hasName("a"), hasInitializer(hasDescendant(cxxTypeidExpr())))),
           hasDescendant(varDecl(
-              hasName("b"), hasInitializer(hasDescendant(cxxTypeidExpr()))))));
+              hasName("b"), hasInitializer(hasDescendant(cxxTypeidExpr())))))));
 }
 
 TEST_P(ImportExpr, ImportTypeTraitExprValDep) {
@@ -1273,8 +1273,8 @@
     "void declToImport() { (void)__builtin_choose_expr(1, 0, 1); }",
     Lang_C, "", Lang_C);
 
-  auto ToResults = match(chooseExpr().bind("choose"), To->getASTContext());
-  auto FromResults = match(chooseExpr().bind("choose"), From->getASTContext());
+  auto ToResults = match(traverse(ast_type_traits::TK_AsIs, chooseExpr().bind("choose")), To->getASTContext());
+  auto FromResults = match(traverse(ast_type_traits::TK_AsIs, chooseExpr().bind("choose")), From->getASTContext());
 
   const ChooseExpr *FromChooseExpr =
       selectFirst<ChooseExpr>("choose", FromResults);
@@ -1512,7 +1512,7 @@
       R"s(
       struct declToImport {
         int a = d;
-        union { 
+        union {
           int b;
           int c;
         };
diff --git a/clang/unittests/AST/SourceLocationTest.cpp b/clang/unittests/AST/SourceLocationTest.cpp
--- a/clang/unittests/AST/SourceLocationTest.cpp
+++ b/clang/unittests/AST/SourceLocationTest.cpp
@@ -268,7 +268,7 @@
   Verifier.expectRange(2, 20, 2, 31);
   EXPECT_TRUE(Verifier.match(
                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
-                  "constant int2 i2 = (int2)(1, 2);", 
+                  "constant int2 i2 = (int2)(1, 2);",
                   compoundLiteralExpr(), Lang_OpenCL));
 }
 
@@ -619,8 +619,8 @@
       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"
@@ -628,7 +628,7 @@
       "+ (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) {
diff --git a/clang/unittests/AST/StmtPrinterTest.cpp b/clang/unittests/AST/StmtPrinterTest.cpp
--- a/clang/unittests/AST/StmtPrinterTest.cpp
+++ b/clang/unittests/AST/StmtPrinterTest.cpp
@@ -138,7 +138,7 @@
     "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"));
 }
 
diff --git a/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
--- a/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
+++ b/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
@@ -180,11 +180,11 @@
 
 TEST(CastExpression, HasCastKind) {
   EXPECT_TRUE(matches("char *p = 0;",
-              castExpr(hasCastKind(CK_NullToPointer))));
+              traverse(ast_type_traits::TK_AsIs, varDecl(has(castExpr(hasCastKind(CK_NullToPointer)))))));
   EXPECT_TRUE(notMatches("char *p = 0;",
-              castExpr(hasCastKind(CK_DerivedToBase))));
+              traverse(ast_type_traits::TK_AsIs, varDecl(has(castExpr(hasCastKind(CK_DerivedToBase)))))));
   EXPECT_TRUE(matches("char *p = 0;",
-              implicitCastExpr(hasCastKind(CK_NullToPointer))));
+              traverse(ast_type_traits::TK_AsIs, varDecl(has(implicitCastExpr(hasCastKind(CK_NullToPointer)))))));
 }
 
 TEST(DeclarationMatcher, HasDescendant) {
@@ -1237,8 +1237,8 @@
 }
 
 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); }",
@@ -1253,15 +1253,15 @@
     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); }",
@@ -1278,8 +1278,8 @@
 }
 
 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}; }",
@@ -2462,7 +2462,7 @@
 }
 
 TEST(HasDefaultArgument, Basic) {
-  EXPECT_TRUE(matches("void x(int val = 0) {}", 
+  EXPECT_TRUE(matches("void x(int val = 0) {}",
                       parmVarDecl(hasDefaultArgument())));
   EXPECT_TRUE(notMatches("void x(int val) {}",
                       parmVarDecl(hasDefaultArgument())));
@@ -2508,7 +2508,7 @@
   EXPECT_TRUE(matches("auto Y() -> int { return 0; }",
                       functionDecl(hasTrailingReturn())));
   EXPECT_TRUE(matches("auto X() -> int;", functionDecl(hasTrailingReturn())));
-  EXPECT_TRUE(notMatches("int X() { return 0; }", 
+  EXPECT_TRUE(notMatches("int X() { return 0; }",
                       functionDecl(hasTrailingReturn())));
   EXPECT_TRUE(notMatches("int X();", functionDecl(hasTrailingReturn())));
   EXPECT_TRUE(notMatchesC("void X();", functionDecl(hasTrailingReturn())));
diff --git a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
--- a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
+++ b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
@@ -296,11 +296,11 @@
   EXPECT_FALSE(matches("template<int N>\n"
                          "struct A {  static const int n = 0; };\n"
                          "struct B : public A<42> {};",
-                       substNonTypeTemplateParmExpr()));
+                       traverse(ast_type_traits::TK_AsIs, substNonTypeTemplateParmExpr())));
   EXPECT_TRUE(matches("template<int N>\n"
                         "struct A {  static const int n = N; };\n"
                         "struct B : public A<42> {};",
-                      substNonTypeTemplateParmExpr()));
+                      traverse(ast_type_traits::TK_AsIs, substNonTypeTemplateParmExpr())));
 }
 
 TEST(Matcher, NonTypeTemplateParmDecl) {
@@ -367,7 +367,7 @@
 
 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(); }",
@@ -572,7 +572,7 @@
 }
 
 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));
@@ -598,7 +598,7 @@
 }
 
 TEST(Matcher, BindTemporaryExpression) {
-  StatementMatcher TempExpression = cxxBindTemporaryExpr();
+  StatementMatcher TempExpression = traverse(ast_type_traits::TK_AsIs, cxxBindTemporaryExpr());
 
   std::string ClassString = "class string { public: string(); ~string(); }; ";
 
@@ -631,13 +631,14 @@
 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();"
                 "void FunctionTakesString(string s);"
                 "void run() { FunctionTakesString(GetStringByValue()); }",
-            materializeTemporaryExpr()));
+            TempExpression));
 
   EXPECT_TRUE(
     notMatches(ClassString +
@@ -648,19 +649,19 @@
                    "  FunctionTakesStringPtr(GetStringPointer());"
                    "  FunctionTakesStringPtr(s);"
                    "}",
-               materializeTemporaryExpr()));
+               TempExpression));
 
   EXPECT_TRUE(
     matches(ClassString +
                  "string GetStringByValue();"
                    "void run() { int k = GetStringByValue().length(); }",
-               materializeTemporaryExpr()));
+               TempExpression));
 
   EXPECT_TRUE(
     notMatches(ClassString +
                  "string GetStringByValue();"
                    "void run() { GetStringByValue(); }",
-               materializeTemporaryExpr()));
+               TempExpression));
 }
 
 TEST(Matcher, NewExpression) {
@@ -756,7 +757,7 @@
 
 TEST(Matcher, ChooseExpr) {
   EXPECT_TRUE(matchesC("void f() { (void)__builtin_choose_expr(1, 2, 3); }",
-                       chooseExpr()));
+                       traverse(ast_type_traits::TK_AsIs, chooseExpr())));
 }
 
 TEST(Matcher, GNUNullExpr) {
@@ -876,12 +877,13 @@
 }
 
 TEST(Matcher, BinaryConditionalOperator) {
-  StatementMatcher AlwaysOne = binaryConditionalOperator(
+   StatementMatcher AlwaysOne = traverse(ast_type_traits::TK_AsIs,
+    binaryConditionalOperator(
     hasCondition(implicitCastExpr(
       has(
-        opaqueValueExpr(
+         opaqueValueExpr(
           hasSourceExpression((integerLiteral(equals(1)))))))),
-    hasFalseExpression(integerLiteral(equals(0))));
+    hasFalseExpression(integerLiteral(equals(0)))));
 
   EXPECT_TRUE(matches("void x() { 1 ?: 0; }", AlwaysOne));
 
@@ -936,9 +938,9 @@
 }
 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) {
@@ -1022,13 +1024,13 @@
 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) {
@@ -1069,10 +1071,10 @@
 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) {
@@ -1098,13 +1100,13 @@
                            "  A(std::initializer_list<int>) {}"
                            "};";
   EXPECT_TRUE(matches(code + "A a{0};",
-                      cxxConstructExpr(has(cxxStdInitializerListExpr()),
+                      traverse(ast_type_traits::TK_AsIs, cxxConstructExpr(has(cxxStdInitializerListExpr()),
                                        hasDeclaration(cxxConstructorDecl(
-                                           ofClass(hasName("A")))))));
+                                           ofClass(hasName("A"))))))));
   EXPECT_TRUE(matches(code + "A a = {0};",
-                      cxxConstructExpr(has(cxxStdInitializerListExpr()),
+                      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 };",
@@ -1178,19 +1180,19 @@
 }
 
 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()))));
+                       traverse(ast_type_traits::TK_AsIs, implicitCastExpr(hasSourceExpression(stringLiteral())))));
   EXPECT_TRUE(matches(
       "const char* str = (\"my-string\");",
-      implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral())))));
+      traverse(ast_type_traits::TK_AsIs, implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral()))))));
 }
 
 TEST(TypeMatching, MatchesTypes) {
diff --git a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
--- a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
+++ b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
@@ -373,7 +373,7 @@
   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();",
@@ -435,8 +435,8 @@
                          "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));
 }
 
@@ -570,13 +570,13 @@
     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.
@@ -587,7 +587,7 @@
     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));
 }
 
@@ -686,7 +686,7 @@
     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 {"
@@ -1113,7 +1113,7 @@
   EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
 
   StatementMatcher OperatorIntPointer = arraySubscriptExpr(
-    hasLHS(hasType(isInteger())), hasRHS(hasType(pointsTo(qualType()))));
+    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));
 }
@@ -1293,8 +1293,8 @@
 TEST(ArraySubscriptMatchers, MatchesArrayBase) {
   EXPECT_TRUE(matches(
     "int i[2]; void f() { i[1] = 2; }",
-    arraySubscriptExpr(hasBase(implicitCastExpr(
-      hasSourceExpression(declRefExpr()))))));
+    traverse(ast_type_traits::TK_AsIs, arraySubscriptExpr(hasBase(implicitCastExpr(
+      hasSourceExpression(declRefExpr())))))));
 }
 
 TEST(Matcher, OfClass) {
@@ -1442,12 +1442,12 @@
 TEST(HasImplicitDestinationType, MatchesSimpleCase) {
   // This test creates an implicit const cast.
   EXPECT_TRUE(matches("int x; const int i = x;",
-                      implicitCastExpr(
-                        hasImplicitDestinationType(isInteger()))));
+                      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;",
-                      implicitCastExpr(hasImplicitDestinationType(
-                        pointsTo(TypeMatcher(anything()))))));
+                      traverse(ast_type_traits::TK_AsIs, implicitCastExpr(hasImplicitDestinationType(
+                        pointsTo(TypeMatcher(anything())))))));
 }
 
 TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
@@ -1579,7 +1579,7 @@
     SomeType i = something();
 }
 )";
-  EXPECT_TRUE(matches(Code, varDecl(
+  EXPECT_TRUE(matches(Code, traverse(ast_type_traits::TK_AsIs, varDecl(
       hasName("i"),
       hasInitializer(exprWithCleanups(has(
         cxxConstructExpr(has(expr(ignoringImplicit(cxxConstructExpr(
@@ -1587,12 +1587,12 @@
           )))))
         )))
       )
-  ));
+  )));
 }
 
 TEST(IgnoringImplicit, DoesNotMatchIncorrectly) {
   EXPECT_TRUE(
-      notMatches("class C {}; C a = C();", varDecl(has(cxxConstructExpr()))));
+      notMatches("class C {}; C a = C();", traverse(ast_type_traits::TK_AsIs, varDecl(has(cxxConstructExpr())))));
 }
 
 TEST(Traversal, traverseMatcher) {
@@ -2008,8 +2008,8 @@
                          varDecl(hasInitializer(ignoringImpCasts(
                            integerLiteral())))));
   EXPECT_TRUE(notMatches("int i = (0);",
-                         varDecl(hasInitializer(ignoringImpCasts(
-                           integerLiteral())))));
+                         traverse(ast_type_traits::TK_AsIs, varDecl(hasInitializer(ignoringImpCasts(
+                           integerLiteral()))))));
   EXPECT_TRUE(notMatches("float i = (float)0;",
                          varDecl(hasInitializer(ignoringImpCasts(
                            integerLiteral())))));
@@ -2123,15 +2123,15 @@
 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()))));
+                      traverse(ast_type_traits::TK_AsIs, implicitCastExpr(
+                        hasSourceExpression(cxxConstructExpr())))));
 }
 
 TEST(HasSourceExpression, MatchesExplicitCasts) {
   EXPECT_TRUE(matches("float x = static_cast<float>(42);",
-                      explicitCastExpr(
+                      traverse(ast_type_traits::TK_AsIs, explicitCastExpr(
                         hasSourceExpression(hasDescendant(
-                          expr(integerLiteral()))))));
+                          expr(integerLiteral())))))));
 }
 
 TEST(UsingDeclaration, MatchesSpecificTarget) {
@@ -2186,17 +2186,17 @@
     "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(
+                      traverse(ast_type_traits::TK_AsIs, switchStmt(forEachSwitchCase(
                         caseStmt(hasCaseConstant(
-                            constantExpr(has(integerLiteral()))))))));
+                            constantExpr(has(integerLiteral())))))))));
   EXPECT_TRUE(notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
-                         switchStmt(forEachSwitchCase(
+                         traverse(ast_type_traits::TK_AsIs, switchStmt(forEachSwitchCase(
                            caseStmt(hasCaseConstant(
-                               constantExpr(has(integerLiteral()))))))));
+                               constantExpr(has(integerLiteral())))))))));
   EXPECT_TRUE(notMatches("void x() { switch(42) { case 1 ... 2:; } }",
-                         switchStmt(forEachSwitchCase(
+                         traverse(ast_type_traits::TK_AsIs, switchStmt(forEachSwitchCase(
                            caseStmt(hasCaseConstant(
-                               constantExpr(has(integerLiteral()))))))));
+                               constantExpr(has(integerLiteral())))))))));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
     switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
@@ -2204,52 +2204,53 @@
 }
 
 TEST(Declaration, HasExplicitSpecifier) {
+
   EXPECT_TRUE(matchesConditionally(
-      "void f();", functionDecl(hasExplicitSpecifier(constantExpr())), false,
+      "void f();", traverse(ast_type_traits::TK_AsIs, functionDecl(hasExplicitSpecifier(constantExpr()))), false,
       "-std=c++2a"));
   EXPECT_TRUE(matchesConditionally(
       "template<bool b> struct S { explicit operator int(); };",
-      cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+      traverse(ast_type_traits::TK_AsIs, 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())))),
+      traverse(ast_type_traits::TK_AsIs, cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral()))))),
       false, "-std=c++2a"));
   EXPECT_TRUE(matchesConditionally(
       "struct S { explicit(true) operator int(); };",
-      cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+      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())))),
+      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())))),
+      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())))),
+      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())))),
+      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>;",
-      cxxDeductionGuideDecl(
-          hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
+      traverse(ast_type_traits::TK_AsIs, cxxDeductionGuideDecl(
+          hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral()))))),
       false, "-std=c++2a"));
   EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int); };"
                                    "explicit(true) S(int) -> S<int>;",
-                                   cxxDeductionGuideDecl(hasExplicitSpecifier(
-                                       constantExpr(has(cxxBoolLiteral())))),
+                                   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>;",
-                                   cxxDeductionGuideDecl(hasExplicitSpecifier(
-                                       constantExpr(has(cxxBoolLiteral())))),
+                                   traverse(ast_type_traits::TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
+                                       constantExpr(has(cxxBoolLiteral()))))),
                                    true, "-std=c++2a"));
 }
 
diff --git a/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp b/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
--- a/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
+++ b/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
@@ -54,6 +54,8 @@
 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);
 }
 
@@ -1129,6 +1131,7 @@
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
+  // return;
 
   AST = buildASTFromCode("void f() { int x, y; __typeof(x = 10) z = y; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
@@ -1158,7 +1161,7 @@
 
   AST = buildASTFromCode(
       "void f() { int x; _Generic(x = 10, int: 0, default: 1); }");
-  Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  Results = match(traverse(ast_type_traits::TK_AsIs, withEnclosingCompound(declRefTo("x"))), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 }
 
diff --git a/clang/unittests/Tooling/RangeSelectorTest.cpp b/clang/unittests/Tooling/RangeSelectorTest.cpp
--- a/clang/unittests/Tooling/RangeSelectorTest.cpp
+++ b/clang/unittests/Tooling/RangeSelectorTest.cpp
@@ -46,6 +46,7 @@
   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");
@@ -101,8 +102,8 @@
                       decl(hasDescendant(cxxCtorInitializer(isBaseInitializer())
                                              .bind("init")))
                           .bind("decl")))
-                  .bind("expr")))
-          .bind("stmt");
+                  .bind("expr"))
+        ).bind("stmt");
 
   return Selector(matchCode(Code, Matcher).Result);
 }
diff --git a/clang/unittests/Tooling/RefactoringCallbacksTest.cpp b/clang/unittests/Tooling/RefactoringCallbacksTest.cpp
--- a/clang/unittests/Tooling/RefactoringCallbacksTest.cpp
+++ b/clang/unittests/Tooling/RefactoringCallbacksTest.cpp
@@ -22,7 +22,7 @@
                      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))
diff --git a/clang/unittests/Tooling/StencilTest.cpp b/clang/unittests/Tooling/StencilTest.cpp
--- a/clang/unittests/Tooling/StencilTest.cpp
+++ b/clang/unittests/Tooling/StencilTest.cpp
@@ -60,7 +60,7 @@
     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();
@@ -331,8 +331,8 @@
     };
   )cc";
   auto StmtMatch =
-      matchStmt(Snippet, returnStmt(hasReturnValue(ignoringImplicit(memberExpr(
-                             hasObjectExpression(expr().bind("obj")))))));
+      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),