[SyntaxTree] Refactor `NodeRole`s

[eduucaldas]

Summary

Previously a NodeRole would generally be prefixed with the NodeKind,
we remove this prefix, as it we redundant and made tests more noisy.

[eduucaldas]

rebase

[gribozavr2]

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

156–181

I'd suggest to remove the cross-references in the comments. In my experience, one is much better off using "find references" in the IDE. The comments can (and do) rapidly become stale.

[eduucaldas]

answer comment.

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

enum class NodeKind : uint16_t {
   ParenDeclarator,
 
   ArraySubscript,
   TrailingReturnType,
   ParametersAndQualifiers,
   MemberPointer,
   UnqualifiedId,
   ParameterDeclarationList,
+  CallArguments,
   // Nested Name Specifiers.
   NestedNameSpecifier,
   GlobalNameSpecifier,
   DecltypeNameSpecifier,
   IdentifierNameSpecifier,
   SimpleTemplateNameSpecifier,
-  CallArguments
 };
 /// For debugging purposes.
 raw_ostream &operator<<(raw_ostream &OS, NodeKind K);
 
 /// A relation between a parent and child node, e.g. 'left-hand-side of
 /// a binary expression'. Used for implementing accessors.
 ///
+/// In general `NodeRole`s should be named the same as their accessors.
+///
 /// Some roles describe parent/child relations that occur multiple times in
 /// language grammar. We define only one role to describe all instances of such
 /// recurring relations. For example, grammar for both "if" and "while"
 /// statements requires an opening paren and a closing paren. The opening
 /// paren token is assigned the OpenParen role regardless of whether it appears
 /// as a child of IfStatement or WhileStatement node. More generally, when
 /// grammar requires a certain fixed token (like a specific keyword, or an
 /// opening paren), we define a role for this token and use it across all
 /// grammar rules with the same requirement. Names of such reusable roles end
 /// with a ~Token or a ~Keyword suffix.
-///
-/// Some roles are assigned only to child nodes of one specific parent syntax
-/// node type. Names of such roles start with the name of the parent syntax tree
-/// node type. For example, a syntax node with a role
-/// BinaryOperatorExpression_leftHandSide can only appear as a child of a
-/// BinaryOperatorExpression node.
 enum class NodeRole : uint8_t {
   // Roles common to multiple node kinds.
   /// A node without a parent
   Detached,
   /// Children of an unknown semantic nature, e.g. skipped tokens, comments.
   Unknown,
   /// An opening parenthesis in argument lists and blocks, e.g. '{', '(', etc.
   OpenParen,
   /// A closing parenthesis in argument lists and blocks, e.g. '}', ')', etc.
   CloseParen,
   /// A keywords that introduces some grammar construct, e.g. 'if', 'try', etc.
   IntroducerKeyword,
   /// A token that represents a literal, e.g. 'nullptr', '1', 'true', etc.
   LiteralToken,
-  /// Tokens or Keywords
+  /// Tokens or Keywords.
   ArrowToken,
   ExternKeyword,
   TemplateKeyword,
   /// An inner statement for those that have only a single child of kind
   /// statement, e.g. loop body for while, for, etc; inner statement for case,
   /// default, etc.
   BodyStatement,
-  List_element,
-  List_delimiter,
+  /// List API roles.
+  ListElement,
+  ListDelimiter,
 
   // Roles specific to particular node kinds.
-  OperatorExpression_operatorToken,
-  UnaryOperatorExpression_operand,
-  BinaryOperatorExpression_leftHandSide,
-  BinaryOperatorExpression_rightHandSide,
-  CaseStatement_value,
-  IfStatement_thenStatement,
-  IfStatement_elseKeyword,
-  IfStatement_elseStatement,
-  ReturnStatement_value,
-  ExpressionStatement_expression,
-  CompoundStatement_statement,
-  StaticAssertDeclaration_condition,
-  StaticAssertDeclaration_message,
-  SimpleDeclaration_declarator,
-  TemplateDeclaration_declaration,
-  ExplicitTemplateInstantiation_declaration,
-  ArraySubscript_sizeExpression,
-  TrailingReturnType_declarator,
-  ParametersAndQualifiers_parameters,
-  ParametersAndQualifiers_trailingReturn,
-  IdExpression_id,
-  IdExpression_qualifier,
-  ParenExpression_subExpression,
-  MemberExpression_object,
-  MemberExpression_accessToken,
-  MemberExpression_member,
-  CallExpression_callee,
-  CallExpression_arguments,
+  OperatorToken,
+  Operand,
+  LeftHandSide,
+  RightHandSide,
+  ReturnValue,
+  CaseValue,
+  ThenStatement,
+  ElseKeyword,
+  ElseStatement,
+  Expression,
+  Statement,
+  Condition,
+  Message,
+  Declarator,
+  Declaration,
+  Size,
+  Parameters,
+  TrailingReturn,
+  UnqualifiedId,
+  Qualifier,
+  SubExpression,
+  Object,
+  AccessToken,
+  Member,
+  Callee,
+  Arguments,
 };
 /// For debugging purposes.
 raw_ostream &operator<<(raw_ostream &OS, NodeRole R);
 
 class SimpleDeclarator;
 
 /// A root node for a translation unit. Parent is always null.
 class TranslationUnit final : public Tree {

 /// case <value>: <body>
 class CaseStatement final : public Statement {
 public:
   CaseStatement() : Statement(NodeKind::CaseStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::CaseStatement;
   }
   Leaf *caseKeyword();
-  Expression *value();
+  Expression *caseValue();
   Statement *body();
 };
 
 /// default: <body>
 class DefaultStatement final : public Statement {
 public:
   DefaultStatement() : Statement(NodeKind::DefaultStatement) {}
   static bool classof(const Node *N) {

 /// return;
 class ReturnStatement final : public Statement {
 public:
   ReturnStatement() : Statement(NodeKind::ReturnStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ReturnStatement;
   }
   Leaf *returnKeyword();
-  Expression *value();
+  Expression *returnValue();
 };
 
 /// for (<decl> : <init>) <body>
 class RangeBasedForStatement final : public Statement {
 public:
   RangeBasedForStatement() : Statement(NodeKind::RangeBasedForStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::RangeBasedForStatement;

 class ArraySubscript final : public Tree {
 public:
   ArraySubscript() : Tree(NodeKind::ArraySubscript) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ArraySubscript;
   }
   // TODO: add an accessor for the "static" keyword.
   Leaf *lbracket();
-  Expression *sizeExpression();
+  Expression *size();
   Leaf *rbracket();
 };
 
 /// Trailing return type after the parameter list, including the arrow token.
 /// E.g. `-> int***`.
 class TrailingReturnType final : public Tree {
 public:
   TrailingReturnType() : Tree(NodeKind::TrailingReturnType) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::TrailingReturnType;
   }
   // TODO: add accessors for specifiers.
   Leaf *arrowToken();
+  // FIXME: This should be a `type-id` following the grammar. Fix this once we
+  // have a representation of `type-id`s.
   SimpleDeclarator *declarator();
 };
 
 /// Models a `parameter-declaration-list` which appears within
 /// `parameters-and-qualifiers`. See C++ [dcl.fct]
 class ParameterDeclarationList final : public List {
 public:
   ParameterDeclarationList() : List(NodeKind::ParameterDeclarationList) {}

clang/lib/Tooling/Syntax/BuildTree.cpp

bool WalkUpFromTranslationUnitDecl(TranslationUnitDecl *TU) {
     return true;
   }
 
   bool WalkUpFromCompoundStmt(CompoundStmt *S) {
     using NodeRole = syntax::NodeRole;
 
     Builder.markChildToken(S->getLBracLoc(), NodeRole::OpenParen);
     for (auto *Child : S->body())
-      Builder.markStmtChild(Child, NodeRole::CompoundStatement_statement);
+      Builder.markStmtChild(Child, NodeRole::Statement);
     Builder.markChildToken(S->getRBracLoc(), NodeRole::CloseParen);
 
     Builder.foldNode(Builder.getStmtRange(S),
                      new (allocator()) syntax::CompoundStatement, S);
     return true;
   }
 
   // Some statements are not yet handled by syntax trees.
public:
   // prefixes.
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc QualifierLoc) {
     if (!QualifierLoc)
       return true;
     for (auto it = QualifierLoc; it; it = it.getPrefix()) {
       auto *NS = BuildNameSpecifier(it);
       if (!NS)
         return false;
-      Builder.markChild(NS, syntax::NodeRole::List_element);
-      Builder.markChildToken(it.getEndLoc(), syntax::NodeRole::List_delimiter);
+      Builder.markChild(NS, syntax::NodeRole::ListElement);
+      Builder.markChildToken(it.getEndLoc(), syntax::NodeRole::ListDelimiter);
     }
     Builder.foldNode(Builder.getRange(QualifierLoc.getSourceRange()),
                      new (allocator()) syntax::NestedNameSpecifier,
                      QualifierLoc);
     return true;
   }
 
   syntax::IdExpression *buildIdExpression(NestedNameSpecifierLoc QualifierLoc,
                                           SourceLocation TemplateKeywordLoc,
                                           SourceRange UnqualifiedIdLoc,
                                           ASTPtr From) {
     if (QualifierLoc) {
-      Builder.markChild(QualifierLoc, syntax::NodeRole::IdExpression_qualifier);
+      Builder.markChild(QualifierLoc, syntax::NodeRole::Qualifier);
       if (TemplateKeywordLoc.isValid())
         Builder.markChildToken(TemplateKeywordLoc,
                                syntax::NodeRole::TemplateKeyword);
     }
 
     auto *TheUnqualifiedId = new (allocator()) syntax::UnqualifiedId;
     Builder.foldNode(Builder.getRange(UnqualifiedIdLoc), TheUnqualifiedId,
                      nullptr);
-    Builder.markChild(TheUnqualifiedId, syntax::NodeRole::IdExpression_id);
+    Builder.markChild(TheUnqualifiedId, syntax::NodeRole::UnqualifiedId);
 
     auto IdExpressionBeginLoc =
         QualifierLoc ? QualifierLoc.getBeginLoc() : UnqualifiedIdLoc.getBegin();
 
     auto *TheIdExpression = new (allocator()) syntax::IdExpression;
     Builder.foldNode(
         Builder.getRange(IdExpressionBeginLoc, UnqualifiedIdLoc.getEnd()),
         TheIdExpression, From);
if (S->isImplicitAccess()) {
                         SourceRange(S->getMemberLoc(), S->getEndLoc()), S);
       return true;
     }
 
     auto *TheIdExpression = buildIdExpression(
         S->getQualifierLoc(), S->getTemplateKeywordLoc(),
         SourceRange(S->getMemberLoc(), S->getEndLoc()), nullptr);
 
-    Builder.markChild(TheIdExpression,
-                      syntax::NodeRole::MemberExpression_member);
+    Builder.markChild(TheIdExpression, syntax::NodeRole::Member);
 
-    Builder.markExprChild(S->getBase(),
-                          syntax::NodeRole::MemberExpression_object);
-    Builder.markChildToken(S->getOperatorLoc(),
-                           syntax::NodeRole::MemberExpression_accessToken);
+    Builder.markExprChild(S->getBase(), syntax::NodeRole::Object);
+    Builder.markChildToken(S->getOperatorLoc(), syntax::NodeRole::AccessToken);
 
     Builder.foldNode(Builder.getExprRange(S),
                      new (allocator()) syntax::MemberExpression, S);
     return true;
   }
 
   bool WalkUpFromDeclRefExpr(DeclRefExpr *S) {
     buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
if (!S->isImplicit()) {
       Builder.foldNode(Builder.getExprRange(S),
                        new (allocator()) syntax::ThisExpression, S);
     }
     return true;
   }
 
   bool WalkUpFromParenExpr(ParenExpr *S) {
     Builder.markChildToken(S->getLParen(), syntax::NodeRole::OpenParen);
-    Builder.markExprChild(S->getSubExpr(),
-                          syntax::NodeRole::ParenExpression_subExpression);
+    Builder.markExprChild(S->getSubExpr(), syntax::NodeRole::SubExpression);
     Builder.markChildToken(S->getRParen(), syntax::NodeRole::CloseParen);
     Builder.foldNode(Builder.getExprRange(S),
                      new (allocator()) syntax::ParenExpression, S);
     return true;
   }
 
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
     Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
     Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
     Builder.foldNode(Builder.getExprRange(S),
                      new (allocator()) syntax::CxxNullPtrExpression, S);
     return true;
   }
 
   bool WalkUpFromUnaryOperator(UnaryOperator *S) {
     Builder.markChildToken(S->getOperatorLoc(),
-                           syntax::NodeRole::OperatorExpression_operatorToken);
-    Builder.markExprChild(S->getSubExpr(),
-                          syntax::NodeRole::UnaryOperatorExpression_operand);
+                           syntax::NodeRole::OperatorToken);
+    Builder.markExprChild(S->getSubExpr(), syntax::NodeRole::Operand);
 
     if (S->isPostfix())
       Builder.foldNode(Builder.getExprRange(S),
                        new (allocator()) syntax::PostfixUnaryOperatorExpression,
                        S);
     else
       Builder.foldNode(Builder.getExprRange(S),
                        new (allocator()) syntax::PrefixUnaryOperatorExpression,
                        S);
 
     return true;
   }
 
   bool WalkUpFromBinaryOperator(BinaryOperator *S) {
-    Builder.markExprChild(
-        S->getLHS(), syntax::NodeRole::BinaryOperatorExpression_leftHandSide);
+    Builder.markExprChild(S->getLHS(), syntax::NodeRole::LeftHandSide);
     Builder.markChildToken(S->getOperatorLoc(),
-                           syntax::NodeRole::OperatorExpression_operatorToken);
-    Builder.markExprChild(
-        S->getRHS(), syntax::NodeRole::BinaryOperatorExpression_rightHandSide);
+                           syntax::NodeRole::OperatorToken);
+    Builder.markExprChild(S->getRHS(), syntax::NodeRole::RightHandSide);
     Builder.foldNode(Builder.getExprRange(S),
                      new (allocator()) syntax::BinaryOperatorExpression, S);
     return true;
   }
 
   syntax::CallArguments *buildCallArguments(CallExpr::arg_range Args) {
     for (const auto &Arg : Args) {
-      Builder.markExprChild(Arg, syntax::NodeRole::List_element);
+      Builder.markExprChild(Arg, syntax::NodeRole::ListElement);
       const auto *DelimiterToken =
           std::next(Builder.findToken(Arg->getEndLoc()));
       if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
-        Builder.markChildToken(DelimiterToken,
-                               syntax::NodeRole::List_delimiter);
+        Builder.markChildToken(DelimiterToken, syntax::NodeRole::ListDelimiter);
     }
 
     auto *Arguments = new (allocator()) syntax::CallArguments;
     if (!Args.empty())
       Builder.foldNode(Builder.getRange((*Args.begin())->getBeginLoc(),
                                         (*(Args.end() - 1))->getEndLoc()),
                        Arguments, nullptr);
 
     return Arguments;
   }
 
   bool WalkUpFromCallExpr(CallExpr *S) {
-    Builder.markExprChild(S->getCallee(),
-                          syntax::NodeRole::CallExpression_callee);
+    Builder.markExprChild(S->getCallee(), syntax::NodeRole::Callee);
 
     const auto *LParenToken =
         std::next(Builder.findToken(S->getCallee()->getEndLoc()));
     // FIXME: Assert that `LParenToken` is indeed a `l_paren` once we have fixed
     // the test on decltype desctructors.
     if (LParenToken->kind() == clang::tok::l_paren)
       Builder.markChildToken(LParenToken, syntax::NodeRole::OpenParen);
 
     Builder.markChild(buildCallArguments(S->arguments()),
-                      syntax::NodeRole::CallExpression_arguments);
+                      syntax::NodeRole::Arguments);
 
     Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);
 
     Builder.foldNode(Builder.getRange(S->getSourceRange()),
                      new (allocator()) syntax::CallExpression, S);
     return true;
   }
 
for (auto *child : S->arguments()) {
         return false;
     }
     return WalkUpFromCXXOperatorCallExpr(S);
   }
 
   bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
     switch (getOperatorNodeKind(*S)) {
     case syntax::NodeKind::BinaryOperatorExpression:
-      Builder.markExprChild(
-          S->getArg(0),
-          syntax::NodeRole::BinaryOperatorExpression_leftHandSide);
-      Builder.markChildToken(
-          S->getOperatorLoc(),
-          syntax::NodeRole::OperatorExpression_operatorToken);
-      Builder.markExprChild(
-          S->getArg(1),
-          syntax::NodeRole::BinaryOperatorExpression_rightHandSide);
+      Builder.markExprChild(S->getArg(0), syntax::NodeRole::LeftHandSide);
+      Builder.markChildToken(S->getOperatorLoc(),
+                             syntax::NodeRole::OperatorToken);
+      Builder.markExprChild(S->getArg(1), syntax::NodeRole::RightHandSide);
       Builder.foldNode(Builder.getExprRange(S),
                        new (allocator()) syntax::BinaryOperatorExpression, S);
       return true;
     case syntax::NodeKind::PrefixUnaryOperatorExpression:
-      Builder.markChildToken(
-          S->getOperatorLoc(),
-          syntax::NodeRole::OperatorExpression_operatorToken);
-      Builder.markExprChild(S->getArg(0),
-                            syntax::NodeRole::UnaryOperatorExpression_operand);
+      Builder.markChildToken(S->getOperatorLoc(),
+                             syntax::NodeRole::OperatorToken);
+      Builder.markExprChild(S->getArg(0), syntax::NodeRole::Operand);
       Builder.foldNode(Builder.getExprRange(S),
                        new (allocator()) syntax::PrefixUnaryOperatorExpression,
                        S);
       return true;
     case syntax::NodeKind::PostfixUnaryOperatorExpression:
-      Builder.markChildToken(
-          S->getOperatorLoc(),
-          syntax::NodeRole::OperatorExpression_operatorToken);
-      Builder.markExprChild(S->getArg(0),
-                            syntax::NodeRole::UnaryOperatorExpression_operand);
+      Builder.markChildToken(S->getOperatorLoc(),
+                             syntax::NodeRole::OperatorToken);
+      Builder.markExprChild(S->getArg(0), syntax::NodeRole::Operand);
       Builder.foldNode(Builder.getExprRange(S),
                        new (allocator()) syntax::PostfixUnaryOperatorExpression,
                        S);
       return true;
     case syntax::NodeKind::CallExpression: {
-      Builder.markExprChild(S->getArg(0),
-                            syntax::NodeRole::CallExpression_callee);
+      Builder.markExprChild(S->getArg(0), syntax::NodeRole::Callee);
 
       const auto *LParenToken =
           std::next(Builder.findToken(S->getArg(0)->getEndLoc()));
       // FIXME: Assert that `LParenToken` is indeed a `l_paren` once we have
       // fixed the test on decltype desctructors.
       if (LParenToken->kind() == clang::tok::l_paren)
         Builder.markChildToken(LParenToken, syntax::NodeRole::OpenParen);
 
       Builder.markChild(buildCallArguments(CallExpr::arg_range(
                             S->arg_begin() + 1, S->arg_end())),
-                        syntax::NodeRole::CallExpression_arguments);
+                        syntax::NodeRole::Arguments);
 
       Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);
 
       Builder.foldNode(Builder.getRange(S->getSourceRange()),
                        new (allocator()) syntax::CallExpression, S);
       return true;
     }
     case syntax::NodeKind::UnknownExpression:
bool WalkUpFromParenTypeLoc(ParenTypeLoc L) {
     Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getRParenLoc()),
                      new (allocator()) syntax::ParenDeclarator, L);
     return true;
   }
 
   // Declarator chunks, they are produced by type locs and some clang::Decls.
   bool WalkUpFromArrayTypeLoc(ArrayTypeLoc L) {
     Builder.markChildToken(L.getLBracketLoc(), syntax::NodeRole::OpenParen);
-    Builder.markExprChild(L.getSizeExpr(),
-                          syntax::NodeRole::ArraySubscript_sizeExpression);
+    Builder.markExprChild(L.getSizeExpr(), syntax::NodeRole::Size);
     Builder.markChildToken(L.getRBracketLoc(), syntax::NodeRole::CloseParen);
     Builder.foldNode(Builder.getRange(L.getLBracketLoc(), L.getRBracketLoc()),
                      new (allocator()) syntax::ArraySubscript, L);
     return true;
   }
 
   syntax::ParameterDeclarationList *
   buildParameterDeclarationList(ArrayRef<ParmVarDecl *> Params) {
     for (auto *P : Params) {
-      Builder.markChild(P, syntax::NodeRole::List_element);
+      Builder.markChild(P, syntax::NodeRole::ListElement);
       const auto *DelimiterToken = std::next(Builder.findToken(P->getEndLoc()));
       if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
-        Builder.markChildToken(DelimiterToken,
-                               syntax::NodeRole::List_delimiter);
+        Builder.markChildToken(DelimiterToken, syntax::NodeRole::ListDelimiter);
     }
     auto *Parameters = new (allocator()) syntax::ParameterDeclarationList;
     if (!Params.empty())
       Builder.foldNode(Builder.getRange(Params.front()->getBeginLoc(),
                                         Params.back()->getEndLoc()),
                        Parameters, nullptr);
     return Parameters;
   }
 
   bool WalkUpFromFunctionTypeLoc(FunctionTypeLoc L) {
     Builder.markChildToken(L.getLParenLoc(), syntax::NodeRole::OpenParen);
 
     Builder.markChild(buildParameterDeclarationList(L.getParams()),
-                      syntax::NodeRole::ParametersAndQualifiers_parameters);
+                      syntax::NodeRole::Parameters);
 
     Builder.markChildToken(L.getRParenLoc(), syntax::NodeRole::CloseParen);
     Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getEndLoc()),
                      new (allocator()) syntax::ParametersAndQualifiers, L);
     return true;
   }
 
   bool WalkUpFromFunctionProtoTypeLoc(FunctionProtoTypeLoc L) {
     if (!L.getTypePtr()->hasTrailingReturn())
       return WalkUpFromFunctionTypeLoc(L);
 
     auto *TrailingReturnTokens = BuildTrailingReturn(L);
     // Finish building the node for parameters.
-    Builder.markChild(TrailingReturnTokens,
-                      syntax::NodeRole::ParametersAndQualifiers_trailingReturn);
+    Builder.markChild(TrailingReturnTokens, syntax::NodeRole::TrailingReturn);
     return WalkUpFromFunctionTypeLoc(L);
   }
 
   bool TraverseMemberPointerTypeLoc(MemberPointerTypeLoc L) {
     // In the source code "void (Y::*mp)()" `MemberPointerTypeLoc` corresponds
     // to "Y::*" but it points to a `ParenTypeLoc` that corresponds to
     // "(Y::*mp)" We thus reverse the order of traversal to get the proper
     // syntax structure.
bool WalkUpFromSwitchStmt(SwitchStmt *S) {
     Builder.foldNode(Builder.getStmtRange(S),
                      new (allocator()) syntax::SwitchStatement, S);
     return true;
   }
 
   bool WalkUpFromCaseStmt(CaseStmt *S) {
     Builder.markChildToken(S->getKeywordLoc(),
                            syntax::NodeRole::IntroducerKeyword);
-    Builder.markExprChild(S->getLHS(), syntax::NodeRole::CaseStatement_value);
+    Builder.markExprChild(S->getLHS(), syntax::NodeRole::CaseValue);
     Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);
     Builder.foldNode(Builder.getStmtRange(S),
                      new (allocator()) syntax::CaseStatement, S);
     return true;
   }
 
   bool WalkUpFromDefaultStmt(DefaultStmt *S) {
     Builder.markChildToken(S->getKeywordLoc(),
                            syntax::NodeRole::IntroducerKeyword);
     Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);
     Builder.foldNode(Builder.getStmtRange(S),
                      new (allocator()) syntax::DefaultStatement, S);
     return true;
   }
 
   bool WalkUpFromIfStmt(IfStmt *S) {
     Builder.markChildToken(S->getIfLoc(), syntax::NodeRole::IntroducerKeyword);
-    Builder.markStmtChild(S->getThen(),
-                          syntax::NodeRole::IfStatement_thenStatement);
-    Builder.markChildToken(S->getElseLoc(),
-                           syntax::NodeRole::IfStatement_elseKeyword);
-    Builder.markStmtChild(S->getElse(),
-                          syntax::NodeRole::IfStatement_elseStatement);
+    Builder.markStmtChild(S->getThen(), syntax::NodeRole::ThenStatement);
+    Builder.markChildToken(S->getElseLoc(), syntax::NodeRole::ElseKeyword);
+    Builder.markStmtChild(S->getElse(), syntax::NodeRole::ElseStatement);
     Builder.foldNode(Builder.getStmtRange(S),
                      new (allocator()) syntax::IfStatement, S);
     return true;
   }
 
   bool WalkUpFromForStmt(ForStmt *S) {
     Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword);
     Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
bool WalkUpFromBreakStmt(BreakStmt *S) {
     Builder.foldNode(Builder.getStmtRange(S),
                      new (allocator()) syntax::BreakStatement, S);
     return true;
   }
 
   bool WalkUpFromReturnStmt(ReturnStmt *S) {
     Builder.markChildToken(S->getReturnLoc(),
                            syntax::NodeRole::IntroducerKeyword);
-    Builder.markExprChild(S->getRetValue(),
-                          syntax::NodeRole::ReturnStatement_value);
+    Builder.markExprChild(S->getRetValue(), syntax::NodeRole::ReturnValue);
     Builder.foldNode(Builder.getStmtRange(S),
                      new (allocator()) syntax::ReturnStatement, S);
     return true;
   }
 
   bool WalkUpFromCXXForRangeStmt(CXXForRangeStmt *S) {
     Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword);
     Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
     Builder.foldNode(Builder.getStmtRange(S),
                      new (allocator()) syntax::RangeBasedForStatement, S);
     return true;
   }
 
   bool WalkUpFromEmptyDecl(EmptyDecl *S) {
     Builder.foldNode(Builder.getDeclarationRange(S),
                      new (allocator()) syntax::EmptyDeclaration, S);
     return true;
   }
 
   bool WalkUpFromStaticAssertDecl(StaticAssertDecl *S) {
-    Builder.markExprChild(S->getAssertExpr(),
-                          syntax::NodeRole::StaticAssertDeclaration_condition);
-    Builder.markExprChild(S->getMessage(),
-                          syntax::NodeRole::StaticAssertDeclaration_message);
+    Builder.markExprChild(S->getAssertExpr(), syntax::NodeRole::Condition);
+    Builder.markExprChild(S->getMessage(), syntax::NodeRole::Message);
     Builder.foldNode(Builder.getDeclarationRange(S),
                      new (allocator()) syntax::StaticAssertDeclaration, S);
     return true;
   }
 
   bool WalkUpFromLinkageSpecDecl(LinkageSpecDecl *S) {
     Builder.foldNode(Builder.getDeclarationRange(S),
                      new (allocator()) syntax::LinkageSpecificationDeclaration,
auto Range = getDeclaratorRange(Builder.sourceManager(),
                                     D->getTypeSourceInfo()->getTypeLoc(),
                                     getQualifiedNameStart(D), Initializer);
 
     // There doesn't have to be a declarator (e.g. `void foo(int)` only has
     // declaration, but no declarator).
     if (Range.getBegin().isValid()) {
       auto *N = new (allocator()) syntax::SimpleDeclarator;
       Builder.foldNode(Builder.getRange(Range), N, nullptr);
-      Builder.markChild(N, syntax::NodeRole::SimpleDeclaration_declarator);
+      Builder.markChild(N, syntax::NodeRole::Declarator);
     }
 
     if (Builder.isResponsibleForCreatingDeclaration(D)) {
       Builder.foldNode(Builder.getDeclarationRange(D),
                        new (allocator()) syntax::SimpleDeclaration, D);
     }
     return true;
   }
syntax::TrailingReturnType *BuildTrailingReturn(FunctionProtoTypeLoc L) {
 
     // Build node for trailing return type.
     auto Return = Builder.getRange(ReturnedType.getSourceRange());
     const auto *Arrow = Return.begin() - 1;
     assert(Arrow->kind() == tok::arrow);
     auto Tokens = llvm::makeArrayRef(Arrow, Return.end());
     Builder.markChildToken(Arrow, syntax::NodeRole::ArrowToken);
     if (ReturnDeclarator)
-      Builder.markChild(ReturnDeclarator,
-                        syntax::NodeRole::TrailingReturnType_declarator);
+      Builder.markChild(ReturnDeclarator, syntax::NodeRole::Declarator);
     auto *R = new (allocator()) syntax::TrailingReturnType;
     Builder.foldNode(Tokens, R, L);
     return R;
   }
 
   void foldExplicitTemplateInstantiation(
       ArrayRef<syntax::Token> Range, const syntax::Token *ExternKW,
       const syntax::Token *TemplateKW,
       syntax::SimpleDeclaration *InnerDeclaration, Decl *From) {
     assert(!ExternKW || ExternKW->kind() == tok::kw_extern);
     assert(TemplateKW && TemplateKW->kind() == tok::kw_template);
     Builder.markChildToken(ExternKW, syntax::NodeRole::ExternKeyword);
     Builder.markChildToken(TemplateKW, syntax::NodeRole::IntroducerKeyword);
-    Builder.markChild(
-        InnerDeclaration,
-        syntax::NodeRole::ExplicitTemplateInstantiation_declaration);
+    Builder.markChild(InnerDeclaration, syntax::NodeRole::Declaration);
     Builder.foldNode(
         Range, new (allocator()) syntax::ExplicitTemplateInstantiation, From);
   }
 
   syntax::TemplateDeclaration *foldTemplateDeclaration(
       ArrayRef<syntax::Token> Range, const syntax::Token *TemplateKW,
       ArrayRef<syntax::Token> TemplatedDeclaration, Decl *From) {
     assert(TemplateKW && TemplateKW->kind() == tok::kw_template);
     Builder.markChildToken(TemplateKW, syntax::NodeRole::IntroducerKeyword);
 
     auto *N = new (allocator()) syntax::TemplateDeclaration;
     Builder.foldNode(Range, N, From);
-    Builder.markChild(N, syntax::NodeRole::TemplateDeclaration_declaration);
+    Builder.markChild(N, syntax::NodeRole::Declaration);
     return N;
   }
 
   /// A small helper to save some typing.
   llvm::BumpPtrAllocator &allocator() { return Builder.allocator(); }
 
   syntax::TreeBuilder &Builder;
   const ASTContext &Context;

 void syntax::TreeBuilder::markStmtChild(Stmt *Child, NodeRole Role) {
   if (!Child)
     return;
 
   syntax::Tree *ChildNode;
   if (Expr *ChildExpr = dyn_cast<Expr>(Child)) {
     // This is an expression in a statement position, consume the trailing
     // semicolon and form an 'ExpressionStatement' node.
-    markExprChild(ChildExpr, NodeRole::ExpressionStatement_expression);
+    markExprChild(ChildExpr, NodeRole::Expression);
     ChildNode = new (allocator()) syntax::ExpressionStatement;
     // (!) 'getStmtRange()' ensures this covers a trailing semicolon.
     Pending.foldChildren(Arena, getStmtRange(Child), ChildNode);
   } else {
     ChildNode = Mapping.find(Child);
   }
   assert(ChildNode != nullptr);
   setRole(ChildNode, Role);

clang/lib/Tooling/Syntax/Nodes.cpp

raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
   case syntax::NodeRole::ArrowToken:
     return OS << "ArrowToken";
   case syntax::NodeRole::ExternKeyword:
     return OS << "ExternKeyword";
   case syntax::NodeRole::TemplateKeyword:
     return OS << "TemplateKeyword";
   case syntax::NodeRole::BodyStatement:
     return OS << "BodyStatement";
-  case syntax::NodeRole::List_element:
-    return OS << "List_element";
-  case syntax::NodeRole::List_delimiter:
-    return OS << "List_delimiter";
-  case syntax::NodeRole::CaseStatement_value:
-    return OS << "CaseStatement_value";
-  case syntax::NodeRole::IfStatement_thenStatement:
-    return OS << "IfStatement_thenStatement";
-  case syntax::NodeRole::IfStatement_elseKeyword:
-    return OS << "IfStatement_elseKeyword";
-  case syntax::NodeRole::IfStatement_elseStatement:
-    return OS << "IfStatement_elseStatement";
-  case syntax::NodeRole::OperatorExpression_operatorToken:
-    return OS << "OperatorExpression_operatorToken";
-  case syntax::NodeRole::UnaryOperatorExpression_operand:
-    return OS << "UnaryOperatorExpression_operand";
-  case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
-    return OS << "BinaryOperatorExpression_leftHandSide";
-  case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
-    return OS << "BinaryOperatorExpression_rightHandSide";
-  case syntax::NodeRole::ReturnStatement_value:
-    return OS << "ReturnStatement_value";
-  case syntax::NodeRole::ExpressionStatement_expression:
-    return OS << "ExpressionStatement_expression";
-  case syntax::NodeRole::CompoundStatement_statement:
-    return OS << "CompoundStatement_statement";
-  case syntax::NodeRole::StaticAssertDeclaration_condition:
-    return OS << "StaticAssertDeclaration_condition";
-  case syntax::NodeRole::StaticAssertDeclaration_message:
-    return OS << "StaticAssertDeclaration_message";
-  case syntax::NodeRole::SimpleDeclaration_declarator:
-    return OS << "SimpleDeclaration_declarator";
-  case syntax::NodeRole::TemplateDeclaration_declaration:
-    return OS << "TemplateDeclaration_declaration";
-  case syntax::NodeRole::ExplicitTemplateInstantiation_declaration:
-    return OS << "ExplicitTemplateInstantiation_declaration";
-  case syntax::NodeRole::ArraySubscript_sizeExpression:
-    return OS << "ArraySubscript_sizeExpression";
-  case syntax::NodeRole::TrailingReturnType_declarator:
-    return OS << "TrailingReturnType_declarator";
-  case syntax::NodeRole::ParametersAndQualifiers_parameters:
-    return OS << "ParametersAndQualifiers_parameters";
-  case syntax::NodeRole::ParametersAndQualifiers_trailingReturn:
-    return OS << "ParametersAndQualifiers_trailingReturn";
-  case syntax::NodeRole::IdExpression_id:
-    return OS << "IdExpression_id";
-  case syntax::NodeRole::IdExpression_qualifier:
-    return OS << "IdExpression_qualifier";
-  case syntax::NodeRole::ParenExpression_subExpression:
-    return OS << "ParenExpression_subExpression";
-  case syntax::NodeRole::MemberExpression_object:
-    return OS << "MemberExpression_object";
-  case syntax::NodeRole::MemberExpression_accessToken:
-    return OS << "MemberExpression_accessToken";
-  case syntax::NodeRole::MemberExpression_member:
-    return OS << "MemberExpression_member";
-  case syntax::NodeRole::CallExpression_callee:
-    return OS << "CallExpression_callee";
-  case syntax::NodeRole::CallExpression_arguments:
-    return OS << "CallExpression_arguments";
+  case syntax::NodeRole::ListElement:
+    return OS << "ListElement";
+  case syntax::NodeRole::ListDelimiter:
+    return OS << "ListDelimiter";
+  case syntax::NodeRole::CaseValue:
+    return OS << "CaseValue";
+  case syntax::NodeRole::ReturnValue:
+    return OS << "ReturnValue";
+  case syntax::NodeRole::ThenStatement:
+    return OS << "ThenStatement";
+  case syntax::NodeRole::ElseKeyword:
+    return OS << "ElseKeyword";
+  case syntax::NodeRole::ElseStatement:
+    return OS << "ElseStatement";
+  case syntax::NodeRole::OperatorToken:
+    return OS << "OperatorToken";
+  case syntax::NodeRole::Operand:
+    return OS << "Operand";
+  case syntax::NodeRole::LeftHandSide:
+    return OS << "LeftHandSide";
+  case syntax::NodeRole::RightHandSide:
+    return OS << "RightHandSide";
+  case syntax::NodeRole::Expression:
+    return OS << "Expression";
+  case syntax::NodeRole::Statement:
+    return OS << "Statement";
+  case syntax::NodeRole::Condition:
+    return OS << "Condition";
+  case syntax::NodeRole::Message:
+    return OS << "Message";
+  case syntax::NodeRole::Declarator:
+    return OS << "Declarator";
+  case syntax::NodeRole::Declaration:
+    return OS << "Declaration";
+  case syntax::NodeRole::Size:
+    return OS << "Size";
+  case syntax::NodeRole::Parameters:
+    return OS << "Parameters";
+  case syntax::NodeRole::TrailingReturn:
+    return OS << "TrailingReturn";
+  case syntax::NodeRole::UnqualifiedId:
+    return OS << "UnqualifiedId";
+  case syntax::NodeRole::Qualifier:
+    return OS << "Qualifier";
+  case syntax::NodeRole::SubExpression:
+    return OS << "SubExpression";
+  case syntax::NodeRole::Object:
+    return OS << "Object";
+  case syntax::NodeRole::AccessToken:
+    return OS << "AccessToken";
+  case syntax::NodeRole::Member:
+    return OS << "Member";
+  case syntax::NodeRole::Callee:
+    return OS << "Callee";
+  case syntax::NodeRole::Arguments:
+    return OS << "Arguments";
   }
   llvm_unreachable("invalid role");
 }
 
 // We could have an interator in list to not pay memory costs of temporary
 // vector
 std::vector<syntax::NameSpecifier *> syntax::NestedNameSpecifier::specifiers() {
   auto specifiersAsNodes = getElementsAsNodes();
for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {
     Children.push_back(
         {llvm::cast<syntax::SimpleDeclaration>(ParameterAsNodeAndComma.element),
          ParameterAsNodeAndComma.delimiter});
   }
   return Children;
 }
 
 syntax::Expression *syntax::MemberExpression::object() {
-  return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::MemberExpression_object));
+  return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Object));
 }
 
 syntax::Leaf *syntax::MemberExpression::templateKeyword() {
   return llvm::cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::TemplateKeyword));
 }
 
 syntax::Leaf *syntax::MemberExpression::accessToken() {
   return llvm::cast_or_null<syntax::Leaf>(
-      findChild(syntax::NodeRole::MemberExpression_accessToken));
+      findChild(syntax::NodeRole::AccessToken));
 }
 
 syntax::IdExpression *syntax::MemberExpression::member() {
   return cast_or_null<syntax::IdExpression>(
-      findChild(syntax::NodeRole::MemberExpression_member));
+      findChild(syntax::NodeRole::Member));
 }
 
 syntax::NestedNameSpecifier *syntax::IdExpression::qualifier() {
   return cast_or_null<syntax::NestedNameSpecifier>(
-      findChild(syntax::NodeRole::IdExpression_qualifier));
+      findChild(syntax::NodeRole::Qualifier));
 }
 
 syntax::Leaf *syntax::IdExpression::templateKeyword() {
   return llvm::cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::TemplateKeyword));
 }
 
 syntax::UnqualifiedId *syntax::IdExpression::unqualifiedId() {
   return cast_or_null<syntax::UnqualifiedId>(
-      findChild(syntax::NodeRole::IdExpression_id));
+      findChild(syntax::NodeRole::UnqualifiedId));
 }
 
 syntax::Leaf *syntax::ParenExpression::openParen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
 syntax::Expression *syntax::ParenExpression::subExpression() {
   return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::ParenExpression_subExpression));
+      findChild(syntax::NodeRole::SubExpression));
 }
 
 syntax::Leaf *syntax::ParenExpression::closeParen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::Leaf *syntax::ThisExpression::thisKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Leaf *syntax::LiteralExpression::literalToken() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
   return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::BinaryOperatorExpression_leftHandSide));
+      findChild(syntax::NodeRole::LeftHandSide));
 }
 
 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
-  return cast_or_null<syntax::Leaf>(
-      findChild(syntax::NodeRole::OperatorExpression_operatorToken));
+  return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
 }
 
 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
-  return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::UnaryOperatorExpression_operand));
+  return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Operand));
 }
 
 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
-  return cast_or_null<syntax::Leaf>(
-      findChild(syntax::NodeRole::OperatorExpression_operatorToken));
+  return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
   return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::BinaryOperatorExpression_rightHandSide));
+      findChild(syntax::NodeRole::RightHandSide));
 }
 
 syntax::Expression *syntax::CallExpression::callee() {
-  return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::CallExpression_callee));
+  return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Callee));
 }
 
 syntax::Leaf *syntax::CallExpression::openParen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
 syntax::CallArguments *syntax::CallExpression::arguments() {
   return cast_or_null<syntax::CallArguments>(
-      findChild(syntax::NodeRole::CallExpression_arguments));
+      findChild(syntax::NodeRole::Arguments));
 }
 
 syntax::Leaf *syntax::CallExpression::closeParen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Statement *syntax::SwitchStatement::body() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
 syntax::Leaf *syntax::CaseStatement::caseKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Expression *syntax::CaseStatement::value() {
+syntax::Expression *syntax::CaseStatement::caseValue() {
   return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::CaseStatement_value));
+      findChild(syntax::NodeRole::CaseValue));
 }
 
 syntax::Statement *syntax::CaseStatement::body() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
 syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Statement *syntax::DefaultStatement::body() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
 syntax::Leaf *syntax::IfStatement::ifKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Statement *syntax::IfStatement::thenStatement() {
   return cast_or_null<syntax::Statement>(
-      findChild(syntax::NodeRole::IfStatement_thenStatement));
+      findChild(syntax::NodeRole::ThenStatement));
 }
 
 syntax::Leaf *syntax::IfStatement::elseKeyword() {
-  return cast_or_null<syntax::Leaf>(
-      findChild(syntax::NodeRole::IfStatement_elseKeyword));
+  return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ElseKeyword));
 }
 
 syntax::Statement *syntax::IfStatement::elseStatement() {
   return cast_or_null<syntax::Statement>(
-      findChild(syntax::NodeRole::IfStatement_elseStatement));
+      findChild(syntax::NodeRole::ElseStatement));
 }
 
 syntax::Leaf *syntax::ForStatement::forKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Statement *syntax::ForStatement::body() {
return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Expression *syntax::ReturnStatement::value() {
+syntax::Expression *syntax::ReturnStatement::returnValue() {
   return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::ReturnStatement_value));
+      findChild(syntax::NodeRole::ReturnValue));
 }
 
 syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Statement *syntax::RangeBasedForStatement::body() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
 syntax::Expression *syntax::ExpressionStatement::expression() {
   return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::ExpressionStatement_expression));
+      findChild(syntax::NodeRole::Expression));
 }
 
 syntax::Leaf *syntax::CompoundStatement::lbrace() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
 std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
   std::vector<syntax::Statement *> Children;
   for (auto *C = firstChild(); C; C = C->nextSibling()) {
-    assert(C->role() == syntax::NodeRole::CompoundStatement_statement);
+    assert(C->role() == syntax::NodeRole::Statement);
     Children.push_back(cast<syntax::Statement>(C));
   }
   return Children;
 }
 
 syntax::Leaf *syntax::CompoundStatement::rbrace() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::Expression *syntax::StaticAssertDeclaration::condition() {
   return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::StaticAssertDeclaration_condition));
+      findChild(syntax::NodeRole::Condition));
 }
 
 syntax::Expression *syntax::StaticAssertDeclaration::message() {
-  return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::StaticAssertDeclaration_message));
+  return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message));
 }
 
 std::vector<syntax::SimpleDeclarator *>
 syntax::SimpleDeclaration::declarators() {
   std::vector<syntax::SimpleDeclarator *> Children;
   for (auto *C = firstChild(); C; C = C->nextSibling()) {
-    if (C->role() == syntax::NodeRole::SimpleDeclaration_declarator)
+    if (C->role() == syntax::NodeRole::Declarator)
       Children.push_back(cast<syntax::SimpleDeclarator>(C));
   }
   return Children;
 }
 
 syntax::Leaf *syntax::TemplateDeclaration::templateKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Declaration *syntax::TemplateDeclaration::declaration() {
   return cast_or_null<syntax::Declaration>(
-      findChild(syntax::NodeRole::TemplateDeclaration_declaration));
+      findChild(syntax::NodeRole::Declaration));
 }
 
 syntax::Leaf *syntax::ExplicitTemplateInstantiation::templateKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Leaf *syntax::ExplicitTemplateInstantiation::externKeyword() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
 }
 
 syntax::Declaration *syntax::ExplicitTemplateInstantiation::declaration() {
   return cast_or_null<syntax::Declaration>(
-      findChild(syntax::NodeRole::ExplicitTemplateInstantiation_declaration));
+      findChild(syntax::NodeRole::Declaration));
 }
 
 syntax::Leaf *syntax::ParenDeclarator::lparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
 syntax::Leaf *syntax::ParenDeclarator::rparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::Leaf *syntax::ArraySubscript::lbracket() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
-syntax::Expression *syntax::ArraySubscript::sizeExpression() {
-  return cast_or_null<syntax::Expression>(
-      findChild(syntax::NodeRole::ArraySubscript_sizeExpression));
+syntax::Expression *syntax::ArraySubscript::size() {
+  return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Size));
 }
 
 syntax::Leaf *syntax::ArraySubscript::rbracket() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::Leaf *syntax::TrailingReturnType::arrowToken() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
 }
 
 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
   return cast_or_null<syntax::SimpleDeclarator>(
-      findChild(syntax::NodeRole::TrailingReturnType_declarator));
+      findChild(syntax::NodeRole::Declarator));
 }
 
 syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
 syntax::ParameterDeclarationList *
 syntax::ParametersAndQualifiers::parameters() {
   return cast_or_null<syntax::ParameterDeclarationList>(
-      findChild(syntax::NodeRole::ParametersAndQualifiers_parameters));
+      findChild(syntax::NodeRole::Parameters));
 }
 
 syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
   return cast_or_null<syntax::TrailingReturnType>(
-      findChild(syntax::NodeRole::ParametersAndQualifiers_trailingReturn));
+      findChild(syntax::NodeRole::TrailingReturn));
 }

clang/lib/Tooling/Syntax/Tree.cpp

 syntax::List::getElementsAsNodesAndDelimiters() {
   if (!firstChild())
     return {};
 
   auto children = std::vector<syntax::List::ElementAndDelimiter<Node>>();
   syntax::Node *elementWithoutDelimiter = nullptr;
   for (auto *C = firstChild(); C; C = C->nextSibling()) {
     switch (C->role()) {
-    case syntax::NodeRole::List_element: {
+    case syntax::NodeRole::ListElement: {
       if (elementWithoutDelimiter) {
         children.push_back({elementWithoutDelimiter, nullptr});
       }
       elementWithoutDelimiter = C;
       break;
     }
-    case syntax::NodeRole::List_delimiter: {
+    case syntax::NodeRole::ListDelimiter: {
       children.push_back({elementWithoutDelimiter, cast<syntax::Leaf>(C)});
       elementWithoutDelimiter = nullptr;
       break;
     }
     default:
       llvm_unreachable(
           "A list can have only elements and delimiters as children.");
     }

 std::vector<syntax::Node *> syntax::List::getElementsAsNodes() {
   if (!firstChild())
     return {};
 
   auto children = std::vector<syntax::Node *>();
   syntax::Node *elementWithoutDelimiter = nullptr;
   for (auto *C = firstChild(); C; C = C->nextSibling()) {
     switch (C->role()) {
-    case syntax::NodeRole::List_element: {
+    case syntax::NodeRole::ListElement: {
       if (elementWithoutDelimiter) {
         children.push_back(elementWithoutDelimiter);
       }
       elementWithoutDelimiter = C;
       break;
     }
-    case syntax::NodeRole::List_delimiter: {
+    case syntax::NodeRole::ListDelimiter: {
       children.push_back(elementWithoutDelimiter);
       elementWithoutDelimiter = nullptr;
       break;
     }
     default:
       llvm_unreachable("A list has only elements or delimiters.");
     }
   }

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int main() {}
 void foo() {}
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'main'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
 | |   `-')' CloseParen
 | `-CompoundStatement
 |   |-'{' OpenParen
 |   `-'}' CloseParen
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'foo'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
     `-'}' CloseParen
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, SimpleVariable) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a;
 int b = 42;
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | `-'a'
 | `-';'
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'b'
   | |-'='
   | `-IntegerLiteralExpression
   |   `-'42' LiteralToken
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, SimpleFunction) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void foo(int a, int b) {}
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'foo'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
   |   | | |-'int'
-  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | | `-SimpleDeclarator Declarator
   |   | |   `-'a'
-  |   | |-',' List_delimiter
-  |   | `-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'int'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     `-'b'
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
     `-'}' CloseParen
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, If) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[if (1) {}]]
   [[if (1) {} else if (0) {}]]
 }
 )cpp",
       {R"txt(
-IfStatement CompoundStatement_statement
+IfStatement Statement
 |-'if' IntroducerKeyword
 |-'('
 |-IntegerLiteralExpression
 | `-'1' LiteralToken
 |-')'
-`-CompoundStatement IfStatement_thenStatement
+`-CompoundStatement ThenStatement
   |-'{' OpenParen
   `-'}' CloseParen
   )txt",
        R"txt(
-IfStatement CompoundStatement_statement
+IfStatement Statement
 |-'if' IntroducerKeyword
 |-'('
 |-IntegerLiteralExpression
 | `-'1' LiteralToken
 |-')'
-|-CompoundStatement IfStatement_thenStatement
+|-CompoundStatement ThenStatement
 | |-'{' OpenParen
 | `-'}' CloseParen
-|-'else' IfStatement_elseKeyword
-`-IfStatement IfStatement_elseStatement
+|-'else' ElseKeyword
+`-IfStatement ElseStatement
   |-'if' IntroducerKeyword
   |-'('
   |-IntegerLiteralExpression
   | `-'0' LiteralToken
   |-')'
-  `-CompoundStatement IfStatement_thenStatement
+  `-CompoundStatement ThenStatement
     |-'{' OpenParen
     `-'}' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, For) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[for (;;)  {}]]
 }
 )cpp",
       {R"txt(
-ForStatement CompoundStatement_statement
+ForStatement Statement
 |-'for' IntroducerKeyword
 |-'('
 |-';'
 |-';'
 |-')'
 `-CompoundStatement BodyStatement
   |-'{' OpenParen
   `-'}' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, RangeBasedFor) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   int a[3];
   [[for (int x : a)
     ;]]
 }
 )cpp",
       {R"txt(
-RangeBasedForStatement CompoundStatement_statement
+RangeBasedForStatement Statement
 |-'for' IntroducerKeyword
 |-'('
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | `-'x'
 | `-':'
 |-IdExpression
-| `-UnqualifiedId IdExpression_id
+| `-UnqualifiedId UnqualifiedId
 |   `-'a'
 |-')'
 `-EmptyStatement BodyStatement
   `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, DeclarationStatement) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[int a = 10;]]
 }
 )cpp",
       {R"txt(
-DeclarationStatement CompoundStatement_statement
+DeclarationStatement Statement
 |-SimpleDeclaration
 | |-'int'
-| `-SimpleDeclarator SimpleDeclaration_declarator
+| `-SimpleDeclarator Declarator
 |   |-'a'
 |   |-'='
 |   `-IntegerLiteralExpression
 |     `-'10' LiteralToken
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, Switch) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[switch (1) {
     case 0:
     default:;
   }]]
 }
 )cpp",
       {R"txt(
-SwitchStatement CompoundStatement_statement
+SwitchStatement Statement
 |-'switch' IntroducerKeyword
 |-'('
 |-IntegerLiteralExpression
 | `-'1' LiteralToken
 |-')'
 `-CompoundStatement BodyStatement
   |-'{' OpenParen
-  |-CaseStatement CompoundStatement_statement
+  |-CaseStatement Statement
   | |-'case' IntroducerKeyword
-  | |-IntegerLiteralExpression CaseStatement_value
+  | |-IntegerLiteralExpression CaseValue
   | | `-'0' LiteralToken
   | |-':'
   | `-DefaultStatement BodyStatement
   |   |-'default' IntroducerKeyword
   |   |-':'
   |   `-EmptyStatement BodyStatement
   |     `-';'
   `-'}' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, While) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[while (1) { continue; break; }]]
 }
 )cpp",
       {R"txt(
-WhileStatement CompoundStatement_statement
+WhileStatement Statement
 |-'while' IntroducerKeyword
 |-'('
 |-IntegerLiteralExpression
 | `-'1' LiteralToken
 |-')'
 `-CompoundStatement BodyStatement
   |-'{' OpenParen
-  |-ContinueStatement CompoundStatement_statement
+  |-ContinueStatement Statement
   | |-'continue' IntroducerKeyword
   | `-';'
-  |-BreakStatement CompoundStatement_statement
+  |-BreakStatement Statement
   | |-'break' IntroducerKeyword
   | `-';'
   `-'}' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnhandledStatement) {
   // Unhandled statements should end up as 'unknown statement'.
   // This example uses a 'label statement', which does not yet have a syntax
   // counterpart.
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 int test() {
   [[foo: return 100;]]
 }
 )cpp",
       {R"txt(
-UnknownStatement CompoundStatement_statement
+UnknownStatement Statement
 |-'foo'
 |-':'
 `-ReturnStatement
   |-'return' IntroducerKeyword
-  |-IntegerLiteralExpression ReturnStatement_value
+  |-IntegerLiteralExpression ReturnValue
   | `-'100' LiteralToken
   `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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();
 }
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'test'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
-    |-ExpressionStatement CompoundStatement_statement
-    | |-CallExpression ExpressionStatement_expression
-    | | |-IdExpression CallExpression_callee
-    | | | `-UnqualifiedId IdExpression_id
+    |-ExpressionStatement Statement
+    | |-CallExpression Expression
+    | | |-IdExpression Callee
+    | | | `-UnqualifiedId UnqualifiedId
     | | |   `-'test'
     | | |-'(' OpenParen
     | | `-')' CloseParen
     | `-';'
-    |-IfStatement CompoundStatement_statement
+    |-IfStatement Statement
     | |-'if' IntroducerKeyword
     | |-'('
     | |-IntegerLiteralExpression
     | | `-'1' LiteralToken
     | |-')'
-    | |-ExpressionStatement IfStatement_thenStatement
-    | | |-CallExpression ExpressionStatement_expression
-    | | | |-IdExpression CallExpression_callee
-    | | | | `-UnqualifiedId IdExpression_id
+    | |-ExpressionStatement ThenStatement
+    | | |-CallExpression Expression
+    | | | |-IdExpression Callee
+    | | | | `-UnqualifiedId UnqualifiedId
     | | | |   `-'test'
     | | | |-'(' OpenParen
     | | | `-')' CloseParen
     | | `-';'
-    | |-'else' IfStatement_elseKeyword
-    | `-ExpressionStatement IfStatement_elseStatement
-    |   |-CallExpression ExpressionStatement_expression
-    |   | |-IdExpression CallExpression_callee
-    |   | | `-UnqualifiedId IdExpression_id
+    | |-'else' ElseKeyword
+    | `-ExpressionStatement ElseStatement
+    |   |-CallExpression Expression
+    |   | |-IdExpression Callee
+    |   | | `-UnqualifiedId UnqualifiedId
     |   | |   `-'test'
     |   | |-'(' OpenParen
     |   | `-')' CloseParen
     |   `-';'
     `-'}' CloseParen
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_Identifier) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[a]];
 }
 )cpp",
       {R"txt(
-IdExpression ExpressionStatement_expression
-`-UnqualifiedId IdExpression_id
+IdExpression Expression
+`-UnqualifiedId UnqualifiedId
   `-'a'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_OperatorFunctionId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   friend X operator+(const X&, const X&);
 };
 void test(X x) {
   [[operator+(x, x)]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-IdExpression Callee
+| `-UnqualifiedId UnqualifiedId
 |   |-'operator'
 |   `-'+'
 |-'(' OpenParen
-|-CallArguments CallExpression_arguments
-| |-IdExpression List_element
-| | `-UnqualifiedId IdExpression_id
+|-CallArguments Arguments
+| |-IdExpression ListElement
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'x'
-| |-',' List_delimiter
-| `-IdExpression List_element
-|   `-UnqualifiedId IdExpression_id
+| |-',' ListDelimiter
+| `-IdExpression ListElement
+|   `-UnqualifiedId UnqualifiedId
 |     `-'x'
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_ConversionFunctionId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   operator int();
 };
 void test(X x) {
   [[x.operator int()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'x'
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| |-'.' AccessToken
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     |-'operator'
 |     `-'int'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_LiteralOperatorId) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _w(char);
 void test() {
   [[operator "" _w('1')]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-IdExpression Callee
+| `-UnqualifiedId UnqualifiedId
 |   |-'operator'
 |   |-'""'
 |   `-'_w'
 |-'(' OpenParen
-|-CallArguments CallExpression_arguments
-| `-CharacterLiteralExpression List_element
+|-CallArguments Arguments
+| `-CharacterLiteralExpression ListElement
 |   `-''1'' LiteralToken
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_Destructor) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X { };
 void test(X x) {
   [[x.~X()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'x'
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| |-'.' AccessToken
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     |-'~'
 |     `-'X'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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
   // not because `Expr::getSourceRange()` returns the range of `x.~` for the
   // `MemberExpr` instead of the expected `x.~decltype(x)`, this is a bug in
   // clang.
   [[x.~decltype(x)()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'x'
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| |-'.' AccessToken
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     `-'~'
 |-'decltype'
 |-'('
 |-'x'
 |-')'
 |-'('
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_TemplateId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T>
 T f();
 void test() {
   [[f<int>()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-IdExpression Callee
+| `-UnqualifiedId UnqualifiedId
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
void test() {
   // ClangAST. We need to ignore leaf implicit nodes.
   [[::n::S s1]];
   [[n::S s2]];
 }
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-NestedNameSpecifier
-| |-'::' List_delimiter
-| |-IdentifierNameSpecifier List_element
+| |-'::' ListDelimiter
+| |-IdentifierNameSpecifier ListElement
 | | `-'n'
-| `-'::' List_delimiter
+| `-'::' ListDelimiter
 |-'S'
-`-SimpleDeclarator SimpleDeclaration_declarator
+`-SimpleDeclarator Declarator
   `-UnknownExpression
     `-'s1'
 )txt",
        R"txt(
 SimpleDeclaration
 |-NestedNameSpecifier
-| |-IdentifierNameSpecifier List_element
+| |-IdentifierNameSpecifier ListElement
 | | `-'n'
-| `-'::' List_delimiter
+| `-'::' ListDelimiter
 |-'S'
-`-SimpleDeclarator SimpleDeclaration_declarator
+`-SimpleDeclarator Declarator
   `-UnknownExpression
     `-'s2'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedId_TemplateSpecifier) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T>
 struct ST {
   struct S { };
 };
 void test() {
   [[::template ST<int>::S s1]];
   [[::ST<int>::S s2]];
 }
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-NestedNameSpecifier
-| |-'::' List_delimiter
-| |-SimpleTemplateNameSpecifier List_element
+| |-'::' ListDelimiter
+| |-SimpleTemplateNameSpecifier ListElement
 | | |-'template'
 | | |-'ST'
 | | |-'<'
 | | |-'int'
 | | `-'>'
-| `-'::' List_delimiter
+| `-'::' ListDelimiter
 |-'S'
-`-SimpleDeclarator SimpleDeclaration_declarator
+`-SimpleDeclarator Declarator
   `-UnknownExpression
     `-'s1'
 )txt",
        R"txt(
 SimpleDeclaration
 |-NestedNameSpecifier
-| |-'::' List_delimiter
-| |-SimpleTemplateNameSpecifier List_element
+| |-'::' ListDelimiter
+| |-SimpleTemplateNameSpecifier ListElement
 | | |-'ST'
 | | |-'<'
 | | |-'int'
 | | `-'>'
-| `-'::' List_delimiter
+| `-'::' ListDelimiter
 |-'S'
-`-SimpleDeclarator SimpleDeclaration_declarator
+`-SimpleDeclarator Declarator
   `-UnknownExpression
     `-'s2'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedId_DecltypeSpecifier) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   static void f(){}
 };
 void test(S s) {
   [[decltype(s)::f()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| |-NestedNameSpecifier IdExpression_qualifier
-| | |-DecltypeNameSpecifier List_element
+CallExpression Expression
+|-IdExpression Callee
+| |-NestedNameSpecifier Qualifier
+| | |-DecltypeNameSpecifier ListElement
 | | | |-'decltype'
 | | | |-'('
 | | | |-IdExpression
-| | | | `-UnqualifiedId IdExpression_id
+| | | | `-UnqualifiedId UnqualifiedId
 | | | |   `-'s'
 | | | `-')'
-| | `-'::' List_delimiter
-| `-UnqualifiedId IdExpression_id
+| | `-'::' ListDelimiter
+| `-UnqualifiedId UnqualifiedId
 |   `-'f'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedId_OptionalTemplateKw) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename U>
   static U f();
 };
 void test() {
   [[S::f<int>()]];
   [[S::template f<int>()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| |-NestedNameSpecifier IdExpression_qualifier
-| | |-IdentifierNameSpecifier List_element
+CallExpression Expression
+|-IdExpression Callee
+| |-NestedNameSpecifier Qualifier
+| | |-IdentifierNameSpecifier ListElement
 | | | `-'S'
-| | `-'::' List_delimiter
-| `-UnqualifiedId IdExpression_id
+| | `-'::' ListDelimiter
+| `-UnqualifiedId UnqualifiedId
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt",
        R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| |-NestedNameSpecifier IdExpression_qualifier
-| | |-IdentifierNameSpecifier List_element
+CallExpression Expression
+|-IdExpression Callee
+| |-NestedNameSpecifier Qualifier
+| | |-IdentifierNameSpecifier ListElement
 | | | `-'S'
-| | `-'::' List_delimiter
+| | `-'::' ListDelimiter
 | |-'template' TemplateKeyword
-| `-UnqualifiedId IdExpression_id
+| `-UnqualifiedId UnqualifiedId
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
struct ST {
     static U f();
   };
 }
 void test() {
   [[::n::template ST<int>::template f<int>()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| |-NestedNameSpecifier IdExpression_qualifier
-| | |-'::' List_delimiter
-| | |-IdentifierNameSpecifier List_element
+CallExpression Expression
+|-IdExpression Callee
+| |-NestedNameSpecifier Qualifier
+| | |-'::' ListDelimiter
+| | |-IdentifierNameSpecifier ListElement
 | | | `-'n'
-| | |-'::' List_delimiter
-| | |-SimpleTemplateNameSpecifier List_element
+| | |-'::' ListDelimiter
+| | |-SimpleTemplateNameSpecifier ListElement
 | | | |-'template'
 | | | |-'ST'
 | | | |-'<'
 | | | |-'int'
 | | | `-'>'
-| | `-'::' List_delimiter
+| | `-'::' ListDelimiter
 | |-'template' TemplateKeyword
-| `-UnqualifiedId IdExpression_id
+| `-UnqualifiedId UnqualifiedId
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }

 template <typename T>
 void test() {
   [[T::template U<int>::f()]];
   [[T::U::f()]];
   [[T::template f<0>()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| |-NestedNameSpecifier IdExpression_qualifier
-| | |-IdentifierNameSpecifier List_element
+CallExpression Expression
+|-IdExpression Callee
+| |-NestedNameSpecifier Qualifier
+| | |-IdentifierNameSpecifier ListElement
 | | | `-'T'
-| | |-'::' List_delimiter
-| | |-SimpleTemplateNameSpecifier List_element
+| | |-'::' ListDelimiter
+| | |-SimpleTemplateNameSpecifier ListElement
 | | | |-'template'
 | | | |-'U'
 | | | |-'<'
 | | | |-'int'
 | | | `-'>'
-| | `-'::' List_delimiter
-| `-UnqualifiedId IdExpression_id
+| | `-'::' ListDelimiter
+| `-UnqualifiedId UnqualifiedId
 |   `-'f'
 |-'(' OpenParen
 `-')' CloseParen
 )txt",
        R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| |-NestedNameSpecifier IdExpression_qualifier
-| | |-IdentifierNameSpecifier List_element
+CallExpression Expression
+|-IdExpression Callee
+| |-NestedNameSpecifier Qualifier
+| | |-IdentifierNameSpecifier ListElement
 | | | `-'T'
-| | |-'::' List_delimiter
-| | |-IdentifierNameSpecifier List_element
+| | |-'::' ListDelimiter
+| | |-IdentifierNameSpecifier ListElement
 | | | `-'U'
-| | `-'::' List_delimiter
-| `-UnqualifiedId IdExpression_id
+| | `-'::' ListDelimiter
+| `-UnqualifiedId UnqualifiedId
 |   `-'f'
 |-'(' OpenParen
 `-')' CloseParen
 )txt",
        R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| |-NestedNameSpecifier IdExpression_qualifier
-| | |-IdentifierNameSpecifier List_element
+CallExpression Expression
+|-IdExpression Callee
+| |-NestedNameSpecifier Qualifier
+| | |-IdentifierNameSpecifier ListElement
 | | | `-'T'
-| | `-'::' List_delimiter
+| | `-'::' ListDelimiter
 | |-'template' TemplateKeyword
-| `-UnqualifiedId IdExpression_id
+| `-UnqualifiedId UnqualifiedId
 |   |-'f'
 |   |-'<'
 |   |-IntegerLiteralExpression
 |   | `-'0' LiteralToken
 |   `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, This_Simple) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   S* test(){
     return [[this]];
   }
 };
 )cpp",
       {R"txt(
-ThisExpression ReturnStatement_value
+ThisExpression ReturnValue
 `-'this' IntroducerKeyword
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, This_ExplicitMemberAccess) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   int a;
   void test(){
     [[this->a]];
   }
 };
 )cpp",
       {R"txt(
-MemberExpression ExpressionStatement_expression
-|-ThisExpression MemberExpression_object
+MemberExpression Expression
+|-ThisExpression Object
 | `-'this' IntroducerKeyword
-|-'->' MemberExpression_accessToken
-`-IdExpression MemberExpression_member
-  `-UnqualifiedId IdExpression_id
+|-'->' AccessToken
+`-IdExpression Member
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, This_ImplicitMemberAccess) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   int a;
   void test(){
     [[a]];
   }
 };
 )cpp",
       {R"txt(
-IdExpression ExpressionStatement_expression
-`-UnqualifiedId IdExpression_id
+IdExpression Expression
+`-UnqualifiedId UnqualifiedId
   `-'a'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ParenExpr) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[(1)]];
   [[((1))]];
   [[(1 + (2))]];
 }
 )cpp",
       {R"txt(
-ParenExpression ExpressionStatement_expression
+ParenExpression Expression
 |-'(' OpenParen
-|-IntegerLiteralExpression ParenExpression_subExpression
+|-IntegerLiteralExpression SubExpression
 | `-'1' LiteralToken
 `-')' CloseParen
 )txt",
        R"txt(
-ParenExpression ExpressionStatement_expression
+ParenExpression Expression
 |-'(' OpenParen
-|-ParenExpression ParenExpression_subExpression
+|-ParenExpression SubExpression
 | |-'(' OpenParen
-| |-IntegerLiteralExpression ParenExpression_subExpression
+| |-IntegerLiteralExpression SubExpression
 | | `-'1' LiteralToken
 | `-')' CloseParen
 `-')' CloseParen
 )txt",
        R"txt(
-ParenExpression ExpressionStatement_expression
+ParenExpression Expression
 |-'(' OpenParen
-|-BinaryOperatorExpression ParenExpression_subExpression
-| |-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+|-BinaryOperatorExpression SubExpression
+| |-IntegerLiteralExpression LeftHandSide
 | | `-'1' LiteralToken
-| |-'+' OperatorExpression_operatorToken
-| `-ParenExpression BinaryOperatorExpression_rightHandSide
+| |-'+' OperatorToken
+| `-ParenExpression RightHandSide
 |   |-'(' OpenParen
-|   |-IntegerLiteralExpression ParenExpression_subExpression
+|   |-IntegerLiteralExpression SubExpression
 |   | `-'2' LiteralToken
 |   `-')' CloseParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UserDefinedLiteral_Char) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _c(char);
 void test() {
   [['2'_c]];
 }
     )cpp",
       {R"txt(
-CharUserDefinedLiteralExpression ExpressionStatement_expression
+CharUserDefinedLiteralExpression Expression
 `-''2'_c' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
+StringUserDefinedLiteralExpression Expression
 `-'"12"_s' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UserDefinedLiteral_Integer) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _i(unsigned long long);
 unsigned operator "" _r(const char*);
 template <char...>
 unsigned operator "" _t();
 
 void test() {
   [[12_i]];
   [[12_r]];
   [[12_t]];
 }
     )cpp",
       {R"txt(
-IntegerUserDefinedLiteralExpression ExpressionStatement_expression
+IntegerUserDefinedLiteralExpression Expression
 `-'12_i' LiteralToken
 )txt",
        R"txt(
-IntegerUserDefinedLiteralExpression ExpressionStatement_expression
+IntegerUserDefinedLiteralExpression Expression
 `-'12_r' LiteralToken
 )txt",
        R"txt(
-IntegerUserDefinedLiteralExpression ExpressionStatement_expression
+IntegerUserDefinedLiteralExpression Expression
 `-'12_t' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UserDefinedLiteral_Float) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _f(long double);
 unsigned operator "" _r(const char*);
 template <char...>
 unsigned operator "" _t();
 
 void test() {
   [[1.2_f]];
   [[1.2_r]];
   [[1.2_t]];
 }
     )cpp",
       {R"txt(
-FloatUserDefinedLiteralExpression ExpressionStatement_expression
+FloatUserDefinedLiteralExpression Expression
 `-'1.2_f' LiteralToken
 )txt",
        R"txt(
-FloatUserDefinedLiteralExpression ExpressionStatement_expression
+FloatUserDefinedLiteralExpression Expression
 `-'1.2_r' LiteralToken
 )txt",
        R"txt(
-FloatUserDefinedLiteralExpression ExpressionStatement_expression
+FloatUserDefinedLiteralExpression Expression
 `-'1.2_t' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, IntegerLiteral_LongLong) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[12ll]];
   [[12ull]];
 }
 )cpp",
       {R"txt(
-IntegerLiteralExpression ExpressionStatement_expression
+IntegerLiteralExpression Expression
 `-'12ll' LiteralToken
 )txt",
        R"txt(
-IntegerLiteralExpression ExpressionStatement_expression
+IntegerLiteralExpression Expression
 `-'12ull' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, IntegerLiteral_Binary) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[0b1100]];
 }
 )cpp",
       {R"txt(
-IntegerLiteralExpression ExpressionStatement_expression
+IntegerLiteralExpression Expression
 `-'0b1100' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, IntegerLiteral_WithDigitSeparators) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[1'2'0ull]];
 }
 )cpp",
       {R"txt(
-IntegerLiteralExpression ExpressionStatement_expression
+IntegerLiteralExpression Expression
 `-'1'2'0ull' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CharacterLiteral) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [['a']];
   [['\n']];
   [['\x20']];
   [['\0']];
   [[L'a']];
   [[L'α']];
 }
 )cpp",
       {R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-''a'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-''\n'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-''\x20'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-''\0'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-'L'a'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-'L'α'' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CharacterLiteral_Utf) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[u'a']];
   [[u'構']];
   [[U'a']];
   [[U'🌲']];
 }
 )cpp",
       {R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-'u'a'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-'u'構'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-'U'a'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-'U'🌲'' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CharacterLiteral_Utf8) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[u8'a']];
   [[u8'\x7f']];
 }
 )cpp",
       {R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-'u8'a'' LiteralToken
 )txt",
        R"txt(
-CharacterLiteralExpression ExpressionStatement_expression
+CharacterLiteralExpression Expression
 `-'u8'\x7f'' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, FloatingLiteral) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[1e-2]];
   [[2.]];
   [[.2]];
   [[2.f]];
 }
 )cpp",
       {R"txt(
-FloatingLiteralExpression ExpressionStatement_expression
+FloatingLiteralExpression Expression
 `-'1e-2' LiteralToken
 )txt",
        R"txt(
-FloatingLiteralExpression ExpressionStatement_expression
+FloatingLiteralExpression Expression
 `-'2.' LiteralToken
 )txt",
        R"txt(
-FloatingLiteralExpression ExpressionStatement_expression
+FloatingLiteralExpression Expression
 `-'.2' LiteralToken
 )txt",
        R"txt(
-FloatingLiteralExpression ExpressionStatement_expression
+FloatingLiteralExpression Expression
 `-'2.f' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, FloatingLiteral_Hexadecimal) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[0xfp1]];
   [[0xf.p1]];
   [[0x.fp1]];
   [[0xf.fp1f]];
 }
 )cpp",
       {R"txt(
-FloatingLiteralExpression ExpressionStatement_expression
+FloatingLiteralExpression Expression
 `-'0xfp1' LiteralToken
 )txt",
        R"txt(
-FloatingLiteralExpression ExpressionStatement_expression
+FloatingLiteralExpression Expression
 `-'0xf.p1' LiteralToken
 )txt",
        R"txt(
-FloatingLiteralExpression ExpressionStatement_expression
+FloatingLiteralExpression Expression
 `-'0x.fp1' LiteralToken
 )txt",
        R"txt(
-FloatingLiteralExpression ExpressionStatement_expression
+FloatingLiteralExpression Expression
 `-'0xf.fp1f' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, StringLiteral) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [["a\n\0\x20"]];
   [[L"αβ"]];
 }
 )cpp",
       {R"txt(
-StringLiteralExpression ExpressionStatement_expression
+StringLiteralExpression Expression
 `-'"a\n\0\x20"' LiteralToken
 )txt",
        R"txt(
-StringLiteralExpression ExpressionStatement_expression
+StringLiteralExpression Expression
 `-'L"αβ"' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, StringLiteral_Utf) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[u8"a\x1f\x05"]];
   [[u"C++抽象構文木"]];
   [[U"📖🌲\n"]];
 }
 )cpp",
       {R"txt(
-StringLiteralExpression ExpressionStatement_expression
+StringLiteralExpression Expression
 `-'u8"a\x1f\x05"' LiteralToken
 )txt",
        R"txt(
-StringLiteralExpression ExpressionStatement_expression
+StringLiteralExpression Expression
 `-'u"C++抽象構文木"' LiteralToken
 )txt",
        R"txt(
-StringLiteralExpression ExpressionStatement_expression
+StringLiteralExpression Expression
 `-'U"📖🌲\n"' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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( //
       "void test() {\n"
       "  R\"SyntaxTree(\n"
       "  Hello \"Syntax\" \\\"\n"
       "  )SyntaxTree\";\n"
       "}\n",
       "TranslationUnit Detached\n"
       "`-SimpleDeclaration\n"
       "  |-'void'\n"
-      "  |-SimpleDeclarator SimpleDeclaration_declarator\n"
+      "  |-SimpleDeclarator Declarator\n"
       "  | |-'test'\n"
       "  | `-ParametersAndQualifiers\n"
       "  |   |-'(' OpenParen\n"
       "  |   `-')' CloseParen\n"
       "  `-CompoundStatement\n"
       "    |-'{' OpenParen\n"
-      "    |-ExpressionStatement CompoundStatement_statement\n"
-      "    | |-StringLiteralExpression ExpressionStatement_expression\n"
+      "    |-ExpressionStatement Statement\n"
+      "    | |-StringLiteralExpression Expression\n"
       "    | | `-'R\"SyntaxTree(\n"
       "  Hello \"Syntax\" \\\"\n"
       "  )SyntaxTree\"' LiteralToken\n"
       "    | `-';'\n"
       "    `-'}' CloseParen\n"));
 }
 
 TEST_P(SyntaxTreeTest, BoolLiteral) {
   if (GetParam().isC()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[true]];
   [[false]];
 }
 )cpp",
       {R"txt(
-BoolLiteralExpression ExpressionStatement_expression
+BoolLiteralExpression Expression
 `-'true' LiteralToken
 )txt",
        R"txt(
-BoolLiteralExpression ExpressionStatement_expression
+BoolLiteralExpression Expression
 `-'false' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[nullptr]];
 }
 )cpp",
       {R"txt(
-CxxNullPtrExpression ExpressionStatement_expression
+CxxNullPtrExpression Expression
 `-'nullptr' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[a++]];
   [[a--]];
 }
 )cpp",
       {R"txt(
-PostfixUnaryOperatorExpression ExpressionStatement_expression
-|-IdExpression UnaryOperatorExpression_operand
-| `-UnqualifiedId IdExpression_id
+PostfixUnaryOperatorExpression Expression
+|-IdExpression Operand
+| `-UnqualifiedId UnqualifiedId
 |   `-'a'
-`-'++' OperatorExpression_operatorToken
+`-'++' OperatorToken
 )txt",
        R"txt(
-PostfixUnaryOperatorExpression ExpressionStatement_expression
-|-IdExpression UnaryOperatorExpression_operand
-| `-UnqualifiedId IdExpression_id
+PostfixUnaryOperatorExpression Expression
+|-IdExpression Operand
+| `-UnqualifiedId UnqualifiedId
 |   `-'a'
-`-'--' OperatorExpression_operatorToken
+`-'--' OperatorToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, PrefixUnaryOperator) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a, int *ap) {
   [[--a]]; [[++a]];
   [[~a]];
   [[-a]];
   [[+a]];
   [[&a]];
   [[*ap]];
   [[!a]];
   [[__real a]]; [[__imag a]];
 }
 )cpp",
       {R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'--' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'--' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'++' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'++' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'~' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'~' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'-' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'-' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'+' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'+' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'&' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'&' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'*' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'*' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'ap'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'!' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'!' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'__real' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'__real' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'__imag' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'__imag' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, PrefixUnaryOperatorCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a, bool b) {
   [[compl a]];
   [[not b]];
 }
 )cpp",
       {R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'compl' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'compl' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt",
        R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'not' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'not' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'b'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperator) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[1 - 2]];
   [[1 == 2]];
   [[a = 1]];
   [[a <<= 1]];
   [[1 || 0]];
   [[1 & 2]];
   [[a != 3]];
 }
 )cpp",
       {R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-IntegerLiteralExpression LeftHandSide
 | `-'1' LiteralToken
-|-'-' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'-' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'2' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-IntegerLiteralExpression LeftHandSide
 | `-'1' LiteralToken
-|-'==' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'==' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'2' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'a'
-|-'=' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'=' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'1' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'a'
-|-'<<=' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'<<=' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'1' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-IntegerLiteralExpression LeftHandSide
 | `-'1' LiteralToken
-|-'||' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'||' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'0' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-IntegerLiteralExpression LeftHandSide
 | `-'1' LiteralToken
-|-'&' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'&' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'2' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'a'
-|-'!=' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'!=' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'3' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperatorCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a) {
   [[true || false]];
   [[true or false]];
   [[1 bitand 2]];
   [[a xor_eq 3]];
 }
 )cpp",
       {R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-BoolLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-BoolLiteralExpression LeftHandSide
 | `-'true' LiteralToken
-|-'||' OperatorExpression_operatorToken
-`-BoolLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'||' OperatorToken
+`-BoolLiteralExpression RightHandSide
   `-'false' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-BoolLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-BoolLiteralExpression LeftHandSide
 | `-'true' LiteralToken
-|-'or' OperatorExpression_operatorToken
-`-BoolLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'or' OperatorToken
+`-BoolLiteralExpression RightHandSide
   `-'false' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-IntegerLiteralExpression LeftHandSide
 | `-'1' LiteralToken
-|-'bitand' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'bitand' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'2' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'a'
-|-'xor_eq' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'xor_eq' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'3' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperator_NestedWithParenthesis) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[(1 + 2) * (4 / 2)]];
 }
 )cpp",
       {R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-ParenExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-ParenExpression LeftHandSide
 | |-'(' OpenParen
-| |-BinaryOperatorExpression ParenExpression_subExpression
-| | |-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+| |-BinaryOperatorExpression SubExpression
+| | |-IntegerLiteralExpression LeftHandSide
 | | | `-'1' LiteralToken
-| | |-'+' OperatorExpression_operatorToken
-| | `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+| | |-'+' OperatorToken
+| | `-IntegerLiteralExpression RightHandSide
 | |   `-'2' LiteralToken
 | `-')' CloseParen
-|-'*' OperatorExpression_operatorToken
-`-ParenExpression BinaryOperatorExpression_rightHandSide
+|-'*' OperatorToken
+`-ParenExpression RightHandSide
   |-'(' OpenParen
-  |-BinaryOperatorExpression ParenExpression_subExpression
-  | |-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+  |-BinaryOperatorExpression SubExpression
+  | |-IntegerLiteralExpression LeftHandSide
   | | `-'4' LiteralToken
-  | |-'/' OperatorExpression_operatorToken
-  | `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+  | |-'/' OperatorToken
+  | `-IntegerLiteralExpression RightHandSide
   |   `-'2' LiteralToken
   `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperator_Associativity) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test(int a, int b) {
   [[a + b + 42]];
   [[a = b = 42]];
 }
 )cpp",
       {R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-BinaryOperatorExpression BinaryOperatorExpression_leftHandSide
-| |-IdExpression BinaryOperatorExpression_leftHandSide
-| | `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-BinaryOperatorExpression LeftHandSide
+| |-IdExpression LeftHandSide
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'a'
-| |-'+' OperatorExpression_operatorToken
-| `-IdExpression BinaryOperatorExpression_rightHandSide
-|   `-UnqualifiedId IdExpression_id
+| |-'+' OperatorToken
+| `-IdExpression RightHandSide
+|   `-UnqualifiedId UnqualifiedId
 |     `-'b'
-|-'+' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'+' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'42' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'a'
-|-'=' OperatorExpression_operatorToken
-`-BinaryOperatorExpression BinaryOperatorExpression_rightHandSide
-  |-IdExpression BinaryOperatorExpression_leftHandSide
-  | `-UnqualifiedId IdExpression_id
+|-'=' OperatorToken
+`-BinaryOperatorExpression RightHandSide
+  |-IdExpression LeftHandSide
+  | `-UnqualifiedId UnqualifiedId
   |   `-'b'
-  |-'=' OperatorExpression_operatorToken
-  `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+  |-'=' OperatorToken
+  `-IntegerLiteralExpression RightHandSide
     `-'42' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperator_Precedence) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void test() {
   [[1 + 2 * 3 + 4]];
   [[1 % 2 + 3 * 4]];
 }
 )cpp",
       {R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-BinaryOperatorExpression BinaryOperatorExpression_leftHandSide
-| |-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-BinaryOperatorExpression LeftHandSide
+| |-IntegerLiteralExpression LeftHandSide
 | | `-'1' LiteralToken
-| |-'+' OperatorExpression_operatorToken
-| `-BinaryOperatorExpression BinaryOperatorExpression_rightHandSide
-|   |-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+| |-'+' OperatorToken
+| `-BinaryOperatorExpression RightHandSide
+|   |-IntegerLiteralExpression LeftHandSide
 |   | `-'2' LiteralToken
-|   |-'*' OperatorExpression_operatorToken
-|   `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|   |-'*' OperatorToken
+|   `-IntegerLiteralExpression RightHandSide
 |     `-'3' LiteralToken
-|-'+' OperatorExpression_operatorToken
-`-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+|-'+' OperatorToken
+`-IntegerLiteralExpression RightHandSide
   `-'4' LiteralToken
 )txt",
        R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-BinaryOperatorExpression BinaryOperatorExpression_leftHandSide
-| |-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-BinaryOperatorExpression LeftHandSide
+| |-IntegerLiteralExpression LeftHandSide
 | | `-'1' LiteralToken
-| |-'%' OperatorExpression_operatorToken
-| `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+| |-'%' OperatorToken
+| `-IntegerLiteralExpression RightHandSide
 |   `-'2' LiteralToken
-|-'+' OperatorExpression_operatorToken
-`-BinaryOperatorExpression BinaryOperatorExpression_rightHandSide
-  |-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide
+|-'+' OperatorToken
+`-BinaryOperatorExpression RightHandSide
+  |-IntegerLiteralExpression LeftHandSide
   | `-'3' LiteralToken
-  |-'*' OperatorExpression_operatorToken
-  `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+  |-'*' OperatorToken
+  `-IntegerLiteralExpression RightHandSide
     `-'4' LiteralToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'x'
-|-'=' OperatorExpression_operatorToken
-`-IdExpression BinaryOperatorExpression_rightHandSide
-  `-UnqualifiedId IdExpression_id
+|-'=' OperatorToken
+`-IdExpression RightHandSide
+  `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, OverloadedOperator_Plus) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   friend X operator+(X, const X&);
 };
 // FIXME: Remove additional `UnknownExpression` wrapping `x`. For that, ignore
 // implicit copy constructor called on `x`. This should've been ignored already,
 // as we `IgnoreImplicit` when traversing an `Stmt`.
 void test(X x, X y) {
   [[x + y]];
 }
 )cpp",
       {R"txt(
-BinaryOperatorExpression ExpressionStatement_expression
-|-UnknownExpression BinaryOperatorExpression_leftHandSide
+BinaryOperatorExpression Expression
+|-UnknownExpression LeftHandSide
 | `-IdExpression
-|   `-UnqualifiedId IdExpression_id
+|   `-UnqualifiedId UnqualifiedId
 |     `-'x'
-|-'+' OperatorExpression_operatorToken
-`-IdExpression BinaryOperatorExpression_rightHandSide
-  `-UnqualifiedId IdExpression_id
+|-'+' OperatorToken
+`-IdExpression RightHandSide
+  `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'x'
-|-'<' OperatorExpression_operatorToken
-`-IdExpression BinaryOperatorExpression_rightHandSide
-  `-UnqualifiedId IdExpression_id
+|-'<' OperatorToken
+`-IdExpression RightHandSide
+  `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'x'
-|-'<<' OperatorExpression_operatorToken
-`-IdExpression BinaryOperatorExpression_rightHandSide
-  `-UnqualifiedId IdExpression_id
+|-'<<' OperatorToken
+`-IdExpression RightHandSide
+  `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'x'
-|-',' OperatorExpression_operatorToken
-`-IdExpression BinaryOperatorExpression_rightHandSide
-  `-UnqualifiedId IdExpression_id
+|-',' OperatorToken
+`-IdExpression RightHandSide
+  `-UnqualifiedId UnqualifiedId
     `-'y'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
-|-IdExpression BinaryOperatorExpression_leftHandSide
-| `-UnqualifiedId IdExpression_id
+BinaryOperatorExpression Expression
+|-IdExpression LeftHandSide
+| `-UnqualifiedId UnqualifiedId
 |   `-'xp'
-|-'->*' OperatorExpression_operatorToken
-`-IdExpression BinaryOperatorExpression_rightHandSide
-  `-UnqualifiedId IdExpression_id
+|-'->*' OperatorToken
+`-IdExpression RightHandSide
+  `-UnqualifiedId UnqualifiedId
     `-'pmi'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, OverloadedOperator_Negation) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   bool operator!();
 };
 void test(X x) {
   [[!x]];
 }
 )cpp",
       {R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'!' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'!' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'x'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, OverloadedOperator_AddressOf) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X* operator&();
 };
 void test(X x) {
   [[&x]];
 }
 )cpp",
       {R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'&' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'&' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'x'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, OverloadedOperator_PrefixIncrement) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   X operator++();
 };
 void test(X x) {
   [[++x]];
 }
 )cpp",
       {R"txt(
-PrefixUnaryOperatorExpression ExpressionStatement_expression
-|-'++' OperatorExpression_operatorToken
-`-IdExpression UnaryOperatorExpression_operand
-  `-UnqualifiedId IdExpression_id
+PrefixUnaryOperatorExpression Expression
+|-'++' OperatorToken
+`-IdExpression Operand
+  `-UnqualifiedId UnqualifiedId
     `-'x'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
-|-IdExpression UnaryOperatorExpression_operand
-| `-UnqualifiedId IdExpression_id
+PostfixUnaryOperatorExpression Expression
+|-IdExpression Operand
+| `-UnqualifiedId UnqualifiedId
 |   `-'x'
-`-'++' OperatorExpression_operatorToken
+`-'++' OperatorToken
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_SimpleWithDot) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   int a;
 };
 void test(struct S s) {
   [[s.a]];
 }
 )cpp",
       {R"txt(
-MemberExpression ExpressionStatement_expression
-|-IdExpression MemberExpression_object
-| `-UnqualifiedId IdExpression_id
+MemberExpression Expression
+|-IdExpression Object
+| `-UnqualifiedId UnqualifiedId
 |   `-'s'
-|-'.' MemberExpression_accessToken
-`-IdExpression MemberExpression_member
-  `-UnqualifiedId IdExpression_id
+|-'.' AccessToken
+`-IdExpression Member
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
-|-IdExpression MemberExpression_object
-| `-UnqualifiedId IdExpression_id
+MemberExpression Expression
+|-IdExpression Object
+| `-UnqualifiedId UnqualifiedId
 |   `-'s'
-|-'.' MemberExpression_accessToken
-`-IdExpression MemberExpression_member
-  `-UnqualifiedId IdExpression_id
+|-'.' AccessToken
+`-IdExpression Member
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_SimpleWithArrow) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   int a;
 };
 void test(struct S* sp) {
   [[sp->a]];
 }
 )cpp",
       {R"txt(
-MemberExpression ExpressionStatement_expression
-|-IdExpression MemberExpression_object
-| `-UnqualifiedId IdExpression_id
+MemberExpression Expression
+|-IdExpression Object
+| `-UnqualifiedId UnqualifiedId
 |   `-'sp'
-|-'->' MemberExpression_accessToken
-`-IdExpression MemberExpression_member
-  `-UnqualifiedId IdExpression_id
+|-'->' AccessToken
+`-IdExpression Member
+  `-UnqualifiedId UnqualifiedId
     `-'a'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_Chaining) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   struct S* next;
 };
 void test(struct S s){
   [[s.next->next]];
 }
 )cpp",
       {R"txt(
-MemberExpression ExpressionStatement_expression
-|-MemberExpression MemberExpression_object
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+MemberExpression Expression
+|-MemberExpression Object
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'s'
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| |-'.' AccessToken
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     `-'next'
-|-'->' MemberExpression_accessToken
-`-IdExpression MemberExpression_member
-  `-UnqualifiedId IdExpression_id
+|-'->' AccessToken
+`-IdExpression Member
+  `-UnqualifiedId UnqualifiedId
     `-'next'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_OperatorFunction) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   bool operator!();
 };
 void test(S s) {
   [[s.operator!()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'s'
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| |-'.' AccessToken
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     |-'operator'
 |     `-'!'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_VariableTemplate) {

 // `ExpressionStatement`. This is a bug in clang, in `getSourceRange` methods.
 void test(S s) [[{
   s.x<int>;
 }]]
 )cpp",
       {R"txt(
 CompoundStatement
 |-'{' OpenParen
-|-ExpressionStatement CompoundStatement_statement
-| `-MemberExpression ExpressionStatement_expression
-|   |-IdExpression MemberExpression_object
-|   | `-UnqualifiedId IdExpression_id
+|-ExpressionStatement Statement
+| `-MemberExpression Expression
+|   |-IdExpression Object
+|   | `-UnqualifiedId UnqualifiedId
 |   |   `-'s'
-|   |-'.' MemberExpression_accessToken
-|   `-IdExpression MemberExpression_member
-|     `-UnqualifiedId IdExpression_id
+|   |-'.' AccessToken
+|   `-IdExpression Member
+|     `-UnqualifiedId UnqualifiedId
 |       `-'x'
 |-'<'
 |-'int'
 |-'>'
 |-';'
 `-'}' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_FunctionTemplate) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename T>
   T f();
 };
 void test(S* sp){
   [[sp->f<int>()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'sp'
-| |-'->' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| |-'->' AccessToken
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     |-'f'
 |     |-'<'
 |     |-'int'
 |     `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_FunctionTemplateWithTemplateKeyword) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename T>
   T f();
 };
 void test(S s){
   [[s.template f<int>()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'s'
-| |-'.' MemberExpression_accessToken
+| |-'.' AccessToken
 | |-'template'
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     |-'f'
 |     |-'<'
 |     |-'int'
 |     `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }

 };
 struct S : public Base {};
 void test(S s){
   [[s.Base::f()]];
   [[s.::S::~S()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'s'
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   |-NestedNameSpecifier IdExpression_qualifier
-|   | |-IdentifierNameSpecifier List_element
+| |-'.' AccessToken
+| `-IdExpression Member
+|   |-NestedNameSpecifier Qualifier
+|   | |-IdentifierNameSpecifier ListElement
 |   | | `-'Base'
-|   | `-'::' List_delimiter
-|   `-UnqualifiedId IdExpression_id
+|   | `-'::' ListDelimiter
+|   `-UnqualifiedId UnqualifiedId
 |     `-'f'
 |-'(' OpenParen
 `-')' CloseParen
       )txt",
        R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'s'
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   |-NestedNameSpecifier IdExpression_qualifier
-|   | |-'::' List_delimiter
-|   | |-IdentifierNameSpecifier List_element
+| |-'.' AccessToken
+| `-IdExpression Member
+|   |-NestedNameSpecifier Qualifier
+|   | |-'::' ListDelimiter
+|   | |-IdentifierNameSpecifier ListElement
 |   | | `-'S'
-|   | `-'::' List_delimiter
-|   `-UnqualifiedId IdExpression_id
+|   | `-'::' ListDelimiter
+|   `-UnqualifiedId UnqualifiedId
 |     |-'~'
 |     `-'S'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_Complex) {
void test(S* sp) {
   // but it should be a child of `MemberExpression` according to the grammar.
   // However one might argue that the 'template' keyword fits better inside
   // `NestedNameSpecifier` because if we change `U<int>` to `UI` we would like
   // equally to change the `NameSpecifier` `template U<int>` to just `UI`.
   [[sp->getU().template U<int>::template f<int>()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-CallExpression MemberExpression_object
-| | |-MemberExpression CallExpression_callee
-| | | |-IdExpression MemberExpression_object
-| | | | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-CallExpression Object
+| | |-MemberExpression Callee
+| | | |-IdExpression Object
+| | | | `-UnqualifiedId UnqualifiedId
 | | | |   `-'sp'
-| | | |-'->' MemberExpression_accessToken
-| | | `-IdExpression MemberExpression_member
-| | |   `-UnqualifiedId IdExpression_id
+| | | |-'->' AccessToken
+| | | `-IdExpression Member
+| | |   `-UnqualifiedId UnqualifiedId
 | | |     `-'getU'
 | | |-'(' OpenParen
 | | `-')' CloseParen
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   |-NestedNameSpecifier IdExpression_qualifier
-|   | |-SimpleTemplateNameSpecifier List_element
+| |-'.' AccessToken
+| `-IdExpression Member
+|   |-NestedNameSpecifier Qualifier
+|   | |-SimpleTemplateNameSpecifier ListElement
 |   | | |-'template'
 |   | | |-'U'
 |   | | |-'<'
 |   | | |-'int'
 |   | | `-'>'
-|   | `-'::' List_delimiter
+|   | `-'::' ListDelimiter
 |   |-'template' TemplateKeyword
-|   `-UnqualifiedId IdExpression_id
+|   `-UnqualifiedId UnqualifiedId
 |     |-'f'
 |     |-'<'
 |     |-'int'
 |     `-'>'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Callee_Member) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S{
   void f();
 };
 void test(S s) {
   [[s.f()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-IdExpression MemberExpression_object
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-MemberExpression Callee
+| |-IdExpression Object
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'s'
-| |-'.' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| |-'.' AccessToken
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     `-'f'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-IdExpression Callee
+| `-UnqualifiedId UnqualifiedId
 |   `-'s'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Callee_OperatorParensChaining) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   S operator()();
 };
 void test(S s) {
   [[s()()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-CallExpression CallExpression_callee
-| |-IdExpression CallExpression_callee
-| | `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-CallExpression Callee
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'s'
 | |-'(' OpenParen
 | `-')' CloseParen
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
struct S: public Base {
   void test() {
     [[this->f()]];
     [[f()]];
     [[this->Base::f()]];
   }
 };
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-ThisExpression MemberExpression_object
+CallExpression Expression
+|-MemberExpression Callee
+| |-ThisExpression Object
 | | `-'this' IntroducerKeyword
-| |-'->' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   `-UnqualifiedId IdExpression_id
+| |-'->' AccessToken
+| `-IdExpression Member
+|   `-UnqualifiedId UnqualifiedId
 |     `-'f'
 |-'(' OpenParen
 `-')' CloseParen
       )txt",
        R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-IdExpression Callee
+| `-UnqualifiedId UnqualifiedId
 |   `-'f'
 |-'(' OpenParen
 `-')' CloseParen
       )txt",
        R"txt(
-CallExpression ExpressionStatement_expression
-|-MemberExpression CallExpression_callee
-| |-ThisExpression MemberExpression_object
+CallExpression Expression
+|-MemberExpression Callee
+| |-ThisExpression Object
 | | `-'this' IntroducerKeyword
-| |-'->' MemberExpression_accessToken
-| `-IdExpression MemberExpression_member
-|   |-NestedNameSpecifier IdExpression_qualifier
-|   | |-IdentifierNameSpecifier List_element
+| |-'->' AccessToken
+| `-IdExpression Member
+|   |-NestedNameSpecifier Qualifier
+|   | |-IdentifierNameSpecifier ListElement
 |   | | `-'Base'
-|   | `-'::' List_delimiter
-|   `-UnqualifiedId IdExpression_id
+|   | `-'::' ListDelimiter
+|   `-UnqualifiedId UnqualifiedId
 |     `-'f'
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Callee_FunctionPointer) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void (*pf)();
 void test() {
   [[pf()]];
   [[(*pf)()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-IdExpression CallExpression_callee
-| `-UnqualifiedId IdExpression_id
+CallExpression Expression
+|-IdExpression Callee
+| `-UnqualifiedId UnqualifiedId
 |   `-'pf'
 |-'(' OpenParen
 `-')' CloseParen
 )txt",
        R"txt(
-CallExpression ExpressionStatement_expression
-|-ParenExpression CallExpression_callee
+CallExpression Expression
+|-ParenExpression Callee
 | |-'(' OpenParen
-| |-PrefixUnaryOperatorExpression ParenExpression_subExpression
-| | |-'*' OperatorExpression_operatorToken
-| | `-IdExpression UnaryOperatorExpression_operand
-| |   `-UnqualifiedId IdExpression_id
+| |-PrefixUnaryOperatorExpression SubExpression
+| | |-'*' OperatorToken
+| | `-IdExpression Operand
+| |   `-UnqualifiedId UnqualifiedId
 | |     `-'pf'
 | `-')' CloseParen
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Callee_MemberFunctionPointer) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   void f();
 };
 void test(S s) {
   void (S::*pmf)();
   pmf = &S::f;
   [[(s.*pmf)()]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-ParenExpression CallExpression_callee
+CallExpression Expression
+|-ParenExpression Callee
 | |-'(' OpenParen
-| |-BinaryOperatorExpression ParenExpression_subExpression
-| | |-IdExpression BinaryOperatorExpression_leftHandSide
-| | | `-UnqualifiedId IdExpression_id
+| |-BinaryOperatorExpression SubExpression
+| | |-IdExpression LeftHandSide
+| | | `-UnqualifiedId UnqualifiedId
 | | |   `-'s'
-| | |-'.*' OperatorExpression_operatorToken
-| | `-IdExpression BinaryOperatorExpression_rightHandSide
-| |   `-UnqualifiedId IdExpression_id
+| | |-'.*' OperatorToken
+| | `-IdExpression RightHandSide
+| |   `-UnqualifiedId UnqualifiedId
 | |     `-'pmf'
 | `-')' CloseParen
 |-'(' OpenParen
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Arguments_Zero) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f();
 void test() {
   [[f();]]
 }
 )cpp",
       {R"txt(
-ExpressionStatement CompoundStatement_statement
-|-CallExpression ExpressionStatement_expression
-| |-IdExpression CallExpression_callee
-| | `-UnqualifiedId IdExpression_id
+ExpressionStatement Statement
+|-CallExpression Expression
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'f'
 | |-'(' OpenParen
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Arguments_One) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int);
 void test() {
   [[f(1);]]
 }
 )cpp",
       {R"txt(
-ExpressionStatement CompoundStatement_statement
-|-CallExpression ExpressionStatement_expression
-| |-IdExpression CallExpression_callee
-| | `-UnqualifiedId IdExpression_id
+ExpressionStatement Statement
+|-CallExpression Expression
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'f'
 | |-'(' OpenParen
-| |-CallArguments CallExpression_arguments
-| | `-IntegerLiteralExpression List_element
+| |-CallArguments Arguments
+| | `-IntegerLiteralExpression ListElement
 | |   `-'1' LiteralToken
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Arguments_Multiple) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int, char, float);
 void test() {
   [[f(1, '2', 3.);]]
 }
 )cpp",
       {R"txt(
-ExpressionStatement CompoundStatement_statement
-|-CallExpression ExpressionStatement_expression
-| |-IdExpression CallExpression_callee
-| | `-UnqualifiedId IdExpression_id
+ExpressionStatement Statement
+|-CallExpression Expression
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'f'
 | |-'(' OpenParen
-| |-CallArguments CallExpression_arguments
-| | |-IntegerLiteralExpression List_element
+| |-CallArguments Arguments
+| | |-IntegerLiteralExpression ListElement
 | | | `-'1' LiteralToken
-| | |-',' List_delimiter
-| | |-CharacterLiteralExpression List_element
+| | |-',' ListDelimiter
+| | |-CharacterLiteralExpression ListElement
 | | | `-''2'' LiteralToken
-| | |-',' List_delimiter
-| | `-FloatingLiteralExpression List_element
+| | |-',' ListDelimiter
+| | `-FloatingLiteralExpression ListElement
 | |   `-'3.' LiteralToken
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Arguments_Assignment) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int);
 void test(int a) {
   [[f(a = 1);]]
 }
 )cpp",
       {R"txt(
-ExpressionStatement CompoundStatement_statement
-|-CallExpression ExpressionStatement_expression
-| |-IdExpression CallExpression_callee
-| | `-UnqualifiedId IdExpression_id
+ExpressionStatement Statement
+|-CallExpression Expression
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'f'
 | |-'(' OpenParen
-| |-CallArguments CallExpression_arguments
-| | `-BinaryOperatorExpression List_element
-| |   |-IdExpression BinaryOperatorExpression_leftHandSide
-| |   | `-UnqualifiedId IdExpression_id
+| |-CallArguments Arguments
+| | `-BinaryOperatorExpression ListElement
+| |   |-IdExpression LeftHandSide
+| |   | `-UnqualifiedId UnqualifiedId
 | |   |   `-'a'
-| |   |-'=' OperatorExpression_operatorToken
-| |   `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+| |   |-'=' OperatorToken
+| |   `-IntegerLiteralExpression RightHandSide
 | |     `-'1' LiteralToken
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, CallExpression_Arguments_BracedInitList_Empty) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 void f(int[]);
 void test() {
   [[f({});]]
 }
 )cpp",
       {R"txt(
-ExpressionStatement CompoundStatement_statement
-|-CallExpression ExpressionStatement_expression
-| |-IdExpression CallExpression_callee
-| | `-UnqualifiedId IdExpression_id
+ExpressionStatement Statement
+|-CallExpression Expression
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'f'
 | |-'(' OpenParen
-| |-CallArguments CallExpression_arguments
-| | `-UnknownExpression List_element
+| |-CallArguments Arguments
+| | `-UnknownExpression ListElement
 | |   `-UnknownExpression
 | |     |-'{'
 | |     `-'}'
 | `-')' CloseParen
 `-';'
 )txt"}));
 }
 
struct T{
   TT b;
 };
 void f(T);
 void test() {
   [[f({1, {}});]]
 }
 )cpp",
       {R"txt(
-ExpressionStatement CompoundStatement_statement
-|-CallExpression ExpressionStatement_expression
-| |-IdExpression CallExpression_callee
-| | `-UnqualifiedId IdExpression_id
+ExpressionStatement Statement
+|-CallExpression Expression
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'f'
 | |-'(' OpenParen
-| |-CallArguments CallExpression_arguments
-| | `-UnknownExpression List_element
+| |-CallArguments Arguments
+| | `-UnknownExpression ListElement
 | |   `-UnknownExpression
 | |     |-'{'
 | |     |-IntegerLiteralExpression
 | |     | `-'1' LiteralToken
 | |     |-','
 | |     |-UnknownExpression
 | |     | `-UnknownExpression
 | |     |   |-'{'
struct T{
   TT b;
 };
 void f(T);
 void test() {
   [[f({.a = 1, .b {}});]]
 }
 )cpp",
       {R"txt(
-ExpressionStatement CompoundStatement_statement
-|-CallExpression ExpressionStatement_expression
-| |-IdExpression CallExpression_callee
-| | `-UnqualifiedId IdExpression_id
+ExpressionStatement Statement
+|-CallExpression Expression
+| |-IdExpression Callee
+| | `-UnqualifiedId UnqualifiedId
 | |   `-'f'
 | |-'(' OpenParen
-| |-CallArguments CallExpression_arguments
-| | `-UnknownExpression List_element
+| |-CallArguments Arguments
+| | `-UnknownExpression ListElement
 | |   `-UnknownExpression
 | |     |-'{'
 | |     |-UnknownExpression
 | |     | |-'.'
 | |     | |-'a'
 | |     | |-'='
 | |     | `-IntegerLiteralExpression
 | |     |   `-'1' LiteralToken
TEST_P(SyntaxTreeTest, CallExpression_Arguments_ParameterPack) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T, typename... Args>
 void test(T t, Args... args) {
   [[test(args...)]];
 }
 )cpp",
       {R"txt(
-CallExpression ExpressionStatement_expression
-|-UnknownExpression CallExpression_callee
+CallExpression Expression
+|-UnknownExpression Callee
 | `-'test'
 |-'(' OpenParen
-|-CallArguments CallExpression_arguments
-| `-UnknownExpression List_element
+|-CallArguments Arguments
+| `-UnknownExpression ListElement
 |   |-IdExpression
-|   | `-UnqualifiedId IdExpression_id
+|   | `-UnqualifiedId UnqualifiedId
 |   |   `-'args'
 |   `-'...'
 `-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int *a, b;
 int *c, d;
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'*'
 | | `-'a'
 | |-','
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | `-'b'
 | `-';'
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'*'
   | `-'c'
   |-','
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | `-'d'
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 typedef int *a, b;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'typedef'
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'*'
   | `-'a'
   |-','
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | `-'b'
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void foo() {
   int *a, b;
   typedef int *ta, tb;
 }
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'foo'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
-    |-DeclarationStatement CompoundStatement_statement
+    |-DeclarationStatement Statement
     | |-SimpleDeclaration
     | | |-'int'
-    | | |-SimpleDeclarator SimpleDeclaration_declarator
+    | | |-SimpleDeclarator Declarator
     | | | |-'*'
     | | | `-'a'
     | | |-','
-    | | `-SimpleDeclarator SimpleDeclaration_declarator
+    | | `-SimpleDeclarator Declarator
     | |   `-'b'
     | `-';'
-    |-DeclarationStatement CompoundStatement_statement
+    |-DeclarationStatement Statement
     | |-SimpleDeclaration
     | | |-'typedef'
     | | |-'int'
-    | | |-SimpleDeclarator SimpleDeclaration_declarator
+    | | |-SimpleDeclarator Declarator
     | | | |-'*'
     | | | `-'ta'
     | | |-','
-    | | `-SimpleDeclarator SimpleDeclaration_declarator
+    | | `-SimpleDeclarator Declarator
     | |   `-'tb'
     | `-';'
     `-'}' CloseParen
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, SizeTTypedef) {
   if (!GetParam().isCXX11OrLater()) {
`-SimpleDeclaration
   |-'('
   |-UnknownExpression
   | |-'sizeof'
   | |-'('
   | |-'void'
   | |-'*'
   | `-')'
   |-')'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | `-'size_t'
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, Namespace_Nested) {
   if (!GetParam().isCXX()) {
     return;

 namespace ns {}
 [[using namespace ::ns;]]
 )cpp",
       {R"txt(
 UsingNamespaceDirective
 |-'using'
 |-'namespace'
 |-NestedNameSpecifier
-| `-'::' List_delimiter
+| `-'::' ListDelimiter
 |-'ns'
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 List_element
+| |-IdentifierNameSpecifier ListElement
 | | `-'ns'
-| `-'::' List_delimiter
+| `-'::' ListDelimiter
 |-'a'
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UsingDeclaration_ClassMember) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X {
   [[using T::foo;]]
   [[using typename T::bar;]]
 };
 )cpp",
       {R"txt(
 UsingDeclaration
 |-'using'
 |-NestedNameSpecifier
-| |-IdentifierNameSpecifier List_element
+| |-IdentifierNameSpecifier ListElement
 | | `-'T'
-| `-'::' List_delimiter
+| `-'::' ListDelimiter
 |-'foo'
 `-';'
 )txt",
        R"txt(
 UsingDeclaration
 |-'using'
 |-'typename'
 |-NestedNameSpecifier
-| |-IdentifierNameSpecifier List_element
+| |-IdentifierNameSpecifier ListElement
 | | `-'T'
-| `-'::' List_delimiter
+| `-'::' ListDelimiter
 |-'bar'
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UsingTypeAlias) {
   if (!GetParam().isCXX11OrLater()) {
     return;

 |-'struct'
 |-'X'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'struct'
 |-'Y'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'*'
 | `-'y1'
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, FreeStandingClasses_Definition) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(

 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'struct'
 |-'Y'
 |-'{'
 |-'}'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'*'
 | `-'y2'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'struct'
 |-'{'
 |-'}'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'*'
 | `-'a1'
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, StaticMemberFunction) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   [[static void f(){}]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'static'
 |-'void'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'f'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   `-')' CloseParen
 `-CompoundStatement
   |-'{' OpenParen
   `-'}' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ConversionMemberFunction) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   [[operator int();]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'operator'
 | |-'int'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, LiteralOperatorDeclaration) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 unsigned operator "" _c(char);
     )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'unsigned'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'operator'
   | |-'""'
   | |-'_c'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | `-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | `-SimpleDeclaration ListElement
   |   |   `-'char'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, NumericLiteralOperatorTemplateDeclaration) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <char...>
 unsigned operator "" _t();
     )cpp",
       R"txt(
 TranslationUnit Detached
-`-TemplateDeclaration TemplateDeclaration_declaration
+`-TemplateDeclaration Declaration
   |-'template' IntroducerKeyword
   |-'<'
   |-SimpleDeclaration
   | `-'char'
   |-'...'
   |-'>'
   `-SimpleDeclaration
     |-'unsigned'
-    |-SimpleDeclarator SimpleDeclaration_declarator
+    |-SimpleDeclarator Declarator
     | |-'operator'
     | |-'""'
     | |-'_t'
     | `-ParametersAndQualifiers
     |   |-'(' OpenParen
     |   `-')' CloseParen
     `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, OverloadedOperatorDeclaration) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   [[X& operator=(const X&);]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'X'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'&'
 | |-'operator'
 | |-'='
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
-|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-|   | `-SimpleDeclaration List_element
+|   |-ParameterDeclarationList Parameters
+|   | `-SimpleDeclaration ListElement
 |   |   |-'const'
 |   |   |-'X'
-|   |   `-SimpleDeclarator SimpleDeclaration_declarator
+|   |   `-SimpleDeclarator Declarator
 |   |     `-'&'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, OverloadedOperatorFriendDeclaration) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   [[friend X operator+(X, const X&);]]
 };
 )cpp",
       {R"txt(
 UnknownDeclaration
 `-SimpleDeclaration
   |-'friend'
   |-'X'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'operator'
   | |-'+'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
   |   | | `-'X'
-  |   | |-',' List_delimiter
-  |   | `-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'const'
   |   |   |-'X'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     `-'&'
   |   `-')' CloseParen
   `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ClassTemplateDeclaration) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template<typename T>
 struct ST {};
 )cpp",
       R"txt(
 TranslationUnit Detached
-`-TemplateDeclaration TemplateDeclaration_declaration
+`-TemplateDeclaration Declaration
   |-'template' IntroducerKeyword
   |-'<'
   |-UnknownDeclaration
   | |-'typename'
   | `-'T'
   |-'>'
   `-SimpleDeclaration
     |-'struct'
TEST_P(SyntaxTreeTest, FunctionTemplateDeclaration) {
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template<typename T>
 T f();
 )cpp",
       R"txt(
 TranslationUnit Detached
-`-TemplateDeclaration TemplateDeclaration_declaration
+`-TemplateDeclaration Declaration
   |-'template' IntroducerKeyword
   |-'<'
   |-UnknownDeclaration
   | |-'typename'
   | `-'T'
   |-'>'
   `-SimpleDeclaration
     |-'T'
-    |-SimpleDeclarator SimpleDeclaration_declarator
+    |-SimpleDeclarator Declarator
     | |-'f'
     | `-ParametersAndQualifiers
     |   |-'(' OpenParen
     |   `-')' CloseParen
     `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, VariableTemplateDeclaration) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T> T var = 10;
 )cpp",
       R"txt(
 TranslationUnit Detached
-`-TemplateDeclaration TemplateDeclaration_declaration
+`-TemplateDeclaration Declaration
   |-'template' IntroducerKeyword
   |-'<'
   |-UnknownDeclaration
   | |-'class'
   | `-'T'
   |-'>'
   `-SimpleDeclaration
     |-'T'
-    |-SimpleDeclarator SimpleDeclaration_declarator
+    |-SimpleDeclarator Declarator
     | |-'var'
     | |-'='
     | `-IntegerLiteralExpression
     |   `-'10' LiteralToken
     `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, StaticMemberFunctionTemplate) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   [[template<typename U>
   static U f();]]
 };
 )cpp",
       {R"txt(
-TemplateDeclaration TemplateDeclaration_declaration
+TemplateDeclaration Declaration
 |-'template' IntroducerKeyword
 |-'<'
 |-UnknownDeclaration
 | |-'typename'
 | `-'U'
 |-'>'
 `-SimpleDeclaration
   |-'static'
   |-'U'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'f'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, NestedTemplates) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T>
 struct X {
   template <class U>
   U foo();
 };
 )cpp",
       R"txt(
 TranslationUnit Detached
-`-TemplateDeclaration TemplateDeclaration_declaration
+`-TemplateDeclaration Declaration
   |-'template' IntroducerKeyword
   |-'<'
   |-UnknownDeclaration
   | |-'class'
   | `-'T'
   |-'>'
   `-SimpleDeclaration
     |-'struct'
     |-'X'
     |-'{'
-    |-TemplateDeclaration TemplateDeclaration_declaration
+    |-TemplateDeclaration Declaration
     | |-'template' IntroducerKeyword
     | |-'<'
     | |-UnknownDeclaration
     | | |-'class'
     | | `-'U'
     | |-'>'
     | `-SimpleDeclaration
     |   |-'U'
-    |   |-SimpleDeclarator SimpleDeclaration_declarator
+    |   |-SimpleDeclarator Declarator
     |   | |-'foo'
     |   | `-ParametersAndQualifiers
     |   |   |-'(' OpenParen
     |   |   `-')' CloseParen
     |   `-';'
     |-'}'
     `-';'
 )txt"));

 }
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-NamespaceDefinition
   |-'namespace'
   |-'n'
   |-'{'
-  |-TemplateDeclaration TemplateDeclaration_declaration
+  |-TemplateDeclaration Declaration
   | |-'template' IntroducerKeyword
   | |-'<'
   | |-UnknownDeclaration
   | | |-'typename'
   | | `-'T'
   | |-'>'
   | `-SimpleDeclaration
   |   |-'struct'
   |   |-'ST'
   |   |-'{'
-  |   |-TemplateDeclaration TemplateDeclaration_declaration
+  |   |-TemplateDeclaration Declaration
   |   | |-'template' IntroducerKeyword
   |   | |-'<'
   |   | |-UnknownDeclaration
   |   | | |-'typename'
   |   | | `-'U'
   |   | |-'>'
   |   | `-SimpleDeclaration
   |   |   |-'static'
   |   |   |-'U'
-  |   |   |-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   |-SimpleDeclarator Declarator
   |   |   | |-'f'
   |   |   | `-ParametersAndQualifiers
   |   |   |   |-'(' OpenParen
   |   |   |   `-')' CloseParen
   |   |   `-';'
   |   |-'}'
   |   `-';'
   `-'}'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, 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",
       {R"txt(
-TemplateDeclaration TemplateDeclaration_declaration
+TemplateDeclaration Declaration
 |-'template' IntroducerKeyword
 |-'<'
 |-UnknownDeclaration
 | |-'class'
 | `-'T'
 |-'>'
 `-SimpleDeclaration
   |-'struct'
   |-NestedNameSpecifier
-  | |-SimpleTemplateNameSpecifier List_element
+  | |-SimpleTemplateNameSpecifier ListElement
   | | |-'X'
   | | |-'<'
   | | |-'T'
   | | `-'>'
-  | `-'::' List_delimiter
+  | `-'::' ListDelimiter
   |-'Y'
   |-'{'
   |-'}'
   `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExplicitTemplateInstantiation_declaration
+`-SimpleDeclaration Declaration
   |-'struct'
   |-'X'
   |-'<'
   |-'double'
   |-'>'
   `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, 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 ExplicitTemplateInstantiation_declaration
+`-SimpleDeclaration Declaration
   |-'struct'
   |-'X'
   |-'<'
   |-'float'
   |-'>'
   `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ClassTemplateSpecialization_Partial) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X {};
 [[template <class T> struct X<T*> {};]]
 )cpp",
       {R"txt(
-TemplateDeclaration TemplateDeclaration_declaration
+TemplateDeclaration Declaration
 |-'template' IntroducerKeyword
 |-'<'
 |-UnknownDeclaration
 | |-'class'
 | `-'T'
 |-'>'
 `-SimpleDeclaration
   |-'struct'
if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <class T> struct X {};
 [[template <> struct X<int> {};]]
 )cpp",
       {R"txt(
-TemplateDeclaration TemplateDeclaration_declaration
+TemplateDeclaration Declaration
 |-'template' IntroducerKeyword
 |-'<'
 |-'>'
 `-SimpleDeclaration
   |-'struct'
   |-'X'
   |-'<'
   |-'int'
EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 static_assert(true, "message");
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-StaticAssertDeclaration
   |-'static_assert'
   |-'('
-  |-BoolLiteralExpression StaticAssertDeclaration_condition
+  |-BoolLiteralExpression Condition
   | `-'true' LiteralToken
   |-','
-  |-StringLiteralExpression StaticAssertDeclaration_message
+  |-StringLiteralExpression Message
   | `-'"message"' LiteralToken
   |-')'
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, StaticAssert_WithoutMessage) {
   if (!GetParam().isCXX17OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 static_assert(true);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-StaticAssertDeclaration
   |-'static_assert'
   |-'('
-  |-BoolLiteralExpression StaticAssertDeclaration_condition
+  |-BoolLiteralExpression Condition
   | `-'true' LiteralToken
   |-')'
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ExternC) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 extern "C" int a;
 extern "C" { int b; int c; }
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-LinkageSpecificationDeclaration
 | |-'extern'
 | |-'"C"'
 | `-SimpleDeclaration
 |   |-'int'
-|   |-SimpleDeclarator SimpleDeclaration_declarator
+|   |-SimpleDeclarator Declarator
 |   | `-'a'
 |   `-';'
 `-LinkageSpecificationDeclaration
   |-'extern'
   |-'"C"'
   |-'{'
   |-SimpleDeclaration
   | |-'int'
-  | |-SimpleDeclarator SimpleDeclaration_declarator
+  | |-SimpleDeclarator Declarator
   | | `-'b'
   | `-';'
   |-SimpleDeclaration
   | |-'int'
-  | |-SimpleDeclarator SimpleDeclaration_declarator
+  | |-SimpleDeclarator Declarator
   | | `-'c'
   | `-';'
   `-'}'
 )txt"));
 }
 
 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 {}
 })cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'test'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
-    |-IfStatement CompoundStatement_statement
+    |-IfStatement Statement
     | |-'if' IntroducerKeyword unmodifiable
     | |-'(' unmodifiable
     | |-BinaryOperatorExpression unmodifiable
-    | | |-IntegerLiteralExpression BinaryOperatorExpression_leftHandSide unmodifiable
+    | | |-IntegerLiteralExpression LeftHandSide unmodifiable
     | | | `-'1' LiteralToken unmodifiable
-    | | |-'+' OperatorExpression_operatorToken unmodifiable
-    | | `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide unmodifiable
+    | | |-'+' OperatorToken unmodifiable
+    | | `-IntegerLiteralExpression RightHandSide unmodifiable
     | |   `-'1' LiteralToken unmodifiable
     | |-')' unmodifiable
-    | |-CompoundStatement IfStatement_thenStatement unmodifiable
+    | |-CompoundStatement ThenStatement unmodifiable
     | | |-'{' OpenParen unmodifiable
     | | `-'}' CloseParen unmodifiable
-    | |-'else' IfStatement_elseKeyword
-    | `-CompoundStatement IfStatement_elseStatement
+    | |-'else' ElseKeyword
+    | `-CompoundStatement ElseStatement
     |   |-'{' OpenParen
     |   `-'}' CloseParen
     `-'}' CloseParen
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ModifiableNodes) {
   // All nodes can be mutated.
OPEN
     2;
   }
 }
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'test'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
-    |-CompoundStatement CompoundStatement_statement
+    |-CompoundStatement Statement
     | |-'{' OpenParen
-    | |-ExpressionStatement CompoundStatement_statement
-    | | |-IntegerLiteralExpression ExpressionStatement_expression
+    | |-ExpressionStatement Statement
+    | | |-IntegerLiteralExpression Expression
     | | | `-'1' LiteralToken
     | | `-';'
     | `-'}' CloseParen
-    |-CompoundStatement CompoundStatement_statement
+    |-CompoundStatement Statement
     | |-'{' OpenParen
-    | |-ExpressionStatement CompoundStatement_statement
-    | | |-IntegerLiteralExpression ExpressionStatement_expression
+    | |-ExpressionStatement Statement
+    | | |-IntegerLiteralExpression Expression
     | | | `-'2' LiteralToken
     | | `-';'
     | `-'}' CloseParen
     `-'}' CloseParen
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ArrayDeclarator_Simple) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a[10];
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'a'
   | `-ArraySubscript
   |   |-'[' OpenParen
-  |   |-IntegerLiteralExpression ArraySubscript_sizeExpression
+  |   |-IntegerLiteralExpression Size
   |   | `-'10' LiteralToken
   |   `-']' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ArrayDeclarator_Multidimensional) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int b[1][2][3];
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'b'
   | |-ArraySubscript
   | | |-'[' OpenParen
-  | | |-IntegerLiteralExpression ArraySubscript_sizeExpression
+  | | |-IntegerLiteralExpression Size
   | | | `-'1' LiteralToken
   | | `-']' CloseParen
   | |-ArraySubscript
   | | |-'[' OpenParen
-  | | |-IntegerLiteralExpression ArraySubscript_sizeExpression
+  | | |-IntegerLiteralExpression Size
   | | | `-'2' LiteralToken
   | | `-']' CloseParen
   | `-ArraySubscript
   |   |-'[' OpenParen
-  |   |-IntegerLiteralExpression ArraySubscript_sizeExpression
+  |   |-IntegerLiteralExpression Size
   |   | `-'3' LiteralToken
   |   `-']' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ArrayDeclarator_UnknownBound) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int c[] = {1,2,3};
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'c'
   | |-ArraySubscript
   | | |-'[' OpenParen
   | | `-']' CloseParen
   | |-'='
   | `-UnknownExpression
   |   `-UnknownExpression
   |     |-'{'
TEST_P(SyntaxTreeTest, ArrayDeclarator_Static) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void f(int xs[static 10]);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'f'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | `-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'int'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     |-'xs'
   |   |     `-ArraySubscript
   |   |       |-'[' OpenParen
   |   |       |-'static'
-  |   |       |-IntegerLiteralExpression ArraySubscript_sizeExpression
+  |   |       |-IntegerLiteralExpression Size
   |   |       | `-'10' LiteralToken
   |   |       `-']' CloseParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Empty) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func();
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'func'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, 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
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'func1'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-| |   | `-SimpleDeclaration List_element
+| |   |-ParameterDeclarationList Parameters
+| |   | `-SimpleDeclaration ListElement
 | |   |   |-'int'
-| |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+| |   |   `-SimpleDeclarator Declarator
 | |   |     `-'a'
 | |   `-')' CloseParen
 | `-';'
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'func2'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-| |   | `-SimpleDeclaration List_element
+| |   |-ParameterDeclarationList Parameters
+| |   | `-SimpleDeclaration ListElement
 | |   |   |-'int'
-| |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+| |   |   `-SimpleDeclarator Declarator
 | |   |     |-'*'
 | |   |     `-'ap'
 | |   `-')' CloseParen
 | `-';'
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'func3'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
   |   | | |-'int'
-  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | | `-SimpleDeclarator Declarator
   |   | |   `-'a'
-  |   | |-',' List_delimiter
-  |   | `-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'float'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     `-'b'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Unnamed) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func1(int);
 int func2(int *);
 int func3(int, float);
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'func1'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-| |   | `-SimpleDeclaration List_element
+| |   |-ParameterDeclarationList Parameters
+| |   | `-SimpleDeclaration ListElement
 | |   |   `-'int'
 | |   `-')' CloseParen
 | `-';'
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'func2'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-| |   | `-SimpleDeclaration List_element
+| |   |-ParameterDeclarationList Parameters
+| |   | `-SimpleDeclaration ListElement
 | |   |   |-'int'
-| |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+| |   |   `-SimpleDeclarator Declarator
 | |   |     `-'*'
 | |   `-')' CloseParen
 | `-';'
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'func3'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
   |   | | `-'int'
-  |   | |-',' List_delimiter
-  |   | `-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
   |   |   `-'float'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest,
        ParametersAndQualifiers_InVariadicFunctionTemplate_ParameterPack) {
   if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T, typename... Args>
 [[void test(T , Args... );]]
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'void'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'test'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
-|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-|   | |-SimpleDeclaration List_element
+|   |-ParameterDeclarationList Parameters
+|   | |-SimpleDeclaration ListElement
 |   | | `-'T'
-|   | |-',' List_delimiter
-|   | `-SimpleDeclaration List_element
+|   | |-',' ListDelimiter
+|   | `-SimpleDeclaration ListElement
 |   |   |-'Args'
 |   |   `-'...'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest,
        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);]]
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'void'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'test'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
-|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-|   | |-SimpleDeclaration List_element
+|   |-ParameterDeclarationList Parameters
+|   | |-SimpleDeclaration ListElement
 |   | | |-'T'
-|   | | `-SimpleDeclarator SimpleDeclaration_declarator
+|   | | `-SimpleDeclarator Declarator
 |   | |   `-'t'
-|   | |-',' List_delimiter
-|   | `-SimpleDeclaration List_element
+|   | |-',' ListDelimiter
+|   | `-SimpleDeclaration ListElement
 |   |   |-'Args'
 |   |   |-'...'
-|   |   `-SimpleDeclarator SimpleDeclaration_declarator
+|   |   `-SimpleDeclarator Declarator
 |   |     `-'args'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest,
        ParametersAndQualifiers_InFreeFunctions_VariadicArguments) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int , char ...);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'test'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
   |   | | `-'int'
-  |   | |-',' List_delimiter
-  |   | `-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
   |   |   `-'char'
   |   |-'...'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest,
        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",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'func'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
   |   | | |-'const'
   |   | | |-'int'
-  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | | `-SimpleDeclarator Declarator
   |   | |   `-'a'
-  |   | |-',' List_delimiter
-  |   | |-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | |-SimpleDeclaration ListElement
   |   | | |-'volatile'
   |   | | |-'int'
-  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | | `-SimpleDeclarator Declarator
   |   | |   `-'b'
-  |   | |-',' List_delimiter
-  |   | `-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'const'
   |   |   |-'volatile'
   |   |   |-'int'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     `-'c'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Cxx_Ref) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func(int& a);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'func'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | `-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'int'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     |-'&'
   |   |     `-'a'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Cxx11_RefRef) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func(int&& a);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'func'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | `-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'int'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     |-'&&'
   |   |     `-'a'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Simple) {
)cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'struct'
   |-'Test'
   |-'{'
   |-SimpleDeclaration
   | |-'int'
-  | |-SimpleDeclarator SimpleDeclaration_declarator
+  | |-SimpleDeclarator Declarator
   | | |-'a'
   | | `-ParametersAndQualifiers
   | |   |-'(' OpenParen
   | |   `-')' CloseParen
   | `-';'
   |-'}'
   `-';'
 )txt"));
struct Test {
   [[int b() const;]]
   [[int c() volatile;]]
   [[int d() const volatile;]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'b'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   `-'const'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'c'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   `-'volatile'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'d'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   |-'const'
 |   `-'volatile'
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Ref) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct Test {
   [[int e() &;]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'e'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   `-'&'
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_RefRef) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct Test {
   [[int f() &&;]]
 };
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'f'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   `-'&&'
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, TrailingReturn) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 auto foo() -> int;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'auto'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'foo'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   |-')' CloseParen
-  |   `-TrailingReturnType ParametersAndQualifiers_trailingReturn
+  |   `-TrailingReturnType TrailingReturn
   |     |-'->' ArrowToken
   |     `-'int'
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, DynamicExceptionSpecification) {
   if (!GetParam().supportsCXXDynamicExceptionSpecification()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct MyException1 {};
 struct MyException2 {};
 [[int a() throw();]]
 [[int b() throw(...);]]
 [[int c() throw(MyException1);]]
 [[int d() throw(MyException1, MyException2);]]
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'a'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   |-'throw'
 |   |-'('
 |   `-')'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'b'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   |-'throw'
 |   |-'('
 |   |-'...'
 |   `-')'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'c'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   |-'throw'
 |   |-'('
 |   |-'MyException1'
 |   `-')'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-'d'
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   |-')' CloseParen
 |   |-'throw'
 |   |-'('
 |   |-'MyException1'
 |   |-','
EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a() noexcept;
 int b() noexcept(true);
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'a'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
 | |   |-')' CloseParen
 | |   `-'noexcept'
 | `-';'
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'b'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   |-')' CloseParen
   |   |-'noexcept'
   |   |-'('
   |   |-BoolLiteralExpression
   |   | `-'true' LiteralToken

 int *(b);
 int (*c)(int);
 int *(d)(int);
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | `-ParenDeclarator
 | |   |-'(' OpenParen
 | |   |-'a'
 | |   `-')' CloseParen
 | `-';'
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'*'
 | | `-ParenDeclarator
 | |   |-'(' OpenParen
 | |   |-'b'
 | |   `-')' CloseParen
 | `-';'
 |-SimpleDeclaration
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-ParenDeclarator
 | | | |-'(' OpenParen
 | | | |-'*'
 | | | |-'c'
 | | | `-')' CloseParen
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-| |   | `-SimpleDeclaration List_element
+| |   |-ParameterDeclarationList Parameters
+| |   | `-SimpleDeclaration ListElement
 | |   |   `-'int'
 | |   `-')' CloseParen
 | `-';'
 `-SimpleDeclaration
   |-'int'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'*'
   | |-ParenDeclarator
   | | |-'(' OpenParen
   | | |-'d'
   | | `-')' CloseParen
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | `-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | `-SimpleDeclaration ListElement
   |   |   `-'int'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, Declaration_ConstVolatileQualifiers_SimpleConst) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 const int west = -1;
 int const east = 1;
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'const'
 | |-'int'
-| |-SimpleDeclarator SimpleDeclaration_declarator
+| |-SimpleDeclarator Declarator
 | | |-'west'
 | | |-'='
 | | `-PrefixUnaryOperatorExpression
-| |   |-'-' OperatorExpression_operatorToken
-| |   `-IntegerLiteralExpression UnaryOperatorExpression_operand
+| |   |-'-' OperatorToken
+| |   `-IntegerLiteralExpression Operand
 | |     `-'1' LiteralToken
 | `-';'
 `-SimpleDeclaration
   |-'int'
   |-'const'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'east'
   | |-'='
   | `-IntegerLiteralExpression
   |   `-'1' LiteralToken
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, Declaration_ConstVolatileQualifiers_MultipleConst) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 const int const universal = 0;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'const'
   |-'int'
   |-'const'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'universal'
   | |-'='
   | `-IntegerLiteralExpression
   |   `-'0' LiteralToken
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, Declaration_ConstVolatileQualifiers_ConstAndVolatile) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 const int const *const *volatile b;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'const'
   |-'int'
   |-'const'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'*'
   | |-'const'
   | |-'*'
   | |-'volatile'
   | `-'b'
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 auto foo() -> auto(*)(int) -> double*;
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'auto'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'foo'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   |-')' CloseParen
-  |   `-TrailingReturnType ParametersAndQualifiers_trailingReturn
+  |   `-TrailingReturnType TrailingReturn
   |     |-'->' ArrowToken
   |     |-'auto'
-  |     `-SimpleDeclarator TrailingReturnType_declarator
+  |     `-SimpleDeclarator Declarator
   |       |-ParenDeclarator
   |       | |-'(' OpenParen
   |       | |-'*'
   |       | `-')' CloseParen
   |       `-ParametersAndQualifiers
   |         |-'(' OpenParen
-  |         |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |         | `-SimpleDeclaration List_element
+  |         |-ParameterDeclarationList Parameters
+  |         | `-SimpleDeclaration ListElement
   |         |   `-'int'
   |         |-')' CloseParen
-  |         `-TrailingReturnType ParametersAndQualifiers_trailingReturn
+  |         `-TrailingReturnType TrailingReturn
   |           |-'->' ArrowToken
   |           |-'double'
-  |           `-SimpleDeclarator TrailingReturnType_declarator
+  |           `-SimpleDeclarator Declarator
   |             `-'*'
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, MemberPointers) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {};
 [[int X::* a;]]
 [[const int X::* b;]]
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-MemberPointer
 | | |-'X'
 | | |-'::'
 | | `-'*'
 | `-'a'
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'const'
 |-'int'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-MemberPointer
 | | |-'X'
 | | |-'::'
 | | `-'*'
 | `-'b'
 `-';'
 )txt"}));
 }

 [[void (X::**xpp)(const int*);]]
 // FIXME: Generate the right syntax tree for this type,
 // i.e. create a syntax node for the outer member pointer
 [[void (X::Y::*xyp)(const int*, char);]]
 )cpp",
       {R"txt(
 SimpleDeclaration
 |-'void'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-ParenDeclarator
 | | |-'(' OpenParen
 | | |-MemberPointer
 | | | |-'X'
 | | | |-'::'
 | | | `-'*'
 | | |-'xp'
 | | `-')' CloseParen
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
 |   `-')' CloseParen
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'void'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-ParenDeclarator
 | | |-'(' OpenParen
 | | |-MemberPointer
 | | | |-'X'
 | | | |-'::'
 | | | `-'*'
 | | |-'*'
 | | |-'xpp'
 | | `-')' CloseParen
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
-|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-|   | `-SimpleDeclaration List_element
+|   |-ParameterDeclarationList Parameters
+|   | `-SimpleDeclaration ListElement
 |   |   |-'const'
 |   |   |-'int'
-|   |   `-SimpleDeclarator SimpleDeclaration_declarator
+|   |   `-SimpleDeclarator Declarator
 |   |     `-'*'
 |   `-')' CloseParen
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'void'
-|-SimpleDeclarator SimpleDeclaration_declarator
+|-SimpleDeclarator Declarator
 | |-ParenDeclarator
 | | |-'(' OpenParen
 | | |-'X'
 | | |-'::'
 | | |-MemberPointer
 | | | |-'Y'
 | | | |-'::'
 | | | `-'*'
 | | |-'xyp'
 | | `-')' CloseParen
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
-|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-|   | |-SimpleDeclaration List_element
+|   |-ParameterDeclarationList Parameters
+|   | |-SimpleDeclaration ListElement
 |   | | |-'const'
 |   | | |-'int'
-|   | | `-SimpleDeclarator SimpleDeclaration_declarator
+|   | | `-SimpleDeclarator Declarator
 |   | |   `-'*'
-|   | |-',' List_delimiter
-|   | `-SimpleDeclaration List_element
+|   | |-',' ListDelimiter
+|   | `-SimpleDeclaration ListElement
 |   |   `-'char'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ComplexDeclarator) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int));
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'x'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
   |   | | |-'char'
-  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | | `-SimpleDeclarator Declarator
   |   | |   `-'a'
-  |   | |-',' List_delimiter
-  |   | `-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'short'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     |-ParenDeclarator
   |   |     | |-'(' OpenParen
   |   |     | |-'*'
   |   |     | |-'b'
   |   |     | `-')' CloseParen
   |   |     `-ParametersAndQualifiers
   |   |       |-'(' OpenParen
-  |   |       |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   |       | `-SimpleDeclaration List_element
+  |   |       |-ParameterDeclarationList Parameters
+  |   |       | `-SimpleDeclaration ListElement
   |   |       |   `-'int'
   |   |       `-')' CloseParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ComplexDeclarator2) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int), long (**c)(long long));
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
-  |-SimpleDeclarator SimpleDeclaration_declarator
+  |-SimpleDeclarator Declarator
   | |-'x'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |-SimpleDeclaration List_element
+  |   |-ParameterDeclarationList Parameters
+  |   | |-SimpleDeclaration ListElement
   |   | | |-'char'
-  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | | `-SimpleDeclarator Declarator
   |   | |   `-'a'
-  |   | |-',' List_delimiter
-  |   | |-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | |-SimpleDeclaration ListElement
   |   | | |-'short'
-  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | | `-SimpleDeclarator Declarator
   |   | |   |-ParenDeclarator
   |   | |   | |-'(' OpenParen
   |   | |   | |-'*'
   |   | |   | |-'b'
   |   | |   | `-')' CloseParen
   |   | |   `-ParametersAndQualifiers
   |   | |     |-'(' OpenParen
-  |   | |     |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   | |     | `-SimpleDeclaration List_element
+  |   | |     |-ParameterDeclarationList Parameters
+  |   | |     | `-SimpleDeclaration ListElement
   |   | |     |   `-'int'
   |   | |     `-')' CloseParen
-  |   | |-',' List_delimiter
-  |   | `-SimpleDeclaration List_element
+  |   | |-',' ListDelimiter
+  |   | `-SimpleDeclaration ListElement
   |   |   |-'long'
-  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |   `-SimpleDeclarator Declarator
   |   |     |-ParenDeclarator
   |   |     | |-'(' OpenParen
   |   |     | |-'*'
   |   |     | |-'*'
   |   |     | |-'c'
   |   |     | `-')' CloseParen
   |   |     `-ParametersAndQualifiers
   |   |       |-'(' OpenParen
-  |   |       |-ParameterDeclarationList ParametersAndQualifiers_parameters
-  |   |       | `-SimpleDeclaration List_element
+  |   |       |-ParameterDeclarationList Parameters
+  |   |       | `-SimpleDeclaration ListElement
   |   |       |   |-'long'
   |   |       |   `-'long'
   |   |       `-')' CloseParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 } // namespace