[SyntaxTree][NFC] Append "get" to syntax Nodes accessor names

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

Author: Eduardo Caldas

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

@@ -271,9 +271,9 @@ class NestedNameSpecifier final : public List {
   static bool classof(const Node *N) {
     return N->kind() <= NodeKind::NestedNameSpecifier;
   }
-  std::vector<NameSpecifier *> specifiers();
+  std::vector<NameSpecifier *> getSpecifiers();
   std::vector<List::ElementAndDelimiter<syntax::NameSpecifier>>
-  specifiersAndDoubleColons();
+  getSpecifiersAndDoubleColons();
 };
 
 /// Models an `unqualified-id`. C++ [expr.prim.id.unqual]
@@ -299,9 +299,9 @@ class IdExpression final : public Expression {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::IdExpression;
   }
-  NestedNameSpecifier *qualifier();
-  Leaf *templateKeyword();
-  UnqualifiedId *unqualifiedId();
+  NestedNameSpecifier *getQualifier();
+  Leaf *getTemplateKeyword();
+  UnqualifiedId *getUnqualifiedId();
 };
 
 /// An expression of an unknown kind, i.e. one not currently handled by the
@@ -321,7 +321,7 @@ class ThisExpression final : public Expression {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ThisExpression;
   }
-  Leaf *thisKeyword();
+  Leaf *getThisKeyword();
 };
 
 /// Models arguments of a function call.
@@ -335,8 +335,8 @@ class CallArguments final : public List {
   static bool classof(const Node *N) {
     return N->kind() <= NodeKind::CallArguments;
   }
-  std::vector<Expression *> arguments();
-  std::vector<List::ElementAndDelimiter<Expression>> argumentsAndCommas();
+  std::vector<Expression *> getArguments();
+  std::vector<List::ElementAndDelimiter<Expression>> getArgumentsAndCommas();
 };
 
 /// A function call. C++ [expr.call]
@@ -349,10 +349,10 @@ class CallExpression final : public Expression {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::CallExpression;
   }
-  Expression *callee();
-  Leaf *openParen();
-  CallArguments *arguments();
-  Leaf *closeParen();
+  Expression *getCallee();
+  Leaf *getOpenParen();
+  CallArguments *getArguments();
+  Leaf *getCloseParen();
 };
 
 /// Models a parenthesized expression `(E)`. C++ [expr.prim.paren]
@@ -363,9 +363,9 @@ class ParenExpression final : public Expression {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ParenExpression;
   }
-  Leaf *openParen();
-  Expression *subExpression();
-  Leaf *closeParen();
+  Leaf *getOpenParen();
+  Expression *getSubExpression();
+  Leaf *getCloseParen();
 };
 
 /// Models a class member access. C++ [expr.ref]
@@ -382,10 +382,10 @@ class MemberExpression final : public Expression {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::MemberExpression;
   }
-  Expression *object();
-  Leaf *accessToken();
-  Leaf *templateKeyword();
-  IdExpression *member();
+  Expression *getObject();
+  Leaf *getAccessToken();
+  Leaf *getTemplateKeyword();
+  IdExpression *getMember();
 };
 
 /// Expression for literals. C++ [lex.literal]
@@ -404,7 +404,7 @@ class LiteralExpression : public Expression {
            N->kind() == NodeKind::CharUserDefinedLiteralExpression ||
            N->kind() == NodeKind::StringUserDefinedLiteralExpression;
   }
-  Leaf *literalToken();
+  Leaf *getLiteralToken();
 };
 
 /// Expression for integer literals. C++ [lex.icon]
@@ -539,8 +539,8 @@ class UnaryOperatorExpression : public Expression {
     return N->kind() == NodeKind::PrefixUnaryOperatorExpression ||
            N->kind() == NodeKind::PostfixUnaryOperatorExpression;
   }
-  Leaf *operatorToken();
-  Expression *operand();
+  Leaf *getOperatorToken();
+  Expression *getOperand();
 };
 
 /// <operator> <operand>
@@ -588,9 +588,9 @@ class BinaryOperatorExpression final : public Expression {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::BinaryOperatorExpression;
   }
-  Expression *lhs();
-  Leaf *operatorToken();
-  Expression *rhs();
+  Expression *getLhs();
+  Leaf *getOperatorToken();
+  Expression *getRhs();
 };
 
 /// An abstract node for C++ statements, e.g. 'while', 'if', etc.
@@ -639,8 +639,8 @@ class SwitchStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::SwitchStatement;
   }
-  Leaf *switchKeyword();
-  Statement *body();
+  Leaf *getSwitchKeyword();
+  Statement *getBody();
 };
 
 /// case <value>: <body>
@@ -650,9 +650,9 @@ class CaseStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::CaseStatement;
   }
-  Leaf *caseKeyword();
-  Expression *caseValue();
-  Statement *body();
+  Leaf *getCaseKeyword();
+  Expression *getCaseValue();
+  Statement *getBody();
 };
 
 /// default: <body>
@@ -662,8 +662,8 @@ class DefaultStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::DefaultStatement;
   }
-  Leaf *defaultKeyword();
-  Statement *body();
+  Leaf *getDefaultKeyword();
+  Statement *getBody();
 };
 
 /// if (cond) <then-statement> else <else-statement>
@@ -674,10 +674,10 @@ class IfStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::IfStatement;
   }
-  Leaf *ifKeyword();
-  Statement *thenStatement();
-  Leaf *elseKeyword();
-  Statement *elseStatement();
+  Leaf *getIfKeyword();
+  Statement *getThenStatement();
+  Leaf *getElseKeyword();
+  Statement *getElseStatement();
 };
 
 /// for (<init>; <cond>; <increment>) <body>
@@ -687,8 +687,8 @@ class ForStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ForStatement;
   }
-  Leaf *forKeyword();
-  Statement *body();
+  Leaf *getForKeyword();
+  Statement *getBody();
 };
 
 /// while (<cond>) <body>
@@ -698,8 +698,8 @@ class WhileStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::WhileStatement;
   }
-  Leaf *whileKeyword();
-  Statement *body();
+  Leaf *getWhileKeyword();
+  Statement *getBody();
 };
 
 /// continue;
@@ -709,7 +709,7 @@ class ContinueStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ContinueStatement;
   }
-  Leaf *continueKeyword();
+  Leaf *getContinueKeyword();
 };
 
 /// break;
@@ -719,7 +719,7 @@ class BreakStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::BreakStatement;
   }
-  Leaf *breakKeyword();
+  Leaf *getBreakKeyword();
 };
 
 /// return <expr>;
@@ -730,8 +730,8 @@ class ReturnStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ReturnStatement;
   }
-  Leaf *returnKeyword();
-  Expression *returnValue();
+  Leaf *getReturnKeyword();
+  Expression *getReturnValue();
 };
 
 /// for (<decl> : <init>) <body>
@@ -741,8 +741,8 @@ class RangeBasedForStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::RangeBasedForStatement;
   }
-  Leaf *forKeyword();
-  Statement *body();
+  Leaf *getForKeyword();
+  Statement *getBody();
 };
 
 /// Expression in a statement position, e.g. functions calls inside compound
@@ -753,7 +753,7 @@ class ExpressionStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ExpressionStatement;
   }
-  Expression *expression();
+  Expression *getExpression();
 };
 
 /// { statement1; statement2; … }
@@ -763,10 +763,10 @@ class CompoundStatement final : public Statement {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::CompoundStatement;
   }
-  Leaf *lbrace();
+  Leaf *getLbrace();
   /// FIXME: use custom iterator instead of 'vector'.
-  std::vector<Statement *> statements();
-  Leaf *rbrace();
+  std::vector<Statement *> getStatements();
+  Leaf *getRbrace();
 };
 
 /// A declaration that can appear at the top-level. Note that this does *not*
@@ -808,8 +808,8 @@ class StaticAssertDeclaration final : public Declaration {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::StaticAssertDeclaration;
   }
-  Expression *condition();
-  Expression *message();
+  Expression *getCondition();
+  Expression *getMessage();
 };
 
 /// extern <string-literal> declaration
@@ -833,7 +833,7 @@ class SimpleDeclaration final : public Declaration {
     return N->kind() == NodeKind::SimpleDeclaration;
   }
   /// FIXME: use custom iterator instead of 'vector'.
-  std::vector<SimpleDeclarator *> declarators();
+  std::vector<SimpleDeclarator *> getDeclarators();
 };
 
 /// template <template-parameters> <declaration>
@@ -843,8 +843,8 @@ class TemplateDeclaration final : public Declaration {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::TemplateDeclaration;
   }
-  Leaf *templateKeyword();
-  Declaration *declaration();
+  Leaf *getTemplateKeyword();
+  Declaration *getDeclaration();
 };
 
 /// template <declaration>
@@ -859,9 +859,9 @@ class ExplicitTemplateInstantiation final : public Declaration {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ExplicitTemplateInstantiation;
   }
-  Leaf *templateKeyword();
-  Leaf *externKeyword();
-  Declaration *declaration();
+  Leaf *getTemplateKeyword();
+  Leaf *getExternKeyword();
+  Declaration *getDeclaration();
 };
 
 /// namespace <name> { <decls> }
@@ -951,8 +951,8 @@ class ParenDeclarator final : public Declarator {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ParenDeclarator;
   }
-  Leaf *lparen();
-  Leaf *rparen();
+  Leaf *getLparen();
+  Leaf *getRparen();
 };
 
 /// Array size specified inside a declarator.
@@ -966,9 +966,9 @@ class ArraySubscript final : public Tree {
     return N->kind() == NodeKind::ArraySubscript;
   }
   // TODO: add an accessor for the "static" keyword.
-  Leaf *lbracket();
-  Expression *size();
-  Leaf *rbracket();
+  Leaf *getLbracket();
+  Expression *getSize();
+  Leaf *getRbracket();
 };
 
 /// Trailing return type after the parameter list, including the arrow token.
@@ -980,10 +980,10 @@ class TrailingReturnType final : public Tree {
     return N->kind() == NodeKind::TrailingReturnType;
   }
   // TODO: add accessors for specifiers.
-  Leaf *arrowToken();
+  Leaf *getArrowToken();
   // FIXME: This should be a `type-id` following the grammar. Fix this once we
   // have a representation of `type-id`s.
-  SimpleDeclarator *declarator();
+  SimpleDeclarator *getDeclarator();
 };
 
 /// Models a `parameter-declaration-list` which appears within
@@ -994,9 +994,9 @@ class ParameterDeclarationList final : public List {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ParameterDeclarationList;
   }
-  std::vector<SimpleDeclaration *> parameterDeclarations();
+  std::vector<SimpleDeclaration *> getParameterDeclarations();
   std::vector<List::ElementAndDelimiter<syntax::SimpleDeclaration>>
-  parametersAndCommas();
+  getParametersAndCommas();
 };
 
 /// Parameter list for a function type and a trailing return type, if the
@@ -1016,10 +1016,10 @@ class ParametersAndQualifiers final : public Tree {
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ParametersAndQualifiers;
   }
-  Leaf *lparen();
-  ParameterDeclarationList *parameters();
-  Leaf *rparen();
-  TrailingReturnType *trailingReturn();
+  Leaf *getLparen();
+  ParameterDeclarationList *getParameters();
+  Leaf *getRparen();
+  TrailingReturnType *getTrailingReturn();
 };
 
 /// Member pointer inside a declarator