Move TestClangConfig into libClangTesting and use it in AST Matchers tests

[gribozavr]

Summary

Previously, AST Matchers tests were using a custom way to run a test
with a specific C++ standard version. I'm migrating them to a shared
infrastructure to specify a Clang target from libClangTesting. I'm also
changing tests for AST Matchers to run in multiple language standards
versions, and under multiple triples that have different behavior with
regards to templates.

To keep the size of the patch manageable, in this patch I'm only
migrating one file to get the process started and get feedback on this
approach.

One caveat is that increasing the number of test configuration does
significantly increase the runtime of AST Matchers tests. On my machine,
the test runtime increases from 2.0 to 6.0s. I think it is worth the
improved test coverage.

[ymandel]

Only nits. Really nice work. I much prefer your new system, having wrestled with config and multi-language testing in the existing framework. However, is this worth an RFC to the list?

clang/include/clang/Testing/TestClangConfig.h

19

Maybe add a brief comment explaining this struct?

21

Is this sufficiently obvious to the reader or is it worth commenting on the meaning of "target"?

65

Add include? ("llvm/Support/raw_ostream.h")

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

652

Nice!

818

Isn't this always true since any given value can't also be other values? Should these be &&?

1025

Maybe add comment explaining this restriction? I take it this was some feature support by gcc for C++03, which is also supported by clang for compatibility (at that language version)?

clang/unittests/Tooling/Syntax/TreeTest.cpp

3824

nit: maybe just

all_configs.push_back({lang, "x86_64-pc-linux-gnu"});

// Windows target is interesting to test because it enables
// `-fdelayed-template-parsing`.
all_configs.push_back({lang, "x86_64-pc-win32-msvc"});

Or, if you'd like a bit nicer, add a constructor to the struct and use emplace_back.

[gribozavr]

Addressed code review comments.

[gribozavr2]

However, is this worth an RFC to the list?

I don't think so. I'm consolidating existing testing infrastructure that was already providing this functionality, and using regular parameterized tests (TEST_P).

clang/include/clang/Testing/TestClangConfig.h

19

Added.

21

Added a comment.

65

Added.

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

818

Thanks -- that was a bug, fixed!

1025

I don't understand it enough to write a comment (I could try to, but I think it is not needed for this patch). This limitation was already present (without a comment) in the original code that I'm refactoring.

Clang accepts this code in C++03 mode, however I took a quick peek at the generated AST, and found that it is different from the AST in, for example, C++11. For example, the CXXConstructExpr required by the matcher only appears in C++03, not in C++11. I think the differences in the AST are the reason for the test not working.

It could be the case that the absence of CXXConstructExpr in non-C++03 is a bug in Clang, but I don't know this area well enough to say right away without an in-depth study.

clang/unittests/Tooling/Syntax/TreeTest.cpp

3824

I didn't want to rely on brace initializers or constructors because they are less readable, and TestClangConfig has the potential to grow quite a few member variables in future.

clang/include/clang/Testing/TestClangConfig.h

+//===--- TestClangConfig.h ------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TESTING_TESTCLANGCONFIG_H
+#define LLVM_CLANG_TESTING_TESTCLANGCONFIG_H
+
+#include "clang/Testing/CommandLineArgs.h"
+#include "llvm/Support/raw_ostream.h"
+#include <string>
+#include <vector>
+
+namespace clang {
+
+/// A Clang configuration for end-to-end tests that can be converted to
+/// command line arguments for the driver.
+///
+/// The configuration is represented as typed, named values, making it easier
+/// and safer to work with compared to an array of string command line flags.
+struct TestClangConfig {
+  TestLanguage Language;
+
+  /// The argument of the `-target` command line flag.
+  std::string Target;
+
+  bool isC() const { return Language == Lang_C89 || Language == Lang_C99; }
+
+  bool isC99OrLater() const { return Language == Lang_C99; }
+
+  bool isCXX() const {
+    return Language == Lang_CXX03 || Language == Lang_CXX11 ||
+           Language == Lang_CXX14 || Language == Lang_CXX17 ||
+           Language == Lang_CXX20;
+  }
+
+  bool isCXX11OrLater() const {
+    return Language == Lang_CXX11 || Language == Lang_CXX14 ||
+           Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+
+  bool isCXX14OrLater() const {
+    return Language == Lang_CXX14 || Language == Lang_CXX17 ||
+           Language == Lang_CXX20;
+  }
+
+  bool isCXX17OrLater() const {
+    return Language == Lang_CXX17 || Language == Lang_CXX20;
+  }
+
+  bool supportsCXXDynamicExceptionSpecification() const {
+    return Language == Lang_CXX03 || Language == Lang_CXX11 ||
+           Language == Lang_CXX14;
+  }
+
+  bool hasDelayedTemplateParsing() const {
+    return Target == "x86_64-pc-win32-msvc";
+  }
+
+  std::vector<std::string> getCommandLineArgs() const {
+    std::vector<std::string> Result = getCommandLineArgsForTesting(Language);
+    Result.push_back("-target");
+    Result.push_back(Target);
+    return Result;
+  }
+
+  std::string toString() const {
+    std::string Result;
+    llvm::raw_string_ostream OS(Result);
+    OS << "{ Language=" << Language << ", Target=" << Target << " }";
+    return OS.str();
+  }
+
+  friend std::ostream &operator<<(std::ostream &OS,
+                                  const TestClangConfig &ClangConfig) {
+    return OS << ClangConfig.toString();
+  }
+};
+
+} // end namespace clang
+
+#endif

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Host.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace ast_matchers {
 
-TEST(Finder, DynamicOnlyAcceptsSomeMatchers) {
-  MatchFinder Finder;
-  EXPECT_TRUE(Finder.addDynamicMatcher(decl(), nullptr));
-  EXPECT_TRUE(Finder.addDynamicMatcher(callExpr(), nullptr));
-  EXPECT_TRUE(Finder.addDynamicMatcher(constantArrayType(hasSize(42)),
-                                       nullptr));
-
-  // Do not accept non-toplevel matchers.
-  EXPECT_FALSE(Finder.addDynamicMatcher(isMain(), nullptr));
-  EXPECT_FALSE(Finder.addDynamicMatcher(hasName("x"), nullptr));
+TEST_P(ASTMatchersTest, Decl_CXX) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Add a test for `decl()` that does not depend on C++.
+    return;
   }
-
-TEST(Decl, MatchesDeclarations) {
   EXPECT_TRUE(notMatches("", decl(usingDecl())));
-  EXPECT_TRUE(matches("namespace x { class X {}; } using x::X;",
-                      decl(usingDecl())));
+  EXPECT_TRUE(
+      matches("namespace x { class X {}; } using x::X;", decl(usingDecl())));
 }
 
-TEST(NameableDeclaration, MatchesVariousDecls) {
+TEST_P(ASTMatchersTest, NameableDeclaration_MatchesVariousDecls) {
   DeclarationMatcher NamedX = namedDecl(hasName("X"));
   EXPECT_TRUE(matches("typedef int X;", NamedX));
   EXPECT_TRUE(matches("int X;", NamedX));
-  EXPECT_TRUE(matches("class foo { virtual void X(); };", NamedX));
-  EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", NamedX));
   EXPECT_TRUE(matches("void foo() { int X; }", NamedX));
-  EXPECT_TRUE(matches("namespace X { }", NamedX));
   EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
 
   EXPECT_TRUE(notMatches("#define X 1", NamedX));
 }
 
-TEST(NameableDeclaration, REMatchesVariousDecls) {
+TEST_P(ASTMatchersTest, NamedDecl_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  DeclarationMatcher NamedX = namedDecl(hasName("X"));
+  EXPECT_TRUE(matches("class foo { virtual void X(); };", NamedX));
+  EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", NamedX));
+  EXPECT_TRUE(matches("namespace X { }", NamedX));
+}
+
+TEST_P(ASTMatchersTest, MatchesNameRE) {
   DeclarationMatcher NamedX = namedDecl(matchesName("::X"));
   EXPECT_TRUE(matches("typedef int Xa;", NamedX));
   EXPECT_TRUE(matches("int Xb;", NamedX));
-  EXPECT_TRUE(matches("class foo { virtual void Xc(); };", NamedX));
-  EXPECT_TRUE(matches("void foo() try { } catch(int Xdef) { }", NamedX));
   EXPECT_TRUE(matches("void foo() { int Xgh; }", NamedX));
-  EXPECT_TRUE(matches("namespace Xij { }", NamedX));
   EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
 
   EXPECT_TRUE(notMatches("#define Xkl 1", NamedX));
 
   DeclarationMatcher StartsWithNo = namedDecl(matchesName("::no"));
   EXPECT_TRUE(matches("int no_foo;", StartsWithNo));
-  EXPECT_TRUE(matches("class foo { virtual void nobody(); };", StartsWithNo));
 
   DeclarationMatcher Abc = namedDecl(matchesName("a.*b.*c"));
   EXPECT_TRUE(matches("int abc;", Abc));
   EXPECT_TRUE(matches("int aFOObBARc;", Abc));
   EXPECT_TRUE(notMatches("int cab;", Abc));
   EXPECT_TRUE(matches("int cabc;", Abc));
 
   DeclarationMatcher StartsWithK = namedDecl(matchesName(":k[^:]*$"));
   EXPECT_TRUE(matches("int k;", StartsWithK));
   EXPECT_TRUE(matches("int kAbc;", StartsWithK));
+}
+
+TEST_P(ASTMatchersTest, MatchesNameRE_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  DeclarationMatcher NamedX = namedDecl(matchesName("::X"));
+  EXPECT_TRUE(matches("class foo { virtual void Xc(); };", NamedX));
+  EXPECT_TRUE(matches("void foo() try { } catch(int Xdef) { }", NamedX));
+  EXPECT_TRUE(matches("namespace Xij { }", NamedX));
+
+  DeclarationMatcher StartsWithNo = namedDecl(matchesName("::no"));
+  EXPECT_TRUE(matches("class foo { virtual void nobody(); };", StartsWithNo));
+
+  DeclarationMatcher StartsWithK = namedDecl(matchesName(":k[^:]*$"));
   EXPECT_TRUE(matches("namespace x { int kTest; }", StartsWithK));
   EXPECT_TRUE(matches("class C { int k; };", StartsWithK));
   EXPECT_TRUE(notMatches("class C { int ckc; };", StartsWithK));
 }
 
-TEST(DeclarationMatcher, MatchClass) {
-  DeclarationMatcher ClassMatcher(recordDecl());
-
-  // This passes on Windows only because we explicitly pass -target
-  // i386-unknown-unknown.  If we were to compile with the default target
-  // triple, we'd want to EXPECT_TRUE if it's Win32 or MSVC.
-  EXPECT_FALSE(matches("", ClassMatcher));
+TEST_P(ASTMatchersTest, DeclarationMatcher_MatchClass) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
 
   DeclarationMatcher ClassX = recordDecl(recordDecl(hasName("X")));
   EXPECT_TRUE(matches("class X;", ClassX));
   EXPECT_TRUE(matches("class X {};", ClassX));
   EXPECT_TRUE(matches("template<class T> class X {};", ClassX));
   EXPECT_TRUE(notMatches("", ClassX));
 }
 
-TEST(DeclarationMatcher, translationUnitDecl) {
+TEST_P(ASTMatchersTest, TranslationUnitDecl) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Add a test for `translationUnitDecl()` that does not depend on
+    // C++.
+    return;
+  }
   StringRef Code = "int MyVar1;\n"
                    "namespace NameSpace {\n"
                    "int MyVar2;\n"
                    "}  // namespace NameSpace\n";
   EXPECT_TRUE(matches(
     Code, varDecl(hasName("MyVar1"), hasDeclContext(translationUnitDecl()))));
   EXPECT_FALSE(matches(
     Code, varDecl(hasName("MyVar2"), hasDeclContext(translationUnitDecl()))));
   EXPECT_TRUE(matches(
     Code,
     varDecl(hasName("MyVar2"),
             hasDeclContext(decl(hasDeclContext(translationUnitDecl()))))));
 }
 
-TEST(DeclarationMatcher, LinkageSpecification) {
+TEST_P(ASTMatchersTest, LinkageSpecDecl) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("extern \"C\" { void foo() {}; }", linkageSpecDecl()));
   EXPECT_TRUE(notMatches("void foo() {};", linkageSpecDecl()));
 }
 
-TEST(ClassTemplate, DoesNotMatchClass) {
+TEST_P(ASTMatchersTest, ClassTemplateDecl_DoesNotMatchClass) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   DeclarationMatcher ClassX = classTemplateDecl(hasName("X"));
   EXPECT_TRUE(notMatches("class X;", ClassX));
   EXPECT_TRUE(notMatches("class X {};", ClassX));
 }
 
-TEST(ClassTemplate, MatchesClassTemplate) {
+TEST_P(ASTMatchersTest, ClassTemplateDecl_MatchesClassTemplate) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   DeclarationMatcher ClassX = classTemplateDecl(hasName("X"));
   EXPECT_TRUE(matches("template<typename T> class X {};", ClassX));
   EXPECT_TRUE(matches("class Z { template<class T> class X {}; };", ClassX));
 }
 
-TEST(ClassTemplate, DoesNotMatchClassTemplateExplicitSpecialization) {
+TEST_P(ASTMatchersTest,
+       ClassTemplateDecl_DoesNotMatchClassTemplateExplicitSpecialization) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("template<typename T> class X { };"
                            "template<> class X<int> { int a; };",
                          classTemplateDecl(hasName("X"),
                                            hasDescendant(fieldDecl(hasName("a"))))));
 }
 
-TEST(ClassTemplate, DoesNotMatchClassTemplatePartialSpecialization) {
+TEST_P(ASTMatchersTest,
+       ClassTemplateDecl_DoesNotMatchClassTemplatePartialSpecialization) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("template<typename T, typename U> class X { };"
                            "template<typename T> class X<T, int> { int a; };",
                          classTemplateDecl(hasName("X"),
                                            hasDescendant(fieldDecl(hasName("a"))))));
 }
 
-TEST(DeclarationMatcher, MatchCudaDecl) {
+TEST(ASTMatchersTestCUDA, CUDAKernelCallExpr) {
   EXPECT_TRUE(matchesWithCuda("__global__ void f() { }"
                                 "void g() { f<<<1, 2>>>(); }",
                               cudaKernelCallExpr()));
-  EXPECT_TRUE(matchesWithCuda("__attribute__((device)) void f() {}",
-                              hasAttr(clang::attr::CUDADevice)));
   EXPECT_TRUE(notMatchesWithCuda("void f() {}",
                                  cudaKernelCallExpr()));
+}
+
+TEST(ASTMatchersTestCUDA, HasAttrCUDA) {
+  EXPECT_TRUE(matchesWithCuda("__attribute__((device)) void f() {}",
+                              hasAttr(clang::attr::CUDADevice)));
   EXPECT_FALSE(notMatchesWithCuda("__attribute__((global)) void f() {}",
                                   hasAttr(clang::attr::CUDAGlobal)));
 }
 
-TEST(ValueDecl, Matches) {
+TEST_P(ASTMatchersTest, ValueDecl) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Fix this test in non-C++ language modes.
+    return;
+  }
   EXPECT_TRUE(matches("enum EnumType { EnumValue };",
                       valueDecl(hasType(asString("enum EnumType")))));
   EXPECT_TRUE(matches("void FunctionDecl();",
                       valueDecl(hasType(asString("void (void)")))));
 }
 
-TEST(FriendDecl, Matches) {
+TEST_P(ASTMatchersTest, FriendDecl) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("class Y { friend class X; };",
                       friendDecl(hasType(asString("class X")))));
   EXPECT_TRUE(matches("class Y { friend class X; };",
                       friendDecl(hasType(recordDecl(hasName("X"))))));
 
   EXPECT_TRUE(matches("class Y { friend void f(); };",
                       functionDecl(hasName("f"), hasParent(friendDecl()))));
 }
 
-TEST(Enum, DoesNotMatchClasses) {
+TEST_P(ASTMatchersTest, EnumDecl_DoesNotMatchClasses) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("class X {};", enumDecl(hasName("X"))));
 }
 
-TEST(Enum, MatchesEnums) {
+TEST_P(ASTMatchersTest, EnumDecl_MatchesEnums) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Fix this test in non-C++ language modes.
+    return;
+  }
   EXPECT_TRUE(matches("enum X {};", enumDecl(hasName("X"))));
 }
 
-TEST(EnumConstant, Matches) {
+TEST_P(ASTMatchersTest, EnumConstantDecl) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Fix this test in non-C++ language modes.
+    return;
+  }
   DeclarationMatcher Matcher = enumConstantDecl(hasName("A"));
   EXPECT_TRUE(matches("enum X{ A };", Matcher));
   EXPECT_TRUE(notMatches("enum X{ B };", Matcher));
   EXPECT_TRUE(notMatches("enum X {};", Matcher));
 }
 
-TEST(TagDecl, MatchesTagDecls) {
+TEST_P(ASTMatchersTest, TagDecl) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Fix this test in non-C++ language modes.
+    return;
+  }
   EXPECT_TRUE(matches("struct X {};", tagDecl(hasName("X"))));
-  EXPECT_TRUE(matches("class C {};", tagDecl(hasName("C"))));
   EXPECT_TRUE(matches("union U {};", tagDecl(hasName("U"))));
   EXPECT_TRUE(matches("enum E {};", tagDecl(hasName("E"))));
 }
 
-TEST(Matcher, UnresolvedLookupExpr) {
-  // FIXME: The test is known to be broken on Windows with delayed template
-  // parsing.
-  EXPECT_TRUE(matchesConditionally("template<typename T>"
-                                   "T foo() { T a; return a; }"
-                                   "template<typename T>"
-                                   "void bar() {"
-                                   "  foo<T>();"
-                                   "}",
-                                   unresolvedLookupExpr(),
-                                   /*ExpectMatch=*/true,
-                                   {"-fno-delayed-template-parsing"}));
+TEST_P(ASTMatchersTest, TagDecl_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(matches("class C {};", tagDecl(hasName("C"))));
+}
+
+TEST_P(ASTMatchersTest, UnresolvedLookupExpr) {
+  if (!GetParam().isCXX() || GetParam().hasDelayedTemplateParsing()) {
+    // FIXME: Fix this test to work with delayed template parsing.
+    return;
+  }
+
+  EXPECT_TRUE(matches("template<typename T>"
+                      unresolvedLookupExpr()));
+}
+
+TEST_P(ASTMatchersTest, UsesADL) {
+  if (!GetParam().isCXX()) {
+    return;
   }
 
-TEST(Matcher, ADLCall) {
   StatementMatcher ADLMatch = callExpr(usesADL());
   StatementMatcher ADLMatchOper = cxxOperatorCallExpr(usesADL());
   StringRef NS_Str = R"cpp(
   namespace NS {
     struct X {};
     void f(X);
     void operator+(X, X);
   }
)cpp";
   EXPECT_TRUE(matches(MkStr("NS::X x; x + x;"), ADLMatch));
   EXPECT_TRUE(matches(MkStr("NS::X x; x + x;"), ADLMatchOper));
   EXPECT_TRUE(notMatches(MkStr("MyX x; x + x;"), ADLMatch));
   EXPECT_TRUE(notMatches(MkStr("MyX x; x + x;"), ADLMatchOper));
   EXPECT_TRUE(matches(MkStr("NS::X x; operator+(x, x);"), ADLMatch));
   EXPECT_TRUE(notMatches(MkStr("NS::X x; NS::operator+(x, x);"), ADLMatch));
 }
 
-TEST(Matcher, Call) {
+TEST_P(ASTMatchersTest, CallExpr_CXX) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Add a test for `callExpr()` that does not depend on C++.
+    return;
+  }
   // FIXME: Do we want to overload Call() to directly take
   // Matcher<Decl>, too?
   StatementMatcher MethodX =
     callExpr(hasDeclaration(cxxMethodDecl(hasName("x"))));
 
   EXPECT_TRUE(matches("class Y { void x() { x(); } };", MethodX));
   EXPECT_TRUE(notMatches("class Y { void x() {} };", MethodX));
 
matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
             MethodOnYPointer));
   EXPECT_TRUE(
     notMatches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
                MethodOnYPointer));
   EXPECT_TRUE(
     notMatches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
                MethodOnYPointer));
 }
-TEST(Matcher, Lambda) {
+
+TEST_P(ASTMatchersTest, LambdaExpr) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   EXPECT_TRUE(matches("auto f = [] (int i) { return i; };",
                       lambdaExpr()));
 }
 
-TEST(Matcher, ForRange) {
+TEST_P(ASTMatchersTest, CXXForRangeStmt) {
+  EXPECT_TRUE(
+      notMatches("void f() { for (int i; i<5; ++i); }", cxxForRangeStmt()));
+}
+
+TEST_P(ASTMatchersTest, CXXForRangeStmt_CXX11) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   EXPECT_TRUE(matches("int as[] = { 1, 2, 3 };"
                         "void f() { for (auto &a : as); }",
                       cxxForRangeStmt()));
-  EXPECT_TRUE(notMatches("void f() { for (int i; i<5; ++i); }",
-                         cxxForRangeStmt()));
 }
 
-TEST(Matcher, SubstNonTypeTemplateParm) {
+TEST_P(ASTMatchersTest, SubstNonTypeTemplateParmExpr) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_FALSE(matches("template<int N>\n"
                          "struct A {  static const int n = 0; };\n"
                          "struct B : public A<42> {};",
                          traverse(TK_AsIs,
                        substNonTypeTemplateParmExpr())));
   EXPECT_TRUE(matches("template<int N>\n"
                         "struct A {  static const int n = N; };\n"
                         "struct B : public A<42> {};",
                          traverse(TK_AsIs,
                       substNonTypeTemplateParmExpr())));
 }
 
-TEST(Matcher, NonTypeTemplateParmDecl) {
+TEST_P(ASTMatchersTest, NonTypeTemplateParmDecl) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("template <int N> void f();",
                       nonTypeTemplateParmDecl(hasName("N"))));
   EXPECT_TRUE(
     notMatches("template <typename T> void f();", nonTypeTemplateParmDecl()));
 }
 
-TEST(Matcher, templateTypeParmDecl) {
+TEST_P(ASTMatchersTest, TemplateTypeParmDecl) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("template <typename T> void f();",
                       templateTypeParmDecl(hasName("T"))));
   EXPECT_TRUE(
     notMatches("template <int N> void f();", templateTypeParmDecl()));
 }
 
-TEST(Matcher, UserDefinedLiteral) {
+TEST_P(ASTMatchersTest, UserDefinedLiteral) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   EXPECT_TRUE(matches("constexpr char operator \"\" _inc (const char i) {"
                         "  return i + 1;"
                         "}"
                         "char c = 'a'_inc;",
                       userDefinedLiteral()));
 }
 
-TEST(Matcher, FlowControl) {
-  EXPECT_TRUE(matches("void f() { while(true) { break; } }", breakStmt()));
-  EXPECT_TRUE(matches("void f() { while(true) { continue; } }",
-                      continueStmt()));
+TEST_P(ASTMatchersTest, FlowControl) {
+  EXPECT_TRUE(matches("void f() { while(1) { break; } }", breakStmt()));
+  EXPECT_TRUE(matches("void f() { while(1) { continue; } }", continueStmt()));
   EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}", gotoStmt()));
   EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}",
                       labelStmt(
                         hasDeclaration(
                           labelDecl(hasName("FOO"))))));
   EXPECT_TRUE(matches("void f() { FOO: ; void *ptr = &&FOO; goto *ptr; }",
                       addrLabelExpr()));
   EXPECT_TRUE(matches("void f() { return; }", returnStmt()));
 }
 
-TEST(Matcher, OverloadedOperatorCall) {
+TEST_P(ASTMatchersTest, CXXOperatorCallExpr) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+
   StatementMatcher OpCall = cxxOperatorCallExpr();
   // Unary operator
   EXPECT_TRUE(matches("class Y { }; "
                         "bool operator!(Y x) { return false; }; "
                         "Y y; bool c = !y;", OpCall));
   // No match -- special operators like "new", "delete"
   // FIXME: operator new takes size_t, for which we need stddef.h, for which
   // we need to figure out include paths in the test.
EXPECT_TRUE(matches("class Y { }; "
                         "bool operator&&(Y x, Y y) { return true; }; "
                         "Y a; Y b; bool c = a && b;",
                       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) {
+TEST_P(ASTMatchersTest, ThisPointerType) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+
   StatementMatcher MethodOnY =
       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(
"class Y {"
       "  public: virtual void x();"
       "};"
       "class X : public Y {"
       "  public: virtual void x();"
       "};"
       "void z() { X *x; x->Y::x(); }", MethodOnY));
 }
 
-TEST(Matcher, VariableUsage) {
+TEST_P(ASTMatchersTest, DeclRefExpr) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Add a test for `declRefExpr()` that does not depend on C++.
+    return;
+  }
   StatementMatcher Reference =
     declRefExpr(to(
       varDecl(hasInitializer(
         cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y"))))))));
 
   EXPECT_TRUE(matches(
     "class Y {"
       " public:"
"class Y {"
       " public:"
       "  bool x() const;"
       "};"
       "void z(const Y &y) {"
       "  bool b = y.x();"
       "}", Reference));
 }
 
-TEST(Matcher, CalledVariable) {
+TEST_P(ASTMatchersTest, CXXMemberCallExpr) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   StatementMatcher CallOnVariableY =
     cxxMemberCallExpr(on(declRefExpr(to(varDecl(hasName("y"))))));
 
   EXPECT_TRUE(matches(
     "class Y { public: void x() { Y y; y.x(); } };", CallOnVariableY));
   EXPECT_TRUE(matches(
     "class Y { public: void x() const { Y y; y.x(); } };", CallOnVariableY));
   EXPECT_TRUE(matches(
     "class Y { public: void x(); };"
       "class X : public Y { void z() { X y; y.x(); } };", CallOnVariableY));
   EXPECT_TRUE(matches(
     "class Y { public: void x(); };"
       "class X : public Y { void z() { X *y; y->x(); } };", CallOnVariableY));
   EXPECT_TRUE(notMatches(
     "class Y { public: void x(); };"
       "class X : public Y { void z() { unsigned long y; ((X*)y)->x(); } };",
     CallOnVariableY));
 }
 
-TEST(UnaryExprOrTypeTraitExpr, MatchesSizeOfAndAlignOf) {
+TEST_P(ASTMatchersTest, UnaryExprOrTypeTraitExpr) {
   EXPECT_TRUE(matches("void x() { int a = sizeof(a); }",
                       unaryExprOrTypeTraitExpr()));
+}
+
+TEST_P(ASTMatchersTest, AlignOfExpr) {
   EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }",
                          alignOfExpr(anything())));
   // FIXME: Uncomment once alignof is enabled.
   // EXPECT_TRUE(matches("void x() { int a = alignof(a); }",
   //                     unaryExprOrTypeTraitExpr()));
   // EXPECT_TRUE(notMatches("void x() { int a = alignof(a); }",
   //                        sizeOfExpr()));
 }
 
-TEST(MemberExpression, DoesNotMatchClasses) {
+TEST_P(ASTMatchersTest, MemberExpr_DoesNotMatchClasses) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("class Y { void x() {} };", memberExpr()));
   EXPECT_TRUE(notMatches("class Y { void x() {} };", unresolvedMemberExpr()));
   EXPECT_TRUE(
       notMatches("class Y { void x() {} };", cxxDependentScopeMemberExpr()));
 }
 
-TEST(MemberExpression, MatchesMemberFunctionCall) {
+TEST_P(ASTMatchersTest, MemberExpr_MatchesMemberFunctionCall) {
+  if (!GetParam().isCXX() || GetParam().hasDelayedTemplateParsing()) {
+    // FIXME: Fix this test to work with delayed template parsing.
+    return;
+  }
   EXPECT_TRUE(matches("class Y { void x() { x(); } };", memberExpr()));
   EXPECT_TRUE(matches("class Y { template <class T> void x() { x<T>(); } };",
                       unresolvedMemberExpr()));
   EXPECT_TRUE(matches("template <class T> void x() { T t; t.f(); }",
                       cxxDependentScopeMemberExpr()));
 }
 
-TEST(MemberExpression, MatchesVariable) {
+TEST_P(ASTMatchersTest, MemberExpr_MatchesVariable) {
+  if (!GetParam().isCXX() || GetParam().hasDelayedTemplateParsing()) {
+    // FIXME: Fix this test to work with delayed template parsing.
+    return;
+  }
   EXPECT_TRUE(
     matches("class Y { void x() { this->y; } int y; };", memberExpr()));
   EXPECT_TRUE(
     matches("class Y { void x() { y; } int y; };", memberExpr()));
   EXPECT_TRUE(
     matches("class Y { void x() { Y y; y.y; } int y; };", memberExpr()));
   EXPECT_TRUE(matches("template <class T>"
                       "class X : T { void f() { this->T::v; } };",
                       cxxDependentScopeMemberExpr()));
   EXPECT_TRUE(matches("template <class T> class X : T { void f() { T::v; } };",
                       cxxDependentScopeMemberExpr()));
   EXPECT_TRUE(matches("template <class T> void x() { T t; t.v; }",
                       cxxDependentScopeMemberExpr()));
 }
 
-TEST(MemberExpression, MatchesStaticVariable) {
+TEST_P(ASTMatchersTest, MemberExpr_MatchesStaticVariable) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
                       memberExpr()));
   EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
                          memberExpr()));
   EXPECT_TRUE(notMatches("class Y { void x() { Y::y; } static int y; };",
                          memberExpr()));
 }
 
-TEST(Function, MatchesFunctionDeclarations) {
+TEST_P(ASTMatchersTest, FunctionDecl) {
   StatementMatcher CallFunctionF = callExpr(callee(functionDecl(hasName("f"))));
 
   EXPECT_TRUE(matches("void f() { f(); }", CallFunctionF));
   EXPECT_TRUE(notMatches("void f() { }", CallFunctionF));
 
-  if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getOS() !=
-    llvm::Triple::Win32) {
-    // FIXME: Make this work for MSVC.
+  EXPECT_TRUE(notMatches("void f(int);", functionDecl(isVariadic())));
+  EXPECT_TRUE(notMatches("void f();", functionDecl(isVariadic())));
+  EXPECT_TRUE(matches("void f(int, ...);", functionDecl(parameterCountIs(1))));
+}
+
+TEST_P(ASTMatchersTest, FunctionDecl_C) {
+  if (!GetParam().isC()) {
+    return;
+  }
+  EXPECT_TRUE(notMatches("void f();", functionDecl(isVariadic())));
+  EXPECT_TRUE(matches("void f();", functionDecl(parameterCountIs(0))));
+}
+
+TEST_P(ASTMatchersTest, FunctionDecl_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+
+  StatementMatcher CallFunctionF = callExpr(callee(functionDecl(hasName("f"))));
+
+  if (!GetParam().hasDelayedTemplateParsing()) {
+    // FIXME: Fix this test to work with delayed template parsing.
     // Dependent contexts, but a non-dependent call.
     EXPECT_TRUE(matches("void f(); template <int N> void g() { f(); }",
                         CallFunctionF));
     EXPECT_TRUE(
       matches("void f(); template <int N> struct S { void g() { f(); } };",
               CallFunctionF));
   }
 
   // Depedent calls don't match.
   EXPECT_TRUE(
     notMatches("void f(int); template <typename T> void g(T t) { f(t); }",
                CallFunctionF));
   EXPECT_TRUE(
     notMatches("void f(int);"
                  "template <typename T> struct S { void g(T t) { f(t); } };",
                CallFunctionF));
 
   EXPECT_TRUE(matches("void f(...);", functionDecl(isVariadic())));
-  EXPECT_TRUE(notMatches("void f(int);", functionDecl(isVariadic())));
+  EXPECT_TRUE(matches("void f(...);", functionDecl(parameterCountIs(0))));
+}
+
+TEST_P(ASTMatchersTest, FunctionDecl_CXX11) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+
   EXPECT_TRUE(notMatches("template <typename... Ts> void f(Ts...);",
                          functionDecl(isVariadic())));
-  EXPECT_TRUE(notMatches("void f();", functionDecl(isVariadic())));
-  EXPECT_TRUE(notMatchesC("void f();", functionDecl(isVariadic())));
-  EXPECT_TRUE(matches("void f(...);", functionDecl(parameterCountIs(0))));
-  EXPECT_TRUE(matchesC("void f();", functionDecl(parameterCountIs(0))));
-  EXPECT_TRUE(matches("void f(int, ...);", functionDecl(parameterCountIs(1))));
 }
 
-TEST(FunctionTemplate, MatchesFunctionTemplateDeclarations) {
+TEST_P(ASTMatchersTest,
+       FunctionTemplateDecl_MatchesFunctionTemplateDeclarations) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(
     matches("template <typename T> void f(T t) {}",
             functionTemplateDecl(hasName("f"))));
 }
 
-TEST(FunctionTemplate, DoesNotMatchFunctionDeclarations) {
+TEST_P(ASTMatchersTest, FunctionTemplate_DoesNotMatchFunctionDeclarations) {
   EXPECT_TRUE(
-    notMatches("void f(double d); void f(int t) {}",
-               functionTemplateDecl(hasName("f"))));
+      notMatches("void f(double d);", functionTemplateDecl(hasName("f"))));
+  EXPECT_TRUE(
+      notMatches("void f(int t) {}", functionTemplateDecl(hasName("f"))));
 }
 
-TEST(FunctionTemplate, DoesNotMatchFunctionTemplateSpecializations) {
+TEST_P(ASTMatchersTest,
+       FunctionTemplateDecl_DoesNotMatchFunctionTemplateSpecializations) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(
     notMatches("void g(); template <typename T> void f(T t) {}"
                  "template <> void f(int t) { g(); }",
                functionTemplateDecl(hasName("f"),
                                     hasDescendant(declRefExpr(to(
                                       functionDecl(hasName("g"))))))));
 }
 
-TEST(Matcher, MatchesClassTemplateSpecialization) {
+TEST_P(ASTMatchersTest, ClassTemplateSpecializationDecl) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("template<typename T> struct A {};"
                         "template<> struct A<int> {};",
                       classTemplateSpecializationDecl()));
   EXPECT_TRUE(matches("template<typename T> struct A {}; A<int> a;",
                       classTemplateSpecializationDecl()));
   EXPECT_TRUE(notMatches("template<typename T> struct A {};",
                          classTemplateSpecializationDecl()));
 }
 
-TEST(DeclaratorDecl, MatchesDeclaratorDecls) {
+TEST_P(ASTMatchersTest, DeclaratorDecl) {
   EXPECT_TRUE(matches("int x;", declaratorDecl()));
+  EXPECT_TRUE(notMatches("struct A {};", declaratorDecl()));
+}
+
+TEST_P(ASTMatchersTest, DeclaratorDecl_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("class A {};", declaratorDecl()));
 }
 
-TEST(ParmVarDecl, MatchesParmVars) {
+TEST_P(ASTMatchersTest, ParmVarDecl) {
   EXPECT_TRUE(matches("void f(int x);", parmVarDecl()));
   EXPECT_TRUE(notMatches("void f();", parmVarDecl()));
 }
 
-TEST(Matcher, ConstructorCall) {
+TEST_P(ASTMatchersTest, Matcher_ConstructorCall) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+
   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; }",
             Constructor));
   EXPECT_TRUE(matches("class X {}; void x(int) { X x; }", Constructor));
 }
 
-TEST(Match, ConstructorInitializers) {
+TEST_P(ASTMatchersTest, Match_ConstructorInitializers) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("class C { int i; public: C(int ii) : i(ii) {} };",
                       cxxCtorInitializer(forField(hasName("i")))));
 }
 
-TEST(Matcher, ThisExpr) {
+TEST_P(ASTMatchersTest, Matcher_ThisExpr) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   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) {
+TEST_P(ASTMatchersTest, Matcher_BindTemporaryExpression) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+
   StatementMatcher TempExpression =
       traverse(ast_type_traits::TK_AsIs, cxxBindTemporaryExpr());
 
   StringRef ClassString = "class string { public: string(); ~string(); }; ";
 
   EXPECT_TRUE(
     matches(ClassString +
               "string GetStringByValue();"
TEST_P(ASTMatchersTest, Matcher_BindTemporaryExpression) {
   EXPECT_TRUE(
     notMatches("class no_dtor {};"
                  "no_dtor GetObjByValue();"
                  "void ConsumeObj(no_dtor param);"
                  "void run() { ConsumeObj(GetObjByValue()); }",
                TempExpression));
 }
 
-TEST(MaterializeTemporaryExpr, MatchesTemporary) {
-  StringRef ClassString = "class string { public: string(); int length(); }; ";
+TEST_P(ASTMatchersTest, MaterializeTemporaryExpr_MatchesTemporaryCXX11CXX14) {
+  if (GetParam().Language != Lang_CXX11 && GetParam().Language != Lang_CXX14) {
+    return;
+  }
+
   StatementMatcher TempExpression =
       traverse(ast_type_traits::TK_AsIs, materializeTemporaryExpr());
 
-  EXPECT_TRUE(matches(
-      ClassString + "string GetStringByValue();"
+  EXPECT_TRUE(matches("class string { public: string(); }; "
+                      "string GetStringByValue();"
                       "void FunctionTakesString(string s);"
                       "void run() { FunctionTakesString(GetStringByValue()); }",
                       TempExpression));
+}
+
+TEST_P(ASTMatchersTest, MaterializeTemporaryExpr_MatchesTemporary) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+
+  StringRef ClassString = "class string { public: string(); int length(); }; ";
+  StatementMatcher TempExpression =
+      traverse(ast_type_traits::TK_AsIs, materializeTemporaryExpr());
 
   EXPECT_TRUE(notMatches(ClassString +
                              "string* GetStringPointer(); "
                              "void FunctionTakesStringPtr(string* s);"
                              "void run() {"
                              "  string* s = GetStringPointer();"
                              "  FunctionTakesStringPtr(GetStringPointer());"
                              "  FunctionTakesStringPtr(s);"
                              "}",
                          TempExpression));
 
   EXPECT_TRUE(matches(ClassString +
                           "string GetStringByValue();"
                           "void run() { int k = GetStringByValue().length(); }",
                       TempExpression));
 
   EXPECT_TRUE(notMatches(ClassString + "string GetStringByValue();"
                                        "void run() { GetStringByValue(); }",
                          TempExpression));
 }
 
-TEST(Matcher, NewExpression) {
+TEST_P(ASTMatchersTest, Matcher_NewExpression) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+
   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(
     matches("class X { public: X(int); }; void x() { new X(0); }", New));
   EXPECT_TRUE(matches("class X {}; void x(int) { new X; }", New));
 }
 
-TEST(Matcher, DeleteExpression) {
+TEST_P(ASTMatchersTest, Matcher_DeleteExpression) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("struct A {}; void f(A* a) { delete a; }",
                       cxxDeleteExpr()));
 }
 
-TEST(Matcher, NoexceptExpression) {
+TEST_P(ASTMatchersTest, Matcher_NoexceptExpression) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   StatementMatcher NoExcept = cxxNoexceptExpr();
   EXPECT_TRUE(matches("void foo(); bool bar = noexcept(foo());", NoExcept));
   EXPECT_TRUE(
       matches("void foo() noexcept; bool bar = noexcept(foo());", NoExcept));
   EXPECT_TRUE(notMatches("void foo() noexcept;", NoExcept));
   EXPECT_TRUE(notMatches("void foo() noexcept(1+1);", NoExcept));
   EXPECT_TRUE(matches("void foo() noexcept(noexcept(1+1));", NoExcept));
 }
 
-TEST(Matcher, DefaultArgument) {
+TEST_P(ASTMatchersTest, Matcher_DefaultArgument) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   StatementMatcher Arg = cxxDefaultArgExpr();
-
   EXPECT_TRUE(matches("void x(int, int = 0) { int y; x(y); }", Arg));
   EXPECT_TRUE(
     matches("class X { void x(int, int = 0) { int y; x(y); } };", Arg));
   EXPECT_TRUE(notMatches("void x(int, int = 0) { int y; x(y, 0); }", Arg));
 }
 
-TEST(Matcher, StringLiterals) {
+TEST_P(ASTMatchersTest, StringLiteral) {
   StatementMatcher Literal = stringLiteral();
   EXPECT_TRUE(matches("const char *s = \"string\";", Literal));
-  // wide string
-  EXPECT_TRUE(matches("const wchar_t *s = L\"string\";", Literal));
   // with escaped characters
   EXPECT_TRUE(matches("const char *s = \"\x05five\";", Literal));
   // no matching -- though the data type is the same, there is no string literal
   EXPECT_TRUE(notMatches("const char s[1] = {'a'};", Literal));
 }
 
-TEST(Matcher, CharacterLiterals) {
-  StatementMatcher CharLiteral = characterLiteral();
-  EXPECT_TRUE(matches("const char c = 'c';", CharLiteral));
+TEST_P(ASTMatchersTest, StringLiteral_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(matches("const wchar_t *s = L\"string\";", stringLiteral()));
+}
+
+TEST_P(ASTMatchersTest, CharacterLiteral) {
+  EXPECT_TRUE(matches("const char c = 'c';", characterLiteral()));
+  EXPECT_TRUE(notMatches("const char c = 0x1;", characterLiteral()));
+}
+
+TEST_P(ASTMatchersTest, CharacterLiteral_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   // wide character
-  EXPECT_TRUE(matches("const char c = L'c';", CharLiteral));
+  EXPECT_TRUE(matches("const char c = L'c';", characterLiteral()));
   // wide character, Hex encoded, NOT MATCHED!
-  EXPECT_TRUE(notMatches("const wchar_t c = 0x2126;", CharLiteral));
-  EXPECT_TRUE(notMatches("const char c = 0x1;", CharLiteral));
+  EXPECT_TRUE(notMatches("const wchar_t c = 0x2126;", characterLiteral()));
 }
 
-TEST(Matcher, IntegerLiterals) {
+TEST_P(ASTMatchersTest, IntegerLiteral) {
   StatementMatcher HasIntLiteral = integerLiteral();
   EXPECT_TRUE(matches("int i = 10;", HasIntLiteral));
   EXPECT_TRUE(matches("int i = 0x1AB;", HasIntLiteral));
   EXPECT_TRUE(matches("int i = 10L;", HasIntLiteral));
   EXPECT_TRUE(matches("int i = 10U;", HasIntLiteral));
 
   // Non-matching cases (character literals, float and double)
   EXPECT_TRUE(notMatches("int i = L'a';",
                          HasIntLiteral));  // this is actually a character
   // literal cast to int
   EXPECT_TRUE(notMatches("int i = 'a';", HasIntLiteral));
   EXPECT_TRUE(notMatches("int i = 1e10;", HasIntLiteral));
   EXPECT_TRUE(notMatches("int i = 10.0;", HasIntLiteral));
 
   // Negative integers.
   EXPECT_TRUE(
       matches("int i = -10;",
               unaryOperator(hasOperatorName("-"),
                             hasUnaryOperand(integerLiteral(equals(10))))));
 }
 
-TEST(Matcher, FloatLiterals) {
+TEST_P(ASTMatchersTest, FloatLiteral) {
   StatementMatcher HasFloatLiteral = floatLiteral();
   EXPECT_TRUE(matches("float i = 10.0;", HasFloatLiteral));
   EXPECT_TRUE(matches("float i = 10.0f;", HasFloatLiteral));
   EXPECT_TRUE(matches("double i = 10.0;", HasFloatLiteral));
   EXPECT_TRUE(matches("double i = 10.0L;", HasFloatLiteral));
   EXPECT_TRUE(matches("double i = 1e10;", HasFloatLiteral));
   EXPECT_TRUE(matches("double i = 5.0;", floatLiteral(equals(5.0))));
   EXPECT_TRUE(matches("double i = 5.0;", floatLiteral(equals(5.0f))));
   EXPECT_TRUE(
     matches("double i = 5.0;", floatLiteral(equals(llvm::APFloat(5.0)))));
 
   EXPECT_TRUE(notMatches("float i = 10;", HasFloatLiteral));
   EXPECT_TRUE(notMatches("double i = 5.0;", floatLiteral(equals(6.0))));
   EXPECT_TRUE(notMatches("double i = 5.0;", floatLiteral(equals(6.0f))));
   EXPECT_TRUE(
     notMatches("double i = 5.0;", floatLiteral(equals(llvm::APFloat(6.0)))));
 }
 
-TEST(Matcher, NullPtrLiteral) {
+TEST_P(ASTMatchersTest, CXXNullPtrLiteralExpr) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   EXPECT_TRUE(matches("int* i = nullptr;", cxxNullPtrLiteralExpr()));
 }
 
-TEST(Matcher, ChooseExpr) {
-  EXPECT_TRUE(matchesC("void f() { (void)__builtin_choose_expr(1, 2, 3); }",
-                       chooseExpr()));
+TEST_P(ASTMatchersTest, ChooseExpr) {
+  EXPECT_TRUE(matches("void f() { (void)__builtin_choose_expr(1, 2, 3); }",
 }
 
-TEST(Matcher, GNUNullExpr) {
+TEST_P(ASTMatchersTest, GNUNullExpr) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("int* i = __null;", gnuNullExpr()));
 }
 
-TEST(Matcher, AtomicExpr) {
+TEST_P(ASTMatchersTest, AtomicExpr) {
   EXPECT_TRUE(matches("void foo() { int *ptr; __atomic_load_n(ptr, 1); }",
                       atomicExpr()));
 }
 
-TEST(Matcher, Initializers) {
-  const char *ToMatch = "void foo() { struct point { double x; double y; };"
+TEST_P(ASTMatchersTest, Initializers_C99) {
+  if (!GetParam().isC99OrLater()) {
+    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 }; }";
-  EXPECT_TRUE(matchesConditionally(
-      ToMatch,
-      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)))))),
-      true, {"-std=gnu++03"}));
-
-  EXPECT_TRUE(matchesC99(
-      ToMatch,
+      "      { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }",
       initListExpr(hasSyntacticForm(initListExpr(
           has(designatedInitExpr(designatorCountIs(2),
                                  hasDescendant(floatLiteral(equals(1.0))),
                                  hasDescendant(integerLiteral(equals(2))))),
           has(designatedInitExpr(designatorCountIs(2),
                                  hasDescendant(floatLiteral(equals(2.0))),
                                  hasDescendant(integerLiteral(equals(2))))),
           has(designatedInitExpr(
               designatorCountIs(2), hasDescendant(floatLiteral(equals(1.0))),
               hasDescendant(integerLiteral(equals(0))))))))));
 }
 
-TEST(Matcher, ParenListExpr) {
+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")))))),
+          has(initListExpr(hasType(asString("struct point")),
+                           has(floatLiteral(equals(2.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); } };"
               "template class foo<int>;",
             varDecl(hasInitializer(parenListExpr(has(unaryOperator()))))));
 }
 
-TEST(Matcher, StmtExpr) {
+TEST_P(ASTMatchersTest, StmtExpr) {
   EXPECT_TRUE(matches("void declToImport() { int C = ({int X=4; X;}); }",
                       varDecl(hasInitializer(stmtExpr()))));
 }
 
-TEST(Matcher, ImportPredefinedExpr) {
+TEST_P(ASTMatchersTest, PredefinedExpr) {
   // __func__ expands as StringLiteral("foo")
   EXPECT_TRUE(matches("void foo() { __func__; }",
                       predefinedExpr(
                         hasType(asString("const char [4]")),
                         has(stringLiteral()))));
 }
 
-TEST(Matcher, AsmStatement) {
+TEST_P(ASTMatchersTest, AsmStatement) {
   EXPECT_TRUE(matches("void foo() { __asm(\"mov al, 2\"); }", asmStmt()));
 }
 
-TEST(Matcher, Conditions) {
+TEST_P(ASTMatchersTest, HasCondition) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Add a test for `hasCondition()` that does not depend on C++.
+    return;
+  }
+
   StatementMatcher Condition =
     ifStmt(hasCondition(cxxBoolLiteral(equals(true))));
 
   EXPECT_TRUE(matches("void x() { if (true) {} }", Condition));
   EXPECT_TRUE(notMatches("void x() { if (false) {} }", Condition));
   EXPECT_TRUE(notMatches("void x() { bool a = true; if (a) {} }", Condition));
   EXPECT_TRUE(notMatches("void x() { if (true || false) {} }", Condition));
   EXPECT_TRUE(notMatches("void x() { if (1) {} }", Condition));
 }
 
-TEST(Matcher, ConditionalOperator) {
+TEST_P(ASTMatchersTest, ConditionalOperator) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Add a test for `conditionalOperator()` that does not depend on
+    // C++.
+    return;
+  }
+
   StatementMatcher Conditional = conditionalOperator(
     hasCondition(cxxBoolLiteral(equals(true))),
     hasTrueExpression(cxxBoolLiteral(equals(false))));
 
   EXPECT_TRUE(matches("void x() { true ? false : true; }", Conditional));
   EXPECT_TRUE(notMatches("void x() { false ? false : true; }", Conditional));
   EXPECT_TRUE(notMatches("void x() { true ? true : false; }", Conditional));
 
   StatementMatcher ConditionalFalse = conditionalOperator(
     hasFalseExpression(cxxBoolLiteral(equals(false))));
 
   EXPECT_TRUE(matches("void x() { true ? true : false; }", ConditionalFalse));
   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) {
+TEST_P(ASTMatchersTest, BinaryConditionalOperator) {
+  if (!GetParam().isCXX()) {
+    // FIXME: This test should work in non-C++ language modes.
+    return;
+  }
+
   StatementMatcher AlwaysOne =
       traverse(ast_type_traits::TK_AsIs,
                binaryConditionalOperator(
                    hasCondition(implicitCastExpr(has(opaqueValueExpr(
                        hasSourceExpression((integerLiteral(equals(1)))))))),
                    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))));
 
   EXPECT_TRUE(matches("void x() { 4 ?: 5; }", FourNotFive));
 }
 
-TEST(ArraySubscriptMatchers, ArraySubscripts) {
+TEST_P(ASTMatchersTest, ArraySubscriptExpr) {
   EXPECT_TRUE(matches("int i[2]; void f() { i[1] = 1; }",
                       arraySubscriptExpr()));
   EXPECT_TRUE(notMatches("int i; void f() { i = 1; }",
                          arraySubscriptExpr()));
 }
 
-TEST(For, FindsForLoops) {
+TEST_P(ASTMatchersTest, ForStmt) {
   EXPECT_TRUE(matches("void f() { for(;;); }", forStmt()));
-  EXPECT_TRUE(matches("void f() { if(true) for(;;); }", forStmt()));
+  EXPECT_TRUE(matches("void f() { if(1) for(;;); }", forStmt()));
+}
+
+TEST_P(ASTMatchersTest, ForStmt_CXX11) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("int as[] = { 1, 2, 3 };"
-                           "void f() { for (auto &a : as); }",
                          forStmt()));
 }
 
-TEST(For, ReportsNoFalsePositives) {
+TEST_P(ASTMatchersTest, ForStmt_NoFalsePositives) {
   EXPECT_TRUE(notMatches("void f() { ; }", forStmt()));
-  EXPECT_TRUE(notMatches("void f() { if(true); }", forStmt()));
+  EXPECT_TRUE(notMatches("void f() { if(1); }", forStmt()));
 }
 
-TEST(CompoundStatement, HandlesSimpleCases) {
+TEST_P(ASTMatchersTest, CompoundStatement) {
   EXPECT_TRUE(notMatches("void f();", compoundStmt()));
   EXPECT_TRUE(matches("void f() {}", compoundStmt()));
   EXPECT_TRUE(matches("void f() {{}}", compoundStmt()));
 }
 
-TEST(CompoundStatement, DoesNotMatchEmptyStruct) {
+TEST_P(ASTMatchersTest, CompoundStatement_DoesNotMatchEmptyStruct) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Add a similar test that does not depend on C++.
+    return;
+  }
   // It's not a compound statement just because there's "{}" in the source
   // text. This is an AST search, not grep.
   EXPECT_TRUE(notMatches("namespace n { struct S {}; }",
                          compoundStmt()));
   EXPECT_TRUE(matches("namespace n { struct S { void f() {{}} }; }",
                       compoundStmt()));
 }
 
-TEST(CastExpression, MatchesExplicitCasts) {
-  EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);",castExpr()));
+TEST_P(ASTMatchersTest, CastExpr_MatchesExplicitCasts) {
   EXPECT_TRUE(matches("void *p = (void *)(&p);", castExpr()));
+}
+
+TEST_P(ASTMatchersTest, CastExpr_MatchesExplicitCasts_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);", castExpr()));
   EXPECT_TRUE(matches("char q, *p = const_cast<char *>(&q);", castExpr()));
   EXPECT_TRUE(matches("char c = char(0);", castExpr()));
 }
-TEST(CastExpression, MatchesImplicitCasts) {
+
+TEST_P(ASTMatchersTest, CastExpression_MatchesImplicitCasts) {
   // This test creates an implicit cast from int to char.
   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;",
+  EXPECT_TRUE(matches("void f() { char c = 0, d = c; }",
                       traverse(ast_type_traits::TK_AsIs, castExpr())));
 }
 
-TEST(CastExpression, DoesNotMatchNonCasts) {
+TEST_P(ASTMatchersTest, CastExpr_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()));
 }
 
-TEST(ReinterpretCast, MatchesSimpleCase) {
+TEST_P(ASTMatchersTest, CastExpr_DoesNotMatchNonCasts_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(notMatches("char c, &q = c;", castExpr()));
+}
+
+TEST_P(ASTMatchersTest, CXXReinterpretCastExpr) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("char* p = reinterpret_cast<char*>(&p);",
                       cxxReinterpretCastExpr()));
 }
 
-TEST(ReinterpretCast, DoesNotMatchOtherCasts) {
+TEST_P(ASTMatchersTest, CXXReinterpretCastExpr_DoesNotMatchOtherCasts) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("char* p = (char*)(&p);", cxxReinterpretCastExpr()));
   EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
                          cxxReinterpretCastExpr()));
   EXPECT_TRUE(notMatches("void* p = static_cast<void*>(&p);",
                          cxxReinterpretCastExpr()));
   EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
                            "B b;"
                            "D* p = dynamic_cast<D*>(&b);",
                          cxxReinterpretCastExpr()));
 }
 
-TEST(FunctionalCast, MatchesSimpleCase) {
+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()));
 }
 
-TEST(FunctionalCast, DoesNotMatchOtherCasts) {
+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()));
   EXPECT_TRUE(
     notMatches(FooClass + "void r() { Foo f = \"hello world\"; }",
                cxxFunctionalCastExpr()));
 }
 
-TEST(DynamicCast, MatchesSimpleCase) {
+TEST_P(ASTMatchersTest, CXXDynamicCastExpr) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("struct B { virtual ~B() {} }; struct D : B {};"
                         "B b;"
                         "D* p = dynamic_cast<D*>(&b);",
                       cxxDynamicCastExpr()));
 }
 
-TEST(StaticCast, MatchesSimpleCase) {
+TEST_P(ASTMatchersTest, CXXStaticCastExpr_MatchesSimpleCase) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("void* p(static_cast<void*>(&p));",
                       cxxStaticCastExpr()));
 }
 
-TEST(StaticCast, DoesNotMatchOtherCasts) {
+TEST_P(ASTMatchersTest, CXXStaticCastExpr_DoesNotMatchOtherCasts) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("char* p = (char*)(&p);", cxxStaticCastExpr()));
   EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
                          cxxStaticCastExpr()));
   EXPECT_TRUE(notMatches("void* p = reinterpret_cast<char*>(&p);",
                          cxxStaticCastExpr()));
   EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
                            "B b;"
                            "D* p = dynamic_cast<D*>(&b);",
                          cxxStaticCastExpr()));
 }
 
-TEST(CStyleCast, MatchesSimpleCase) {
+TEST_P(ASTMatchersTest, CStyleCastExpr_MatchesSimpleCase) {
   EXPECT_TRUE(matches("int i = (int) 2.2f;", cStyleCastExpr()));
 }
 
-TEST(CStyleCast, DoesNotMatchOtherCasts) {
+TEST_P(ASTMatchersTest, CStyleCastExpr_DoesNotMatchOtherCasts) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);"
                            "char q, *r = const_cast<char*>(&q);"
                            "void* s = reinterpret_cast<char*>(&s);"
                            "struct B { virtual ~B() {} }; struct D : B {};"
                            "B b;"
                            "D* t = dynamic_cast<D*>(&b);",
                          cStyleCastExpr()));
 }
 
-TEST(ImplicitCast, MatchesSimpleCase) {
+TEST_P(ASTMatchersTest, ImplicitCastExpr_MatchesSimpleCase) {
   // This test creates an implicit const cast.
-  EXPECT_TRUE(matches("int x = 0; const int y = x;",
+  EXPECT_TRUE(matches("void f() { int x = 0; const int y = x; }",
                       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;",
                       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;",
                       traverse(ast_type_traits::TK_AsIs,
                                varDecl(hasInitializer(implicitCastExpr())))));
 }
 
-TEST(ImplicitCast, DoesNotMatchIncorrectly) {
+TEST_P(ASTMatchersTest, ImplicitCastExpr_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;",
                          varDecl(hasInitializer(implicitCastExpr()))));
-  EXPECT_TRUE(notMatches("int x = 0, &y = x;",
+  EXPECT_TRUE(
+      notMatches("int x = (0);", varDecl(hasInitializer(implicitCastExpr()))));
+  EXPECT_TRUE(notMatches("void f() { int x = 0; double d = (double) x; }",
                          varDecl(hasInitializer(implicitCastExpr()))));
+}
 
-  EXPECT_TRUE(notMatches("int x = 0; double d = (double) x;",
+TEST_P(ASTMatchersTest, ImplicitCastExpr_DoesNotMatchIncorrectly_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(notMatches("int x = 0, &y = x;",
                          varDecl(hasInitializer(implicitCastExpr()))));
   EXPECT_TRUE(notMatches("const int *p; int *q = const_cast<int *>(p);",
                          varDecl(hasInitializer(implicitCastExpr()))));
-
-  EXPECT_TRUE(notMatches("int x = (0);",
-                         varDecl(hasInitializer(implicitCastExpr()))));
 }
 
-TEST(Statement, DoesNotMatchDeclarations) {
-  EXPECT_TRUE(notMatches("class X {};", stmt()));
+TEST_P(ASTMatchersTest, Stmt_DoesNotMatchDeclarations) {
+  EXPECT_TRUE(notMatches("struct X {};", stmt()));
 }
 
-TEST(Statement, MatchesCompoundStatments) {
+TEST_P(ASTMatchersTest, Stmt_MatchesCompoundStatments) {
   EXPECT_TRUE(matches("void x() {}", stmt()));
 }
 
-TEST(DeclarationStatement, DoesNotMatchCompoundStatements) {
+TEST_P(ASTMatchersTest, DeclStmt_DoesNotMatchCompoundStatements) {
   EXPECT_TRUE(notMatches("void x() {}", declStmt()));
 }
 
-TEST(DeclarationStatement, MatchesVariableDeclarationStatements) {
+TEST_P(ASTMatchersTest, DeclStmt_MatchesVariableDeclarationStatements) {
   EXPECT_TRUE(matches("void x() { int a; }", declStmt()));
 }
 
-TEST(ExprWithCleanups, MatchesExprWithCleanups) {
+TEST_P(ASTMatchersTest, ExprWithCleanups_MatchesExprWithCleanups) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("struct Foo { ~Foo(); };"
                       "const Foo f = Foo();",
                       traverse(ast_type_traits::TK_AsIs,
                                varDecl(hasInitializer(exprWithCleanups())))));
   EXPECT_FALSE(matches("struct Foo { }; Foo a;"
                        "const Foo f = a;",
                        traverse(ast_type_traits::TK_AsIs,
                                 varDecl(hasInitializer(exprWithCleanups())))));
 }
 
-TEST(InitListExpression, MatchesInitListExpression) {
+TEST_P(ASTMatchersTest, InitListExpr) {
   EXPECT_TRUE(matches("int a[] = { 1, 2 };",
                       initListExpr(hasType(asString("int [2]")))));
-  EXPECT_TRUE(matches("struct B { int x, y; }; B b = { 5, 6 };",
+  EXPECT_TRUE(matches("struct B { int x, y; }; struct B b = { 5, 6 };",
                       initListExpr(hasType(recordDecl(hasName("B"))))));
+  EXPECT_TRUE(
+    matches("int i[1] = {42, [0] = 43};", integerLiteral(equals(42))));
+}
+
+TEST_P(ASTMatchersTest, InitListExpr_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   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) {
+TEST_P(ASTMatchersTest,
+       CXXStdInitializerListExpression_MatchesCXXStdInitializerListExpression) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   StringRef code = "namespace std {"
                    "template <typename> class initializer_list {"
                    "  public: initializer_list() noexcept {}"
                    "};"
                    "}"
                    "struct A {"
                    "  A(std::initializer_list<int>) {}"
                    "};";
EXPECT_TRUE(
                                         hasDeclaration(cxxConstructorDecl(
                                             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) {
+TEST_P(ASTMatchersTest, UsingDecl_MatchesUsingDeclarations) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("namespace X { int x; } using X::x;",
                       usingDecl()));
 }
 
-TEST(UsingDeclaration, MatchesShadowUsingDelcarations) {
+TEST_P(ASTMatchersTest, UsingDecl_MatchesShadowUsingDelcarations) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("namespace f { int a; } using f::a;",
                       usingDecl(hasAnyUsingShadowDecl(hasName("a")))));
 }
 
-TEST(UsingDirectiveDeclaration, MatchesUsingNamespace) {
+TEST_P(ASTMatchersTest, UsingDirectiveDecl_MatchesUsingNamespace) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("namespace X { int x; } using namespace X;",
                       usingDirectiveDecl()));
   EXPECT_FALSE(
     matches("namespace X { int x; } using X::x;", usingDirectiveDecl()));
 }
 
-
-TEST(While, MatchesWhileLoops) {
+TEST_P(ASTMatchersTest, WhileStmt) {
   EXPECT_TRUE(notMatches("void x() {}", whileStmt()));
-  EXPECT_TRUE(matches("void x() { while(true); }", whileStmt()));
-  EXPECT_TRUE(notMatches("void x() { do {} while(true); }", whileStmt()));
+  EXPECT_TRUE(matches("void x() { while(1); }", whileStmt()));
+  EXPECT_TRUE(notMatches("void x() { do {} while(1); }", whileStmt()));
 }
 
-TEST(Do, MatchesDoLoops) {
-  EXPECT_TRUE(matches("void x() { do {} while(true); }", doStmt()));
-  EXPECT_TRUE(matches("void x() { do ; while(false); }", doStmt()));
+TEST_P(ASTMatchersTest, DoStmt_MatchesDoLoops) {
+  EXPECT_TRUE(matches("void x() { do {} while(1); }", doStmt()));
+  EXPECT_TRUE(matches("void x() { do ; while(0); }", doStmt()));
 }
 
-TEST(Do, DoesNotMatchWhileLoops) {
-  EXPECT_TRUE(notMatches("void x() { while(true) {} }", doStmt()));
+TEST_P(ASTMatchersTest, DoStmt_DoesNotMatchWhileLoops) {
+  EXPECT_TRUE(notMatches("void x() { while(1) {} }", doStmt()));
 }
 
-TEST(SwitchCase, MatchesCase) {
+TEST_P(ASTMatchersTest, SwitchCase_MatchesCase) {
   EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchCase()));
   EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchCase()));
   EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchCase()));
   EXPECT_TRUE(notMatches("void x() { switch(42) {} }", switchCase()));
 }
 
-TEST(SwitchCase, MatchesSwitch) {
+TEST_P(ASTMatchersTest, SwitchCase_MatchesSwitch) {
   EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchStmt()));
   EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchStmt()));
   EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchStmt()));
   EXPECT_TRUE(notMatches("void x() {}", switchStmt()));
 }
 
-TEST(ExceptionHandling, SimpleCases) {
+TEST_P(ASTMatchersTest, CxxExceptionHandling_SimpleCases) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", cxxCatchStmt()));
   EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", cxxTryStmt()));
   EXPECT_TRUE(
     notMatches("void foo() try { } catch(int X) { }", cxxThrowExpr()));
   EXPECT_TRUE(matches("void foo() try { throw; } catch(int X) { }",
                       cxxThrowExpr()));
   EXPECT_TRUE(matches("void foo() try { throw 5;} catch(int X) { }",
                       cxxThrowExpr()));
   EXPECT_TRUE(matches("void foo() try { throw; } catch(...) { }",
                       cxxCatchStmt(isCatchAll())));
   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) {
+TEST_P(ASTMatchersTest, ParenExpr_SimpleCases) {
   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();",
+  EXPECT_TRUE(notMatches("int f() { return 1; }; void g() { int a = f(); }",
                          traverse(ast_type_traits::TK_AsIs, parenExpr())));
 }
 
-TEST(ParenExpression, IgnoringParens) {
+TEST_P(ASTMatchersTest, IgnoringParens) {
   EXPECT_FALSE(matches(
       "const char* str = (\"my-string\");",
       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) {
+TEST_P(ASTMatchersTest, QualType) {
   EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
 }
 
-TEST(TypeMatching, MatchesConstantArrayTypes) {
+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))));
   EXPECT_TRUE(matches("int b[2*21];", constantArrayType(hasSize(42))));
   EXPECT_TRUE(notMatches("int c[41], d[43];", constantArrayType(hasSize(42))));
 }
 
-TEST(TypeMatching, MatchesDependentSizedArrayTypes) {
+TEST_P(ASTMatchersTest, DependentSizedArrayType) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches(
     "template <typename T, int Size> class array { T data[Size]; };",
     dependentSizedArrayType()));
   EXPECT_TRUE(notMatches(
     "int a[42]; int b[] = { 2, 3 }; void f() { int c[b[0]]; }",
     dependentSizedArrayType()));
 }
 
-TEST(TypeMatching, MatchesIncompleteArrayType) {
+TEST_P(ASTMatchersTest, IncompleteArrayType) {
   EXPECT_TRUE(matches("int a[] = { 2, 3 };", incompleteArrayType()));
   EXPECT_TRUE(matches("void f(int a[]) {}", incompleteArrayType()));
 
   EXPECT_TRUE(notMatches("int a[42]; void f() { int b[a[0]]; }",
                          incompleteArrayType()));
 }
 
-TEST(TypeMatching, MatchesVariableArrayType) {
+TEST_P(ASTMatchersTest, VariableArrayType) {
   EXPECT_TRUE(matches("void f(int b) { int a[b]; }", variableArrayType()));
   EXPECT_TRUE(notMatches("int a[] = {2, 3}; int b[42];", variableArrayType()));
 
   EXPECT_TRUE(matches(
     "void f(int b) { int a[b]; }",
     variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
       varDecl(hasName("b")))))))));
 }
 
-
-TEST(TypeMatching, MatchesAtomicTypes) {
+TEST_P(ASTMatchersTest, AtomicType) {
   if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getOS() !=
     llvm::Triple::Win32) {
     // FIXME: Make this work for MSVC.
     EXPECT_TRUE(matches("_Atomic(int) i;", atomicType()));
 
     EXPECT_TRUE(matches("_Atomic(int) i;",
                         atomicType(hasValueType(isInteger()))));
     EXPECT_TRUE(notMatches("_Atomic(float) f;",
                            atomicType(hasValueType(isInteger()))));
   }
 }
 
-TEST(TypeMatching, MatchesAutoTypes) {
+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()));
 
   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;",
   //                    autoType(hasDeducedType(isInteger()))));
   //EXPECT_TRUE(notMatches("auto b = 2.0;",
   //                       autoType(hasDeducedType(isInteger()))));
 }
 
-TEST(TypeMatching, MatchesDeclTypes) {
+TEST_P(ASTMatchersTest, DecltypeType) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   EXPECT_TRUE(matches("decltype(1 + 1) sum = 1 + 1;", decltypeType()));
   EXPECT_TRUE(matches("decltype(1 + 1) sum = 1 + 1;",
                       decltypeType(hasUnderlyingType(isInteger()))));
 }
 
-TEST(TypeMatching, MatchesFunctionTypes) {
+TEST_P(ASTMatchersTest, FunctionType) {
   EXPECT_TRUE(matches("int (*f)(int);", functionType()));
   EXPECT_TRUE(matches("void f(int i) {}", functionType()));
 }
 
-TEST(TypeMatching, IgnoringParens) {
+TEST_P(ASTMatchersTest, IgnoringParens_Type) {
   EXPECT_TRUE(
       notMatches("void (*fp)(void);", pointerType(pointee(functionType()))));
   EXPECT_TRUE(matches("void (*fp)(void);",
                       pointerType(pointee(ignoringParens(functionType())))));
 }
 
-TEST(TypeMatching, MatchesFunctionProtoTypes) {
+TEST_P(ASTMatchersTest, FunctionProtoType) {
   EXPECT_TRUE(matches("int (*f)(int);", functionProtoType()));
   EXPECT_TRUE(matches("void f(int i);", functionProtoType()));
+  EXPECT_TRUE(matches("void f(void);", functionProtoType(parameterCountIs(0))));
+}
+
+TEST_P(ASTMatchersTest, FunctionProtoType_C) {
+  if (!GetParam().isC()) {
+    return;
+  }
+  EXPECT_TRUE(notMatches("void f();", functionProtoType()));
+}
+
+TEST_P(ASTMatchersTest, FunctionProtoType_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("void f();", functionProtoType(parameterCountIs(0))));
-  EXPECT_TRUE(notMatchesC("void f();", functionProtoType()));
-  EXPECT_TRUE(
-    matchesC("void f(void);", functionProtoType(parameterCountIs(0))));
 }
 
-TEST(TypeMatching, MatchesParenType) {
+TEST_P(ASTMatchersTest, ParenType) {
   EXPECT_TRUE(
     matches("int (*array)[4];", varDecl(hasType(pointsTo(parenType())))));
   EXPECT_TRUE(notMatches("int *array[4];", varDecl(hasType(parenType()))));
 
   EXPECT_TRUE(matches(
     "int (*ptr_to_func)(int);",
     varDecl(hasType(pointsTo(parenType(innerType(functionType())))))));
   EXPECT_TRUE(notMatches(
     "int (*ptr_to_array)[4];",
     varDecl(hasType(pointsTo(parenType(innerType(functionType())))))));
 }
 
-TEST(TypeMatching, PointerTypes) {
+TEST_P(ASTMatchersTest, PointerType) {
   // FIXME: Reactive when these tests can be more specific (not matching
   // implicit code on certain platforms), likely when we have hasDescendant for
   // Types/TypeLocs.
   //EXPECT_TRUE(matchAndVerifyResultTrue(
   //    "int* a;",
   //    pointerTypeLoc(pointeeLoc(typeLoc().bind("loc"))),
   //    std::make_unique<VerifyIdIsBoundTo<TypeLoc>>("loc", 1)));
   //EXPECT_TRUE(matchAndVerifyResultTrue(
   //    "int* a;",
   //    pointerTypeLoc().bind("loc"),
   //    std::make_unique<VerifyIdIsBoundTo<TypeLoc>>("loc", 1)));
   EXPECT_TRUE(matches(
     "int** a;",
     loc(pointerType(pointee(qualType())))));
   EXPECT_TRUE(matches(
     "int** a;",
     loc(pointerType(pointee(pointerType())))));
   EXPECT_TRUE(matches(
     "int* b; int* * const a = &b;",
     loc(qualType(isConstQualified(), pointerType()))));
 
-  StringRef Fragment = "struct A { int i; }; int A::* ptr = &A::i;";
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
-                                           hasType(blockPointerType()))));
-  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
-                                        hasType(memberPointerType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
-                                           hasType(pointerType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
-                                           hasType(referenceType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
-                                           hasType(lValueReferenceType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
-                                           hasType(rValueReferenceType()))));
-
-  Fragment = "int *ptr;";
+  StringRef Fragment = "int *ptr;";
   EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
                                            hasType(blockPointerType()))));
   EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
                                            hasType(memberPointerType()))));
   EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
                                         hasType(pointerType()))));
   EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
                                            hasType(referenceType()))));
+}
+
+TEST_P(ASTMatchersTest, PointerType_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  StringRef Fragment = "struct A { int i; }; int A::* ptr = &A::i;";
+  EXPECT_TRUE(notMatches(Fragment,
+                         varDecl(hasName("ptr"), hasType(blockPointerType()))));
+  EXPECT_TRUE(
+      matches(Fragment, varDecl(hasName("ptr"), hasType(memberPointerType()))));
+  EXPECT_TRUE(
+      notMatches(Fragment, varDecl(hasName("ptr"), hasType(pointerType()))));
+  EXPECT_TRUE(
+      notMatches(Fragment, varDecl(hasName("ptr"), hasType(referenceType()))));
+  EXPECT_TRUE(notMatches(
+      Fragment, varDecl(hasName("ptr"), hasType(lValueReferenceType()))));
+  EXPECT_TRUE(notMatches(
+      Fragment, varDecl(hasName("ptr"), hasType(rValueReferenceType()))));
 
   Fragment = "int a; int &ref = a;";
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
-                                           hasType(blockPointerType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
-                                           hasType(memberPointerType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
-                                           hasType(pointerType()))));
-  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
-                                        hasType(referenceType()))));
-  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
-                                        hasType(lValueReferenceType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
-                                           hasType(rValueReferenceType()))));
+  EXPECT_TRUE(notMatches(Fragment,
+                         varDecl(hasName("ref"), hasType(blockPointerType()))));
+  EXPECT_TRUE(notMatches(
+      Fragment, varDecl(hasName("ref"), hasType(memberPointerType()))));
+  EXPECT_TRUE(
+      notMatches(Fragment, varDecl(hasName("ref"), hasType(pointerType()))));
+  EXPECT_TRUE(
+      matches(Fragment, varDecl(hasName("ref"), hasType(referenceType()))));
+  EXPECT_TRUE(matches(Fragment,
+                      varDecl(hasName("ref"), hasType(lValueReferenceType()))));
+  EXPECT_TRUE(notMatches(
+      Fragment, varDecl(hasName("ref"), hasType(rValueReferenceType()))));
+}
 
-  Fragment = "int &&ref = 2;";
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
-                                           hasType(blockPointerType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
-                                           hasType(memberPointerType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
-                                           hasType(pointerType()))));
-  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
-                                        hasType(referenceType()))));
-  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
-                                           hasType(lValueReferenceType()))));
-  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
-                                        hasType(rValueReferenceType()))));
+TEST_P(ASTMatchersTest, PointerType_CXX11) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  StringRef Fragment = "int &&ref = 2;";
+  EXPECT_TRUE(notMatches(Fragment,
+                         varDecl(hasName("ref"), hasType(blockPointerType()))));
+  EXPECT_TRUE(notMatches(
+      Fragment, varDecl(hasName("ref"), hasType(memberPointerType()))));
+  EXPECT_TRUE(
+      notMatches(Fragment, varDecl(hasName("ref"), hasType(pointerType()))));
+  EXPECT_TRUE(
+      matches(Fragment, varDecl(hasName("ref"), hasType(referenceType()))));
+  EXPECT_TRUE(notMatches(
+      Fragment, varDecl(hasName("ref"), hasType(lValueReferenceType()))));
+  EXPECT_TRUE(matches(Fragment,
+                      varDecl(hasName("ref"), hasType(rValueReferenceType()))));
+}
+
+TEST_P(ASTMatchersTest, AutoRefTypes) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
   }
 
-TEST(TypeMatching, AutoRefTypes) {
   StringRef Fragment = "auto a = 1;"
                        "auto b = a;"
                        "auto &c = a;"
                        "auto &&d = c;"
                        "auto &&e = 2;";
   EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("a"),
                                            hasType(referenceType()))));
   EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("b"),
TEST_P(ASTMatchersTest, AutoRefTypes) {
   EXPECT_TRUE(matches(Fragment, varDecl(hasName("e"),
                                         hasType(referenceType()))));
   EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("e"),
                                            hasType(lValueReferenceType()))));
   EXPECT_TRUE(matches(Fragment, varDecl(hasName("e"),
                                         hasType(rValueReferenceType()))));
 }
 
-TEST(TypeMatching, MatchesEnumTypes) {
+TEST_P(ASTMatchersTest, EnumType) {
+  EXPECT_TRUE(
+      matches("enum Color { Green }; enum Color color;", loc(enumType())));
+}
+
+TEST_P(ASTMatchersTest, EnumType_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("enum Color { Green }; Color color;",
                       loc(enumType())));
+}
+
+TEST_P(ASTMatchersTest, EnumType_CXX11) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   EXPECT_TRUE(matches("enum class Color { Green }; Color color;",
                       loc(enumType())));
 }
 
-TEST(TypeMatching, MatchesPointersToConstTypes) {
+TEST_P(ASTMatchersTest, PointerType_MatchesPointersToConstTypes) {
   EXPECT_TRUE(matches("int b; int * const a = &b;",
                       loc(pointerType())));
   EXPECT_TRUE(matches("int b; int * const a = &b;",
                       loc(pointerType())));
   EXPECT_TRUE(matches(
     "int b; const int * a = &b;",
     loc(pointerType(pointee(builtinType())))));
   EXPECT_TRUE(matches(
     "int b; const int * a = &b;",
     pointerType(pointee(builtinType()))));
 }
 
-TEST(TypeMatching, MatchesTypedefTypes) {
+TEST_P(ASTMatchersTest, TypedefType) {
   EXPECT_TRUE(matches("typedef int X; X a;", varDecl(hasName("a"),
                                                      hasType(typedefType()))));
 }
 
-TEST(TypeMatching, MatchesTemplateSpecializationType) {
+TEST_P(ASTMatchersTest, TemplateSpecializationType) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("template <typename T> class A{}; A<int> a;",
                       templateSpecializationType()));
 }
 
-TEST(TypeMatching, MatchesDeucedTemplateSpecializationType) {
+TEST_P(ASTMatchersTest, DeducedTemplateSpecializationType) {
+  if (!GetParam().isCXX17OrLater()) {
+    return;
+  }
   EXPECT_TRUE(
       matches("template <typename T> class A{ public: A(T) {} }; A a(1);",
-              deducedTemplateSpecializationType(), langCxx17OrLater()));
+              deducedTemplateSpecializationType()));
 }
 
-TEST(TypeMatching, MatchesRecordType) {
-  EXPECT_TRUE(matches("class C{}; C c;", recordType()));
-  EXPECT_TRUE(matches("struct S{}; S s;",
+TEST_P(ASTMatchersTest, RecordType) {
+  EXPECT_TRUE(matches("struct S {}; struct S s;",
                       recordType(hasDeclaration(recordDecl(hasName("S"))))));
   EXPECT_TRUE(notMatches("int i;",
                          recordType(hasDeclaration(recordDecl(hasName("S"))))));
 }
 
-TEST(TypeMatching, MatchesElaboratedType) {
+TEST_P(ASTMatchersTest, RecordType_CXX) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(matches("class C {}; C c;", recordType()));
+  EXPECT_TRUE(matches("struct S {}; S s;",
+                      recordType(hasDeclaration(recordDecl(hasName("S"))))));
+}
+
+TEST_P(ASTMatchersTest, ElaboratedType) {
+  if (!GetParam().isCXX()) {
+    // FIXME: Add a test for `elaboratedType()` that does not depend on C++.
+    return;
+  }
   EXPECT_TRUE(matches(
     "namespace N {"
       "  namespace M {"
       "    class D {};"
       "  }"
       "}"
       "N::M::D d;", elaboratedType()));
   EXPECT_TRUE(matches("class C {} c;", elaboratedType()));
   EXPECT_TRUE(notMatches("class C {}; C c;", elaboratedType()));
 }
 
-TEST(TypeMatching, MatchesSubstTemplateTypeParmType) {
+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()))))));
 }
 
-TEST(NNS, MatchesNestedNameSpecifiers) {
+TEST_P(ASTMatchersTest, NestedNameSpecifier) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;",
                       nestedNameSpecifier()));
   EXPECT_TRUE(matches("template <typename T> class A { typename T::B b; };",
                       nestedNameSpecifier()));
   EXPECT_TRUE(matches("struct A { void f(); }; void A::f() {}",
                       nestedNameSpecifier()));
   EXPECT_TRUE(matches("namespace a { namespace b {} } namespace ab = a::b;",
                       nestedNameSpecifier()));
 
   EXPECT_TRUE(matches(
     "struct A { static void f() {} }; void g() { A::f(); }",
     nestedNameSpecifier()));
   EXPECT_TRUE(notMatches(
     "struct A { static void f() {} }; void g(A* a) { a->f(); }",
     nestedNameSpecifier()));
 }
 
-TEST(NullStatement, SimpleCases) {
+TEST_P(ASTMatchersTest, NullStmt) {
   EXPECT_TRUE(matches("void f() {int i;;}", nullStmt()));
   EXPECT_TRUE(notMatches("void f() {int i;}", nullStmt()));
 }
 
-TEST(NS, Alias) {
+TEST_P(ASTMatchersTest, NamespaceAliasDecl) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches("namespace test {} namespace alias = ::test;",
                       namespaceAliasDecl(hasName("alias"))));
 }
 
-TEST(NNS, MatchesTypes) {
+TEST_P(ASTMatchersTest, NestedNameSpecifier_MatchesTypes) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   NestedNameSpecifierMatcher Matcher = nestedNameSpecifier(
     specifiesType(hasDeclaration(recordDecl(hasName("A")))));
   EXPECT_TRUE(matches("struct A { struct B {}; }; A::B b;", Matcher));
   EXPECT_TRUE(matches("struct A { struct B { struct C {}; }; }; A::B::C c;",
                       Matcher));
   EXPECT_TRUE(notMatches("namespace A { struct B {}; } A::B b;", Matcher));
 }
 
-TEST(NNS, MatchesNamespaceDecls) {
+TEST_P(ASTMatchersTest, NestedNameSpecifier_MatchesNamespaceDecls) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   NestedNameSpecifierMatcher Matcher = nestedNameSpecifier(
     specifiesNamespace(hasName("ns")));
   EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;", Matcher));
   EXPECT_TRUE(notMatches("namespace xx { struct A {}; } xx::A a;", Matcher));
   EXPECT_TRUE(notMatches("struct ns { struct A {}; }; ns::A a;", Matcher));
 }
 
-TEST(NNS, MatchesNestedNameSpecifierPrefixes) {
+TEST_P(ASTMatchersTest,
+       NestedNameSpecifier_MatchesNestedNameSpecifierPrefixes) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matches(
     "struct A { struct B { struct C {}; }; }; A::B::C c;",
     nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A"))))));
   EXPECT_TRUE(matches(
     "struct A { struct B { struct C {}; }; }; A::B::C c;",
     nestedNameSpecifierLoc(hasPrefix(
       specifiesTypeLoc(loc(qualType(asString("struct A"))))))));
   EXPECT_TRUE(matches(
     "namespace N { struct A { struct B { struct C {}; }; }; } N::A::B::C c;",
     nestedNameSpecifierLoc(hasPrefix(
       specifiesTypeLoc(loc(qualType(asString("struct N::A"))))))));
 }
 
-
 template <typename T>
 class VerifyAncestorHasChildIsEqual : public BoundNodesCallback {
 public:
   bool run(const BoundNodes *Nodes) override { return false; }
 
   bool run(const BoundNodes *Nodes, ASTContext *Context) override {
     const T *Node = Nodes->getNodeAs<T>("");
     return verify(*Nodes, *Context, Node);
bool verify(const BoundNodes &Nodes, ASTContext &Context, const Type *Node) {
     const auto *Dec = Nodes.getNodeAs<FieldDecl>("decl");
     return selectFirst<T>(
       "", match(fieldDecl(hasParent(decl(has(fieldDecl(
         hasType(type(equalsNode(TypedNode)).bind(""))))))),
                 *Dec, Context)) != nullptr;
   }
 };
 
-TEST(IsEqualTo, MatchesNodesByIdentity) {
+TEST_P(ASTMatchersTest, IsEqualTo_MatchesNodesByIdentity) {
+  EXPECT_TRUE(matchAndVerifyResultTrue(
+      "void f() { if (1) if(1) {} }", ifStmt().bind(""),
+      std::make_unique<VerifyAncestorHasChildIsEqual<IfStmt>>()));
+}
+
+TEST_P(ASTMatchersTest, IsEqualTo_MatchesNodesByIdentity_Cxx) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { class Y {}; };", recordDecl(hasName("::X::Y")).bind(""),
       std::make_unique<VerifyAncestorHasChildIsEqual<CXXRecordDecl>>()));
   EXPECT_TRUE(matchAndVerifyResultTrue(
-    "void f() { if (true) if(true) {} }", ifStmt().bind(""),
-    std::make_unique<VerifyAncestorHasChildIsEqual<IfStmt>>()));
-  EXPECT_TRUE(matchAndVerifyResultTrue(
       "class X { class Y {} y; };",
       fieldDecl(hasName("y"), hasType(type().bind(""))).bind("decl"),
       std::make_unique<VerifyAncestorHasChildIsEqual<Type>>()));
 }
 
-TEST(TypedefDeclMatcher, Match) {
+TEST_P(ASTMatchersTest, TypedefDecl) {
   EXPECT_TRUE(matches("typedef int typedefDeclTest;",
                       typedefDecl(hasName("typedefDeclTest"))));
-  EXPECT_TRUE(notMatches("using typedefDeclTest2 = int;",
-                         typedefDecl(hasName("typedefDeclTest2"))));
 }
 
-TEST(TypeAliasDeclMatcher, Match) {
-  EXPECT_TRUE(matches("using typeAliasTest2 = int;",
-                      typeAliasDecl(hasName("typeAliasTest2"))));
+TEST_P(ASTMatchersTest, TypedefDecl_Cxx) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(notMatches("using typedefDeclTest = int;",
+                         typedefDecl(hasName("typedefDeclTest"))));
+}
+
+TEST_P(ASTMatchersTest, TypeAliasDecl) {
   EXPECT_TRUE(notMatches("typedef int typeAliasTest;",
                          typeAliasDecl(hasName("typeAliasTest"))));
 }
 
-TEST(TypedefNameDeclMatcher, Match) {
+TEST_P(ASTMatchersTest, TypeAliasDecl_CXX) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(matches("using typeAliasTest = int;",
+                      typeAliasDecl(hasName("typeAliasTest"))));
+}
+
+TEST_P(ASTMatchersTest, TypedefNameDecl) {
   EXPECT_TRUE(matches("typedef int typedefNameDeclTest1;",
                       typedefNameDecl(hasName("typedefNameDeclTest1"))));
-  EXPECT_TRUE(matches("using typedefNameDeclTest2 = int;",
-                      typedefNameDecl(hasName("typedefNameDeclTest2"))));
 }
 
-TEST(TypeAliasTemplateDeclMatcher, Match) {
+TEST_P(ASTMatchersTest, TypedefNameDecl_CXX) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(matches("using typedefNameDeclTest = int;",
+                      typedefNameDecl(hasName("typedefNameDeclTest"))));
+}
+
+TEST_P(ASTMatchersTest, TypeAliasTemplateDecl) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   StringRef Code = R"(
     template <typename T>
     class X { T t; };
 
     template <typename T>
     using typeAliasTemplateDecl = X<T>;
 
     using typeAliasDecl = X<int>;
   )";
   EXPECT_TRUE(
       matches(Code, typeAliasTemplateDecl(hasName("typeAliasTemplateDecl"))));
   EXPECT_TRUE(
       notMatches(Code, typeAliasTemplateDecl(hasName("typeAliasDecl"))));
 }
 
-TEST(ObjCMessageExprMatcher, SimpleExprs) {
-  // don't find ObjCMessageExpr where none are present
+TEST(ASTMatchersTestObjC, ObjCMessageExpr) {
+  // Don't find ObjCMessageExpr where none are present.
   EXPECT_TRUE(notMatchesObjC("", objcMessageExpr(anything())));
 
   StringRef Objc1String = "@interface Str "
                           " - (Str *)uppercaseString;"
                           "@end "
                           "@interface foo "
                           "- (void)contents;"
                           "- (void)meth:(Str *)text;"
EXPECT_TRUE(matchesObjC(
     objcMessageExpr(hasSelector("contents"), numSelectorArgs(0))));
   EXPECT_TRUE(matchesObjC(
     Objc1String,
     objcMessageExpr(matchesSelector("uppercase*"),
                     argumentCountIs(0)
     )));
 }
 
-TEST(ObjCDeclMatcher, CoreDecls) {
+TEST(ASTMatchersTestObjC, ObjCDecls) {
   StringRef ObjCString = "@protocol Proto "
                          "- (void)protoDidThing; "
                          "@end "
                          "@interface Thing "
                          "@property int enabled; "
                          "@end "
                          "@interface Thing (ABC) "
                          "- (void)abc_doThing; "
TEST(ASTMatchersTestObjC, ObjCDecls) {
   EXPECT_TRUE(matchesObjC(
     ObjCString,
     objcIvarDecl(hasName("_ivar"))));
   EXPECT_TRUE(matchesObjC(
     ObjCString,
     objcPropertyDecl(hasName("enabled"))));
 }
 
-TEST(ObjCStmtMatcher, ExceptionStmts) {
+TEST(ASTMatchersTestObjC, ObjCExceptionStmts) {
   StringRef ObjCString = "void f(id obj) {"
                          "  @try {"
                          "    @throw obj;"
                          "  } @catch (...) {"
                          "  } @finally {}"
                          "}";
 
   EXPECT_TRUE(matchesObjC(
     ObjCString,
     objcTryStmt()));
   EXPECT_TRUE(matchesObjC(
     ObjCString,
     objcThrowStmt()));
   EXPECT_TRUE(matchesObjC(
     ObjCString,
     objcCatchStmt()));
   EXPECT_TRUE(matchesObjC(
     ObjCString,
     objcFinallyStmt()));
 }
 
-TEST(ObjCAutoreleaseMatcher, AutoreleasePool) {
+TEST(ASTMatchersTestObjC, ObjCAutoreleasePoolStmt) {
   StringRef ObjCString = "void f() {"
                          "@autoreleasepool {"
                          "  int x = 1;"
                          "}"
                          "}";
   EXPECT_TRUE(matchesObjC(ObjCString, autoreleasePoolStmt()));
   StringRef ObjCStringNoPool = "void f() { int x = 1; }";
   EXPECT_FALSE(matchesObjC(ObjCStringNoPool, autoreleasePoolStmt()));
 }
 
-TEST(OMPExecutableDirective, Matches) {
+TEST(ASTMatchersTestOpenMP, OMPExecutableDirective) {
   auto Matcher = stmt(ompExecutableDirective());
 
   StringRef Source0 = R"(
 void x() {
 #pragma omp parallel
 ;
 })";
   EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher));
 
   StringRef Source1 = R"(
 void x() {
 #pragma omp taskyield
 ;
 })";
   EXPECT_TRUE(matchesWithOpenMP(Source1, Matcher));
 
   StringRef Source2 = R"(
 void x() {
 ;
 })";
   EXPECT_TRUE(notMatchesWithOpenMP(Source2, Matcher));
 }
 
-TEST(OMPDefaultClause, Matches) {
+TEST(ASTMatchersTestOpenMP, OMPDefaultClause) {
   auto Matcher = ompExecutableDirective(hasAnyClause(ompDefaultClause()));
 
   StringRef Source0 = R"(
 void x() {
 ;
 })";
   EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher));
 
;
   StringRef Source4 = R"(
 void x(int x) {
 #pragma omp parallel num_threads(x)
 ;
 })";
   EXPECT_TRUE(notMatchesWithOpenMP(Source4, Matcher));
 }
 
-TEST(MatchFinderAPI, matchesDynamic) {
+TEST(ASTMatchersTest, Finder_DynamicOnlyAcceptsSomeMatchers) {
+  MatchFinder Finder;
+  EXPECT_TRUE(Finder.addDynamicMatcher(decl(), nullptr));
+  EXPECT_TRUE(Finder.addDynamicMatcher(callExpr(), nullptr));
+  EXPECT_TRUE(
+      Finder.addDynamicMatcher(constantArrayType(hasSize(42)), nullptr));
 
+  // Do not accept non-toplevel matchers.
+  EXPECT_FALSE(Finder.addDynamicMatcher(isMain(), nullptr));
+  EXPECT_FALSE(Finder.addDynamicMatcher(hasName("x"), nullptr));
+}
+
+TEST(MatchFinderAPI, MatchesDynamic) {
   StringRef SourceCode = "struct A { void f() {} };";
   auto Matcher = functionDecl(isDefinition()).bind("method");
 
   auto astUnit = tooling::buildASTFromCode(SourceCode);
 
   auto GlobalBoundNodes = matchDynamic(Matcher, astUnit->getASTContext());
 
   EXPECT_EQ(GlobalBoundNodes.size(), 1u);
   EXPECT_EQ(GlobalBoundNodes[0].getMap().size(), 1u);
 
   auto GlobalMethodNode = GlobalBoundNodes[0].getNodeAs<FunctionDecl>("method");
   EXPECT_TRUE(GlobalMethodNode != nullptr);
 
   auto MethodBoundNodes =
       matchDynamic(Matcher, *GlobalMethodNode, astUnit->getASTContext());
   EXPECT_EQ(MethodBoundNodes.size(), 1u);
   EXPECT_EQ(MethodBoundNodes[0].getMap().size(), 1u);
 
   auto MethodNode = MethodBoundNodes[0].getNodeAs<FunctionDecl>("method");
   EXPECT_EQ(MethodNode, GlobalMethodNode);
 }
 
+static std::vector<TestClangConfig> allTestClangConfigs() {
+  std::vector<TestClangConfig> all_configs;
+  for (TestLanguage lang : {Lang_C89, Lang_C99, Lang_CXX03, Lang_CXX11,
+                            Lang_CXX14, Lang_CXX17, Lang_CXX20}) {
+    TestClangConfig config;
+    config.Language = lang;
+
+    // Use an unknown-unknown triple so we don't instantiate the full system
+    // toolchain.  On Linux, instantiating the toolchain involves stat'ing
+    // large portions of /usr/lib, and this slows down not only this test, but
+    // all other tests, via contention in the kernel.
+    //
+    // FIXME: This is a hack to work around the fact that there's no way to do
+    // the equivalent of runToolOnCodeWithArgs without instantiating a full
+    // Driver.  We should consider having a function, at least for tests, that
+    // invokes cc1.
+    config.Target = "i386-unknown-unknown";
+    all_configs.push_back(config);
+
+    // Windows target is interesting to test because it enables
+    // `-fdelayed-template-parsing`.
+    config.Target = "x86_64-pc-win32-msvc";
+    all_configs.push_back(config);
+  }
+  return all_configs;
+}
+
+INSTANTIATE_TEST_CASE_P(ASTMatchersTests, ASTMatchersTest,
+                        testing::ValuesIn(allTestClangConfigs()), );
+
 } // namespace ast_matchers
 } // namespace clang

clang/unittests/ASTMatchers/ASTMatchersTest.h

 //===- unittest/Tooling/ASTMatchersTest.h - Matcher tests helpers ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_UNITTESTS_ASTMATCHERS_ASTMATCHERSTEST_H
 #define LLVM_CLANG_UNITTESTS_ASTMATCHERS_ASTMATCHERSTEST_H
 
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Testing/CommandLineArgs.h"
+#include "clang/Testing/TestClangConfig.h"
 #include "clang/Tooling/Tooling.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace ast_matchers {
 
 using clang::tooling::buildASTFromCodeWithArgs;
 using clang::tooling::newFrontendActionFactory;
testing::AssertionResult matchesConditionally(
   MatchFinder Finder;
   VerifyMatch VerifyFound(nullptr, &Found);
   Finder.addMatcher(AMatcher, &VerifyFound);
   VerifyMatch VerifyDynamicFound(nullptr, &DynamicFound);
   if (!Finder.addDynamicMatcher(AMatcher, &VerifyDynamicFound))
     return testing::AssertionFailure() << "Could not add dynamic matcher";
   std::unique_ptr<FrontendActionFactory> Factory(
       newFrontendActionFactory(&Finder));
-  // Some tests need rtti/exceptions on.  Use an unknown-unknown triple so we
-  // don't instantiate the full system toolchain.  On Linux, instantiating the
-  // toolchain involves stat'ing large portions of /usr/lib, and this slows down
-  // not only this test, but all other tests, via contention in the kernel.
+  std::vector<std::string> Args = {
+      // Some tests need rtti/exceptions on.
+      "-frtti", "-fexceptions",
+      // Ensure that tests specify the C++ standard version that they need.
+      "-Werror=c++14-extensions", "-Werror=c++17-extensions",
+      "-Werror=c++20-extensions"};
+  // Append additional arguments at the end to allow overriding the default
+  // choices that we made above.
+  llvm::copy(CompileArgs, std::back_inserter(Args));
+  if (llvm::find(Args, "-target") == Args.end()) {
+    // Use an unknown-unknown triple so we don't instantiate the full system
+    // toolchain.  On Linux, instantiating the toolchain involves stat'ing
+    // large portions of /usr/lib, and this slows down not only this test, but
+    // all other tests, via contention in the kernel.
     //
-  // FIXME: This is a hack to work around the fact that there's no way to do the
-  // equivalent of runToolOnCodeWithArgs without instantiating a full Driver.
-  // We should consider having a function, at least for tests, that invokes cc1.
-  std::vector<std::string> Args(CompileArgs.begin(), CompileArgs.end());
-  Args.insert(Args.end(), {"-frtti", "-fexceptions",
-                           "-target", "i386-unknown-unknown"});
+    // FIXME: This is a hack to work around the fact that there's no way to do
+    // the equivalent of runToolOnCodeWithArgs without instantiating a full
+    // Driver.  We should consider having a function, at least for tests, that
+    // invokes cc1.
+    Args.push_back("-target");
+    Args.push_back("i386-unknown-unknown");
+  }
+
   if (!runToolOnCodeWithArgs(
           Factory->create(), Code, Args, Filename, "clang-tool",
           std::make_shared<PCHContainerOperations>(), VirtualMappedFiles)) {
     return testing::AssertionFailure() << "Parsing error in \"" << Code << "\"";
   }
   if (Found != DynamicFound) {
     return testing::AssertionFailure() << "Dynamic match result ("
                                        << DynamicFound
testing::AssertionResult matchesConditionally(
   return testing::AssertionSuccess();
 }
 
 template <typename T>
 testing::AssertionResult
 matchesConditionally(const Twine &Code, const T &AMatcher, bool ExpectMatch,
                      ArrayRef<TestLanguage> TestLanguages) {
   for (auto Lang : TestLanguages) {
-    std::vector<std::string> Args = getCommandLineArgsForTesting(Lang);
-    Args.insert(Args.end(),
-                {"-Werror=c++14-extensions", "-Werror=c++17-extensions",
-                 "-Werror=c++20-extensions"});
-    auto Result = matchesConditionally(Code, AMatcher, ExpectMatch, Args,
-                                       FileContentMappings(),
-                                       getFilenameForTesting(Lang));
+    auto Result = matchesConditionally(
+        Code, AMatcher, ExpectMatch, getCommandLineArgsForTesting(Lang),
+        FileContentMappings(), getFilenameForTesting(Lang));
     if (!Result)
       return Result;
   }
 
   return testing::AssertionSuccess();
 }
 
 template <typename T>

 
 template <typename T>
 testing::AssertionResult matchesC(const Twine &Code, const T &AMatcher) {
   return matchesConditionally(Code, AMatcher, true, {}, FileContentMappings(),
                               "input.c");
 }
 
 template <typename T>
-testing::AssertionResult matchesC99(const Twine &Code, const T &AMatcher) {
-  return matchesConditionally(Code, AMatcher, true, {Lang_C99});
-}
-
-template <typename T>
 testing::AssertionResult notMatchesC(const Twine &Code, const T &AMatcher) {
   return matchesConditionally(Code, AMatcher, false, {Lang_C89});
 }
 
 template <typename T>
 testing::AssertionResult notMatchesObjC(const Twine &Code, const T &AMatcher) {
   return matchesObjC(Code, AMatcher, false);
 }

 private:
   const std::string Id;
   const int ExpectedCount;
   int Count;
   const std::string ExpectedName;
   std::string Name;
 };
 
+class ASTMatchersTest : public ::testing::Test,
+                        public ::testing::WithParamInterface<TestClangConfig> {
+protected:
+  template <typename T>
+  testing::AssertionResult matches(const Twine &Code, const T &AMatcher) {
+    const TestClangConfig &TestConfig = GetParam();
+    return clang::ast_matchers::matchesConditionally(
+        Code, AMatcher, /*ExpectMatch=*/true, TestConfig.getCommandLineArgs(),
+        FileContentMappings(), getFilenameForTesting(TestConfig.Language));
+  }
+
+  template <typename T>
+  testing::AssertionResult notMatches(const Twine &Code, const T &AMatcher) {
+    const TestClangConfig &TestConfig = GetParam();
+    return clang::ast_matchers::matchesConditionally(
+        Code, AMatcher, /*ExpectMatch=*/false, TestConfig.getCommandLineArgs(),
+        FileContentMappings(), getFilenameForTesting(TestConfig.Language));
+  }
+};
+
 } // namespace ast_matchers
 } // namespace clang
 
 #endif  // LLVM_CLANG_UNITTESTS_AST_MATCHERS_AST_MATCHERS_TEST_H

clang/unittests/Tooling/Syntax/TreeTest.cpp

 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Testing/CommandLineArgs.h"
+#include "clang/Testing/TestClangConfig.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Syntax/BuildTree.h"
 #include "clang/Tooling/Syntax/Mutations.h"
 #include "clang/Tooling/Syntax/Nodes.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
static llvm::ArrayRef<syntax::Token> tokens(syntax::Node *N) {
   assert(N->isOriginal() && "tokens of modified nodes are not well-defined");
   if (auto *L = dyn_cast<syntax::Leaf>(N))
     return llvm::makeArrayRef(L->token(), 1);
   auto *T = cast<syntax::Tree>(N);
   return llvm::makeArrayRef(T->firstLeaf()->token(),
                             T->lastLeaf()->token() + 1);
 }
 
-struct TestClangConfig {
-  TestLanguage Language;
-  std::string Target;
-
-  bool isC99OrLater() const { return Language == Lang_C99; }
-
-  bool isC() const { return Language == Lang_C89 || Language == Lang_C99; }
-
-  bool isCXX() const {
-    return Language == Lang_CXX03 || Language == Lang_CXX11 ||
-           Language == Lang_CXX14 || Language == Lang_CXX17 ||
-           Language == Lang_CXX20;
-  }
-
-  bool isCXX11OrLater() const {
-    return Language == Lang_CXX11 || Language == Lang_CXX14 ||
-           Language == Lang_CXX17 || Language == Lang_CXX20;
-  }
-
-  bool isCXX14OrLater() const {
-    return Language == Lang_CXX14 || Language == Lang_CXX17 ||
-           Language == Lang_CXX20;
-  }
-
-  bool isCXX17OrLater() const {
-    return Language == Lang_CXX17 || Language == Lang_CXX20;
-  }
-
-  bool supportsCXXDynamicExceptionSpecification() const {
-    return Language == Lang_CXX03 || Language == Lang_CXX11 ||
-           Language == Lang_CXX14;
-  }
-
-  bool hasDelayedTemplateParsing() const {
-    return Target == "x86_64-pc-win32-msvc";
-  }
-
-  std::vector<std::string> getCommandLineArgs() const {
-    std::vector<std::string> Result = getCommandLineArgsForTesting(Language);
-    Result.push_back("-target");
-    Result.push_back(Target);
-    return Result;
-  }
-
-  std::string toString() const {
-    std::string Result;
-    llvm::raw_string_ostream OS(Result);
-    OS << "{ Language=" << Language << ", Target=" << Target << " }";
-    return OS.str();
-  }
-
-  friend std::ostream &operator<<(std::ostream &OS,
-                                  const TestClangConfig &ClangConfig) {
-    return OS << ClangConfig.toString();
-  }
-
-  static std::vector<TestClangConfig> &allConfigs() {
-    static std::vector<TestClangConfig> all_configs = []() {
-      std::vector<TestClangConfig> all_configs;
-      for (TestLanguage lang : {Lang_C89, Lang_C99, Lang_CXX03, Lang_CXX11,
-                                Lang_CXX14, Lang_CXX17, Lang_CXX20}) {
-        TestClangConfig config;
-        config.Language = lang;
-        config.Target = "x86_64-pc-linux-gnu";
-        all_configs.push_back(config);
-
-        // Windows target is interesting to test because it enables
-        // `-fdelayed-template-parsing`.
-        config.Target = "x86_64-pc-win32-msvc";
-        all_configs.push_back(config);
-      }
-      return all_configs;
-    }();
-    return all_configs;
-  }
-};
-
 class SyntaxTreeTest : public ::testing::Test,
                        public ::testing::WithParamInterface<TestClangConfig> {
 protected:
   // Build a syntax tree for the code.
   syntax::TranslationUnit *buildTree(llvm::StringRef Code,
                                      const TestClangConfig &ClangConfig) {
     // FIXME: this code is almost the identical to the one in TokensTest. Share
     //        it.
TEST_P(SyntaxTreeTest, SynthesizedNodes) {
 
   auto *S = syntax::createEmptyStatement(*Arena);
   ASSERT_NE(S, nullptr);
   EXPECT_TRUE(S->canModify());
   EXPECT_FALSE(S->isOriginal());
   EXPECT_TRUE(S->isDetached());
 }
 
+static std::vector<TestClangConfig> allTestClangConfigs() {
+  std::vector<TestClangConfig> all_configs;
+  for (TestLanguage lang : {Lang_C89, Lang_C99, Lang_CXX03, Lang_CXX11,
+                            Lang_CXX14, Lang_CXX17, Lang_CXX20}) {
+    TestClangConfig config;
+    config.Language = lang;
+    config.Target = "x86_64-pc-linux-gnu";
+    all_configs.push_back(config);
+
+    // Windows target is interesting to test because it enables
+    // `-fdelayed-template-parsing`.
+    config.Target = "x86_64-pc-win32-msvc";
+    all_configs.push_back(config);
+  }
+  return all_configs;
+}
+
 INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, SyntaxTreeTest,
-                        testing::ValuesIn(TestClangConfig::allConfigs()), );
+                        testing::ValuesIn(allTestClangConfigs()), );
 
 } // namespace