Run syntax tree tests in many language modes

[gribozavr]

Rebased the patch on top of the current master.

[hlopko]

LGTM, thanks!

[eduucaldas]

clang/unittests/Tooling/Syntax/TreeTest.cpp

54–63

These could be on the clang/Testing

181

Note: This already adds -fsyntax-only as a flag

205–206

is RunWithDelayedTemplateParsing being used?

[gribozavr2]

clang/unittests/Tooling/Syntax/TreeTest.cpp

54–63

I agree, but I'll move this type in a future change, when I will be unifying the infrastructure with the one that we have in other tests. I'm afraid of moving it right now because I'm not sure it is the right abstraction.

181

It is not clear we can rely on that -- it seems like an implementation detail of createInvocationFromCommandLine that the TODO suggests should be changed.

205–206

Indeed not -- removed!

[gribozavr]

Updated according to the code review.

clang/unittests/Tooling/Syntax/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(SyntaxTests
   TreeTest.cpp
   TokensTest.cpp
 )
 
 clang_target_link_libraries(SyntaxTests
   PRIVATE
   clangAST
   clangBasic
   clangFrontend
   clangLex
   clangSerialization
+  clangTesting
   clangTooling
   clangToolingCore
   clangToolingSyntax
   )
 
 target_link_libraries(SyntaxTests
   PRIVATE
   LLVMTestingSupport
 )

clang/unittests/Tooling/Syntax/TreeTest.cpp

 #include "clang/AST/Stmt.h"
 #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/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"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdlib>
 
 using namespace clang;
 
 namespace {
 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);
 }
 
-class SyntaxTreeTest : public ::testing::Test {
+struct TestClangConfig {
+  TestLanguage Language;
+  std::string Target;
+
+  bool isCXX() const {
+    return Language == Lang_CXX || Language == Lang_CXX11 ||
+           Language == Lang_CXX14 || Language == Lang_CXX17 ||
+           Language == Lang_CXX2a;
+  }
+
+  bool isCXX11OrLater() const {
+    return Language == Lang_CXX11 || Language == Lang_CXX14 ||
+           Language == Lang_CXX17 || Language == Lang_CXX2a;
+  }
+
+  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_C, Lang_C89, Lang_CXX, Lang_CXX11,
+                                Lang_CXX14, Lang_CXX17, Lang_CXX2a}) {
+        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 std::string &Target = "x86_64-pc-linux-gnu") {
+  syntax::TranslationUnit *buildTree(llvm::StringRef Code,
+                                     const TestClangConfig &ClangConfig) {
     // FIXME: this code is almost the identical to the one in TokensTest. Share
     //        it.
     class BuildSyntaxTree : public ASTConsumer {
     public:
       BuildSyntaxTree(syntax::TranslationUnit *&Root,
                       std::unique_ptr<syntax::Arena> &Arena,
                       std::unique_ptr<syntax::TokenCollector> Tokens)
           : Root(Root), Arena(Arena), Tokens(std::move(Tokens)) {
syntax::TranslationUnit *buildTree(llvm::StringRef Code,
     FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy(""));
 
     if (!Diags->getClient())
       Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), DiagOpts.get()));
     Diags->setSeverityForGroup(diag::Flavor::WarningOrError, "unused-value",
                                diag::Severity::Ignored, SourceLocation());
 
     // Prepare to run a compiler.
-    std::vector<const char *> Args = {
-        "syntax-test", "-target",       Target.c_str(),
-        FileName,      "-fsyntax-only", "-std=c++17",
+    std::vector<std::string> Args = {
+        "syntax-test",
+        "-fsyntax-only",
     };
-    Invocation = createInvocationFromCommandLine(Args, Diags, FS);
+    llvm::copy(ClangConfig.getCommandLineArgs(), std::back_inserter(Args));
+    Args.push_back(FileName);
+
+    std::vector<const char *> ArgsCStr;
+    for (const std::string &arg : Args) {
+      ArgsCStr.push_back(arg.c_str());
+    }
+
+    Invocation = createInvocationFromCommandLine(ArgsCStr, Diags, FS);
     assert(Invocation);
     Invocation->getFrontendOpts().DisableFree = false;
     Invocation->getPreprocessorOpts().addRemappedFile(
         FileName, llvm::MemoryBuffer::getMemBufferCopy(Code).release());
     CompilerInstance Compiler;
     Compiler.setInvocation(Invocation);
     Compiler.setDiagnostics(Diags.get());
     Compiler.setFileManager(FileMgr.get());
     Compiler.setSourceManager(SourceMgr.get());
 
     syntax::TranslationUnit *Root = nullptr;
     BuildSyntaxTreeAction Recorder(Root, this->Arena);
 
     // Action could not be executed but the frontend didn't identify any errors
     // in the code ==> problem in setting up the action.
     if (!Compiler.ExecuteAction(Recorder) &&
         Diags->getClient()->getNumErrors() == 0) {
       ADD_FAILURE() << "failed to run the frontend";
       std::abort();
     }
     return Root;
   }
 
-  void expectTreeDumpEqual(StringRef Code, StringRef Tree,
-                           bool RunWithDelayedTemplateParsing = true) {
+  void expectTreeDumpEqual(StringRef Code, StringRef Tree) {
+    SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
     SCOPED_TRACE(Code);
 
-    std::string Expected = Tree.trim().str();
-
-    // We want to run the test with -fdelayed-template-parsing enabled and
-    // disabled, therefore we use these representative targets that differ in
-    // the default value.
-    // We are not passing -fdelayed-template-parsing directly but we are using
-    // the `-target` to improve coverage and discover differences in behavior
-    // early.
-    for (const std::string Target :
-         {"x86_64-pc-linux-gnu", "x86_64-pc-win32-msvc"}) {
-      if (!RunWithDelayedTemplateParsing &&
-          Target == "x86_64-pc-win32-msvc") {
-        continue;
-      }
-      auto *Root = buildTree(Code, Target);
-      EXPECT_EQ(Diags->getClient()->getNumErrors(), 0u)
-          << "Source file has syntax errors, they were printed to the test log";
-      std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim());
-      EXPECT_EQ(Expected, Actual)
-          << "for target " << Target << " the resulting dump is:\n"
-          << Actual;
-    }
+    auto *Root = buildTree(Code, GetParam());
+    EXPECT_EQ(Tree.trim().str(), Actual);
   }
 
   // Adds a file to the test VFS.
   void addFile(llvm::StringRef Path, llvm::StringRef Contents) {
     if (!FS->addFile(Path, time_t(),
                      llvm::MemoryBuffer::getMemBufferCopy(Contents))) {
       ADD_FAILURE() << "could not add a file to VFS: " << Path;
     }
llvm::IntrusiveRefCntPtr<FileManager> FileMgr =
       new FileManager(FileSystemOptions(), FS);
   llvm::IntrusiveRefCntPtr<SourceManager> SourceMgr =
       new SourceManager(*Diags, *FileMgr);
   std::shared_ptr<CompilerInvocation> Invocation;
   // Set after calling buildTree().
   std::unique_ptr<syntax::Arena> Arena;
 };
 
-TEST_F(SyntaxTreeTest, Simple) {
+TEST_P(SyntaxTreeTest, Simple) {
   expectTreeDumpEqual(
       R"cpp(
 int main() {}
 void foo() {}
     )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
`-SimpleDeclaration
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, SimpleVariable) {
+TEST_P(SyntaxTreeTest, SimpleVariable) {
   expectTreeDumpEqual(
       R"cpp(
 int a;
 int b = 42;
     )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | `-a
 | `-;
 `-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-b
   | |-=
   | `-UnknownExpression
   |   `-42
   `-;
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, SimpleFunction) {
+TEST_P(SyntaxTreeTest, SimpleFunction) {
   expectTreeDumpEqual(
       R"cpp(
 void foo(int a, int b) {}
     )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
`-SimpleDeclaration
   |   |   `-b
   |   `-)
   `-CompoundStatement
     |-{
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, If) {
+TEST_P(SyntaxTreeTest, If) {
   expectTreeDumpEqual(
       R"cpp(
 int main() {
-  if (true) {}
-  if (true) {} else if (false) {}
+  if (1) {}
+  if (1) {} else if (0) {}
 }
         )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-main
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     |-IfStatement
     | |-if
     | |-(
     | |-UnknownExpression
-    | | `-true
+    | | `-1
     | |-)
     | `-CompoundStatement
     |   |-{
     |   `-}
     |-IfStatement
     | |-if
     | |-(
     | |-UnknownExpression
-    | | `-true
+    | | `-1
     | |-)
     | |-CompoundStatement
     | | |-{
     | | `-}
     | |-else
     | `-IfStatement
     |   |-if
     |   |-(
     |   |-UnknownExpression
-    |   | `-false
+    |   | `-0
     |   |-)
     |   `-CompoundStatement
     |     |-{
     |     `-}
     `-}
         )txt");
 }
 
-TEST_F(SyntaxTreeTest, For) {
+TEST_P(SyntaxTreeTest, For) {
   expectTreeDumpEqual(
       R"cpp(
 void test() {
   for (;;)  {}
 }
 )cpp",
       R"txt(
 *: TranslationUnit
`-CompoundStatement
     | |-)
     | `-CompoundStatement
     |   |-{
     |   `-}
     `-}
         )txt");
 }
 
-TEST_F(SyntaxTreeTest, RangeBasedFor) {
+TEST_P(SyntaxTreeTest, RangeBasedFor) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 void test() {
   int a[3];
-  for (int x : a) ;
+  for (int x : a)
+    ;
 }
       )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
`-CompoundStatement
     | | `-a
     | |-)
     | `-EmptyStatement
     |   `-;
     `-}
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, DeclarationStatement) {
+TEST_P(SyntaxTreeTest, DeclarationStatement) {
   expectTreeDumpEqual("void test() { int a = 10; }",
                       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
`-CompoundStatement
     | |   |-=
     | |   `-UnknownExpression
     | |     `-10
     | `-;
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, Switch) {
+TEST_P(SyntaxTreeTest, Switch) {
   expectTreeDumpEqual(
       R"cpp(
 void test() {
-  switch (true) {
+  switch (1) {
     case 0:
     default:;
   }
 }
 )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     |-SwitchStatement
     | |-switch
     | |-(
     | |-UnknownExpression
-    | | `-true
+    | | `-1
     | |-)
     | `-CompoundStatement
     |   |-{
     |   |-CaseStatement
     |   | |-case
     |   | |-UnknownExpression
     |   | | `-0
     |   | |-:
     |   | `-DefaultStatement
     |   |   |-default
     |   |   |-:
     |   |   `-EmptyStatement
     |   |     `-;
     |   `-}
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, While) {
+TEST_P(SyntaxTreeTest, While) {
   expectTreeDumpEqual(
       R"cpp(
 void test() {
-  while (true) { continue; break; }
+  while (1) { continue; break; }
 }
 )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     |-WhileStatement
     | |-while
     | |-(
     | |-UnknownExpression
-    | | `-true
+    | | `-1
     | |-)
     | `-CompoundStatement
     |   |-{
     |   |-ContinueStatement
     |   | |-continue
     |   | `-;
     |   |-BreakStatement
     |   | |-break
     |   | `-;
     |   `-}
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, UnhandledStatement) {
+TEST_P(SyntaxTreeTest, UnhandledStatement) {
   // Unhandled statements should end up as 'unknown statement'.
   // This example uses a 'label statement', which does not yet have a syntax
   // counterpart.
   expectTreeDumpEqual("int main() { foo: return 100; }",
                       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-int
`-CompoundStatement
     |   |-return
     |   |-UnknownExpression
     |   | `-100
     |   `-;
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, Expressions) {
+TEST_P(SyntaxTreeTest, Expressions) {
   // expressions should be wrapped in 'ExpressionStatement' when they appear
   // in a statement position.
   expectTreeDumpEqual(
       R"cpp(
 void test() {
   test();
-  if (true) test(); else test();
+  if (1) test(); else test();
 }
     )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-UnknownExpression
     | | |-UnknownExpression
     | | | `-test
     | | |-(
     | | `-)
     | `-;
     |-IfStatement
     | |-if
     | |-(
     | |-UnknownExpression
-    | | `-true
+    | | `-1
     | |-)
     | |-ExpressionStatement
     | | |-UnknownExpression
     | | | |-UnknownExpression
     | | | | `-test
     | | | |-(
     | | | `-)
     | | `-;
     | |-else
     | `-ExpressionStatement
     |   |-UnknownExpression
     |   | |-UnknownExpression
     |   | | `-test
     |   | |-(
     |   | `-)
     |   `-;
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, PostfixUnaryOperator) {
+TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
   expectTreeDumpEqual(
       R"cpp(
 void test(int a) {
   a++;
   a--;
 }
     )cpp",
       R"txt(
`-CompoundStatement
     | | |-UnknownExpression
     | | | `-a
     | | `---
     | `-;
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, PrefixUnaryOperator) {
+TEST_P(SyntaxTreeTest, PrefixUnaryOperator) {
+  if (!GetParam().isCXX()) {
+    // TODO: Split parts that depend on C++ into a separate test.
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 void test(int a, int *ap, bool b) {
   --a; ++a;
   ~a; compl a;
   -a;
   +a;
   &a;
`-CompoundStatement
     | | |-__imag
     | | `-UnknownExpression
     | |   `-a
     | `-;
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, BinaryOperator) {
+TEST_P(SyntaxTreeTest, BinaryOperator) {
+  if (!GetParam().isCXX()) {
+    // TODO: Split parts that depend on C++ into a separate test.
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 void test(int a) {
   1 - 2;
   1 == 2;
   a = 1;
   a <<= 1;
 
`-CompoundStatement
     | | |-xor_eq
     | | `-UnknownExpression
     | |   `-3
     | `-;
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, NestedBinaryOperator) {
+TEST_P(SyntaxTreeTest, NestedBinaryOperator) {
   expectTreeDumpEqual(
       R"cpp(
 void test(int a, int b) {
   (1 + 2) * (4 / 2);
   a + b + 42;
   a = b = 42;
   a + b * 4 + 2;
   a % 2 + b * 42;
`-CompoundStatement
     | |   |-*
     | |   `-UnknownExpression
     | |     `-42
     | `-;
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, UserDefinedBinaryOperator) {
+TEST_P(SyntaxTreeTest, UserDefinedBinaryOperator) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 struct X {
   X& operator=(const X&);
   friend X operator+(X, const X&);
   friend bool operator<(const X&, const X&);
 };
 void test(X x, X y) {
`-CompoundStatement
     | | | `-<
     | | `-UnknownExpression
     | |   `-y
     | `-;
     `-}
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
+TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   expectTreeDumpEqual(
       R"cpp(
       int *a, b; int *c, d;
   )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
`-SimpleDeclaration
   | `-c
   |-,
   |-SimpleDeclarator
   | `-d
   `-;
   )txt");
 }
 
-TEST_F(SyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
+TEST_P(SyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
   expectTreeDumpEqual(
       R"cpp(
     typedef int *a, b;
   )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-typedef
   |-int
   |-SimpleDeclarator
   | |-*
   | `-a
   |-,
   |-SimpleDeclarator
   | `-b
   `-;
   )txt");
 }
 
-TEST_F(SyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
+TEST_P(SyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
   expectTreeDumpEqual(
       R"cpp(
 void foo() {
       int *a, b;
       typedef int *ta, tb;
 }
   )cpp",
       R"txt(
`-CompoundStatement
     | | |-,
     | | `-SimpleDeclarator
     | |   `-tb
     | `-;
     `-}
   )txt");
 }
 
-TEST_F(SyntaxTreeTest, Namespaces) {
+TEST_P(SyntaxTreeTest, Namespaces) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 namespace a { namespace b {} }
 namespace a::b {}
 namespace {}
 
 namespace foo = a;
     )cpp",
`-NamespaceAliasDefinition
   |-namespace
   |-foo
   |-=
   |-a
   `-;
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, UsingDirective) {
+TEST_P(SyntaxTreeTest, UsingDirective) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 namespace ns {}
 using namespace ::ns;
     )cpp",
       R"txt(
 *: TranslationUnit
 |-NamespaceDefinition
 | |-namespace
 | |-ns
 | |-{
 | `-}
 `-UsingNamespaceDirective
   |-using
   |-namespace
   |-::
   |-ns
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, UsingDeclaration) {
+TEST_P(SyntaxTreeTest, UsingDeclaration) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 namespace ns { int a; }
 using ns::a;
     )cpp",
       R"txt(
 *: TranslationUnit
 |-NamespaceDefinition
`-UsingDeclaration
   |-using
   |-ns
   |-::
   |-a
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, FreeStandingClasses) {
+TEST_P(SyntaxTreeTest, FreeStandingClasses) {
   // Free-standing classes, must live inside a SimpleDeclaration.
   expectTreeDumpEqual(
       R"cpp(
 struct X;
 struct X {};
 
 struct Y *y1;
 struct Y {} *y2;
`-SimpleDeclaration
   |-}
   |-SimpleDeclarator
   | |-*
   | `-a1
   `-;
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, Templates) {
+TEST_P(SyntaxTreeTest, Templates) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  if (GetParam().hasDelayedTemplateParsing()) {
+    // FIXME: Make this test work on Windows by generating the expected syntax
+    // tree when `-fdelayed-template-parsing` is active.
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 template <class T> struct cls {};
 template <class T> int var = 10;
 template <class T> int fun() {}
     )cpp",
       R"txt(
 *: TranslationUnit
`-SimpleDeclaration
     |-SimpleDeclarator
     | |-fun
     | `-ParametersAndQualifiers
     |   |-(
     |   `-)
     `-CompoundStatement
       |-{
       `-}
-)txt",
-      // FIXME: Make this test work on windows by generating the expected Syntax
-      // tree when -fdelayed-template-parsing is active.
-      /*RunWithDelayedTemplateParsing=*/false);
+)txt");
 }
 
-TEST_F(SyntaxTreeTest, NestedTemplates) {
+TEST_P(SyntaxTreeTest, NestedTemplates) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 template <class T>
 struct X {
   template <class U>
   U foo();
 };
     )cpp",
`-SimpleDeclaration
     |   |   |-(
     |   |   `-)
     |   `-;
     |-}
     `-;
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, Templates2) {
+TEST_P(SyntaxTreeTest, Templates2) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 template <class T> struct X { struct Y; };
 template <class T> struct X<T>::Y {};
     )cpp",
       R"txt(
 *: TranslationUnit
 |-TemplateDeclaration
`-SimpleDeclaration
     |-::
     |-Y
     |-{
     |-}
     `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, TemplatesUsingUsing) {
+TEST_P(SyntaxTreeTest, TemplatesUsingUsing) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 template <class T> struct X {
   using T::foo;
   using typename T::bar;
 };
     )cpp",
       R"txt(
`-SimpleDeclaration
     | |-::
     | |-bar
     | `-;
     |-}
     `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, ExplicitTemplateInstantations) {
+TEST_P(SyntaxTreeTest, ExplicitTemplateInstantations) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 template <class T> struct X {};
 template <class T> struct X<T*> {};
 template <> struct X<int> {};
 
 template struct X<double>;
 extern template struct X<float>;
`-SimpleDeclaration
     |-X
     |-<
     |-float
     |->
     `-;
 )txt");
 }
 
-TEST_F(SyntaxTreeTest, UsingType) {
+TEST_P(SyntaxTreeTest, UsingType) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 using type = int;
     )cpp",
       R"txt(
 *: TranslationUnit
 `-TypeAliasDeclaration
   |-using
   |-type
   |-=
   |-int
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, EmptyDeclaration) {
+TEST_P(SyntaxTreeTest, EmptyDeclaration) {
   expectTreeDumpEqual(
       R"cpp(
 ;
     )cpp",
       R"txt(
 *: TranslationUnit
 `-EmptyDeclaration
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, StaticAssert) {
+TEST_P(SyntaxTreeTest, StaticAssert) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 static_assert(true, "message");
 static_assert(true);
     )cpp",
       R"txt(
 *: TranslationUnit
 |-StaticAssertDeclaration
`-StaticAssertDeclaration
   |-(
   |-UnknownExpression
   | `-true
   |-)
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, ExternC) {
+TEST_P(SyntaxTreeTest, ExternC) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 extern "C" int a;
 extern "C" { int b; int c; }
     )cpp",
       R"txt(
 *: TranslationUnit
 |-LinkageSpecificationDeclaration
`-LinkageSpecificationDeclaration
   | |-int
   | |-SimpleDeclarator
   | | `-c
   | `-;
   `-}
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, NonModifiableNodes) {
+TEST_P(SyntaxTreeTest, NonModifiableNodes) {
   // Some nodes are non-modifiable, they are marked with 'I:'.
   expectTreeDumpEqual(
       R"cpp(
 #define HALF_IF if (1+
 #define HALF_IF_2 1) {}
 void test() {
   HALF_IF HALF_IF_2 else {}
 })cpp",
`-CompoundStatement
     | |-else
     | `-CompoundStatement
     |   |-{
     |   `-}
     `-}
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, ModifiableNodes) {
+TEST_P(SyntaxTreeTest, ModifiableNodes) {
   // All nodes can be mutated.
   expectTreeDumpEqual(
       R"cpp(
 #define OPEN {
 #define CLOSE }
 
 void test() {
   OPEN
`-CompoundStatement
     | | |-UnknownExpression
     | | | `-2
     | | `-;
     | `-}
     `-}
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, ArraySubscriptsInDeclarators) {
+TEST_P(SyntaxTreeTest, ArraySubscriptsInDeclarators) {
   expectTreeDumpEqual(
       R"cpp(
 int a[10];
 int b[1][2][3];
 int c[] = {1,2,3};
 // void f(int xs[static 10]);
     )cpp",
       R"txt(
`-SimpleDeclaration
   |     | `-2
   |     |-,
   |     |-UnknownExpression
   |     | `-3
   |     `-}
   `-;       )txt");
 }
 
-TEST_F(SyntaxTreeTest, ParameterListsInDeclarators) {
+TEST_P(SyntaxTreeTest, ParameterListsInDeclarators) {
+  if (!GetParam().isCXX()) {
+    // TODO: Split parts that depend on C++ into a separate test.
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 struct Test {
   int a() const;
   int b() volatile;
   int c() &;
   int d() &&;
   int foo(int a, int b);
`-SimpleDeclaration
   | |   |   `-f
   | |   `-)
   | `-;
   |-}
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, TrailingConst) {
+TEST_P(SyntaxTreeTest, TrailingConst) {
+  if (!GetParam().isCXX()) {
+    // TODO: Split parts that depend on C++ into a separate test.
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 struct X {
   int foo() const;
 };
     )cpp",
       R"txt(
 *: TranslationUnit
`-SimpleDeclaration
   | |   |-)
   | |   `-const
   | `-;
   |-}
   `-;
     )txt");
 }
 
-TEST_F(SyntaxTreeTest, TrailingReturn) {
+TEST_P(SyntaxTreeTest, TrailingReturn) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 auto foo() -> int;
     )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-auto
   |-SimpleDeclarator
   | |-foo
   | `-ParametersAndQualifiers
   |   |-(
   |   |-)
   |   `-TrailingReturnType
   |     |-->
   |     `-int
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, ExceptionSpecification) {
+TEST_P(SyntaxTreeTest, ExceptionSpecification) {
+  if (!GetParam().isCXX11OrLater()) {
+    // TODO: Split parts that depend on C++11 into a separate test.
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 int a() noexcept;
 int b() noexcept(true);
 int c() throw();
     )cpp",
       R"txt(
 *: TranslationUnit
`-SimpleDeclaration
   |   |-)
   |   |-throw
   |   |-(
   |   `-)
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, DeclaratorsInParentheses) {
+TEST_P(SyntaxTreeTest, DeclaratorsInParentheses) {
   expectTreeDumpEqual(
       R"cpp(
 int (a);
 int *(b);
 int (*c)(int);
 int *(d)(int);
     )cpp",
       R"txt(
`-SimpleDeclaration
   |   |-(
   |   |-SimpleDeclaration
   |   | `-int
   |   `-)
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, ConstVolatileQualifiers) {
+TEST_P(SyntaxTreeTest, ConstVolatileQualifiers) {
   expectTreeDumpEqual(
       R"cpp(
 const int west = -1;
 int const east = 1;
 const int const universal = 0;
 const int const *const *volatile b;
     )cpp",
       R"txt(
`-SimpleDeclaration
   | |-const
   | |-*
   | |-volatile
   | `-b
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
+TEST_P(SyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 auto foo() -> auto(*)(int) -> double*;
     )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-auto
`-SimpleDeclaration
   |           |-->
   |           |-double
   |           `-SimpleDeclarator
   |             `-*
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, MemberPointers) {
+TEST_P(SyntaxTreeTest, MemberPointers) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
   expectTreeDumpEqual(
       R"cpp(
 struct X {};
 int X::* a;
 const int X::* b;
     )cpp",
       R"txt(
 *: TranslationUnit
`-SimpleDeclaration
   | | |-X
   | | |-::
   | | `-*
   | `-b
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, ComplexDeclarator) {
+TEST_P(SyntaxTreeTest, ComplexDeclarator) {
   expectTreeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int));
     )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
`-SimpleDeclaration
   |   |     |-SimpleDeclaration
   |   |     | `-int
   |   |     `-)
   |   `-)
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, ComplexDeclarator2) {
+TEST_P(SyntaxTreeTest, ComplexDeclarator2) {
   expectTreeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int), long (**c)(long long));
     )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
`-SimpleDeclaration
   |   |     | |-long
   |   |     | `-long
   |   |     `-)
   |   `-)
   `-;
        )txt");
 }
 
-TEST_F(SyntaxTreeTest, Mutations) {
+TEST_P(SyntaxTreeTest, Mutations) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+
   using Transformation = std::function<void(
       const llvm::Annotations & /*Input*/, syntax::TranslationUnit * /*Root*/)>;
   auto CheckTransformation = [this](std::string Input, std::string Expected,
                                     Transformation Transform) -> void {
     llvm::Annotations Source(Input);
-    auto *Root = buildTree(Source.code());
+    auto *Root = buildTree(Source.code(), GetParam());
 
     Transform(Source, Root);
 
     auto Replacements = syntax::computeReplacements(*Arena, *Root);
     auto Output = tooling::applyAllReplacements(Source.code(), Replacements);
     if (!Output) {
       ADD_FAILURE() << "could not apply replacements: "
                     << llvm::toString(Output.takeError());
std::vector<std::pair<std::string /*Input*/, std::string /*Expected*/>>
           {"void test() { [[100+100;]] test(); }", "void test() {  test(); }"},
           {"void test() { if (true) [[{}]] else {} }",
            "void test() { if (true) ; else {} }"},
           {"void test() { [[;]] }", "void test() {  }"}};
   for (const auto &C : Cases)
     CheckTransformation(C.first, C.second, RemoveStatement);
 }
 
-TEST_F(SyntaxTreeTest, SynthesizedNodes) {
-  buildTree("");
+TEST_P(SyntaxTreeTest, SynthesizedNodes) {
+  buildTree("", GetParam());
 
   auto *C = syntax::createPunctuation(*Arena, tok::comma);
   ASSERT_NE(C, nullptr);
   EXPECT_EQ(C->token()->kind(), tok::comma);
   EXPECT_TRUE(C->canModify());
   EXPECT_FALSE(C->isOriginal());
   EXPECT_TRUE(C->isDetached());
 
   auto *S = syntax::createEmptyStatement(*Arena);
   ASSERT_NE(S, nullptr);
   EXPECT_TRUE(S->canModify());
   EXPECT_FALSE(S->isOriginal());
   EXPECT_TRUE(S->isDetached());
 }
 
+INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, SyntaxTreeTest,
+                        testing::ValuesIn(TestClangConfig::allConfigs()));
+
 } // namespace