[Syntax] Model FunctionDefinition.

[hokein]

Fix and simplify the test.

clang/include/clang/Tooling/Syntax/Nodes.h

public:
   ExplicitTemplateInstantiation()
       : Declaration(NodeKind::ExplicitTemplateInstantiation) {}
   static bool classof(const Node *N);
   Leaf *getTemplateKeyword();
   Leaf *getExternKeyword();
   Declaration *getDeclaration();
 };
 
+/// Models a function definition. C++ [dcl.fct.def]
+/// e.g. `void func() {}`
+class FunctionDefinition final : public Declaration {
+public:
+  FunctionDefinition() : Declaration(NodeKind::FunctionDefinition) {}
+  static bool classof(const Node *N);
+  SimpleDeclarator *getDeclarator();
+  // FIXME: support "= default;", "= delete;".
+  syntax::Statement *getFunctionBody();
+};
+
 /// namespace <name> { <decls> }
 class NamespaceDefinition final : public Declaration {
 public:
   NamespaceDefinition() : Declaration(NodeKind::NamespaceDefinition) {}
   static bool classof(const Node *N);
 };
 
 /// namespace <name> = <namespace-reference>

clang/include/clang/Tooling/Syntax/Nodes.td

 def Declaration : External<Tree> {}
 def UnknownDeclaration : External<Declaration> {}
 def EmptyDeclaration : External<Declaration> {}
 def StaticAssertDeclaration : External<Declaration> {}
 def LinkageSpecificationDeclaration : External<Declaration> {}
 def SimpleDeclaration : External<Declaration> {}
 def TemplateDeclaration : External<Declaration> {}
 def ExplicitTemplateInstantiation : External<Declaration> {}
+def FunctionDefinition : External<Declaration> {}
 def NamespaceDefinition : External<Declaration> {}
 def NamespaceAliasDefinition : External<Declaration> {}
 def UsingNamespaceDirective : External<Declaration> {}
 def UsingDeclaration : External<Declaration> {}
 def TypeAliasDeclaration : External<Declaration> {}
 
 // Declarators.
 def Declarator : External<Tree> {}

clang/lib/Tooling/Syntax/BuildTree.cpp

explicit BuildTreeVisitor(ASTContext &Context, syntax::TreeBuilder &Builder)
       : Builder(Builder), Context(Context) {}
 
   bool shouldTraversePostOrder() const { return true; }
 
   bool WalkUpFromDeclaratorDecl(DeclaratorDecl *DD) {
     return processDeclaratorAndDeclaration(DD);
   }
 
+  bool WalkUpFromFunctionDecl(FunctionDecl *FF) {
+    if (FF->isDefined()) {
+      auto Declarator = new (allocator()) syntax::SimpleDeclarator();
+      auto DeclaratorRange = getDeclaratorRange(
+          Builder.sourceManager(), FF->getTypeSourceInfo()->getTypeLoc(),
+          getQualifiedNameStart(FF), getInitializerRange(FF));
+      Builder.foldNode(Builder.getRange(DeclaratorRange), Declarator, nullptr);
+      Builder.markChild(Declarator, syntax::NodeRole::Declarator);
+      if (FF->doesThisDeclarationHaveABody())
+        Builder.markStmtChild(FF->getBody(), syntax::NodeRole::BodyStatement);
+      Builder.foldNode(Builder.getRange(FF->getSourceRange()),
+                       new (allocator()) syntax::FunctionDefinition, FF);
+      return true;
+    }
+    // this is not a function definition, build declaration instead.
+    return WalkUpFromDeclaratorDecl(FF);
+  }
+
   bool WalkUpFromTypedefNameDecl(TypedefNameDecl *TD) {
     return processDeclaratorAndDeclaration(TD);
   }
 
   bool VisitDecl(Decl *D) {
     assert(!D->isImplicit());
     Builder.foldNode(Builder.getDeclarationRange(D),
                      new (allocator()) syntax::UnknownDeclaration(), D);

clang/lib/Tooling/Syntax/Nodes.cpp

syntax::Leaf *syntax::ExplicitTemplateInstantiation::getExternKeyword() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
 }
 
 syntax::Declaration *syntax::ExplicitTemplateInstantiation::getDeclaration() {
   return cast_or_null<syntax::Declaration>(
       findChild(syntax::NodeRole::Declaration));
 }
 
+syntax::SimpleDeclarator *syntax::FunctionDefinition::getDeclarator() {
+  return cast_or_null<syntax::SimpleDeclarator>(
+      findChild(syntax::NodeRole::Declarator));
+}
+
+syntax::Statement *syntax::FunctionDefinition::getFunctionBody() {
+  return cast_or_null<syntax::Statement>(
+      findChild(syntax::NodeRole::BodyStatement));
+}
+
 syntax::Leaf *syntax::ParenDeclarator::getLparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
 syntax::Leaf *syntax::ParenDeclarator::getRparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 

clang/lib/Tooling/Syntax/Synthesis.cpp

syntax::Tree *allocateTree(syntax::Arena &A, syntax::NodeKind Kind) {
   case syntax::NodeKind::SimpleDeclaration:
     return new (A.getAllocator()) syntax::SimpleDeclaration;
   case syntax::NodeKind::TemplateDeclaration:
     return new (A.getAllocator()) syntax::TemplateDeclaration;
   case syntax::NodeKind::ExplicitTemplateInstantiation:
     return new (A.getAllocator()) syntax::ExplicitTemplateInstantiation;
   case syntax::NodeKind::NamespaceDefinition:
     return new (A.getAllocator()) syntax::NamespaceDefinition;
+  case syntax::NodeKind::FunctionDefinition:
+    return new (A.getAllocator()) syntax::FunctionDefinition;
   case syntax::NodeKind::NamespaceAliasDefinition:
     return new (A.getAllocator()) syntax::NamespaceAliasDefinition;
   case syntax::NodeKind::UsingNamespaceDirective:
     return new (A.getAllocator()) syntax::UsingNamespaceDirective;
   case syntax::NodeKind::UsingDeclaration:
     return new (A.getAllocator()) syntax::UsingDeclaration;
   case syntax::NodeKind::TypeAliasDeclaration:
     return new (A.getAllocator()) syntax::TypeAliasDeclaration;

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

::testing::AssertionResult errorOK(StringRef RawCode) {
     }
     return ::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
-| |-'int'
-| |-DeclaratorList Declarators
-| | `-SimpleDeclarator ListElement
-| |   |-'main'
-| |   `-ParametersAndQualifiers
-| |     |-'(' OpenParen
-| |     `-')' CloseParen
-| `-CompoundStatement
-|   |-'{' OpenParen
-|   `-'}' CloseParen
-`-SimpleDeclaration
-  |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'foo'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     `-')' CloseParen
-  `-CompoundStatement
-    |-'{' OpenParen
-    `-'}' CloseParen
-)txt"));
-}
-
 TEST_P(BuildSyntaxTreeTest, SimpleVariable) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a;
 int b = 42;
 )cpp",
       R"txt(
 TranslationUnit Detached
`-SimpleDeclaration
   |   |-'='
   |   `-IntegerLiteralExpression
   |     `-'42' LiteralToken
   `-';'
 )txt"));
 }
 
 TEST_P(BuildSyntaxTreeTest, SimpleFunction) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
-void foo(int a, int b) {}
+[[void foo(int a, int b) {}]]
 )cpp",
-      R"txt(
+      {R"txt(
 TranslationUnit Detached
-`-SimpleDeclaration
+`-FunctionDefinition
   |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'foo'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     |-ParameterDeclarationList Parameters
-  |     | |-SimpleDeclaration ListElement
-  |     | | |-'int'
-  |     | | `-DeclaratorList Declarators
-  |     | |   `-SimpleDeclarator ListElement
-  |     | |     `-'a'
-  |     | |-',' ListDelimiter
-  |     | `-SimpleDeclaration ListElement
-  |     |   |-'int'
-  |     |   `-DeclaratorList Declarators
-  |     |     `-SimpleDeclarator ListElement
-  |     |       `-'b'
-  |     `-')' CloseParen
-  `-CompoundStatement
+  |-SimpleDeclarator Declarator
+  | |-'foo'
+  | `-ParametersAndQualifiers
+  |   |-'(' OpenParen
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
+  |   | | |-'int'
+  |   | | `-DeclaratorList Declarators
+  |   | |   `-SimpleDeclarator ListElement
+  |   | |     `-'a'
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
+  |   |   |-'int'
+  |   |   `-DeclaratorList Declarators
+  |   |     `-SimpleDeclarator ListElement
+  |   |       `-'b'
+  |   `-')' CloseParen
+  `-CompoundStatement BodyStatement
     |-'{' OpenParen
     `-'}' CloseParen
-)txt"));
+)txt"}));
 }
 
 TEST_P(BuildSyntaxTreeTest, Simple_BackslashInsideToken) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 in\
 t a;
 )cpp",
`-ReturnStatement
   | `-'100' LiteralToken
   `-';'
 )txt"}));
 }
 
 TEST_P(BuildSyntaxTreeTest, Expressions) {
   // expressions should be wrapped in 'ExpressionStatement' when they appear
   // in a statement position.
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
-  test();
-  if (1) test(); else test();
+  [[test();]]
+  [[if (1) test(); else test();]]
 }
 )cpp",
-      R"txt(
-TranslationUnit Detached
-`-SimpleDeclaration
-  |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'test'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     `-')' CloseParen
-  `-CompoundStatement
-    |-'{' OpenParen
-    |-ExpressionStatement Statement
-    | |-CallExpression Expression
-    | | |-IdExpression Callee
-    | | | `-UnqualifiedId UnqualifiedId
-    | | |   `-'test'
-    | | |-'(' OpenParen
-    | | `-')' CloseParen
-    | `-';'
-    |-IfStatement Statement
-    | |-'if' IntroducerKeyword
-    | |-'('
-    | |-ExpressionStatement Condition
-    | | `-IntegerLiteralExpression Expression
-    | |   `-'1' LiteralToken
-    | |-')'
-    | |-ExpressionStatement ThenStatement
-    | | |-CallExpression Expression
-    | | | |-IdExpression Callee
-    | | | | `-UnqualifiedId UnqualifiedId
-    | | | |   `-'test'
-    | | | |-'(' OpenParen
-    | | | `-')' CloseParen
-    | | `-';'
-    | |-'else' ElseKeyword
-    | `-ExpressionStatement ElseStatement
-    |   |-CallExpression Expression
-    |   | |-IdExpression Callee
-    |   | | `-UnqualifiedId UnqualifiedId
-    |   | |   `-'test'
-    |   | |-'(' OpenParen
-    |   | `-')' CloseParen
-    |   `-';'
-    `-'}' CloseParen
-)txt"));
+      {R"txt(
+ExpressionStatement Statement
+|-CallExpression Expression
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
+| |   `-'test'
+| |-'(' OpenParen
+| `-')' CloseParen
+`-';'
+)txt",
+       R"txt(
+IfStatement Statement
+|-'if' IntroducerKeyword
+|-'('
+|-ExpressionStatement Condition
+| `-IntegerLiteralExpression Expression
+|   `-'1' LiteralToken
+|-')'
+|-ExpressionStatement ThenStatement
+| |-CallExpression Expression
+| | |-IdExpression Callee
+| | | `-UnqualifiedId UnqualifiedId
+| | |   `-'test'
+| | |-'(' OpenParen
+| | `-')' CloseParen
+| `-';'
+|-'else' ElseKeyword
+`-ExpressionStatement ElseStatement
+  |-CallExpression Expression
+  | |-IdExpression Callee
+  | | `-UnqualifiedId UnqualifiedId
+  | |   `-'test'
+  | |-'(' OpenParen
+  | `-')' CloseParen
+  `-';'
+)txt"}));
 }
 
 TEST_P(BuildSyntaxTreeTest, UnqualifiedId_Identifier) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[a]];
 }

 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(treeDumpEqualOnAnnotations( //
       "void test() {\n"
-      "  R\"SyntaxTree(\n"
+      "  [[R\"SyntaxTree(\n"
       "  Hello \"Syntax\" \\\"\n"
-      "  )SyntaxTree\";\n"
+      "  )SyntaxTree\"]];\n"
       "}\n",
-      "TranslationUnit Detached\n"
-      "`-SimpleDeclaration\n"
-      "  |-'void'\n"
-      "  |-DeclaratorList Declarators\n"
-      "  | `-SimpleDeclarator ListElement\n"
-      "  |   |-'test'\n"
-      "  |   `-ParametersAndQualifiers\n"
-      "  |     |-'(' OpenParen\n"
-      "  |     `-')' CloseParen\n"
-      "  `-CompoundStatement\n"
-      "    |-'{' OpenParen\n"
-      "    |-ExpressionStatement Statement\n"
-      "    | |-StringLiteralExpression Expression\n"
-      "    | | `-'R\"SyntaxTree(\n"
+      {"StringLiteralExpression Expression\n"
+       "`-'R\"SyntaxTree(\n"
        "  Hello \"Syntax\" \\\"\n"
-      "  )SyntaxTree\"' LiteralToken\n"
-      "    | `-';'\n"
-      "    `-'}' CloseParen\n"));
+       "  )SyntaxTree\"' LiteralToken\n"}));
 }
 
 TEST_P(BuildSyntaxTreeTest, BoolLiteral) {
   if (GetParam().isC()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(

 };
 // FIXME: `<int>` should be a child of `MemberExpression` and `;` of
 // `ExpressionStatement`. This is a bug in clang, in `getSourceRange` methods.
 void test(S s) [[{
   s.x<int>;
 }]]
 )cpp",
       {R"txt(
-CompoundStatement
+CompoundStatement BodyStatement
 |-'{' OpenParen
 |-ExpressionStatement Statement
 | `-MemberExpression Expression
 |   |-IdExpression Object
 |   | `-UnqualifiedId UnqualifiedId
 |   |   `-'s'
 |   |-'.' AccessToken
 |   `-IdExpression Member
`-SimpleDeclaration
   | |-',' ListDelimiter
   | `-SimpleDeclarator ListElement
   |   `-'b'
   `-';'
 )txt"));
 }
 
 TEST_P(BuildSyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
-  EXPECT_TRUE(treeDumpEqual(
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void foo() {
-  int *a, b;
-  typedef int *ta, tb;
+  [[int *a, b]];
+  [[typedef int *ta, tb]];
 }
 )cpp",
+      {R"txt(
+SimpleDeclaration
+|-'int'
+`-DeclaratorList Declarators
+  |-SimpleDeclarator ListElement
+  | |-'*'
+  | `-'a'
+  |-',' ListDelimiter
+  `-SimpleDeclarator ListElement
+    `-'b'
+)txt",
        R"txt(
-TranslationUnit Detached
-`-SimpleDeclaration
-  |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'foo'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     `-')' CloseParen
-  `-CompoundStatement
-    |-'{' OpenParen
-    |-DeclarationStatement Statement
-    | |-SimpleDeclaration
-    | | |-'int'
-    | | `-DeclaratorList Declarators
-    | |   |-SimpleDeclarator ListElement
-    | |   | |-'*'
-    | |   | `-'a'
-    | |   |-',' ListDelimiter
-    | |   `-SimpleDeclarator ListElement
-    | |     `-'b'
-    | `-';'
-    |-DeclarationStatement Statement
-    | |-SimpleDeclaration
-    | | |-'typedef'
-    | | |-'int'
-    | | `-DeclaratorList Declarators
-    | |   |-SimpleDeclarator ListElement
-    | |   | |-'*'
-    | |   | `-'ta'
-    | |   |-',' ListDelimiter
-    | |   `-SimpleDeclarator ListElement
-    | |     `-'tb'
-    | `-';'
-    `-'}' CloseParen
-)txt"));
+SimpleDeclaration
+|-'typedef'
+|-'int'
+`-DeclaratorList Declarators
+  |-SimpleDeclarator ListElement
+  | |-'*'
+  | `-'ta'
+  |-',' ListDelimiter
+  `-SimpleDeclarator ListElement
+    `-'tb'
+)txt"}));
 }
 
 TEST_P(BuildSyntaxTreeTest, SizeTTypedef) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
TEST_P(BuildSyntaxTreeTest, StaticMemberFunction) {
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   [[static void f(){}]]
 };
 )cpp",
       {R"txt(
-SimpleDeclaration
+FunctionDefinition
 |-'static'
 |-'void'
-|-DeclaratorList Declarators
-| `-SimpleDeclarator ListElement
-|   |-'f'
-|   `-ParametersAndQualifiers
-|     |-'(' OpenParen
-|     `-')' CloseParen
-`-CompoundStatement
+|-SimpleDeclarator Declarator
+| |-'f'
+| `-ParametersAndQualifiers
+|   |-'(' OpenParen
+|   `-')' CloseParen
+`-CompoundStatement BodyStatement
   |-'{' OpenParen
   `-'}' CloseParen
 )txt"}));
 }
 
 TEST_P(BuildSyntaxTreeTest, OutOfLineMemberFunctionDefinition) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   void f();
 };
 [[void S::f(){}]]
 )cpp",
       {R"txt(
-SimpleDeclaration
+FunctionDefinition
 |-'void'
-|-DeclaratorList Declarators
-| `-SimpleDeclarator ListElement
-|   |-NestedNameSpecifier
-|   | |-IdentifierNameSpecifier ListElement
-|   | | `-'S'
-|   | `-'::' ListDelimiter
-|   |-'f'
-|   `-ParametersAndQualifiers
-|     |-'(' OpenParen
-|     `-')' CloseParen
-`-CompoundStatement
+|-SimpleDeclarator Declarator
+| |-NestedNameSpecifier
+| | |-IdentifierNameSpecifier ListElement
+| | | `-'S'
+| | `-'::' ListDelimiter
+| |-'f'
+| `-ParametersAndQualifiers
+|   |-'(' OpenParen
+|   `-')' CloseParen
+`-CompoundStatement BodyStatement
   |-'{' OpenParen
   `-'}' CloseParen
 )txt"}));
 }
 
 TEST_P(BuildSyntaxTreeTest, ConversionMemberFunction) {
   if (!GetParam().isCXX()) {
     return;
void test() {
 
   OPEN
     2;
   }
 }
 )cpp",
       R"txt(
 TranslationUnit Detached
-`-SimpleDeclaration
+`-FunctionDefinition
   |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'test'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     `-')' CloseParen
-  `-CompoundStatement
+  |-SimpleDeclarator Declarator
+  | |-'test'
+  | `-ParametersAndQualifiers
+  |   |-'(' OpenParen
+  |   `-')' CloseParen
+  `-CompoundStatement BodyStatement
     |-'{' OpenParen
     |-CompoundStatement Statement
     | |-'{' OpenParen
     | |-ExpressionStatement Statement
     | | |-IntegerLiteralExpression Expression
     | | | `-'1' LiteralToken
     | | `-';'
     | `-'}' CloseParen
TEST_P(BuildSyntaxTreeTest, Macro_ObjectLike_MatchTree) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 #define BRACES {}
 
 void test() BRACES
 )cpp",
       R"txt(
 TranslationUnit Detached
-`-SimpleDeclaration
+`-FunctionDefinition
   |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'test'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     `-')' CloseParen
-  `-CompoundStatement
+  |-SimpleDeclarator Declarator
+  | |-'test'
+  | `-ParametersAndQualifiers
+  |   |-'(' OpenParen
+  |   `-')' CloseParen
+  `-CompoundStatement BodyStatement
     |-'{' OpenParen unmodifiable
     `-'}' CloseParen unmodifiable
 )txt"));
 }
 
 TEST_P(BuildSyntaxTreeTest, Macro_ObjectLike_MismatchTree) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 #define HALF_IF if (1+
 #define HALF_IF_2 1) {}
 void test() {
   HALF_IF HALF_IF_2 else {}
 })cpp",
       R"txt(
 TranslationUnit Detached
-`-SimpleDeclaration
+`-FunctionDefinition
   |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'test'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     `-')' CloseParen
-  `-CompoundStatement
+  |-SimpleDeclarator Declarator
+  | |-'test'
+  | `-ParametersAndQualifiers
+  |   |-'(' OpenParen
+  |   `-')' CloseParen
+  `-CompoundStatement BodyStatement
     |-'{' OpenParen
     |-IfStatement Statement
     | |-'if' IntroducerKeyword unmodifiable
     | |-'(' unmodifiable
     | |-ExpressionStatement Condition unmodifiable
     | | `-BinaryOperatorExpression Expression unmodifiable
     | |   |-IntegerLiteralExpression LeftHandSide unmodifiable
     | |   | `-'1' LiteralToken unmodifiable

 #define MIN(X,Y) X < Y ? X : Y
 
 void test() {
   MIN(1,2);
 }
 )cpp",
       R"txt(
 TranslationUnit Detached
-`-SimpleDeclaration
+`-FunctionDefinition
   |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'test'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     `-')' CloseParen
-  `-CompoundStatement
+  |-SimpleDeclarator Declarator
+  | |-'test'
+  | `-ParametersAndQualifiers
+  |   |-'(' OpenParen
+  |   `-')' CloseParen
+  `-CompoundStatement BodyStatement
     |-'{' OpenParen
     |-ExpressionStatement Statement
     | |-UnknownExpression Expression
     | | |-BinaryOperatorExpression unmodifiable
     | | | |-IntegerLiteralExpression LeftHandSide
     | | | | `-'1' LiteralToken
     | | | |-'<' OperatorToken unmodifiable
     | | | `-IntegerLiteralExpression RightHandSide
EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 #define HALF_IF(X) if (X &&
 #define HALF_IF_2(Y) Y) {}
 void test() {
   HALF_IF(1) HALF_IF_2(0) else {}
 })cpp",
       R"txt(
 TranslationUnit Detached
-`-SimpleDeclaration
+`-FunctionDefinition
   |-'void'
-  |-DeclaratorList Declarators
-  | `-SimpleDeclarator ListElement
-  |   |-'test'
-  |   `-ParametersAndQualifiers
-  |     |-'(' OpenParen
-  |     `-')' CloseParen
-  `-CompoundStatement
+  |-SimpleDeclarator Declarator
+  | |-'test'
+  | `-ParametersAndQualifiers
+  |   |-'(' OpenParen
+  |   `-')' CloseParen
+  `-CompoundStatement BodyStatement
     |-'{' OpenParen
     |-IfStatement Statement
     | |-'if' IntroducerKeyword unmodifiable
     | |-'(' unmodifiable
     | |-ExpressionStatement Condition unmodifiable
     | | `-BinaryOperatorExpression Expression unmodifiable
     | |   |-IntegerLiteralExpression LeftHandSide
     | |   | `-'1' LiteralToken

 void f(int);
 void g(int, int);
 void test() [[{
   CALL(f, 0);
   CALL(g, 0, 1);
 }]]
 )cpp",
       {R"txt(
-CompoundStatement
+CompoundStatement BodyStatement
 |-'{' OpenParen
 |-ExpressionStatement Statement
 | |-CallExpression Expression
 | | |-IdExpression Callee
 | | | `-UnqualifiedId UnqualifiedId
 | | |   `-'f'
 | | |-'(' OpenParen unmodifiable
 | | |-CallArguments Arguments

clang/unittests/Tooling/Syntax/SynthesisTest.cpp

void test() {
 
   auto *Copy = deepCopyExpandingMacros(*Arena, OriginalTree);
 
   // The syntax tree stores already expanded Tokens, we can only see whether the
   // macro was expanded when computing replacements. The dump does show that
   // nodes in the copy are `modifiable`.
   EXPECT_TRUE(treeDumpEqual(Copy, R"txt(
 TranslationUnit Detached synthesized
-`-SimpleDeclaration synthesized
+`-FunctionDefinition synthesized
   |-'void' synthesized
-  |-DeclaratorList Declarators synthesized
-  | `-SimpleDeclarator ListElement synthesized
-  |   |-'test' synthesized
-  |   `-ParametersAndQualifiers synthesized
-  |     |-'(' OpenParen synthesized
-  |     `-')' CloseParen synthesized
-  `-CompoundStatement synthesized
+  |-SimpleDeclarator Declarator synthesized
+  | |-'test' synthesized
+  | `-ParametersAndQualifiers synthesized
+  |   |-'(' OpenParen synthesized
+  |   `-')' CloseParen synthesized
+  `-CompoundStatement BodyStatement synthesized
     |-'{' OpenParen synthesized
     |-IfStatement Statement synthesized
     | |-'if' IntroducerKeyword synthesized
     | |-'(' synthesized
     | |-ExpressionStatement Condition synthesized
     | | `-BinaryOperatorExpression Expression synthesized
     | |   |-IntegerLiteralExpression LeftHandSide synthesized
     | |   | `-'1' LiteralToken synthesized