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

[eduucaldas]

It's worth noting that accessors in the base APIs don't follow this rule. Should we refactor them as well? In this patch?
Examples:

class Arena {
public:
  const SourceManager &sourceManager() const { return SourceMgr; }
  const LangOptions &langOptions() const { return LangOpts; }
  const TokenBuffer &tokenBuffer() const;
  std::pair<FileID, ArrayRef<Token>>
  lexBuffer(std::unique_ptr<llvm::MemoryBuffer> Buffer);

class Node {
public:
  NodeKind kind() const { return static_cast<NodeKind>(Kind); }
  NodeRole role() const { return static_cast<NodeRole>(Role); }
  Tree *parent() { return Parent; }
  Node *nextSibling() { return NextSibling; }

class Leaf final : public Node {
public:
  const Token *token() const { return Tok; }
};

class Tree : public Node {
public:
  Node *firstChild() { return FirstChild; }
  Leaf *firstLeaf();
  Leaf *lastLeaf();

[gribozavr2]

It's worth noting that accessors in the base APIs don't follow this rule. Should we refactor them as well?

I'd say yes.

In this patch?

Up to you.

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

 /// Models a `nested-name-specifier`. C++ [expr.prim.id.qual]
 /// e.g. the `std::vector<int>::` in `std::vector<int>::size`.
 class NestedNameSpecifier final : public List {
 public:
   NestedNameSpecifier() : List(NodeKind::NestedNameSpecifier) {}
   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]
 /// e.g. the `size` in `std::vector<int>::size`.
 class UnqualifiedId final : public Tree {
 public:
   UnqualifiedId() : Tree(NodeKind::UnqualifiedId) {}
   static bool classof(const Node *N) {

 /// qualified-id:
 ///   nested-name-specifier template_opt unqualified-id
 class IdExpression final : public Expression {
 public:
   IdExpression() : Expression(NodeKind::IdExpression) {}
   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
 /// syntax tree.
 class UnknownExpression final : public Expression {
 public:
   UnknownExpression() : Expression(NodeKind::UnknownExpression) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::UnknownExpression;
   }
 };
 
 /// Models a this expression `this`. C++ [expr.prim.this]
 class ThisExpression final : public Expression {
 public:
   ThisExpression() : Expression(NodeKind::ThisExpression) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ThisExpression;
   }
-  Leaf *thisKeyword();
+  Leaf *getThisKeyword();
 };
 
 /// Models arguments of a function call.
 ///   call-arguments:
 ///     delimited_list(expression, ',')
 /// Note: This construct is a simplification of the grammar rule for
 /// `expression-list`, that is used in the definition of `call-expression`
 class CallArguments final : public List {
 public:
   CallArguments() : List(NodeKind::CallArguments) {}
   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]
 /// call-expression:
 ///   expression '(' call-arguments ')'
 /// e.g `f(1, '2')` or `this->Base::f()`
 class CallExpression final : public Expression {
 public:
   CallExpression() : Expression(NodeKind::CallExpression) {}
   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]
 /// e.g. `(3 + 2)` in `a = 1 + (3 + 2);`
 class ParenExpression final : public Expression {
 public:
   ParenExpression() : Expression(NodeKind::ParenExpression) {}
   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]
 /// member-expression:
 ///   expression -> template_opt id-expression
 ///   expression .  template_opt id-expression
 /// e.g. `x.a`, `xp->a`
 ///
 /// Note: An implicit member access inside a class, i.e. `a` instead of
 /// `this->a`, is an `id-expression`.
 class MemberExpression final : public Expression {
 public:
   MemberExpression() : Expression(NodeKind::MemberExpression) {}
   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]
 class LiteralExpression : public Expression {
 public:
   LiteralExpression(NodeKind K) : Expression(K) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::IntegerLiteralExpression ||
            N->kind() == NodeKind::CharacterLiteralExpression ||
            N->kind() == NodeKind::FloatingLiteralExpression ||
            N->kind() == NodeKind::StringLiteralExpression ||
            N->kind() == NodeKind::BoolLiteralExpression ||
            N->kind() == NodeKind::CxxNullPtrExpression ||
            N->kind() == NodeKind::IntegerUserDefinedLiteralExpression ||
            N->kind() == NodeKind::FloatUserDefinedLiteralExpression ||
            N->kind() == NodeKind::CharUserDefinedLiteralExpression ||
            N->kind() == NodeKind::StringUserDefinedLiteralExpression;
   }
-  Leaf *literalToken();
+  Leaf *getLiteralToken();
 };
 
 /// Expression for integer literals. C++ [lex.icon]
 class IntegerLiteralExpression final : public LiteralExpression {
 public:
   IntegerLiteralExpression()
       : LiteralExpression(NodeKind::IntegerLiteralExpression) {}
   static bool classof(const Node *N) {

 /// An abstract class for prefix and postfix unary operators.
 class UnaryOperatorExpression : public Expression {
 public:
   UnaryOperatorExpression(NodeKind K) : Expression(K) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::PrefixUnaryOperatorExpression ||
            N->kind() == NodeKind::PostfixUnaryOperatorExpression;
   }
-  Leaf *operatorToken();
-  Expression *operand();
+  Leaf *getOperatorToken();
+  Expression *getOperand();
 };
 
 /// <operator> <operand>
 ///
 /// For example:
 ///   +a          -b
 ///   !c          not c
 ///   ~d          compl d

 ///   a |= b
 ///   a and_eq b
 class BinaryOperatorExpression final : public Expression {
 public:
   BinaryOperatorExpression() : Expression(NodeKind::BinaryOperatorExpression) {}
   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.
 /// FIXME: add accessors for semicolon of statements that have it.
 class Statement : public Tree {
 public:
   Statement(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N) {

 
 /// switch (<cond>) <body>
 class SwitchStatement final : public Statement {
 public:
   SwitchStatement() : Statement(NodeKind::SwitchStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::SwitchStatement;
   }
-  Leaf *switchKeyword();
-  Statement *body();
+  Leaf *getSwitchKeyword();
+  Statement *getBody();
 };
 
 /// 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 *caseValue();
-  Statement *body();
+  Leaf *getCaseKeyword();
+  Expression *getCaseValue();
+  Statement *getBody();
 };
 
 /// default: <body>
 class DefaultStatement final : public Statement {
 public:
   DefaultStatement() : Statement(NodeKind::DefaultStatement) {}
   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>
 /// FIXME: add condition that models 'expression  or variable declaration'
 class IfStatement final : public Statement {
 public:
   IfStatement() : Statement(NodeKind::IfStatement) {}
   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>
 class ForStatement final : public Statement {
 public:
   ForStatement() : Statement(NodeKind::ForStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ForStatement;
   }
-  Leaf *forKeyword();
-  Statement *body();
+  Leaf *getForKeyword();
+  Statement *getBody();
 };
 
 /// while (<cond>) <body>
 class WhileStatement final : public Statement {
 public:
   WhileStatement() : Statement(NodeKind::WhileStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::WhileStatement;
   }
-  Leaf *whileKeyword();
-  Statement *body();
+  Leaf *getWhileKeyword();
+  Statement *getBody();
 };
 
 /// continue;
 class ContinueStatement final : public Statement {
 public:
   ContinueStatement() : Statement(NodeKind::ContinueStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ContinueStatement;
   }
-  Leaf *continueKeyword();
+  Leaf *getContinueKeyword();
 };
 
 /// break;
 class BreakStatement final : public Statement {
 public:
   BreakStatement() : Statement(NodeKind::BreakStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::BreakStatement;
   }
-  Leaf *breakKeyword();
+  Leaf *getBreakKeyword();
 };
 
 /// return <expr>;
 /// 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 *returnValue();
+  Leaf *getReturnKeyword();
+  Expression *getReturnValue();
 };
 
 /// 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;
   }
-  Leaf *forKeyword();
-  Statement *body();
+  Leaf *getForKeyword();
+  Statement *getBody();
 };
 
 /// Expression in a statement position, e.g. functions calls inside compound
 /// statements or inside a loop body.
 class ExpressionStatement final : public Statement {
 public:
   ExpressionStatement() : Statement(NodeKind::ExpressionStatement) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ExpressionStatement;
   }
-  Expression *expression();
+  Expression *getExpression();
 };
 
 /// { statement1; statement2; … }
 class CompoundStatement final : public Statement {
 public:
   CompoundStatement() : Statement(NodeKind::CompoundStatement) {}
   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*
 /// correspond 1-to-1 to clang::Decl. Syntax trees distinguish between top-level
 /// declarations (e.g. namespace definitions) and declarators (e.g. variables,
 /// typedefs, etc.). Declarators are stored inside SimpleDeclaration.
 class Declaration : public Tree {
 public:

 /// static_assert(<condition>, <message>)
 /// static_assert(<condition>)
 class StaticAssertDeclaration final : public Declaration {
 public:
   StaticAssertDeclaration() : Declaration(NodeKind::StaticAssertDeclaration) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::StaticAssertDeclaration;
   }
-  Expression *condition();
-  Expression *message();
+  Expression *getCondition();
+  Expression *getMessage();
 };
 
 /// extern <string-literal> declaration
 /// extern <string-literal> { <decls>  }
 class LinkageSpecificationDeclaration final : public Declaration {
 public:
   LinkageSpecificationDeclaration()
       : Declaration(NodeKind::LinkageSpecificationDeclaration) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::LinkageSpecificationDeclaration;
   }
 };
 
 /// Groups multiple declarators (e.g. variables, typedefs, etc.) together. All
 /// grouped declarators share the same declaration specifiers (e.g. 'int' or
 /// 'typedef').
 class SimpleDeclaration final : public Declaration {
 public:
   SimpleDeclaration() : Declaration(NodeKind::SimpleDeclaration) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::SimpleDeclaration;
   }
   /// FIXME: use custom iterator instead of 'vector'.
-  std::vector<SimpleDeclarator *> declarators();
+  std::vector<SimpleDeclarator *> getDeclarators();
 };
 
 /// template <template-parameters> <declaration>
 class TemplateDeclaration final : public Declaration {
 public:
   TemplateDeclaration() : Declaration(NodeKind::TemplateDeclaration) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::TemplateDeclaration;
   }
-  Leaf *templateKeyword();
-  Declaration *declaration();
+  Leaf *getTemplateKeyword();
+  Declaration *getDeclaration();
 };
 
 /// template <declaration>
 /// Examples:
 ///     template struct X<int>
 ///     template void foo<int>()
 ///     template int var<double>
 class ExplicitTemplateInstantiation final : public Declaration {
 public:
   ExplicitTemplateInstantiation()
       : Declaration(NodeKind::ExplicitTemplateInstantiation) {}
   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> }
 class NamespaceDefinition final : public Declaration {
 public:
   NamespaceDefinition() : Declaration(NodeKind::NamespaceDefinition) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::NamespaceDefinition;

 /// E.g. `(***a)` from `int (***a) = nullptr;`
 /// See comment of Declarator for more details.
 class ParenDeclarator final : public Declarator {
 public:
   ParenDeclarator() : Declarator(NodeKind::ParenDeclarator) {}
   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.
 /// E.g:
 ///   `[10]` in `int a[10];`
 ///   `[static 10]` in `void f(int xs[static 10]);`
 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 *size();
-  Leaf *rbracket();
+  Leaf *getLbracket();
+  Expression *getSize();
+  Leaf *getRbracket();
 };
 
 /// 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();
+  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
 /// `parameters-and-qualifiers`. See C++ [dcl.fct]
 class ParameterDeclarationList final : public List {
 public:
   ParameterDeclarationList() : List(NodeKind::ParameterDeclarationList) {}
   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
 /// function has one.
 /// E.g.:
 ///  `(int a) volatile ` in `int foo(int a) volatile;`
 ///  `(int a) &&` in `int foo(int a) &&;`
 ///  `() -> int` in `auto foo() -> int;`
 ///  `() const` in `int foo() const;`
 ///  `() noexcept` in `int foo() noexcept;`
 ///  `() throw()` in `int foo() throw();`
 ///
 /// (!) override doesn't belong here.
 class ParametersAndQualifiers final : public Tree {
 public:
   ParametersAndQualifiers() : Tree(NodeKind::ParametersAndQualifiers) {}
   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
 /// E.g. `X::*` in `int X::* a = 0;`
 class MemberPointer final : public Tree {
 public:
   MemberPointer() : Tree(NodeKind::MemberPointer) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::MemberPointer;
   }
 };
 
 } // namespace syntax
 } // namespace clang
 #endif

clang/lib/Tooling/Syntax/Nodes.cpp

raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
   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() {
+std::vector<syntax::NameSpecifier *>
+syntax::NestedNameSpecifier::getSpecifiers() {
   auto specifiersAsNodes = getElementsAsNodes();
   std::vector<syntax::NameSpecifier *> Children;
   for (const auto &element : specifiersAsNodes) {
     Children.push_back(llvm::cast<syntax::NameSpecifier>(element));
   }
   return Children;
 }
 
 std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
-syntax::NestedNameSpecifier::specifiersAndDoubleColons() {
+syntax::NestedNameSpecifier::getSpecifiersAndDoubleColons() {
   auto specifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
   std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
       Children;
   for (const auto &specifierAndDoubleColon : specifiersAsNodesAndDoubleColons) {
     Children.push_back(
         {llvm::cast<syntax::NameSpecifier>(specifierAndDoubleColon.element),
          specifierAndDoubleColon.delimiter});
   }
   return Children;
 }
 
-std::vector<syntax::Expression *> syntax::CallArguments::arguments() {
+std::vector<syntax::Expression *> syntax::CallArguments::getArguments() {
   auto ArgumentsAsNodes = getElementsAsNodes();
   std::vector<syntax::Expression *> Children;
   for (const auto &ArgumentAsNode : ArgumentsAsNodes) {
     Children.push_back(llvm::cast<syntax::Expression>(ArgumentAsNode));
   }
   return Children;
 }
 
 std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
-syntax::CallArguments::argumentsAndCommas() {
+syntax::CallArguments::getArgumentsAndCommas() {
   auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
   std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> Children;
   for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
     Children.push_back(
         {llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
          ArgumentAsNodeAndComma.delimiter});
   }
   return Children;
 }
 
 std::vector<syntax::SimpleDeclaration *>
-syntax::ParameterDeclarationList::parameterDeclarations() {
+syntax::ParameterDeclarationList::getParameterDeclarations() {
   auto ParametersAsNodes = getElementsAsNodes();
   std::vector<syntax::SimpleDeclaration *> Children;
   for (const auto &ParameterAsNode : ParametersAsNodes) {
     Children.push_back(llvm::cast<syntax::SimpleDeclaration>(ParameterAsNode));
   }
   return Children;
 }
 
 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
-syntax::ParameterDeclarationList::parametersAndCommas() {
+syntax::ParameterDeclarationList::getParametersAndCommas() {
   auto ParametersAsNodesAndCommas = getElementsAsNodesAndDelimiters();
   std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
       Children;
   for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {
     Children.push_back(
         {llvm::cast<syntax::SimpleDeclaration>(ParameterAsNodeAndComma.element),
          ParameterAsNodeAndComma.delimiter});
   }
   return Children;
 }
 
-syntax::Expression *syntax::MemberExpression::object() {
+syntax::Expression *syntax::MemberExpression::getObject() {
   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Object));
 }
 
-syntax::Leaf *syntax::MemberExpression::templateKeyword() {
+syntax::Leaf *syntax::MemberExpression::getTemplateKeyword() {
   return llvm::cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::TemplateKeyword));
 }
 
-syntax::Leaf *syntax::MemberExpression::accessToken() {
+syntax::Leaf *syntax::MemberExpression::getAccessToken() {
   return llvm::cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::AccessToken));
 }
 
-syntax::IdExpression *syntax::MemberExpression::member() {
+syntax::IdExpression *syntax::MemberExpression::getMember() {
   return cast_or_null<syntax::IdExpression>(
       findChild(syntax::NodeRole::Member));
 }
 
-syntax::NestedNameSpecifier *syntax::IdExpression::qualifier() {
+syntax::NestedNameSpecifier *syntax::IdExpression::getQualifier() {
   return cast_or_null<syntax::NestedNameSpecifier>(
       findChild(syntax::NodeRole::Qualifier));
 }
 
-syntax::Leaf *syntax::IdExpression::templateKeyword() {
+syntax::Leaf *syntax::IdExpression::getTemplateKeyword() {
   return llvm::cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::TemplateKeyword));
 }
 
-syntax::UnqualifiedId *syntax::IdExpression::unqualifiedId() {
+syntax::UnqualifiedId *syntax::IdExpression::getUnqualifiedId() {
   return cast_or_null<syntax::UnqualifiedId>(
       findChild(syntax::NodeRole::UnqualifiedId));
 }
 
-syntax::Leaf *syntax::ParenExpression::openParen() {
+syntax::Leaf *syntax::ParenExpression::getOpenParen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
-syntax::Expression *syntax::ParenExpression::subExpression() {
+syntax::Expression *syntax::ParenExpression::getSubExpression() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::SubExpression));
 }
 
-syntax::Leaf *syntax::ParenExpression::closeParen() {
+syntax::Leaf *syntax::ParenExpression::getCloseParen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
-syntax::Leaf *syntax::ThisExpression::thisKeyword() {
+syntax::Leaf *syntax::ThisExpression::getThisKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Leaf *syntax::LiteralExpression::literalToken() {
+syntax::Leaf *syntax::LiteralExpression::getLiteralToken() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
 }
 
-syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
+syntax::Expression *syntax::BinaryOperatorExpression::getLhs() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::LeftHandSide));
 }
 
-syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
+syntax::Leaf *syntax::UnaryOperatorExpression::getOperatorToken() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
 }
 
-syntax::Expression *syntax::UnaryOperatorExpression::operand() {
+syntax::Expression *syntax::UnaryOperatorExpression::getOperand() {
   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Operand));
 }
 
-syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
+syntax::Leaf *syntax::BinaryOperatorExpression::getOperatorToken() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
 }
 
-syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
+syntax::Expression *syntax::BinaryOperatorExpression::getRhs() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::RightHandSide));
 }
 
-syntax::Expression *syntax::CallExpression::callee() {
+syntax::Expression *syntax::CallExpression::getCallee() {
   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Callee));
 }
 
-syntax::Leaf *syntax::CallExpression::openParen() {
+syntax::Leaf *syntax::CallExpression::getOpenParen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
-syntax::CallArguments *syntax::CallExpression::arguments() {
+syntax::CallArguments *syntax::CallExpression::getArguments() {
   return cast_or_null<syntax::CallArguments>(
       findChild(syntax::NodeRole::Arguments));
 }
 
-syntax::Leaf *syntax::CallExpression::closeParen() {
+syntax::Leaf *syntax::CallExpression::getCloseParen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
-syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
+syntax::Leaf *syntax::SwitchStatement::getSwitchKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Statement *syntax::SwitchStatement::body() {
+syntax::Statement *syntax::SwitchStatement::getBody() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
-syntax::Leaf *syntax::CaseStatement::caseKeyword() {
+syntax::Leaf *syntax::CaseStatement::getCaseKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Expression *syntax::CaseStatement::caseValue() {
+syntax::Expression *syntax::CaseStatement::getCaseValue() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::CaseValue));
 }
 
-syntax::Statement *syntax::CaseStatement::body() {
+syntax::Statement *syntax::CaseStatement::getBody() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
-syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {
+syntax::Leaf *syntax::DefaultStatement::getDefaultKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Statement *syntax::DefaultStatement::body() {
+syntax::Statement *syntax::DefaultStatement::getBody() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
-syntax::Leaf *syntax::IfStatement::ifKeyword() {
+syntax::Leaf *syntax::IfStatement::getIfKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Statement *syntax::IfStatement::thenStatement() {
+syntax::Statement *syntax::IfStatement::getThenStatement() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::ThenStatement));
 }
 
-syntax::Leaf *syntax::IfStatement::elseKeyword() {
+syntax::Leaf *syntax::IfStatement::getElseKeyword() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ElseKeyword));
 }
 
-syntax::Statement *syntax::IfStatement::elseStatement() {
+syntax::Statement *syntax::IfStatement::getElseStatement() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::ElseStatement));
 }
 
-syntax::Leaf *syntax::ForStatement::forKeyword() {
+syntax::Leaf *syntax::ForStatement::getForKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Statement *syntax::ForStatement::body() {
+syntax::Statement *syntax::ForStatement::getBody() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
-syntax::Leaf *syntax::WhileStatement::whileKeyword() {
+syntax::Leaf *syntax::WhileStatement::getWhileKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Statement *syntax::WhileStatement::body() {
+syntax::Statement *syntax::WhileStatement::getBody() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
-syntax::Leaf *syntax::ContinueStatement::continueKeyword() {
+syntax::Leaf *syntax::ContinueStatement::getContinueKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Leaf *syntax::BreakStatement::breakKeyword() {
+syntax::Leaf *syntax::BreakStatement::getBreakKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
+syntax::Leaf *syntax::ReturnStatement::getReturnKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Expression *syntax::ReturnStatement::returnValue() {
+syntax::Expression *syntax::ReturnStatement::getReturnValue() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::ReturnValue));
 }
 
-syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {
+syntax::Leaf *syntax::RangeBasedForStatement::getForKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Statement *syntax::RangeBasedForStatement::body() {
+syntax::Statement *syntax::RangeBasedForStatement::getBody() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));
 }
 
-syntax::Expression *syntax::ExpressionStatement::expression() {
+syntax::Expression *syntax::ExpressionStatement::getExpression() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::Expression));
 }
 
-syntax::Leaf *syntax::CompoundStatement::lbrace() {
+syntax::Leaf *syntax::CompoundStatement::getLbrace() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
-std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
+std::vector<syntax::Statement *> syntax::CompoundStatement::getStatements() {
   std::vector<syntax::Statement *> Children;
   for (auto *C = firstChild(); C; C = C->nextSibling()) {
     assert(C->role() == syntax::NodeRole::Statement);
     Children.push_back(cast<syntax::Statement>(C));
   }
   return Children;
 }
 
-syntax::Leaf *syntax::CompoundStatement::rbrace() {
+syntax::Leaf *syntax::CompoundStatement::getRbrace() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
-syntax::Expression *syntax::StaticAssertDeclaration::condition() {
+syntax::Expression *syntax::StaticAssertDeclaration::getCondition() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::Condition));
 }
 
-syntax::Expression *syntax::StaticAssertDeclaration::message() {
+syntax::Expression *syntax::StaticAssertDeclaration::getMessage() {
   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message));
 }
 
 std::vector<syntax::SimpleDeclarator *>
-syntax::SimpleDeclaration::declarators() {
+syntax::SimpleDeclaration::getDeclarators() {
   std::vector<syntax::SimpleDeclarator *> Children;
   for (auto *C = firstChild(); C; C = C->nextSibling()) {
     if (C->role() == syntax::NodeRole::Declarator)
       Children.push_back(cast<syntax::SimpleDeclarator>(C));
   }
   return Children;
 }
 
-syntax::Leaf *syntax::TemplateDeclaration::templateKeyword() {
+syntax::Leaf *syntax::TemplateDeclaration::getTemplateKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Declaration *syntax::TemplateDeclaration::declaration() {
+syntax::Declaration *syntax::TemplateDeclaration::getDeclaration() {
   return cast_or_null<syntax::Declaration>(
       findChild(syntax::NodeRole::Declaration));
 }
 
-syntax::Leaf *syntax::ExplicitTemplateInstantiation::templateKeyword() {
+syntax::Leaf *syntax::ExplicitTemplateInstantiation::getTemplateKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
-syntax::Leaf *syntax::ExplicitTemplateInstantiation::externKeyword() {
+syntax::Leaf *syntax::ExplicitTemplateInstantiation::getExternKeyword() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
 }
 
-syntax::Declaration *syntax::ExplicitTemplateInstantiation::declaration() {
+syntax::Declaration *syntax::ExplicitTemplateInstantiation::getDeclaration() {
   return cast_or_null<syntax::Declaration>(
       findChild(syntax::NodeRole::Declaration));
 }
 
-syntax::Leaf *syntax::ParenDeclarator::lparen() {
+syntax::Leaf *syntax::ParenDeclarator::getLparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
-syntax::Leaf *syntax::ParenDeclarator::rparen() {
+syntax::Leaf *syntax::ParenDeclarator::getRparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
-syntax::Leaf *syntax::ArraySubscript::lbracket() {
+syntax::Leaf *syntax::ArraySubscript::getLbracket() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
-syntax::Expression *syntax::ArraySubscript::size() {
+syntax::Expression *syntax::ArraySubscript::getSize() {
   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Size));
 }
 
-syntax::Leaf *syntax::ArraySubscript::rbracket() {
+syntax::Leaf *syntax::ArraySubscript::getRbracket() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
-syntax::Leaf *syntax::TrailingReturnType::arrowToken() {
+syntax::Leaf *syntax::TrailingReturnType::getArrowToken() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
 }
 
-syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
+syntax::SimpleDeclarator *syntax::TrailingReturnType::getDeclarator() {
   return cast_or_null<syntax::SimpleDeclarator>(
       findChild(syntax::NodeRole::Declarator));
 }
 
-syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
+syntax::Leaf *syntax::ParametersAndQualifiers::getLparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
 syntax::ParameterDeclarationList *
-syntax::ParametersAndQualifiers::parameters() {
+syntax::ParametersAndQualifiers::getParameters() {
   return cast_or_null<syntax::ParameterDeclarationList>(
       findChild(syntax::NodeRole::Parameters));
 }
 
-syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
+syntax::Leaf *syntax::ParametersAndQualifiers::getRparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
-syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
+syntax::TrailingReturnType *
+syntax::ParametersAndQualifiers::getTrailingReturn() {
   return cast_or_null<syntax::TrailingReturnType>(
       findChild(syntax::NodeRole::TrailingReturn));
 }