[SyntaxTree] Refactor `NodeRole`s

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

Differential Revision: https://reviews.llvm.org/D86636

3 files changed, 139 insertions, 182 deletions

diff --git a/clang/lib/Tooling/Syntax/BuildTree.cpp b/clang/lib/Tooling/Syntax/BuildTree.cpp
index deae46d..9e2f817 100644
--- a/clang/lib/Tooling/Syntax/BuildTree.cpp
+++ b/clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -662,7 +662,7 @@ public:
 
     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),
@@ -873,8 +873,8 @@ public:
       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,
@@ -887,7 +887,7 @@ public:
                                           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);
@@ -896,7 +896,7 @@ public:
     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();
@@ -923,13 +923,10 @@ public:
         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);
@@ -963,8 +960,7 @@ public:
 
   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);
@@ -1015,9 +1011,8 @@ public:
 
   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),
@@ -1032,12 +1027,10 @@ public:
   }
 
   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;
@@ -1045,12 +1038,11 @@ public:
 
   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;
@@ -1063,8 +1055,7 @@ public:
   }
 
   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()));
@@ -1074,7 +1065,7 @@ public:
       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);
 
@@ -1109,41 +1100,31 @@ public:
   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()));
@@ -1154,7 +1135,7 @@ public:
 
       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);
 
@@ -1201,8 +1182,7 @@ public:
   // 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);
@@ -1212,11 +1192,10 @@ public:
   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())
@@ -1230,7 +1209,7 @@ public:
     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()),
@@ -1244,8 +1223,7 @@ public:
 
     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);
   }
 
@@ -1293,7 +1271,7 @@ public:
   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);
@@ -1311,12 +1289,9 @@ public:
 
   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;
@@ -1358,8 +1333,7 @@ public:
   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;
@@ -1380,10 +1354,8 @@ public:
   }
 
   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;
@@ -1476,7 +1448,7 @@ private:
     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)) {
@@ -1510,8 +1482,7 @@ private:
     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;
@@ -1525,9 +1496,7 @@ private:
     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);
   }
@@ -1540,7 +1509,7 @@ private:
 
     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;
   }
 
@@ -1592,7 +1561,7 @@ void syntax::TreeBuilder::markStmtChild(Stmt *Child, NodeRole Role) {
   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);
diff --git a/clang/lib/Tooling/Syntax/Nodes.cpp b/clang/lib/Tooling/Syntax/Nodes.cpp
index 984cc5d..2e7668c 100644
--- a/clang/lib/Tooling/Syntax/Nodes.cpp
+++ b/clang/lib/Tooling/Syntax/Nodes.cpp
@@ -162,66 +162,62 @@ raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
     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");
 }
@@ -295,8 +291,7 @@ syntax::ParameterDeclarationList::parametersAndCommas() {
 }
 
 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() {
@@ -306,17 +301,17 @@ syntax::Leaf *syntax::MemberExpression::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() {
@@ -326,7 +321,7 @@ syntax::Leaf *syntax::IdExpression::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() {
@@ -335,7 +330,7 @@ syntax::Leaf *syntax::ParenExpression::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() {
@@ -353,32 +348,28 @@ syntax::Leaf *syntax::LiteralExpression::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() {
@@ -387,7 +378,7 @@ syntax::Leaf *syntax::CallExpression::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() {
@@ -409,9 +400,9 @@ syntax::Leaf *syntax::CaseStatement::caseKeyword() {
       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() {
@@ -436,17 +427,16 @@ syntax::Leaf *syntax::IfStatement::ifKeyword() {
 
 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() {
@@ -484,9 +474,9 @@ syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
       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() {
@@ -501,7 +491,7 @@ syntax::Statement *syntax::RangeBasedForStatement::body() {
 
 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() {
@@ -511,7 +501,7 @@ syntax::Leaf *syntax::CompoundStatement::lbrace() {
 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;
@@ -523,19 +513,18 @@ syntax::Leaf *syntax::CompoundStatement::rbrace() {
 
 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;
@@ -548,7 +537,7 @@ syntax::Leaf *syntax::TemplateDeclaration::templateKeyword() {
 
 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() {
@@ -562,7 +551,7 @@ syntax::Leaf *syntax::ExplicitTemplateInstantiation::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() {
@@ -577,9 +566,8 @@ 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() {
@@ -592,7 +580,7 @@ syntax::Leaf *syntax::TrailingReturnType::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() {
@@ -602,7 +590,7 @@ syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
 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() {
@@ -611,5 +599,5 @@ syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
 
 syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
   return cast_or_null<syntax::TrailingReturnType>(
-      findChild(syntax::NodeRole::ParametersAndQualifiers_trailingReturn));
+      findChild(syntax::NodeRole::TrailingReturn));
 }
diff --git a/clang/lib/Tooling/Syntax/Tree.cpp b/clang/lib/Tooling/Syntax/Tree.cpp
index 777c24e..2cef806 100644
--- a/clang/lib/Tooling/Syntax/Tree.cpp
+++ b/clang/lib/Tooling/Syntax/Tree.cpp
@@ -276,14 +276,14 @@ syntax::List::getElementsAsNodesAndDelimiters() {
   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;
@@ -321,14 +321,14 @@ std::vector<syntax::Node *> syntax::List::getElementsAsNodes() {
   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;