[SyntaxTree] Specialize `TreeTestBase` for `BuildTreeTest` and `MutationsTest`

[eduucaldas]

clang/unittests/Tooling/Syntax/MutationsTest.cpp

60–70

I think it makes sense to split this into a separate file as well.

If agreed this will be done in a separate patch, because it will also incur the creation of a Synthesis.h.

Currently BuildTree.h is backed by Synthesis.cpp and BuildTree.cpp which I don't think makes a lot of sense

[eduucaldas]

• [SyntaxTree] Extract SynthesisTest from MutationsTest

[gribozavr2]

clang/unittests/Tooling/Syntax/MutationsTest.cpp

48

56–57

Could we split it into multiple test cases?

TEST_P(MutationTest, RemoveStatement_BinaryExpression) {
  CheckTransformation(
    RemoveStatement,
    "void test() { [[100+100;]] test(); }",
    "void test() {  test(); }");
}

Also consider moving the std::function argument in CheckTransformation to the first position for readability of the call.

clang/unittests/Tooling/Syntax/SynthesisTest.cpp

2–3

[eduucaldas]

• MutationsTest: Split tests and infrastructure
• SynthesisTest: Split tests

[eduucaldas]

nit

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

 
 #include "TreeTestBase.h"
 
 using namespace clang;
 using namespace clang::syntax;
 
 namespace {
 
-TEST_P(SyntaxTreeTest, Simple) {
+class BuildSyntaxTreeTest : public SyntaxTreeTest {
+protected:
+  ::testing::AssertionResult treeDumpEqual(StringRef Code, StringRef Tree) {
+    SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
+
+    auto *Root = buildTree(Code, GetParam());
+    if (Diags->getClient()->getNumErrors() != 0) {
+      return ::testing::AssertionFailure()
+             << "Source file has syntax errors, they were printed to the test "
+                "log";
+    }
+    auto Actual = StringRef(Root->dump(Arena->sourceManager())).trim().str();
+    // EXPECT_EQ shows the diff between the two strings if they are different.
+    EXPECT_EQ(Tree.trim().str(), Actual);
+    if (Actual != Tree.trim().str()) {
+      return ::testing::AssertionFailure();
+    }
+    return ::testing::AssertionSuccess();
+  }
+
+  ::testing::AssertionResult
+  treeDumpEqualOnAnnotations(StringRef CodeWithAnnotations,
+                             ArrayRef<StringRef> TreeDumps) {
+    SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
+
+    auto AnnotatedCode = llvm::Annotations(CodeWithAnnotations);
+    auto *Root = buildTree(AnnotatedCode.code(), GetParam());
+
+    if (Diags->getClient()->getNumErrors() != 0) {
+      return ::testing::AssertionFailure()
+             << "Source file has syntax errors, they were printed to the test "
+                "log";
+    }
+
+    auto AnnotatedRanges = AnnotatedCode.ranges();
+    if (AnnotatedRanges.size() != TreeDumps.size()) {
+      return ::testing::AssertionFailure()
+             << "The number of annotated ranges in the source code is "
+                "different "
+                "to the number of their corresponding tree dumps.";
+    }
+    bool Failed = false;
+    for (unsigned i = 0; i < AnnotatedRanges.size(); i++) {
+      auto *AnnotatedNode = nodeByRange(AnnotatedRanges[i], Root);
+      assert(AnnotatedNode);
+      auto AnnotatedNodeDump =
+          StringRef(AnnotatedNode->dump(Arena->sourceManager())).trim().str();
+      // EXPECT_EQ shows the diff between the two strings if they are different.
+      EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump)
+          << "Dumps diverged for the code:\n"
+          << AnnotatedCode.code().slice(AnnotatedRanges[i].Begin,
+                                        AnnotatedRanges[i].End);
+      if (AnnotatedNodeDump != TreeDumps[i].trim().str())
+        Failed = true;
+    }
+    return Failed ? ::testing::AssertionFailure()
+                  : ::testing::AssertionSuccess();
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, BuildSyntaxTreeTest,
+                        testing::ValuesIn(allTestClangConfigs()), );
+
+TEST_P(BuildSyntaxTreeTest, Simple) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int main() {}
 void foo() {}
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
`-SimpleDeclaration
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
     `-'}' CloseParen
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, SimpleVariable) {
+TEST_P(BuildSyntaxTreeTest, SimpleVariable) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a;
 int b = 42;
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
 | |-SimpleDeclarator Declarator
 | | `-'a'
 | `-';'
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator Declarator
   | |-'b'
   | |-'='
   | `-IntegerLiteralExpression
   |   `-'42' LiteralToken
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, SimpleFunction) {
+TEST_P(BuildSyntaxTreeTest, SimpleFunction) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void foo(int a, int b) {}
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
`-SimpleDeclaration
   |   |     `-'b'
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
     `-'}' CloseParen
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, If) {
+TEST_P(BuildSyntaxTreeTest, If) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[if (1) {}]]
   [[if (1) {} else if (0) {}]]
 }
 )cpp",
       {R"txt(
`-IfStatement ElseStatement
   | `-'0' LiteralToken
   |-')'
   `-CompoundStatement ThenStatement
     |-'{' OpenParen
     `-'}' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, For) {
+TEST_P(BuildSyntaxTreeTest, For) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[for (;;)  {}]]
 }
 )cpp",
       {R"txt(
 ForStatement Statement
 |-'for' IntroducerKeyword
 |-'('
 |-';'
 |-';'
 |-')'
 `-CompoundStatement BodyStatement
   |-'{' OpenParen
   `-'}' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, RangeBasedFor) {
+TEST_P(BuildSyntaxTreeTest, RangeBasedFor) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   int a[3];
   [[for (int x : a)

 | `-UnqualifiedId UnqualifiedId
 |   `-'a'
 |-')'
 `-EmptyStatement BodyStatement
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, DeclarationStatement) {
+TEST_P(BuildSyntaxTreeTest, DeclarationStatement) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[int a = 10;]]
 }
 )cpp",
       {R"txt(
 DeclarationStatement Statement
 |-SimpleDeclaration
 | |-'int'
 | `-SimpleDeclarator Declarator
 |   |-'a'
 |   |-'='
 |   `-IntegerLiteralExpression
 |     `-'10' LiteralToken
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, Switch) {
+TEST_P(BuildSyntaxTreeTest, Switch) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[switch (1) {
     case 0:
     default:;
   }]]
 }
`-CompoundStatement BodyStatement
   |   |-'default' IntroducerKeyword
   |   |-':'
   |   `-EmptyStatement BodyStatement
   |     `-';'
   `-'}' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, While) {
+TEST_P(BuildSyntaxTreeTest, While) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[while (1) { continue; break; }]]
 }
 )cpp",
       {R"txt(
 WhileStatement Statement
`-CompoundStatement BodyStatement
   | `-';'
   |-BreakStatement Statement
   | |-'break' IntroducerKeyword
   | `-';'
   `-'}' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UnhandledStatement) {
+TEST_P(BuildSyntaxTreeTest, UnhandledStatement) {
   // Unhandled statements should end up as 'unknown statement'.
   // This example uses a 'label statement', which does not yet have a syntax
   // counterpart.
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 int test() {
   [[foo: return 100;]]
 }
 )cpp",
       {R"txt(
 UnknownStatement Statement
 |-'foo'
 |-':'
 `-ReturnStatement
   |-'return' IntroducerKeyword
   |-IntegerLiteralExpression ReturnValue
   | `-'100' LiteralToken
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, Expressions) {
+TEST_P(BuildSyntaxTreeTest, Expressions) {
   // expressions should be wrapped in 'ExpressionStatement' when they appear
   // in a statement position.
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   test();
   if (1) test(); else test();
 }
`-CompoundStatement
     |   | |   `-'test'
     |   | |-'(' OpenParen
     |   | `-')' CloseParen
     |   `-';'
     `-'}' CloseParen
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedId_Identifier) {
+TEST_P(BuildSyntaxTreeTest, UnqualifiedId_Identifier) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[a]];
 }
 )cpp",
       {R"txt(
 IdExpression Expression
 `-UnqualifiedId UnqualifiedId
   `-'a'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedId_OperatorFunctionId) {
+TEST_P(BuildSyntaxTreeTest, UnqualifiedId_OperatorFunctionId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   friend X operator+(const X&, const X&);
 };

 | |-',' ListDelimiter
 | `-IdExpression ListElement
 |   `-UnqualifiedId UnqualifiedId
 |     `-'x'
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedId_ConversionFunctionId) {
+TEST_P(BuildSyntaxTreeTest, UnqualifiedId_ConversionFunctionId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   operator int();
 };

 |   `-UnqualifiedId UnqualifiedId
 |     |-'operator'
 |     `-'int'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedId_LiteralOperatorId) {
+TEST_P(BuildSyntaxTreeTest, UnqualifiedId_LiteralOperatorId) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _w(char);
 void test() {
   [[operator "" _w('1')]];

 |-'(' OpenParen
 |-CallArguments Arguments
 | `-CharacterLiteralExpression ListElement
 |   `-''1'' LiteralToken
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedId_Destructor) {
+TEST_P(BuildSyntaxTreeTest, UnqualifiedId_Destructor) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X { };
 void test(X x) {
   [[x.~X()]];

 |   `-UnqualifiedId UnqualifiedId
 |     |-'~'
 |     `-'X'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedId_DecltypeDestructor) {
+TEST_P(BuildSyntaxTreeTest, UnqualifiedId_DecltypeDestructor) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X { };
 void test(X x) {
   // FIXME: Make `decltype(x)` a child of `MemberExpression`. It is currently

 |-'('
 |-'x'
 |-')'
 |-'('
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedId_TemplateId) {
+TEST_P(BuildSyntaxTreeTest, UnqualifiedId_TemplateId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T>
 T f();
 void test() {
   [[f<int>()]];
 }
 )cpp",
       {R"txt(
 CallExpression Expression
 |-IdExpression Callee
 | `-UnqualifiedId UnqualifiedId
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, QualifiedId_NamespaceSpecifier) {
+TEST_P(BuildSyntaxTreeTest, QualifiedId_NamespaceSpecifier) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 namespace n {
   struct S { };
 }

 | | `-'n'
 | `-'::' ListDelimiter
 |-'S'
 `-SimpleDeclarator Declarator
   `-'s2'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, QualifiedId_TemplateSpecifier) {
+TEST_P(BuildSyntaxTreeTest, QualifiedId_TemplateSpecifier) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T>
 struct ST {
   struct S { };

 | | `-'>'
 | `-'::' ListDelimiter
 |-'S'
 `-SimpleDeclarator Declarator
   `-'s2'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, QualifiedId_DecltypeSpecifier) {
+TEST_P(BuildSyntaxTreeTest, QualifiedId_DecltypeSpecifier) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   static void f(){}
 };

 | | `-'::' ListDelimiter
 | `-UnqualifiedId UnqualifiedId
 |   `-'f'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, QualifiedId_OptionalTemplateKw) {
+TEST_P(BuildSyntaxTreeTest, QualifiedId_OptionalTemplateKw) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename U>
   static U f();

 |   |-'<'
 |   |-'int'
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, QualifiedId_Complex) {
+TEST_P(BuildSyntaxTreeTest, QualifiedId_Complex) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 namespace n {
   template<typename T>
   struct ST {

 |   |-'<'
 |   |-'int'
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, QualifiedId_DependentType) {
+TEST_P(BuildSyntaxTreeTest, QualifiedId_DependentType) {
   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;
   }

 |   |-IntegerLiteralExpression
 |   | `-'0' LiteralToken
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, This_Simple) {
+TEST_P(BuildSyntaxTreeTest, This_Simple) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   S* test(){
     return [[this]];
   }
 };
 )cpp",
       {R"txt(
 ThisExpression ReturnValue
 `-'this' IntroducerKeyword
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, This_ExplicitMemberAccess) {
+TEST_P(BuildSyntaxTreeTest, This_ExplicitMemberAccess) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   int a;
   void test(){
     [[this->a]];
   }
 };
 )cpp",
       {R"txt(
 MemberExpression Expression
 |-ThisExpression Object
 | `-'this' IntroducerKeyword
 |-'->' AccessToken
 `-IdExpression Member
   `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, This_ImplicitMemberAccess) {
+TEST_P(BuildSyntaxTreeTest, This_ImplicitMemberAccess) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   int a;
   void test(){
     [[a]];
   }
 };
 )cpp",
       {R"txt(
 IdExpression Expression
 `-UnqualifiedId UnqualifiedId
   `-'a'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ParenExpr) {
+TEST_P(BuildSyntaxTreeTest, ParenExpr) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[(1)]];
   [[((1))]];
   [[(1 + (2))]];
 }
 )cpp",

 |   |-'(' OpenParen
 |   |-IntegerLiteralExpression SubExpression
 |   | `-'2' LiteralToken
 |   `-')' CloseParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UserDefinedLiteral_Char) {
+TEST_P(BuildSyntaxTreeTest, UserDefinedLiteral_Char) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _c(char);
 void test() {
   [['2'_c]];
 }
     )cpp",
       {R"txt(
 CharUserDefinedLiteralExpression Expression
 `-''2'_c' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UserDefinedLiteral_String) {
+TEST_P(BuildSyntaxTreeTest, UserDefinedLiteral_String) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 typedef decltype(sizeof(void *)) size_t;
 
 unsigned operator "" _s(const char*, size_t);
 
 void test() {
   [["12"_s]];
 }
     )cpp",
       {R"txt(
 StringUserDefinedLiteralExpression Expression
 `-'"12"_s' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UserDefinedLiteral_Integer) {
+TEST_P(BuildSyntaxTreeTest, UserDefinedLiteral_Integer) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _i(unsigned long long);
 unsigned operator "" _r(const char*);
 template <char...>

 `-'12_r' LiteralToken
 )txt",
        R"txt(
 IntegerUserDefinedLiteralExpression Expression
 `-'12_t' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UserDefinedLiteral_Float) {
+TEST_P(BuildSyntaxTreeTest, UserDefinedLiteral_Float) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _f(long double);
 unsigned operator "" _r(const char*);
 template <char...>

 `-'1.2_r' LiteralToken
 )txt",
        R"txt(
 FloatUserDefinedLiteralExpression Expression
 `-'1.2_t' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, IntegerLiteral_LongLong) {
+TEST_P(BuildSyntaxTreeTest, IntegerLiteral_LongLong) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[12ll]];
   [[12ull]];
 }
 )cpp",
       {R"txt(
 IntegerLiteralExpression Expression
 `-'12ll' LiteralToken
 )txt",
        R"txt(
 IntegerLiteralExpression Expression
 `-'12ull' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, IntegerLiteral_Binary) {
+TEST_P(BuildSyntaxTreeTest, IntegerLiteral_Binary) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[0b1100]];
 }
 )cpp",
       {R"txt(
 IntegerLiteralExpression Expression
 `-'0b1100' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, IntegerLiteral_WithDigitSeparators) {
+TEST_P(BuildSyntaxTreeTest, IntegerLiteral_WithDigitSeparators) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[1'2'0ull]];
 }
 )cpp",
       {R"txt(
 IntegerLiteralExpression Expression
 `-'1'2'0ull' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CharacterLiteral) {
+TEST_P(BuildSyntaxTreeTest, CharacterLiteral) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [['a']];
   [['\n']];
   [['\x20']];
   [['\0']];
   [[L'a']];

 `-'L'a'' LiteralToken
 )txt",
        R"txt(
 CharacterLiteralExpression Expression
 `-'L'α'' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CharacterLiteral_Utf) {
+TEST_P(BuildSyntaxTreeTest, CharacterLiteral_Utf) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[u'a']];
   [[u'構']];

 `-'U'a'' LiteralToken
 )txt",
        R"txt(
 CharacterLiteralExpression Expression
 `-'U'🌲'' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CharacterLiteral_Utf8) {
+TEST_P(BuildSyntaxTreeTest, CharacterLiteral_Utf8) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[u8'a']];
   [[u8'\x7f']];
 }
 )cpp",
       {R"txt(
 CharacterLiteralExpression Expression
 `-'u8'a'' LiteralToken
 )txt",
        R"txt(
 CharacterLiteralExpression Expression
 `-'u8'\x7f'' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, FloatingLiteral) {
+TEST_P(BuildSyntaxTreeTest, FloatingLiteral) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[1e-2]];
   [[2.]];
   [[.2]];
   [[2.f]];
 }

 `-'.2' LiteralToken
 )txt",
        R"txt(
 FloatingLiteralExpression Expression
 `-'2.f' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, FloatingLiteral_Hexadecimal) {
+TEST_P(BuildSyntaxTreeTest, FloatingLiteral_Hexadecimal) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[0xfp1]];
   [[0xf.p1]];

 `-'0x.fp1' LiteralToken
 )txt",
        R"txt(
 FloatingLiteralExpression Expression
 `-'0xf.fp1f' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, StringLiteral) {
+TEST_P(BuildSyntaxTreeTest, StringLiteral) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [["a\n\0\x20"]];
   [[L"αβ"]];
 }
 )cpp",
       {R"txt(
 StringLiteralExpression Expression
 `-'"a\n\0\x20"' LiteralToken
 )txt",
        R"txt(
 StringLiteralExpression Expression
 `-'L"αβ"' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, StringLiteral_Utf) {
+TEST_P(BuildSyntaxTreeTest, StringLiteral_Utf) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[u8"a\x1f\x05"]];
   [[u"C++抽象構文木"]];

 `-'u"C++抽象構文木"' LiteralToken
 )txt",
        R"txt(
 StringLiteralExpression Expression
 `-'U"📖🌲\n"' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, StringLiteral_Raw) {
+TEST_P(BuildSyntaxTreeTest, StringLiteral_Raw) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   // This test uses regular string literals instead of raw string literals to
   // hold source code and expected output because of a bug in MSVC up to MSVC
   // 2019 16.2:
   // https://developercommunity.visualstudio.com/content/problem/67300/stringifying-raw-string-literal.html
   EXPECT_TRUE(treeDumpEqual( //
EXPECT_TRUE(treeDumpEqual( //
       "    | |-StringLiteralExpression Expression\n"
       "    | | `-'R\"SyntaxTree(\n"
       "  Hello \"Syntax\" \\\"\n"
       "  )SyntaxTree\"' LiteralToken\n"
       "    | `-';'\n"
       "    `-'}' CloseParen\n"));
 }
 
-TEST_P(SyntaxTreeTest, BoolLiteral) {
+TEST_P(BuildSyntaxTreeTest, BoolLiteral) {
   if (GetParam().isC()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[true]];
   [[false]];
 }
 )cpp",
       {R"txt(
 BoolLiteralExpression Expression
 `-'true' LiteralToken
 )txt",
        R"txt(
 BoolLiteralExpression Expression
 `-'false' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
+TEST_P(BuildSyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[nullptr]];
 }
 )cpp",
       {R"txt(
 CxxNullPtrExpression Expression
 `-'nullptr' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
+TEST_P(BuildSyntaxTreeTest, PostfixUnaryOperator) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[a++]];
   [[a--]];
 }
 )cpp",
       {R"txt(
 PostfixUnaryOperatorExpression Expression
 |-IdExpression Operand
 | `-UnqualifiedId UnqualifiedId
 |   `-'a'
 `-'++' OperatorToken
 )txt",
        R"txt(
 PostfixUnaryOperatorExpression Expression
 |-IdExpression Operand
 | `-UnqualifiedId UnqualifiedId
 |   `-'a'
 `-'--' OperatorToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, PrefixUnaryOperator) {
+TEST_P(BuildSyntaxTreeTest, PrefixUnaryOperator) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a, int *ap) {
   [[--a]]; [[++a]];
   [[~a]];
   [[-a]];
   [[+a]];
   [[&a]];

 PrefixUnaryOperatorExpression Expression
 |-'__imag' OperatorToken
 `-IdExpression Operand
   `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, PrefixUnaryOperatorCxx) {
+TEST_P(BuildSyntaxTreeTest, PrefixUnaryOperatorCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a, bool b) {
   [[compl a]];
   [[not b]];

 PrefixUnaryOperatorExpression Expression
 |-'not' OperatorToken
 `-IdExpression Operand
   `-UnqualifiedId UnqualifiedId
     `-'b'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, BinaryOperator) {
+TEST_P(BuildSyntaxTreeTest, BinaryOperator) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[1 - 2]];
   [[1 == 2]];
   [[a = 1]];
   [[a <<= 1]];
   [[1 || 0]];

 | `-UnqualifiedId UnqualifiedId
 |   `-'a'
 |-'!=' OperatorToken
 `-IntegerLiteralExpression RightHandSide
   `-'3' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, BinaryOperatorCxx) {
+TEST_P(BuildSyntaxTreeTest, BinaryOperatorCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[true || false]];
   [[true or false]];

 | `-UnqualifiedId UnqualifiedId
 |   `-'a'
 |-'xor_eq' OperatorToken
 `-IntegerLiteralExpression RightHandSide
   `-'3' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, BinaryOperator_NestedWithParenthesis) {
+TEST_P(BuildSyntaxTreeTest, BinaryOperator_NestedWithParenthesis) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[(1 + 2) * (4 / 2)]];
 }
 )cpp",
       {R"txt(
 BinaryOperatorExpression Expression
`-ParenExpression RightHandSide
   | | `-'4' LiteralToken
   | |-'/' OperatorToken
   | `-IntegerLiteralExpression RightHandSide
   |   `-'2' LiteralToken
   `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, BinaryOperator_Associativity) {
+TEST_P(BuildSyntaxTreeTest, BinaryOperator_Associativity) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a, int b) {
   [[a + b + 42]];
   [[a = b = 42]];
 }
 )cpp",
       {R"txt(
`-BinaryOperatorExpression RightHandSide
   | `-UnqualifiedId UnqualifiedId
   |   `-'b'
   |-'=' OperatorToken
   `-IntegerLiteralExpression RightHandSide
     `-'42' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, BinaryOperator_Precedence) {
+TEST_P(BuildSyntaxTreeTest, BinaryOperator_Precedence) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[1 + 2 * 3 + 4]];
   [[1 % 2 + 3 * 4]];
 }
 )cpp",
       {R"txt(
`-BinaryOperatorExpression RightHandSide
   |-IntegerLiteralExpression LeftHandSide
   | `-'3' LiteralToken
   |-'*' OperatorToken
   `-IntegerLiteralExpression RightHandSide
     `-'4' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_Assignment) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Assignment) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X& operator=(const X&);
 };
 void test(X x, X y) {
   [[x = y]];
 }
 )cpp",
       {R"txt(
 BinaryOperatorExpression Expression
 |-IdExpression LeftHandSide
 | `-UnqualifiedId UnqualifiedId
 |   `-'x'
 |-'=' OperatorToken
 `-IdExpression RightHandSide
   `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_Plus) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Plus) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   friend X operator+(X, const X&);
 };
 void test(X x, X y) {
   [[x + y]];
 }
 )cpp",
       {R"txt(
 BinaryOperatorExpression Expression
 |-IdExpression LeftHandSide
 | `-UnqualifiedId UnqualifiedId
 |   `-'x'
 |-'+' OperatorToken
 `-IdExpression RightHandSide
   `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_Less) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Less) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   friend bool operator<(const X&, const X&);
 };
 void test(X x, X y) {
   [[x < y]];
 }
 )cpp",
       {R"txt(
 BinaryOperatorExpression Expression
 |-IdExpression LeftHandSide
 | `-UnqualifiedId UnqualifiedId
 |   `-'x'
 |-'<' OperatorToken
 `-IdExpression RightHandSide
   `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_LeftShift) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_LeftShift) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   friend X operator<<(X&, const X&);
 };
 void test(X x, X y) {
   [[x << y]];
 }
 )cpp",
       {R"txt(
 BinaryOperatorExpression Expression
 |-IdExpression LeftHandSide
 | `-UnqualifiedId UnqualifiedId
 |   `-'x'
 |-'<<' OperatorToken
 `-IdExpression RightHandSide
   `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_Comma) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Comma) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X operator,(X&);
 };
 void test(X x, X y) {
   [[x, y]];
 }
 )cpp",
       {R"txt(
 BinaryOperatorExpression Expression
 |-IdExpression LeftHandSide
 | `-UnqualifiedId UnqualifiedId
 |   `-'x'
 |-',' OperatorToken
 `-IdExpression RightHandSide
   `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_PointerToMember) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_PointerToMember) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X operator->*(int);
 };
 void test(X* xp, int X::* pmi) {
   [[xp->*pmi]];
 }
 )cpp",
       {R"txt(
 BinaryOperatorExpression Expression
 |-IdExpression LeftHandSide
 | `-UnqualifiedId UnqualifiedId
 |   `-'xp'
 |-'->*' OperatorToken
 `-IdExpression RightHandSide
   `-UnqualifiedId UnqualifiedId
     `-'pmi'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_Negation) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Negation) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   bool operator!();
 };
 void test(X x) {
   [[!x]];
 }
 )cpp",
       {R"txt(
 PrefixUnaryOperatorExpression Expression
 |-'!' OperatorToken
 `-IdExpression Operand
   `-UnqualifiedId UnqualifiedId
     `-'x'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_AddressOf) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_AddressOf) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X* operator&();
 };
 void test(X x) {
   [[&x]];
 }
 )cpp",
       {R"txt(
 PrefixUnaryOperatorExpression Expression
 |-'&' OperatorToken
 `-IdExpression Operand
   `-UnqualifiedId UnqualifiedId
     `-'x'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_PrefixIncrement) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_PrefixIncrement) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X operator++();
 };
 void test(X x) {
   [[++x]];
 }
 )cpp",
       {R"txt(
 PrefixUnaryOperatorExpression Expression
 |-'++' OperatorToken
 `-IdExpression Operand
   `-UnqualifiedId UnqualifiedId
     `-'x'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperator_PostfixIncrement) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperator_PostfixIncrement) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X operator++(int);
 };
 void test(X x) {
   [[x++]];
 }
 )cpp",
       {R"txt(
 PostfixUnaryOperatorExpression Expression
 |-IdExpression Operand
 | `-UnqualifiedId UnqualifiedId
 |   `-'x'
 `-'++' OperatorToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_SimpleWithDot) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_SimpleWithDot) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   int a;
 };
 void test(struct S s) {
   [[s.a]];
 }
 )cpp",
       {R"txt(
 MemberExpression Expression
 |-IdExpression Object
 | `-UnqualifiedId UnqualifiedId
 |   `-'s'
 |-'.' AccessToken
 `-IdExpression Member
   `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_StaticDataMember) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_StaticDataMember) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   static int a;
 };
 void test(S s) {
   [[s.a]];
 }
 )cpp",
       {R"txt(
 MemberExpression Expression
 |-IdExpression Object
 | `-UnqualifiedId UnqualifiedId
 |   `-'s'
 |-'.' AccessToken
 `-IdExpression Member
   `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_SimpleWithArrow) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_SimpleWithArrow) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   int a;
 };
 void test(struct S* sp) {
   [[sp->a]];
 }
 )cpp",
       {R"txt(
 MemberExpression Expression
 |-IdExpression Object
 | `-UnqualifiedId UnqualifiedId
 |   `-'sp'
 |-'->' AccessToken
 `-IdExpression Member
   `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_Chaining) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_Chaining) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   struct S* next;
 };
 void test(struct S s){
   [[s.next->next]];
 }

 |     `-'next'
 |-'->' AccessToken
 `-IdExpression Member
   `-UnqualifiedId UnqualifiedId
     `-'next'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_OperatorFunction) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_OperatorFunction) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   bool operator!();
 };

 |   `-UnqualifiedId UnqualifiedId
 |     |-'operator'
 |     `-'!'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_VariableTemplate) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_VariableTemplate) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename T>
   static constexpr T x = 42;

 |-'<'
 |-'int'
 |-'>'
 |-';'
 `-'}' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_FunctionTemplate) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_FunctionTemplate) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename T>
   T f();

 |     |-'<'
 |     |-'int'
 |     `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_FunctionTemplateWithTemplateKeyword) {
+TEST_P(BuildSyntaxTreeTest,
+       MemberExpression_FunctionTemplateWithTemplateKeyword) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename T>
   T f();

 |     |-'<'
 |     |-'int'
 |     `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_WithQualifier) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_WithQualifier) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct Base {
   void f();
 };

 |   `-UnqualifiedId UnqualifiedId
 |     |-'~'
 |     `-'S'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberExpression_Complex) {
+TEST_P(BuildSyntaxTreeTest, MemberExpression_Complex) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T>
 struct U {
   template<typename U>

 |     |-'<'
 |     |-'int'
 |     `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Callee_Member) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_Member) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S{
   void f();
 };

 | `-IdExpression Member
 |   `-UnqualifiedId UnqualifiedId
 |     `-'f'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Callee_OperatorParens) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_OperatorParens) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   void operator()();
 };
 void test(S s) {
   [[s()]];
 }
 )cpp",
       {R"txt(
 CallExpression Expression
 |-IdExpression Callee
 | `-UnqualifiedId UnqualifiedId
 |   `-'s'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Callee_OperatorParensChaining) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_OperatorParensChaining) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   S operator()();
 };

 | |   `-'s'
 | |-'(' OpenParen
 | `-')' CloseParen
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Callee_MemberWithThis) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_MemberWithThis) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct Base {
   void f();
 };

 |   | `-'::' ListDelimiter
 |   `-UnqualifiedId UnqualifiedId
 |     `-'f'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Callee_FunctionPointer) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_FunctionPointer) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void (*pf)();
 void test() {
   [[pf()]];

 | |   `-UnqualifiedId UnqualifiedId
 | |     `-'pf'
 | `-')' CloseParen
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Callee_MemberFunctionPointer) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_MemberFunctionPointer) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   void f();
 };

 | |   `-UnqualifiedId UnqualifiedId
 | |     `-'pmf'
 | `-')' CloseParen
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Arguments_Zero) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_Zero) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f();
 void test() {
   [[f();]]
 }
 )cpp",
       {R"txt(
 ExpressionStatement Statement
 |-CallExpression Expression
 | |-IdExpression Callee
 | | `-UnqualifiedId UnqualifiedId
 | |   `-'f'
 | |-'(' OpenParen
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Arguments_One) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_One) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int);
 void test() {
   [[f(1);]]

 | |-CallArguments Arguments
 | | `-IntegerLiteralExpression ListElement
 | |   `-'1' LiteralToken
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Arguments_Multiple) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_Multiple) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int, char, float);
 void test() {
   [[f(1, '2', 3.);]]

 | | |-',' ListDelimiter
 | | `-FloatingLiteralExpression ListElement
 | |   `-'3.' LiteralToken
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Arguments_Assignment) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_Assignment) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int);
 void test(int a) {
   [[f(a = 1);]]

 | |   |-'=' OperatorToken
 | |   `-IntegerLiteralExpression RightHandSide
 | |     `-'1' LiteralToken
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Arguments_BracedInitList_Empty) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_BracedInitList_Empty) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int[]);
 void test() {
   [[f({});]]

 | |   `-UnknownExpression
 | |     |-'{'
 | |     `-'}'
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Arguments_BracedInitList_Simple) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_BracedInitList_Simple) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct TT {};
 struct T{
   int a;

 | |     |   |-'{'
 | |     |   `-'}'
 | |     `-'}'
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Arguments_BracedInitList_Designated) {
+TEST_P(BuildSyntaxTreeTest,
+       CallExpression_Arguments_BracedInitList_Designated) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct TT {};
 struct T{
   int a;

 | |     |     |-'{'
 | |     |     `-'}'
 | |     `-'}'
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_Arguments_ParameterPack) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_ParameterPack) {
   if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T, typename... Args>
 void test(T t, Args... args) {
   [[test(args...)]];

 |   |-IdExpression
 |   | `-UnqualifiedId UnqualifiedId
 |   |   `-'args'
 |   `-'...'
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, CallExpression_DefaultArguments) {
+TEST_P(BuildSyntaxTreeTest, CallExpression_DefaultArguments) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int i = 1, char c = '2');
 void test() {
   [[f()]];

 | | `-'1' LiteralToken
 | |-',' ListDelimiter
 | `-CharacterLiteralExpression ListElement
 |   `-''2'' LiteralToken
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
+TEST_P(BuildSyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int *a, b;
 int *c, d;
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
`-SimpleDeclaration
   | `-'c'
   |-','
   |-SimpleDeclarator Declarator
   | `-'d'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
+TEST_P(BuildSyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 typedef int *a, b;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'typedef'
   |-'int'
   |-SimpleDeclarator Declarator
   | |-'*'
   | `-'a'
   |-','
   |-SimpleDeclarator Declarator
   | `-'b'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
+TEST_P(BuildSyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void foo() {
   int *a, b;
   typedef int *ta, tb;
 }
 )cpp",
       R"txt(
`-CompoundStatement
     | | |-','
     | | `-SimpleDeclarator Declarator
     | |   `-'tb'
     | `-';'
     `-'}' CloseParen
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, SizeTTypedef) {
+TEST_P(BuildSyntaxTreeTest, SizeTTypedef) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 typedef decltype(sizeof(void *)) size_t;
     )cpp",
       R"txt(
`-SimpleDeclaration
   | `-')'
   |-')'
   |-SimpleDeclarator Declarator
   | `-'size_t'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, Namespace_Nested) {
+TEST_P(BuildSyntaxTreeTest, Namespace_Nested) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace a { namespace b {} }
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-NamespaceDefinition
   |-'namespace'
   |-'a'
   |-'{'
   |-NamespaceDefinition
   | |-'namespace'
   | |-'b'
   | |-'{'
   | `-'}'
   `-'}'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, Namespace_NestedDefinition) {
+TEST_P(BuildSyntaxTreeTest, Namespace_NestedDefinition) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace a::b {}
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-NamespaceDefinition
   |-'namespace'
   |-'a'
   |-'::'
   |-'b'
   |-'{'
   `-'}'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, Namespace_Unnamed) {
+TEST_P(BuildSyntaxTreeTest, Namespace_Unnamed) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace {}
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-NamespaceDefinition
   |-'namespace'
   |-'{'
   `-'}'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, Namespace_Alias) {
+TEST_P(BuildSyntaxTreeTest, Namespace_Alias) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 namespace a {}
 [[namespace foo = a;]]
 )cpp",
       {R"txt(
 NamespaceAliasDefinition
 |-'namespace'
 |-'foo'
 |-'='
 |-'a'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UsingDirective) {
+TEST_P(BuildSyntaxTreeTest, UsingDirective) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 namespace ns {}
 [[using namespace ::ns;]]
 )cpp",
       {R"txt(
 UsingNamespaceDirective
 |-'using'
 |-'namespace'
 |-NestedNameSpecifier
 | `-'::' ListDelimiter
 |-'ns'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UsingDeclaration_Namespace) {
+TEST_P(BuildSyntaxTreeTest, UsingDeclaration_Namespace) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 namespace ns { int a; }
 [[using ns::a;]]
 )cpp",
       {R"txt(
 UsingDeclaration
 |-'using'
 |-NestedNameSpecifier
 | |-IdentifierNameSpecifier ListElement
 | | `-'ns'
 | `-'::' ListDelimiter
 |-'a'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UsingDeclaration_ClassMember) {
+TEST_P(BuildSyntaxTreeTest, UsingDeclaration_ClassMember) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X {
   [[using T::foo;]]
   [[using typename T::bar;]]

 | |-IdentifierNameSpecifier ListElement
 | | `-'T'
 | `-'::' ListDelimiter
 |-'bar'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UsingTypeAlias) {
+TEST_P(BuildSyntaxTreeTest, UsingTypeAlias) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 using type = int;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-TypeAliasDeclaration
   |-'using'
   |-'type'
   |-'='
   |-'int'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, FreeStandingClass_ForwardDeclaration) {
+TEST_P(BuildSyntaxTreeTest, FreeStandingClass_ForwardDeclaration) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 [[struct X;]]
 [[struct Y *y1;]]
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'struct'
 |-'X'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'struct'
 |-'Y'
 |-SimpleDeclarator Declarator
 | |-'*'
 | `-'y1'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, FreeStandingClasses_Definition) {
+TEST_P(BuildSyntaxTreeTest, FreeStandingClasses_Definition) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 [[struct X {};]]
 [[struct Y {} *y2;]]
 [[struct {} *a1;]]
 )cpp",
       {R"txt(
 SimpleDeclaration

 |-'}'
 |-SimpleDeclarator Declarator
 | |-'*'
 | `-'a1'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, StaticMemberFunction) {
+TEST_P(BuildSyntaxTreeTest, StaticMemberFunction) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   [[static void f(){}]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'static'
 |-'void'
 |-SimpleDeclarator Declarator
 | |-'f'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   `-')' CloseParen
 `-CompoundStatement
   |-'{' OpenParen
   `-'}' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OutOfLineMemberFunctionDefinition) {
+TEST_P(BuildSyntaxTreeTest, OutOfLineMemberFunctionDefinition) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   void f();
 };

 |   |-'(' OpenParen
 |   `-')' CloseParen
 `-CompoundStatement
   |-'{' OpenParen
   `-'}' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ConversionMemberFunction) {
+TEST_P(BuildSyntaxTreeTest, ConversionMemberFunction) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   [[operator int();]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-SimpleDeclarator Declarator
 | |-'operator'
 | |-'int'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, LiteralOperatorDeclaration) {
+TEST_P(BuildSyntaxTreeTest, LiteralOperatorDeclaration) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 unsigned operator "" _c(char);
     )cpp",
       R"txt(
`-SimpleDeclaration
   |   |-ParameterDeclarationList Parameters
   |   | `-SimpleDeclaration ListElement
   |   |   `-'char'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, NumericLiteralOperatorTemplateDeclaration) {
+TEST_P(BuildSyntaxTreeTest, NumericLiteralOperatorTemplateDeclaration) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <char...>
 unsigned operator "" _t();
     )cpp",
`-SimpleDeclaration
     | |-'_t'
     | `-ParametersAndQualifiers
     |   |-'(' OpenParen
     |   `-')' CloseParen
     `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperatorDeclaration) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperatorDeclaration) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   [[X& operator=(const X&);]]
 };

 |   |   |-'X'
 |   |   `-SimpleDeclarator Declarator
 |   |     `-'&'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, OverloadedOperatorFriendDeclaration) {
+TEST_P(BuildSyntaxTreeTest, OverloadedOperatorFriendDeclaration) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   [[friend X operator+(X, const X&);]]
 };
`-SimpleDeclaration
   |   |   |-'X'
   |   |   `-SimpleDeclarator Declarator
   |   |     `-'&'
   |   `-')' CloseParen
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ClassTemplateDeclaration) {
+TEST_P(BuildSyntaxTreeTest, ClassTemplateDeclaration) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template<typename T>
 struct ST {};
 )cpp",
`-SimpleDeclaration
     |-'struct'
     |-'ST'
     |-'{'
     |-'}'
     `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, FunctionTemplateDeclaration) {
+TEST_P(BuildSyntaxTreeTest, FunctionTemplateDeclaration) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template<typename T>
 T f();
 )cpp",
`-SimpleDeclaration
     | |-'f'
     | `-ParametersAndQualifiers
     |   |-'(' OpenParen
     |   `-')' CloseParen
     `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, VariableTemplateDeclaration) {
+TEST_P(BuildSyntaxTreeTest, VariableTemplateDeclaration) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T> T var = 10;
 )cpp",
       R"txt(
`-SimpleDeclaration
     | |-'var'
     | |-'='
     | `-IntegerLiteralExpression
     |   `-'10' LiteralToken
     `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, StaticMemberFunctionTemplate) {
+TEST_P(BuildSyntaxTreeTest, StaticMemberFunctionTemplate) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   [[template<typename U>
   static U f();]]
`-SimpleDeclaration
   | |-'f'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, NestedTemplates) {
+TEST_P(BuildSyntaxTreeTest, NestedTemplates) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T>
 struct X {
   template <class U>
`-SimpleDeclaration
     |   |   |-'(' OpenParen
     |   |   `-')' CloseParen
     |   `-';'
     |-'}'
     `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, NestedTemplatesInNamespace) {
+TEST_P(BuildSyntaxTreeTest, NestedTemplatesInNamespace) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace n {
   template<typename T>
   struct ST {
`-NamespaceDefinition
   |   |   |   `-')' CloseParen
   |   |   `-';'
   |   |-'}'
   |   `-';'
   `-'}'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ClassTemplate_MemberClassDefinition) {
+TEST_P(BuildSyntaxTreeTest, ClassTemplate_MemberClassDefinition) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X { struct Y; };
 [[template <class T> struct X<T>::Y {};]]
 )cpp",
`-SimpleDeclaration
   | `-'::' ListDelimiter
   |-'Y'
   |-'{'
   |-'}'
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ExplicitClassTemplateInstantation_Definition) {
+TEST_P(BuildSyntaxTreeTest, ExplicitClassTemplateInstantation_Definition) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X {};
 [[template struct X<double>;]]
 )cpp",
       {R"txt(
 ExplicitTemplateInstantiation
 |-'template' IntroducerKeyword
 `-SimpleDeclaration Declaration
   |-'struct'
   |-'X'
   |-'<'
   |-'double'
   |-'>'
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ExplicitClassTemplateInstantation_Declaration) {
+TEST_P(BuildSyntaxTreeTest, ExplicitClassTemplateInstantation_Declaration) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X {};
 [[extern template struct X<float>;]]
 )cpp",
       {R"txt(
 ExplicitTemplateInstantiation
 |-'extern' ExternKeyword
 |-'template' IntroducerKeyword
 `-SimpleDeclaration Declaration
   |-'struct'
   |-'X'
   |-'<'
   |-'float'
   |-'>'
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ClassTemplateSpecialization_Partial) {
+TEST_P(BuildSyntaxTreeTest, ClassTemplateSpecialization_Partial) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X {};
 [[template <class T> struct X<T*> {};]]
 )cpp",
`-SimpleDeclaration
   |-'*'
   |-'>'
   |-'{'
   |-'}'
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ClassTemplateSpecialization_Full) {
+TEST_P(BuildSyntaxTreeTest, ClassTemplateSpecialization_Full) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X {};
 [[template <> struct X<int> {};]]
 )cpp",
`-SimpleDeclaration
   |-'int'
   |-'>'
   |-'{'
   |-'}'
   `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, EmptyDeclaration) {
+TEST_P(BuildSyntaxTreeTest, EmptyDeclaration) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 ;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-EmptyDeclaration
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, StaticAssert) {
+TEST_P(BuildSyntaxTreeTest, StaticAssert) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 static_assert(true, "message");
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-StaticAssertDeclaration
   |-'static_assert'
   |-'('
   |-BoolLiteralExpression Condition
   | `-'true' LiteralToken
   |-','
   |-StringLiteralExpression Message
   | `-'"message"' LiteralToken
   |-')'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, StaticAssert_WithoutMessage) {
+TEST_P(BuildSyntaxTreeTest, StaticAssert_WithoutMessage) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 static_assert(true);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-StaticAssertDeclaration
   |-'static_assert'
   |-'('
   |-BoolLiteralExpression Condition
   | `-'true' LiteralToken
   |-')'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ExternC) {
+TEST_P(BuildSyntaxTreeTest, ExternC) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 extern "C" int a;
 extern "C" { int b; int c; }
 )cpp",
`-LinkageSpecificationDeclaration
   | |-'int'
   | |-SimpleDeclarator Declarator
   | | `-'c'
   | `-';'
   `-'}'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, NonModifiableNodes) {
+TEST_P(BuildSyntaxTreeTest, NonModifiableNodes) {
   // Some nodes are non-modifiable, they are marked with 'I:'.
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 #define HALF_IF if (1+
 #define HALF_IF_2 1) {}
 void test() {
   HALF_IF HALF_IF_2 else {}
 })cpp",
`-CompoundStatement
     | |-'else' ElseKeyword
     | `-CompoundStatement ElseStatement
     |   |-'{' OpenParen
     |   `-'}' CloseParen
     `-'}' CloseParen
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ModifiableNodes) {
+TEST_P(BuildSyntaxTreeTest, ModifiableNodes) {
   // All nodes can be mutated.
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 #define OPEN {
 #define CLOSE }
 
 void test() {
   OPEN
`-CompoundStatement
     | | |-IntegerLiteralExpression Expression
     | | | `-'2' LiteralToken
     | | `-';'
     | `-'}' CloseParen
     `-'}' CloseParen
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, InitDeclarator_Equal) {
+TEST_P(BuildSyntaxTreeTest, InitDeclarator_Equal) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S { S(int);};
 void test() {
   [[S s = 1]];
 }
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'S'
 `-SimpleDeclarator Declarator
   |-'s'
   |-'='
   `-IntegerLiteralExpression
     `-'1' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, InitDeclarator_Brace) {
+TEST_P(BuildSyntaxTreeTest, InitDeclarator_Brace) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S { 
   S();
   S(int);
`-UnknownExpression
     | `-'1' LiteralToken
     |-','
     |-FloatingLiteralExpression
     | `-'2.' LiteralToken
     `-'}'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, InitDeclarator_EqualBrace) {
+TEST_P(BuildSyntaxTreeTest, InitDeclarator_EqualBrace) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S { 
   S();
   S(int);
`-UnknownExpression
     | `-'1' LiteralToken
     |-','
     |-FloatingLiteralExpression
     | `-'2.' LiteralToken
     `-'}'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, InitDeclarator_Paren) {
+TEST_P(BuildSyntaxTreeTest, InitDeclarator_Paren) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   S(int);
   S(int, float);

 |   |-','
 |   |-FloatingLiteralExpression
 |   | `-'2.' LiteralToken
 |   `-')'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, InitDeclarator_Paren_DefaultArguments) {
+TEST_P(BuildSyntaxTreeTest, InitDeclarator_Paren_DefaultArguments) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   S(int i = 1, float = 2.);
 };

 |   |-','
 |   |-FloatingLiteralExpression
 |   | `-'2.' LiteralToken
 |   `-')'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ImplicitConversion_Argument) {
+TEST_P(BuildSyntaxTreeTest, ImplicitConversion_Argument) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X(int);
 };

 |-'(' OpenParen
 |-CallArguments Arguments
 | `-IntegerLiteralExpression ListElement
 |   `-'1' LiteralToken
 `-')' CloseParen
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ImplicitConversion_Return) {
+TEST_P(BuildSyntaxTreeTest, ImplicitConversion_Return) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X(int);
 };
 X CreateX(){
   [[return 1;]]
 }
 )cpp",
       {R"txt(
 ReturnStatement Statement
 |-'return' IntroducerKeyword
 |-IntegerLiteralExpression ReturnValue
 | `-'1' LiteralToken
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ConstructorCall_ZeroArguments) {
+TEST_P(BuildSyntaxTreeTest, ConstructorCall_ZeroArguments) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X();
 };
 X test() {
   [[return X();]]
 }
 )cpp",
       {R"txt(
 ReturnStatement Statement
 |-'return' IntroducerKeyword
 |-UnknownExpression ReturnValue
 | |-'X'
 | |-'('
 | `-')'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ConstructorCall_OneArgument) {
+TEST_P(BuildSyntaxTreeTest, ConstructorCall_OneArgument) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X(int);
 };

 | |-'('
 | |-IntegerLiteralExpression
 | | `-'1' LiteralToken
 | `-')'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ConstructorCall_MultipleArguments) {
+TEST_P(BuildSyntaxTreeTest, ConstructorCall_MultipleArguments) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X(int, char);
 };

 | |-','
 | |-CharacterLiteralExpression
 | | `-''2'' LiteralToken
 | `-')'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ConstructorCall_DefaultArguments) {
+TEST_P(BuildSyntaxTreeTest, ConstructorCall_DefaultArguments) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X(int i = 1, char c = '2');
 };

 | `-'1' LiteralToken
 |-','
 |-CharacterLiteralExpression
 | `-''2'' LiteralToken
 `-')'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, TypeConversion_FunctionalNotation) {
+TEST_P(BuildSyntaxTreeTest, TypeConversion_FunctionalNotation) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 float test() {
   [[return float(1);]]
 }
 )cpp",
       {R"txt(
 ReturnStatement Statement
 |-'return' IntroducerKeyword
 |-UnknownExpression ReturnValue
 | |-'float'
 | |-'('
 | |-IntegerLiteralExpression
 | | `-'1' LiteralToken
 | `-')'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ArrayDeclarator_Simple) {
+TEST_P(BuildSyntaxTreeTest, ArrayDeclarator_Simple) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a[10];
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator Declarator
   | |-'a'
   | `-ArraySubscript
   |   |-'[' OpenParen
   |   |-IntegerLiteralExpression Size
   |   | `-'10' LiteralToken
   |   `-']' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ArrayDeclarator_Multidimensional) {
+TEST_P(BuildSyntaxTreeTest, ArrayDeclarator_Multidimensional) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int b[1][2][3];
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
`-SimpleDeclaration
   |   |-'[' OpenParen
   |   |-IntegerLiteralExpression Size
   |   | `-'3' LiteralToken
   |   `-']' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ArrayDeclarator_UnknownBound) {
+TEST_P(BuildSyntaxTreeTest, ArrayDeclarator_UnknownBound) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int c[] = {1,2,3};
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
`-SimpleDeclaration
   |     |-','
   |     |-IntegerLiteralExpression
   |     | `-'3' LiteralToken
   |     `-'}'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ArrayDeclarator_Static) {
+TEST_P(BuildSyntaxTreeTest, ArrayDeclarator_Static) {
   if (!GetParam().isC99OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void f(int xs[static 10]);
 )cpp",
       R"txt(
`-SimpleDeclaration
   |   |       |-IntegerLiteralExpression Size
   |   |       | `-'10' LiteralToken
   |   |       `-']' CloseParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Empty) {
+TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Empty) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func();
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator Declarator
   | |-'func'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Named) {
+TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Named) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func1(int a);
 int func2(int *ap);
 int func3(int a, float b);
 )cpp",
       R"txt(
 TranslationUnit Detached
`-SimpleDeclaration
   |   |   |-'float'
   |   |   `-SimpleDeclarator Declarator
   |   |     `-'b'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Unnamed) {
+TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Unnamed) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func1(int);
 int func2(int *);
 int func3(int, float);
 )cpp",
       R"txt(
 TranslationUnit Detached
`-SimpleDeclaration
   |   | |-',' ListDelimiter
   |   | `-SimpleDeclaration ListElement
   |   |   `-'float'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Default_One) {
+TEST_P(BuildSyntaxTreeTest,
+       ParametersAndQualifiers_InFreeFunctions_Default_One) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 int func1([[int a = 1]]);
 )cpp",
       {R"txt(
 ParameterDeclarationList Parameters
 `-SimpleDeclaration ListElement
   |-'int'
   `-SimpleDeclarator Declarator
     |-'a'
     |-'='
     `-IntegerLiteralExpression
       `-'1' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest,
+TEST_P(BuildSyntaxTreeTest,
        ParametersAndQualifiers_InFreeFunctions_Default_Multiple) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 int func2([[int *ap, int a = 1, char c = '2']]);
 )cpp",
`-SimpleDeclaration ListElement
   `-SimpleDeclarator Declarator
     |-'c'
     |-'='
     `-CharacterLiteralExpression
       `-''2'' LiteralToken
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest,
+TEST_P(BuildSyntaxTreeTest,
        ParametersAndQualifiers_InVariadicFunctionTemplate_ParameterPack) {
   if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T, typename... Args>
 [[void test(T , Args... );]]

 |   | `-SimpleDeclaration ListElement
 |   |   |-'Args'
 |   |   `-'...'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest,
+TEST_P(BuildSyntaxTreeTest,
        ParametersAndQualifiers_InVariadicFunctionTemplate_NamedParameterPack) {
   if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T, typename... Args>
 [[void test(T t, Args... args);]]

 |   |   |-'...'
 |   |   `-SimpleDeclarator Declarator
 |   |     `-'args'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest,
+TEST_P(BuildSyntaxTreeTest,
        ParametersAndQualifiers_InFreeFunctions_VariadicArguments) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int , char ...);
 )cpp",
`-SimpleDeclaration
   |   | `-SimpleDeclaration ListElement
   |   |   `-'char'
   |   |-'...'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest,
+TEST_P(BuildSyntaxTreeTest,
        ParametersAndQualifiers_InFreeFunctions_Cxx_CvQualifiers) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func(const int a, volatile int b, const volatile int c);
 )cpp",
`-SimpleDeclaration
   |   |   |-'int'
   |   |   `-SimpleDeclarator Declarator
   |   |     `-'c'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Cxx_Ref) {
+TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Cxx_Ref) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func(int& a);
 )cpp",
       R"txt(
`-SimpleDeclaration
   |   |   `-SimpleDeclarator Declarator
   |   |     |-'&'
   |   |     `-'a'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Cxx11_RefRef) {
+TEST_P(BuildSyntaxTreeTest,
+       ParametersAndQualifiers_InFreeFunctions_Cxx11_RefRef) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func(int&& a);
 )cpp",
       R"txt(
`-SimpleDeclaration
   |   |   `-SimpleDeclarator Declarator
   |   |     |-'&&'
   |   |     `-'a'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Simple) {
+TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Simple) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct Test {
   int a();
 };
`-SimpleDeclaration
   | |   |-'(' OpenParen
   | |   `-')' CloseParen
   | `-';'
   |-'}'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_CvQualifiers) {
+TEST_P(BuildSyntaxTreeTest,
+       ParametersAndQualifiers_InMemberFunctions_CvQualifiers) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct Test {
   [[int b() const;]]
   [[int c() volatile;]]

 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   |-'const'
 |   `-'volatile'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Ref) {
+TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Ref) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct Test {
   [[int e() &;]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'int'
 |-SimpleDeclarator Declarator
 | |-'e'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   `-'&'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_RefRef) {
+TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_RefRef) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct Test {
   [[int f() &&;]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'int'
 |-SimpleDeclarator Declarator
 | |-'f'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   `-'&&'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, TrailingReturn) {
+TEST_P(BuildSyntaxTreeTest, TrailingReturn) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 auto foo() -> int;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'auto'
   |-SimpleDeclarator Declarator
   | |-'foo'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   |-')' CloseParen
   |   `-TrailingReturnType TrailingReturn
   |     |-'->' ArrowToken
   |     `-'int'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, DynamicExceptionSpecification) {
+TEST_P(BuildSyntaxTreeTest, DynamicExceptionSpecification) {
   if (!GetParam().supportsCXXDynamicExceptionSpecification()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct MyException1 {};
 struct MyException2 {};
 [[int a() throw();]]

 |   |-'MyException1'
 |   |-','
 |   |-'MyException2'
 |   `-')'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, NoexceptExceptionSpecification) {
+TEST_P(BuildSyntaxTreeTest, NoexceptExceptionSpecification) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a() noexcept;
 int b() noexcept(true);
 )cpp",
`-SimpleDeclaration
   |   |-'('
   |   |-BoolLiteralExpression
   |   | `-'true' LiteralToken
   |   `-')'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, DeclaratorsInParentheses) {
+TEST_P(BuildSyntaxTreeTest, DeclaratorsInParentheses) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int (a);
 int *(b);
 int (*c)(int);
 int *(d)(int);
 )cpp",
       R"txt(
`-SimpleDeclaration
   |   |-ParameterDeclarationList Parameters
   |   | `-SimpleDeclaration ListElement
   |   |   `-'int'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, Declaration_ConstVolatileQualifiers_SimpleConst) {
+TEST_P(BuildSyntaxTreeTest, Declaration_ConstVolatileQualifiers_SimpleConst) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 const int west = -1;
 int const east = 1;
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
`-SimpleDeclaration
   | |-'east'
   | |-'='
   | `-IntegerLiteralExpression
   |   `-'1' LiteralToken
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, Declaration_ConstVolatileQualifiers_MultipleConst) {
+TEST_P(BuildSyntaxTreeTest, Declaration_ConstVolatileQualifiers_MultipleConst) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 const int const universal = 0;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'const'
   |-'int'
   |-'const'
   |-SimpleDeclarator Declarator
   | |-'universal'
   | |-'='
   | `-IntegerLiteralExpression
   |   `-'0' LiteralToken
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, Declaration_ConstVolatileQualifiers_ConstAndVolatile) {
+TEST_P(BuildSyntaxTreeTest,
+       Declaration_ConstVolatileQualifiers_ConstAndVolatile) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 const int const *const *volatile b;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'const'
   |-'int'
   |-'const'
   |-SimpleDeclarator Declarator
   | |-'*'
   | |-'const'
   | |-'*'
   | |-'volatile'
   | `-'b'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
+TEST_P(BuildSyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 auto foo() -> auto(*)(int) -> double*;
 )cpp",
       R"txt(
`-SimpleDeclaration
   |           |-'->' ArrowToken
   |           |-'double'
   |           `-SimpleDeclarator Declarator
   |             `-'*'
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, MemberPointers) {
+TEST_P(BuildSyntaxTreeTest, MemberPointers) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {};
 [[int X::* a;]]
 [[const int X::* b;]]

 | | |-'X'
 | | |-'::'
 | | `-'*'
 | `-'b'
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, MemberFunctionPointer) {
+TEST_P(BuildSyntaxTreeTest, MemberFunctionPointer) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   struct Y {};
 };

 |   | |-',' ListDelimiter
 |   | `-SimpleDeclaration ListElement
 |   |   `-'char'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
-TEST_P(SyntaxTreeTest, ComplexDeclarator) {
+TEST_P(BuildSyntaxTreeTest, ComplexDeclarator) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int));
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
`-SimpleDeclaration
   |   |       | `-SimpleDeclaration ListElement
   |   |       |   `-'int'
   |   |       `-')' CloseParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, ComplexDeclarator2) {
+TEST_P(BuildSyntaxTreeTest, ComplexDeclarator2) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int), long (**c)(long long));
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'

clang/unittests/Tooling/Syntax/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(SyntaxTests
   TreeTestBase.cpp
   BuildTreeTest.cpp
   MutationsTest.cpp
+  SynthesisTest.cpp
   TokensTest.cpp
 )
 
 clang_target_link_libraries(SyntaxTests
   PRIVATE
   clangAST
   clangBasic
   clangFrontend

clang/unittests/Tooling/Syntax/MutationsTest.cpp

 #include "TreeTestBase.h"
 #include "clang/Tooling/Syntax/BuildTree.h"
 
 using namespace clang;
 using namespace clang::syntax;
 
 namespace {
 
-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 {
+class MutationTest : public SyntaxTreeTest {
+protected:
+  using Transformation = std::function<void(const llvm::Annotations & /*Input*/,
+                                            TranslationUnit * /*Root*/)>;
+  void CheckTransformation(Transformation Transform, std::string Input,
+                           std::string Expected) {
     llvm::Annotations Source(Input);
     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());
       return;
     }
 
     EXPECT_EQ(Expected, *Output) << "input is:\n" << Input;
   };
 
   // Removes the selected statement. Input should have exactly one selected
   // range and it should correspond to a single statement.
-  auto RemoveStatement = [this](const llvm::Annotations &Input,
-                                syntax::TranslationUnit *TU) {
-    auto *S = cast<syntax::Statement>(nodeByRange(Input.range(), TU));
+  Transformation RemoveStatement = [this](const llvm::Annotations &Input,
+                                          TranslationUnit *Root) {
+    auto *S = cast<syntax::Statement>(nodeByRange(Input.range(), Root));
     ASSERT_TRUE(S->canModify()) << "cannot remove a statement";
     syntax::removeStatement(*Arena, S);
     EXPECT_TRUE(S->isDetached());
     EXPECT_FALSE(S->isOriginal())
         << "node removed from tree cannot be marked as original";
   };
+};
 
-  std::vector<std::pair<std::string /*Input*/, std::string /*Expected*/>>
-      Cases = {
-          {"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);
+INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, MutationTest,
+                        ::testing::ValuesIn(allTestClangConfigs()), );
+
+TEST_P(MutationTest, RemoveStatement_InCompound) {
+  CheckTransformation(RemoveStatement, "void test() { [[100+100;]] test(); }",
+                      "void test() {  test(); }");
 }
 
-TEST_P(SyntaxTreeTest, SynthesizedNodes) {
-  buildTree("", GetParam());
+TEST_P(MutationTest, RemoveStatement_InCompound_Empty) {
+  CheckTransformation(RemoveStatement, "void test() { [[;]] }",
+                      "void test() {  }");
+}
 
-  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());
+TEST_P(MutationTest, RemoveStatement_LeaveEmpty) {
+  CheckTransformation(RemoveStatement, "void test() { if (1) [[{}]] else {} }",
+                      "void test() { if (1) ; else {} }");
 }
 } // namespace

clang/unittests/Tooling/Syntax/SynthesisTest.cpp

+//===- SynthesisTest.cpp --------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests synthesis API for syntax trees.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TreeTestBase.h"
+#include "clang/Tooling/Syntax/BuildTree.h"
+
+using namespace clang;
+using namespace clang::syntax;
+
+namespace {
+
+INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, SyntaxTreeTest,
+                        ::testing::ValuesIn(allTestClangConfigs()), );
+
+TEST_P(SyntaxTreeTest, Leaf_Punctuation) {
+  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());
+}
+
+TEST_P(SyntaxTreeTest, Statement_Empty) {
+  buildTree("", GetParam());
+
+  auto *S = syntax::createEmptyStatement(*Arena);
+  ASSERT_NE(S, nullptr);
+  EXPECT_TRUE(S->canModify());
+  EXPECT_FALSE(S->isOriginal());
+  EXPECT_TRUE(S->isDetached());
+}
+} // namespace

clang/unittests/Tooling/Syntax/TreeTestBase.h

 namespace syntax {
 class SyntaxTreeTest : public ::testing::Test,
                        public ::testing::WithParamInterface<TestClangConfig> {
 protected:
   // Build a syntax tree for the code.
   TranslationUnit *buildTree(StringRef Code,
                              const TestClangConfig &ClangConfig);
 
-  ::testing::AssertionResult treeDumpEqual(StringRef Code, StringRef Tree);
-
-  ::testing::AssertionResult
-  treeDumpEqualOnAnnotations(StringRef CodeWithAnnotations,
-                             ArrayRef<StringRef> TreeDumps);
   /// Finds the deepest node in the tree that covers exactly \p R.
   /// FIXME: implement this efficiently and move to public syntax tree API.
   syntax::Node *nodeByRange(llvm::Annotations::Range R, syntax::Node *Root);
 
   // Data fields.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
       new DiagnosticsEngine(new DiagnosticIDs, DiagOpts.get());
   IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS =
       new llvm::vfs::InMemoryFileSystem;
   IntrusiveRefCntPtr<FileManager> FileMgr =
       new FileManager(FileSystemOptions(), FS);
   IntrusiveRefCntPtr<SourceManager> SourceMgr =
       new SourceManager(*Diags, *FileMgr);
   std::shared_ptr<CompilerInvocation> Invocation;
   // Set after calling buildTree().
   std::unique_ptr<syntax::TokenBuffer> TB;
   std::unique_ptr<syntax::Arena> Arena;
 };
+
+std::vector<TestClangConfig> allTestClangConfigs();
 } // namespace syntax
 } // namespace clang
 #endif // LLVM_CLANG_UNITTESTS_TOOLING_SYNTAX_TREETESTBASE_H

clang/unittests/Tooling/Syntax/TreeTestBase.cpp

 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);
 }
+} // namespace
 
-std::vector<TestClangConfig> allTestClangConfigs() {
+std::vector<TestClangConfig> clang::syntax::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(allTestClangConfigs()), );
-} // namespace
-
 syntax::TranslationUnit *
 SyntaxTreeTest::buildTree(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::TokenBuffer> &TB,
SyntaxTreeTest::buildTree(StringRef Code, const TestClangConfig &ClangConfig) {
   if (!Compiler.ExecuteAction(Recorder) &&
       Diags->getClient()->getNumErrors() == 0) {
     ADD_FAILURE() << "failed to run the frontend";
     std::abort();
   }
   return Root;
 }
 
-::testing::AssertionResult SyntaxTreeTest::treeDumpEqual(StringRef Code,
-                                                         StringRef Tree) {
-  SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
-
-  auto *Root = buildTree(Code, GetParam());
-  if (Diags->getClient()->getNumErrors() != 0) {
-    return ::testing::AssertionFailure()
-           << "Source file has syntax errors, they were printed to the test "
-              "log";
-  }
-  auto Actual = StringRef(Root->dump(Arena->sourceManager())).trim().str();
-  // EXPECT_EQ shows the diff between the two strings if they are different.
-  EXPECT_EQ(Tree.trim().str(), Actual);
-  if (Actual != Tree.trim().str()) {
-    return ::testing::AssertionFailure();
-  }
-  return ::testing::AssertionSuccess();
-}
-
-::testing::AssertionResult
-SyntaxTreeTest::treeDumpEqualOnAnnotations(StringRef CodeWithAnnotations,
-                                           ArrayRef<StringRef> TreeDumps) {
-  SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
-
-  auto AnnotatedCode = llvm::Annotations(CodeWithAnnotations);
-  auto *Root = buildTree(AnnotatedCode.code(), GetParam());
-
-  if (Diags->getClient()->getNumErrors() != 0) {
-    return ::testing::AssertionFailure()
-           << "Source file has syntax errors, they were printed to the test "
-              "log";
-  }
-
-  auto AnnotatedRanges = AnnotatedCode.ranges();
-  if (AnnotatedRanges.size() != TreeDumps.size()) {
-    return ::testing::AssertionFailure()
-           << "The number of annotated ranges in the source code is different "
-              "to the number of their corresponding tree dumps.";
-  }
-  bool Failed = false;
-  for (unsigned i = 0; i < AnnotatedRanges.size(); i++) {
-    auto *AnnotatedNode = nodeByRange(AnnotatedRanges[i], Root);
-    assert(AnnotatedNode);
-    auto AnnotatedNodeDump =
-        StringRef(AnnotatedNode->dump(Arena->sourceManager())).trim().str();
-    // EXPECT_EQ shows the diff between the two strings if they are different.
-    EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump)
-        << "Dumps diverged for the code:\n"
-        << AnnotatedCode.code().slice(AnnotatedRanges[i].Begin,
-                                      AnnotatedRanges[i].End);
-    if (AnnotatedNodeDump != TreeDumps[i].trim().str())
-      Failed = true;
-  }
-  return Failed ? ::testing::AssertionFailure() : ::testing::AssertionSuccess();
-}
-
 syntax::Node *SyntaxTreeTest::nodeByRange(llvm::Annotations::Range R,
                                           syntax::Node *Root) {
   ArrayRef<syntax::Token> Toks = tokens(Root);
 
   if (Toks.front().location().isFileID() && Toks.back().location().isFileID() &&
       syntax::Token::range(*SourceMgr, Toks.front(), Toks.back()) ==
           syntax::FileRange(SourceMgr->getMainFileID(), R.Begin, R.End))
     return Root;