[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

1 files changed, 47 insertions, 78 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);