[SyntaxTree]: Use Annotations in tests to reduce noise

[eduucaldas]

Use unsigned long in the loop index

[eduucaldas]

A proposition, upon review I'll change other tests.

One concern is that we might lose coverage while reducing noise. But I'll take a look into that with calm when changing the tests.

clang/unittests/Tooling/Syntax/TreeTest.cpp

186–187

I just wanted to do a for( auto [range, dump]& : zip(AnnotatedRanges,TreeDumps))

Is indexed loop the way to go in C++?
And also I used 0u here because we make a comparison to std::vector::size_type, is there a less error-prone way of writing those loop indexes?

[gribozavr2]

clang/unittests/Tooling/Syntax/TreeTest.cpp

186–187

Yes, I believe what you have now is indeed the best way.

[eduucaldas]

Use annotations to reduce noise of expression tests

clang/unittests/Tooling/Syntax/TreeTest.cpp

::testing::AssertionResult treeDumpEqual(StringRef Code, StringRef Tree) {
     // 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();
+    assert(AnnotatedRanges.size() == TreeDumps.size());
+    for (auto i = 0ul; i < AnnotatedRanges.size(); i++) {
+      auto *AnnotatedNode = nodeByRange(AnnotatedRanges[i], Root);
+      assert(AnnotatedNode);
+      auto AnnotatedNodeDump =
+          std::string(StringRef(AnnotatedNode->dump(*Arena)).trim());
+      // EXPECT_EQ shows the diff between the two strings if they are different.
+      EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump);
+      if (AnnotatedNodeDump != TreeDumps[i].trim().str())
+        return ::testing::AssertionFailure();
+    }
+    return ::testing::AssertionSuccess();
+  }
+
   // Adds a file to the test VFS.
   void addFile(StringRef Path, StringRef Contents) {
     if (!FS->addFile(Path, time_t(),
                      llvm::MemoryBuffer::getMemBufferCopy(Contents))) {
       ADD_FAILURE() << "could not add a file to VFS: " << Path;
     }
   }
 
`-CompoundStatement
     |   | |   `-test
     |   | |-(
     |   | `-)
     |   `-;
     `-}
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedId) {
+TEST_P(SyntaxTreeTest, UnqualifiedIdDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   // TODO: Expose `id-expression` from `Declarator`
   friend X operator+(const X&, const X&);
   operator int();
 };
 template<typename T>
 void f(T&);
-void test(X x) {
-  x;                      // identifier
-  operator+(x, x);        // operator-function-id
-  f<X>(x);                // template-id
-  // TODO: Expose `id-expression` from `MemberExpr`
-  x.operator int();       // conversion-funtion-id
-  x.~X();                 // ~type-name
-}
+void test(X x);
 )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{
 | |-UnknownDeclaration
`-SimpleDeclaration
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-x
   |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-IdExpression
-    | | `-UnqualifiedId
-    | |   `-x
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   |-operator
-    | | |   `-+
-    | | |-(
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | |-,
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   |-f
-    | | |   |-<
-    | | |   |-X
-    | | |   `->
-    | | |-(
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-UnknownExpression
-    | | | |-IdExpression
-    | | | | `-UnqualifiedId
-    | | | |   `-x
-    | | | |-.
-    | | | |-operator
-    | | | `-int
-    | | |-(
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-UnknownExpression
-    | | | |-IdExpression
-    | | | | `-UnqualifiedId
-    | | | |   `-x
-    | | | |-.
-    | | | |-~
-    | | | `-X
-    | | |-(
-    | | `-)
-    | `-;
-    `-}
-)txt"));
+  `-;
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct X {
+  // TODO: Expose `id-expression` from `Declarator`
+  friend X operator+(const X&, const X&);
+  operator int();
+};
+template<typename T>
+void f(T&);
+void test(X x) 
+[[{
+  x;                      // identifier
+  operator+(x, x);        // operator-function-id
+  f<X>(x);                // template-id
+  // TODO: Expose `id-expression` from `MemberExpr`
+  x.operator int();       // conversion-funtion-id
+  x.~X();                 // ~type-name
+}]]
+)cpp",
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedIdCxx11OrLater) {
+TEST_P(SyntaxTreeTest, UnqualifiedIdCxx11OrLaterDecl) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X { };
 unsigned operator "" _w(long long unsigned);
-void test(X x) {
-  operator "" _w(1llu);   // literal-operator-id
-  // TODO: Expose `id-expression` from `MemberExpr`
-  x.~decltype(x)();       // ~decltype-specifier
-}
+void test(X x);
 )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{
 | |-}
`-SimpleDeclaration
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-x
   |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   |-operator
-    | | |   |-""
-    | | |   `-_w
-    | | |-(
-    | | |-IntegerLiteralExpression
-    | | | `-1llu
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-UnknownExpression
-    | | | |-IdExpression
-    | | | | `-UnqualifiedId
-    | | | |   `-x
-    | | | |-.
-    | | | `-~
-    | | |-decltype
-    | | |-(
-    | | |-x
-    | | |-)
-    | | |-(
-    | | `-)
-    | `-;
-    `-}
-)txt"));
+  `-;
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UnqualifiedIdCxx11OrLater) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct X { };
+unsigned operator "" _w(long long unsigned);
+void test(X x) 
+[[{
+  operator "" _w(1llu);   // literal-operator-id
+  // TODO: Expose `id-expression` from `MemberExpr`
+  x.~decltype(x)();       // ~decltype-specifier
+}]]
+)cpp",
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
-TEST_P(SyntaxTreeTest, QualifiedId) {
+TEST_P(SyntaxTreeTest, QualifiedIdDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace n {
   struct S {
     template<typename T>
     struct ST {
       static void f();
     };
   };
 }
 template<typename T>
 struct ST {
   struct S {
     template<typename U>
     static U f();
   };
 };
-void test() {
-  ::                 // global-namespace-specifier
-  n::                // namespace-specifier
-  S::                // type-name-specifier
-  template ST<int>:: // type-template-instantiation-specifier
-  f();
-
-  n::                // namespace-specifier
-  S::                // type-name-specifier
-  ST<int>::          // type-template-instantiation-specifier
-  f();
-
-  ST<int>::         // type-name-specifier
-  S::               // type-name-specifier
-  f<int>();
-
-  ST<int>::         // type-name-specifier
-  S::               // type-name-specifier
-  template f<int>();
-}
+void test(); 
 )cpp",
       R"txt(
 *: TranslationUnit
 |-NamespaceDefinition
 | |-namespace
 | |-n
 | |-{
 | |-SimpleDeclaration

 |   `-;
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | |-NestedNameSpecifier
-    | | | | |-::
-    | | | | |-IdentifierNameSpecifier
-    | | | | | `-n
-    | | | | |-::
-    | | | | |-IdentifierNameSpecifier
-    | | | | | `-S
-    | | | | |-::
-    | | | | |-SimpleTemplateNameSpecifier
-    | | | | | |-template
-    | | | | | |-ST
-    | | | | | |-<
-    | | | | | |-int
-    | | | | | `->
-    | | | | `-::
-    | | | `-UnqualifiedId
-    | | |   `-f
-    | | |-(
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | |-NestedNameSpecifier
-    | | | | |-IdentifierNameSpecifier
-    | | | | | `-n
-    | | | | |-::
-    | | | | |-IdentifierNameSpecifier
-    | | | | | `-S
-    | | | | |-::
-    | | | | |-SimpleTemplateNameSpecifier
-    | | | | | |-ST
-    | | | | | |-<
-    | | | | | |-int
-    | | | | | `->
-    | | | | `-::
-    | | | `-UnqualifiedId
-    | | |   `-f
-    | | |-(
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | |-NestedNameSpecifier
-    | | | | |-SimpleTemplateNameSpecifier
-    | | | | | |-ST
-    | | | | | |-<
-    | | | | | |-int
-    | | | | | `->
-    | | | | |-::
-    | | | | |-IdentifierNameSpecifier
-    | | | | | `-S
-    | | | | `-::
-    | | | `-UnqualifiedId
-    | | |   |-f
-    | | |   |-<
-    | | |   |-int
-    | | |   `->
-    | | |-(
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | |-NestedNameSpecifier
-    | | | | |-SimpleTemplateNameSpecifier
-    | | | | | |-ST
-    | | | | | |-<
-    | | | | | |-int
-    | | | | | `->
-    | | | | |-::
-    | | | | |-IdentifierNameSpecifier
-    | | | | | `-S
-    | | | | `-::
-    | | | |-template
-    | | | `-UnqualifiedId
-    | | |   |-f
-    | | |   |-<
-    | | |   |-int
-    | | |   `->
-    | | |-(
-    | | `-)
-    | `-;
-    `-}
-)txt"));
+  `-;
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, QualifiedId) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+namespace n {
+  struct S {
+    template<typename T>
+    struct ST {
+      static void f();
+    };
+  };
+}
+template<typename T>
+struct ST {
+  struct S {
+    template<typename U>
+    static U f();
+  };
+};
+void test() 
+[[{
+::n::S::template ST<int>::f();
+n::S::ST<int>::f();
+ST<int>::S::f<int>();
+ST<int>::S::template f<int>();
+}]]
+)cpp",
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedIdWithDependentType) {
   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;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <typename T>
-void test() {
+void test() 
+[[{
   T::template U<int>::f();
-
   T::U::f();
-
   T::template f<0>();
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-TemplateDeclaration
-  |-template
-  |-<
-  |-UnknownDeclaration
-  | |-typename
-  | `-T
-  |->
-  `-SimpleDeclaration
-    |-void
-    |-SimpleDeclarator
-    | |-test
-    | `-ParametersAndQualifiers
-    |   |-(
-    |   `-)
-    `-CompoundStatement
-      |-{
-      |-ExpressionStatement
-      | |-UnknownExpression
-      | | |-IdExpression
-      | | | |-NestedNameSpecifier
-      | | | | |-IdentifierNameSpecifier
-      | | | | | `-T
-      | | | | |-::
-      | | | | |-SimpleTemplateNameSpecifier
-      | | | | | |-template
-      | | | | | |-U
-      | | | | | |-<
-      | | | | | |-int
-      | | | | | `->
-      | | | | `-::
-      | | | `-UnqualifiedId
-      | | |   `-f
-      | | |-(
-      | | `-)
-      | `-;
-      |-ExpressionStatement
-      | |-UnknownExpression
-      | | |-IdExpression
-      | | | |-NestedNameSpecifier
-      | | | | |-IdentifierNameSpecifier
-      | | | | | `-T
-      | | | | |-::
-      | | | | |-IdentifierNameSpecifier
-      | | | | | `-U
-      | | | | `-::
-      | | | `-UnqualifiedId
-      | | |   `-f
-      | | |-(
-      | | `-)
-      | `-;
-      |-ExpressionStatement
-      | |-UnknownExpression
-      | | |-IdExpression
-      | | | |-NestedNameSpecifier
-      | | | | |-IdentifierNameSpecifier
-      | | | | | `-T
-      | | | | `-::
-      | | | |-template
-      | | | `-UnqualifiedId
-      | | |   |-f
-      | | |   |-<
-      | | |   |-IntegerLiteralExpression
-      | | |   | `-0
-      | | |   `->
-      | | |-(
-      | | `-)
-      | `-;
-      `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
-TEST_P(SyntaxTreeTest, QualifiedIdDecltype) {
+TEST_P(SyntaxTreeTest, QualifiedIdDecltypeDecl) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct S {
   static void f(){}
 };
-void test(S s) {
-  decltype(s)::   // decltype-specifier
-      f();
-}
+void test(S s);
 )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-S
 | |-{
 | |-SimpleDeclaration
`-SimpleDeclaration
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-S
   |   | `-SimpleDeclarator
   |   |   `-s
   |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | |-NestedNameSpecifier
-    | | | | |-DecltypeNameSpecifier
-    | | | | | |-decltype
-    | | | | | |-(
-    | | | | | |-IdExpression
-    | | | | | | `-UnqualifiedId
-    | | | | | |   `-s
-    | | | | | `-)
-    | | | | `-::
-    | | | `-UnqualifiedId
-    | | |   `-f
-    | | |-(
-    | | `-)
-    | `-;
-    `-}
-)txt"));
+  `-;
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, QualifiedIdDecltype) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct S {
+  static void f(){}
+};
+void test(S s) 
+[[{
+  decltype(s)::   // decltype-specifier
+      f();
+}]]
+)cpp",
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ParenExpr) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() [[{
   (1);
   ((1));
   (1 + (2));
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-ParenExpression
-    | | |-(
-    | | |-IntegerLiteralExpression
-    | | | `-1
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-ParenExpression
-    | | |-(
-    | | |-ParenExpression
-    | | | |-(
-    | | | |-IntegerLiteralExpression
-    | | | | `-1
-    | | | `-)
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-ParenExpression
-    | | |-(
-    | | |-BinaryOperatorExpression
-    | | | |-IntegerLiteralExpression
-    | | | | `-1
-    | | | |-+
-    | | | `-ParenExpression
-    | | |   |-(
-    | | |   |-IntegerLiteralExpression
-    | | |   | `-2
-    | | |   `-)
-    | | `-)
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UserDefinedLiteral) {
+TEST_P(SyntaxTreeTest, UserDefinedLiteralDecl) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 typedef decltype(sizeof(void *)) size_t;
 
 unsigned operator "" _i(unsigned long long);
 unsigned operator "" _f(long double);
 unsigned operator "" _c(char);
 unsigned operator "" _s(const char*, size_t);
 unsigned operator "" _r(const char*);
 template <char...>
 unsigned operator "" _t();
 
-void test() {
-  12_i;   // call: operator "" _i(12uLL)      | kind: integer
-  1.2_f;  // call: operator "" _f(1.2L)       | kind: float
-  '2'_c;  // call: operator "" _c('2')        | kind: char
-  "12"_s; // call: operator "" _s("12")       | kind: string
-
-  12_r;   // call: operator "" _r("12")       | kind: integer
-  1.2_r;  // call: operator "" _i("1.2")      | kind: float
-  12_t;   // call: operator<'1', '2'> "" _x() | kind: integer
-  1.2_t;  // call: operator<'1', '2'> "" _x() | kind: float
-}
+void test();
     )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-typedef
 | |-decltype
 | |-(
 | |-UnknownExpression

 |   `-;
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-IntegerUserDefinedLiteralExpression
-    | | `-12_i
-    | `-;
-    |-ExpressionStatement
-    | |-FloatUserDefinedLiteralExpression
-    | | `-1.2_f
-    | `-;
-    |-ExpressionStatement
-    | |-CharUserDefinedLiteralExpression
-    | | `-'2'_c
-    | `-;
-    |-ExpressionStatement
-    | |-StringUserDefinedLiteralExpression
-    | | `-"12"_s
-    | `-;
-    |-ExpressionStatement
-    | |-IntegerUserDefinedLiteralExpression
-    | | `-12_r
-    | `-;
-    |-ExpressionStatement
-    | |-FloatUserDefinedLiteralExpression
-    | | `-1.2_r
-    | `-;
-    |-ExpressionStatement
-    | |-IntegerUserDefinedLiteralExpression
-    | | `-12_t
-    | `-;
-    |-ExpressionStatement
-    | |-FloatUserDefinedLiteralExpression
-    | | `-1.2_t
-    | `-;
-    `-}
-)txt"));
+  `-;
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UserDefinedLiteral) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+typedef decltype(sizeof(void *)) size_t;
+
+unsigned operator "" _i(unsigned long long);
+unsigned operator "" _f(long double);
+unsigned operator "" _c(char);
+unsigned operator "" _s(const char*, size_t);
+unsigned operator "" _r(const char*);
+template <char...>
+unsigned operator "" _t();
+
+void test() 
+[[{
+  12_i;   // call: operator "" _i(12uLL)      | kind: integer
+  1.2_f;  // call: operator "" _f(1.2L)       | kind: float
+  '2'_c;  // call: operator "" _c('2')        | kind: char
+  "12"_s; // call: operator "" _s("12")       | kind: string
+
+  12_r;   // call: operator "" _r("12")       | kind: integer
+  1.2_r;  // call: operator "" _i("1.2")      | kind: float
+  12_t;   // call: operator<'1', '2'> "" _x() | kind: integer
+  1.2_t;  // call: operator<'1', '2'> "" _x() | kind: float
+}]]
+    )cpp",
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, IntegerLiteralLongLong) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() 
+[[{
   12ll;
   12ull;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-IntegerLiteralExpression
-    | | `-12ll
-    | `-;
-    |-ExpressionStatement
-    | |-IntegerLiteralExpression
-    | | `-12ull
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, IntegerLiteralBinary) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
`-CompoundStatement
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, IntegerLiteralWithDigitSeparators) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() 
+[[{
   1'2'0ull;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-IntegerLiteralExpression
-    | | `-1'2'0ull
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CharacterLiteral) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() 
+[[{
   'a';
   '\n';
   '\x20';
   '\0';
   L'a';
   L'α';
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-CharacterLiteralExpression
-    | | `-'a'
-    | `-;
-    |-ExpressionStatement
-    | |-CharacterLiteralExpression
-    | | `-'\n'
-    | `-;
-    |-ExpressionStatement
-    | |-CharacterLiteralExpression
-    | | `-'\x20'
-    | `-;
-    |-ExpressionStatement
-    | |-CharacterLiteralExpression
-    | | `-'\0'
-    | `-;
-    |-ExpressionStatement
-    | |-CharacterLiteralExpression
-    | | `-L'a'
-    | `-;
-    |-ExpressionStatement
-    | |-CharacterLiteralExpression
-    | | `-L'α'
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
+// FIXME: This has problems with annotations
 TEST_P(SyntaxTreeTest, CharacterLiteralUtf) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   u'a';
`-CompoundStatement
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, CharacterLiteralUtf8) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() 
+[[{
   u8'a';
   u8'\x7f';
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-CharacterLiteralExpression
-    | | `-u8'a'
-    | `-;
-    |-ExpressionStatement
-    | |-CharacterLiteralExpression
-    | | `-u8'\x7f'
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, FloatingLiteral) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() 
+[[{
   1e-2;
   2.;
   .2;
   2.f;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-FloatingLiteralExpression
-    | | `-1e-2
-    | `-;
-    |-ExpressionStatement
-    | |-FloatingLiteralExpression
-    | | `-2.
-    | `-;
-    |-ExpressionStatement
-    | |-FloatingLiteralExpression
-    | | `-.2
-    | `-;
-    |-ExpressionStatement
-    | |-FloatingLiteralExpression
-    | | `-2.f
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, FloatingLiteralHexadecimal) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() [[{
   0xfp1;
   0xf.p1;
   0x.fp1;
   0xf.fp1f;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-FloatingLiteralExpression
-    | | `-0xfp1
-    | `-;
-    |-ExpressionStatement
-    | |-FloatingLiteralExpression
-    | | `-0xf.p1
-    | `-;
-    |-ExpressionStatement
-    | |-FloatingLiteralExpression
-    | | `-0x.fp1
-    | `-;
-    |-ExpressionStatement
-    | |-FloatingLiteralExpression
-    | | `-0xf.fp1f
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, StringLiteral) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() [[{
   "a\n\0\x20";
   L"αβ";
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-StringLiteralExpression
-    | | `-"a\n\0\x20"
-    | `-;
-    |-ExpressionStatement
-    | |-StringLiteralExpression
-    | | `-L"αβ"
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, StringLiteralUtf) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() 
+[[{
   u8"a\x1f\x05";
   u"C++抽象構文木";
   U"📖🌲\n";
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-StringLiteralExpression
-    | | `-u8"a\x1f\x05"
-    | `-;
-    |-ExpressionStatement
-    | |-StringLiteralExpression
-    | | `-u"C++抽象構文木"
-    | `-;
-    |-ExpressionStatement
-    | |-StringLiteralExpression
-    | | `-U"📖🌲\n"
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, StringLiteralRaw) {
   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( //
-      "void test() {\n"
+  EXPECT_TRUE(treeDumpEqualOnAnnotations("void test() [[{\n"
                                          "  R\"SyntaxTree(\n"
                                          "  Hello \"Syntax\" \\\"\n"
                                          "  )SyntaxTree\";\n"
-      "}\n",
-      "*: TranslationUnit\n"
-      "`-SimpleDeclaration\n"
-      "  |-void\n"
-      "  |-SimpleDeclarator\n"
-      "  | |-test\n"
-      "  | `-ParametersAndQualifiers\n"
-      "  |   |-(\n"
-      "  |   `-)\n"
-      "  `-CompoundStatement\n"
-      "    |-{\n"
-      "    |-ExpressionStatement\n"
-      "    | |-StringLiteralExpression\n"
-      "    | | `-R\"SyntaxTree(\n"
+                                         "}]]\n",
+                                         {"CompoundStatement\n"
+                                          "|-{\n"
+                                          "|-ExpressionStatement\n"
+                                          "| |-StringLiteralExpression\n"
+                                          "| | `-R\"SyntaxTree(\n"
                                           "  Hello \"Syntax\" \\\"\n"
                                           "  )SyntaxTree\"\n"
-      "    | `-;\n"
-      "    `-}\n"));
+                                          "| `-;\n"
+                                          "`-}\n"}));
 }
 
 TEST_P(SyntaxTreeTest, BoolLiteral) {
   if (GetParam().isC()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() [[{
   true;
   false;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-BoolLiteralExpression
-    | | `-true
-    | `-;
-    |-ExpressionStatement
-    | |-BoolLiteralExpression
-    | | `-false
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test() {
+void test() [[{
   nullptr;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-CxxNullPtrExpression
-    | | `-nullptr
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test(int a) {
+void test(int a) [[{
   a++;
   a--;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   |-SimpleDeclaration
-  |   | |-int
-  |   | `-SimpleDeclarator
-  |   |   `-a
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-PostfixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-a
-    | | `-++
-    | `-;
-    |-ExpressionStatement
-    | |-PostfixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-a
-    | | `---
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, PrefixUnaryOperator) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test(int a, int *ap) {
+void test(int a, int *ap) [[{
   --a; ++a;
   ~a;
   -a;
   +a;
   &a;
   *ap;
   !a;
   __real a; __imag a;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   |-SimpleDeclaration
-  |   | |-int
-  |   | `-SimpleDeclarator
-  |   |   `-a
-  |   |-,
-  |   |-SimpleDeclaration
-  |   | |-int
-  |   | `-SimpleDeclarator
-  |   |   |-*
-  |   |   `-ap
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |---
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-++
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-~
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |--
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-+
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-&
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-*
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-ap
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-!
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-__real
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-__imag
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, PrefixUnaryOperatorCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test(int a, bool b) {
+void test(int a, bool b) [[{
   compl a;
   not b;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   |-SimpleDeclaration
-  |   | |-int
-  |   | `-SimpleDeclarator
-  |   |   `-a
-  |   |-,
-  |   |-SimpleDeclaration
-  |   | |-bool
-  |   | `-SimpleDeclarator
-  |   |   `-b
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-compl
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-a
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-not
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-b
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
+// FIXME: Annotations don't work here because there is a `^`
 TEST_P(SyntaxTreeTest, BinaryOperator) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int a) {
   1 - 2;
   1 == 2;
   a = 1;
   a <<= 1;
`-CompoundStatement
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperatorCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test(int a) {
+void test(int a) [[{
   true || false;
   true or false;
   1 bitand 2;
   a xor_eq 3;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   |-SimpleDeclaration
-  |   | |-int
-  |   | `-SimpleDeclarator
-  |   |   `-a
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-BoolLiteralExpression
-    | | | `-true
-    | | |-||
-    | | `-BoolLiteralExpression
-    | |   `-false
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-BoolLiteralExpression
-    | | | `-true
-    | | |-or
-    | | `-BoolLiteralExpression
-    | |   `-false
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-IntegerLiteralExpression
-    | | | `-1
-    | | |-bitand
-    | | `-IntegerLiteralExpression
-    | |   `-2
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-a
-    | | |-xor_eq
-    | | `-IntegerLiteralExpression
-    | |   `-3
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, NestedBinaryOperator) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void test(int a, int b) {
+void test(int a, int b) [[{
   (1 + 2) * (4 / 2);
   a + b + 42;
   a = b = 42;
   a + b * 4 + 2;
   a % 2 + b * 42;
-}
+}]]
 )cpp",
-      R"txt(
-*: TranslationUnit
-`-SimpleDeclaration
-  |-void
-  |-SimpleDeclarator
-  | |-test
-  | `-ParametersAndQualifiers
-  |   |-(
-  |   |-SimpleDeclaration
-  |   | |-int
-  |   | `-SimpleDeclarator
-  |   |   `-a
-  |   |-,
-  |   |-SimpleDeclaration
-  |   | |-int
-  |   | `-SimpleDeclarator
-  |   |   `-b
-  |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-ParenExpression
-    | | | |-(
-    | | | |-BinaryOperatorExpression
-    | | | | |-IntegerLiteralExpression
-    | | | | | `-1
-    | | | | |-+
-    | | | | `-IntegerLiteralExpression
-    | | | |   `-2
-    | | | `-)
-    | | |-*
-    | | `-ParenExpression
-    | |   |-(
-    | |   |-BinaryOperatorExpression
-    | |   | |-IntegerLiteralExpression
-    | |   | | `-4
-    | |   | |-/
-    | |   | `-IntegerLiteralExpression
-    | |   |   `-2
-    | |   `-)
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-BinaryOperatorExpression
-    | | | |-IdExpression
-    | | | | `-UnqualifiedId
-    | | | |   `-a
-    | | | |-+
-    | | | `-IdExpression
-    | | |   `-UnqualifiedId
-    | | |     `-b
-    | | |-+
-    | | `-IntegerLiteralExpression
-    | |   `-42
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-a
-    | | |-=
-    | | `-BinaryOperatorExpression
-    | |   |-IdExpression
-    | |   | `-UnqualifiedId
-    | |   |   `-b
-    | |   |-=
-    | |   `-IntegerLiteralExpression
-    | |     `-42
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-BinaryOperatorExpression
-    | | | |-IdExpression
-    | | | | `-UnqualifiedId
-    | | | |   `-a
-    | | | |-+
-    | | | `-BinaryOperatorExpression
-    | | |   |-IdExpression
-    | | |   | `-UnqualifiedId
-    | | |   |   `-b
-    | | |   |-*
-    | | |   `-IntegerLiteralExpression
-    | | |     `-4
-    | | |-+
-    | | `-IntegerLiteralExpression
-    | |   `-2
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-BinaryOperatorExpression
-    | | | |-IdExpression
-    | | | | `-UnqualifiedId
-    | | | |   `-a
-    | | | |-%
-    | | | `-IntegerLiteralExpression
-    | | |   `-2
-    | | |-+
-    | | `-BinaryOperatorExpression
-    | |   |-IdExpression
-    | |   | `-UnqualifiedId
-    | |   |   `-b
-    | |   |-*
-    | |   `-IntegerLiteralExpression
-    | |     `-42
-    | `-;
-    `-}
-)txt"));
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UserDefinedBinaryOperator) {
+TEST_P(SyntaxTreeTest, UserDefinedBinaryOperatorDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   X& operator=(const X&);
   friend X operator+(X, const X&);
   friend bool operator<(const X&, const X&);
   friend X operator<<(X&, const X&);
   X operator,(X&);
   X operator->*(int);
   // TODO: Unbox operators in syntax tree.
   // Represent operators by `+` instead of `IdExpression-UnqualifiedId-+`
 };
-void test(X x, X y, X* xp, int X::* pmi) {
-  x = y;
-  x + y;
-  x < y;
-  x << y;
-  x, y;
-  xp->*pmi;
-}
+void test(X x, X y, X* xp, int X::* pmi) ;
 )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{
 | |-SimpleDeclaration
`-SimpleDeclaration
   |   | |-int
   |   | `-SimpleDeclarator
   |   |   |-MemberPointer
   |   |   | |-X
   |   |   | |-::
   |   |   | `-*
   |   |   `-pmi
   |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-=
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-y
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-UnknownExpression
-    | | | `-IdExpression
-    | | |   `-UnqualifiedId
-    | | |     `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-+
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-y
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-<
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-y
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-<<
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-y
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-,
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-y
-    | `-;
-    |-ExpressionStatement
-    | |-BinaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-xp
-    | | |-->*
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-pmi
-    | `-;
-    `-}
-)txt"));
+  `-;
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UserDefinedBinaryOperator) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct X {
+  X& operator=(const X&);
+  friend X operator+(X, const X&);
+  friend bool operator<(const X&, const X&);
+  friend X operator<<(X&, const X&);
+  X operator,(X&);
+  X operator->*(int);
+  // TODO: Unbox operators in syntax tree.
+  // Represent operators by `+` instead of `IdExpression-UnqualifiedId-+`
+};
+void test(X x, X y, X* xp, int X::* pmi) [[{
+  x = y;
+  x + y;
+  x < y;
+  x << y;
+  x, y;
+  xp->*pmi;
+}]]
+)cpp",
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UserDefinedUnaryPrefixOperator) {
+TEST_P(SyntaxTreeTest, UserDefinedUnaryPrefixOperatorDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   X operator++();
   bool operator!();
   X* operator&();
 };
-void test(X x) {
-  ++x;
-  !x;
-  &x;
-}
+void test(X x);
 )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{
 | |-SimpleDeclaration
`-SimpleDeclaration
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-x
   |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-++
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-x
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-!
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-x
-    | `-;
-    |-ExpressionStatement
-    | |-PrefixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-&
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-x
-    | `-;
-    `-}
-)txt"));
+  `-;
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UserDefinedUnaryPrefixOperator) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct X {
+  X operator++();
+  bool operator!();
+  X* operator&();
+};
+void test(X x) [[{
+  ++x;
+  !x;
+  &x;
+}]]
+)cpp",
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
-TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperator) {
+TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperatorDecl) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   X operator++(int);
 };
-void test(X x) {
-  x++;
-}
+void test(X x);
 )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{
 | |-SimpleDeclaration
`-SimpleDeclaration
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-x
   |   `-)
-  `-CompoundStatement
-    |-{
-    |-ExpressionStatement
-    | |-PostfixUnaryOperatorExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | `-IdExpression
-    | |   `-UnqualifiedId
-    | |     `-++
-    | `-;
-    `-}
-)txt"));
+  `-;
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperator) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct X {
+  X operator++(int);
+};
+void test(X x) [[{
+  x++;
+}]]
+)cpp",
+      {R"txt(
+CompoundStatement
+)txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int *a, b;
 int *c, d;
 )cpp",
`-LinkageSpecificationDeclaration
   | |-int
   | |-SimpleDeclarator
   | | `-c
   | `-;
   `-}
 )txt"));
 }
 
+// FIXME: This could use annotations
 TEST_P(SyntaxTreeTest, 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 {}
`-SimpleDeclaration
   |           |-->
   |           |-double
   |           `-SimpleDeclarator
   |             `-*
   `-;
 )txt"));
 }
 
+// FIXME: This could use annotations
 TEST_P(SyntaxTreeTest, MemberPointers) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {};
 int X::* a;
`-SimpleDeclaration
   | | |-X
   | | |-::
   | | `-*
   | `-b
   `-;
 )txt"));
 }
 
+// FIXME: This could use annotations
 TEST_P(SyntaxTreeTest, MemberFunctionPointer) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   struct Y {};