[SyntaxTree][NFC] Rename functions to start with verb

[eduucaldas]

Summary

According to LLVM coding standards:
https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

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

 
 class SimpleDeclarator;
 
 /// A root node for a translation unit. Parent is always null.
 class TranslationUnit final : public Tree {
 public:
   TranslationUnit() : Tree(NodeKind::TranslationUnit) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::TranslationUnit;
+    return N->getKind() == NodeKind::TranslationUnit;
   }
 };
 
 /// A base class for all expressions. Note that expressions are not statements,
 /// even though they are in clang.
 class Expression : public Tree {
 public:
   Expression(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N) {
-    return NodeKind::UnknownExpression <= N->kind() &&
-           N->kind() <= NodeKind::UnknownExpression;
+    return NodeKind::UnknownExpression <= N->getKind() &&
+           N->getKind() <= NodeKind::UnknownExpression;
   }
 };
 
 /// A sequence of these specifiers make a `nested-name-specifier`.
 /// e.g. the `std` or `vector<int>` in `std::vector<int>::size`.
 class NameSpecifier : public Tree {
 public:
   NameSpecifier(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::GlobalNameSpecifier ||
-           N->kind() == NodeKind::DecltypeNameSpecifier ||
-           N->kind() == NodeKind::IdentifierNameSpecifier ||
-           N->kind() == NodeKind::SimpleTemplateNameSpecifier;
+    return N->getKind() == NodeKind::GlobalNameSpecifier ||
+           N->getKind() == NodeKind::DecltypeNameSpecifier ||
+           N->getKind() == NodeKind::IdentifierNameSpecifier ||
+           N->getKind() == NodeKind::SimpleTemplateNameSpecifier;
   }
 };
 
 /// The global namespace name specifier, this specifier doesn't correspond to a
 /// token instead an absence of tokens before a `::` characterizes it, in
 /// `::std::vector<int>` it would be characterized by the absence of a token
 /// before the first `::`
 class GlobalNameSpecifier final : public NameSpecifier {
 public:
   GlobalNameSpecifier() : NameSpecifier(NodeKind::GlobalNameSpecifier) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::GlobalNameSpecifier;
+    return N->getKind() == NodeKind::GlobalNameSpecifier;
   }
 };
 
 /// A name specifier holding a decltype, of the form: `decltype ( expression ) `
 /// e.g. the `decltype(s)` in `decltype(s)::size`.
 class DecltypeNameSpecifier final : public NameSpecifier {
 public:
   DecltypeNameSpecifier() : NameSpecifier(NodeKind::DecltypeNameSpecifier) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::DecltypeNameSpecifier;
+    return N->getKind() == NodeKind::DecltypeNameSpecifier;
   }
 };
 
 /// A identifier name specifier, of the form `identifier`
 /// e.g. the `std` in `std::vector<int>::size`.
 class IdentifierNameSpecifier final : public NameSpecifier {
 public:
   IdentifierNameSpecifier()
       : NameSpecifier(NodeKind::IdentifierNameSpecifier) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::IdentifierNameSpecifier;
+    return N->getKind() == NodeKind::IdentifierNameSpecifier;
   }
 };
 
 /// A name specifier with a simple-template-id, of the form `template_opt
 /// identifier < template-args >` e.g. the `vector<int>` in
 /// `std::vector<int>::size`.
 class SimpleTemplateNameSpecifier final : public NameSpecifier {
 public:
   SimpleTemplateNameSpecifier()
       : NameSpecifier(NodeKind::SimpleTemplateNameSpecifier) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::SimpleTemplateNameSpecifier;
+    return N->getKind() == NodeKind::SimpleTemplateNameSpecifier;
   }
 };
 
 /// 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;
+    return N->getKind() <= NodeKind::NestedNameSpecifier;
   }
   std::vector<NameSpecifier *> getSpecifiers();
   std::vector<List::ElementAndDelimiter<syntax::NameSpecifier>>
   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) {
-    return N->kind() == NodeKind::UnqualifiedId;
+    return N->getKind() == NodeKind::UnqualifiedId;
   }
 };
 
 /// Models an `id-expression`, e.g. `std::vector<int>::size`.
 /// C++ [expr.prim.id]
 /// id-expression:
 ///   unqualified-id
 ///   qualified-id
 /// 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;
+    return N->getKind() == NodeKind::IdExpression;
   }
   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;
+    return N->getKind() == 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;
+    return N->getKind() == NodeKind::ThisExpression;
   }
   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;
+    return N->getKind() <= NodeKind::CallArguments;
   }
   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;
+    return N->getKind() == NodeKind::CallExpression;
   }
   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;
+    return N->getKind() == NodeKind::ParenExpression;
   }
   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;
+    return N->getKind() == NodeKind::MemberExpression;
   }
   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;
+    return N->getKind() == NodeKind::IntegerLiteralExpression ||
+           N->getKind() == NodeKind::CharacterLiteralExpression ||
+           N->getKind() == NodeKind::FloatingLiteralExpression ||
+           N->getKind() == NodeKind::StringLiteralExpression ||
+           N->getKind() == NodeKind::BoolLiteralExpression ||
+           N->getKind() == NodeKind::CxxNullPtrExpression ||
+           N->getKind() == NodeKind::IntegerUserDefinedLiteralExpression ||
+           N->getKind() == NodeKind::FloatUserDefinedLiteralExpression ||
+           N->getKind() == NodeKind::CharUserDefinedLiteralExpression ||
+           N->getKind() == NodeKind::StringUserDefinedLiteralExpression;
   }
   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) {
-    return N->kind() == NodeKind::IntegerLiteralExpression;
+    return N->getKind() == NodeKind::IntegerLiteralExpression;
   }
 };
 
 /// Expression for character literals. C++ [lex.ccon]
 class CharacterLiteralExpression final : public LiteralExpression {
 public:
   CharacterLiteralExpression()
       : LiteralExpression(NodeKind::CharacterLiteralExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::CharacterLiteralExpression;
+    return N->getKind() == NodeKind::CharacterLiteralExpression;
   }
 };
 
 /// Expression for floating-point literals. C++ [lex.fcon]
 class FloatingLiteralExpression final : public LiteralExpression {
 public:
   FloatingLiteralExpression()
       : LiteralExpression(NodeKind::FloatingLiteralExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::FloatingLiteralExpression;
+    return N->getKind() == NodeKind::FloatingLiteralExpression;
   }
 };
 
 /// Expression for string-literals. C++ [lex.string]
 class StringLiteralExpression final : public LiteralExpression {
 public:
   StringLiteralExpression()
       : LiteralExpression(NodeKind::StringLiteralExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::StringLiteralExpression;
+    return N->getKind() == NodeKind::StringLiteralExpression;
   }
 };
 
 /// Expression for boolean literals. C++ [lex.bool]
 class BoolLiteralExpression final : public LiteralExpression {
 public:
   BoolLiteralExpression()
       : LiteralExpression(NodeKind::BoolLiteralExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::BoolLiteralExpression;
+    return N->getKind() == NodeKind::BoolLiteralExpression;
   }
 };
 
 /// Expression for the `nullptr` literal. C++ [lex.nullptr]
 class CxxNullPtrExpression final : public LiteralExpression {
 public:
   CxxNullPtrExpression() : LiteralExpression(NodeKind::CxxNullPtrExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::CxxNullPtrExpression;
+    return N->getKind() == NodeKind::CxxNullPtrExpression;
   }
 };
 
 /// Expression for user-defined literal. C++ [lex.ext]
 /// user-defined-literal:
 ///   user-defined-integer-literal
 ///   user-defined-floating-point-literal
 ///   user-defined-string-literal
 ///   user-defined-character-literal
 class UserDefinedLiteralExpression : public LiteralExpression {
 public:
   UserDefinedLiteralExpression(NodeKind K) : LiteralExpression(K) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::IntegerUserDefinedLiteralExpression ||
-           N->kind() == NodeKind::FloatUserDefinedLiteralExpression ||
-           N->kind() == NodeKind::CharUserDefinedLiteralExpression ||
-           N->kind() == NodeKind::StringUserDefinedLiteralExpression;
+    return N->getKind() == NodeKind::IntegerUserDefinedLiteralExpression ||
+           N->getKind() == NodeKind::FloatUserDefinedLiteralExpression ||
+           N->getKind() == NodeKind::CharUserDefinedLiteralExpression ||
+           N->getKind() == NodeKind::StringUserDefinedLiteralExpression;
   }
 };
 
 /// Expression for user-defined-integer-literal. C++ [lex.ext]
 class IntegerUserDefinedLiteralExpression final
     : public UserDefinedLiteralExpression {
 public:
   IntegerUserDefinedLiteralExpression()
       : UserDefinedLiteralExpression(
             NodeKind::IntegerUserDefinedLiteralExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::IntegerUserDefinedLiteralExpression;
+    return N->getKind() == NodeKind::IntegerUserDefinedLiteralExpression;
   }
 };
 
 /// Expression for user-defined-floating-point-literal. C++ [lex.ext]
 class FloatUserDefinedLiteralExpression final
     : public UserDefinedLiteralExpression {
 public:
   FloatUserDefinedLiteralExpression()
       : UserDefinedLiteralExpression(
             NodeKind::FloatUserDefinedLiteralExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::FloatUserDefinedLiteralExpression;
+    return N->getKind() == NodeKind::FloatUserDefinedLiteralExpression;
   }
 };
 
 /// Expression for user-defined-character-literal. C++ [lex.ext]
 class CharUserDefinedLiteralExpression final
     : public UserDefinedLiteralExpression {
 public:
   CharUserDefinedLiteralExpression()
       : UserDefinedLiteralExpression(
             NodeKind::CharUserDefinedLiteralExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::CharUserDefinedLiteralExpression;
+    return N->getKind() == NodeKind::CharUserDefinedLiteralExpression;
   }
 };
 
 /// Expression for user-defined-string-literal. C++ [lex.ext]
 class StringUserDefinedLiteralExpression final
     : public UserDefinedLiteralExpression {
 public:
   StringUserDefinedLiteralExpression()
       : UserDefinedLiteralExpression(
             NodeKind::StringUserDefinedLiteralExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::StringUserDefinedLiteralExpression;
+    return N->getKind() == NodeKind::StringUserDefinedLiteralExpression;
   }
 };
 
 /// 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;
+    return N->getKind() == NodeKind::PrefixUnaryOperatorExpression ||
+           N->getKind() == NodeKind::PostfixUnaryOperatorExpression;
   }
   Leaf *getOperatorToken();
   Expression *getOperand();
 };
 
 /// <operator> <operand>
 ///
 /// For example:
 ///   +a          -b
 ///   !c          not c
 ///   ~d          compl d
 ///   *e          &f
 ///   ++h         --h
 ///   __real i    __imag i
 class PrefixUnaryOperatorExpression final : public UnaryOperatorExpression {
 public:
   PrefixUnaryOperatorExpression()
       : UnaryOperatorExpression(NodeKind::PrefixUnaryOperatorExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::PrefixUnaryOperatorExpression;
+    return N->getKind() == NodeKind::PrefixUnaryOperatorExpression;
   }
 };
 
 /// <operand> <operator>
 ///
 /// For example:
 ///   a++
 ///   b--
 class PostfixUnaryOperatorExpression final : public UnaryOperatorExpression {
 public:
   PostfixUnaryOperatorExpression()
       : UnaryOperatorExpression(NodeKind::PostfixUnaryOperatorExpression) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::PostfixUnaryOperatorExpression;
+    return N->getKind() == NodeKind::PostfixUnaryOperatorExpression;
   }
 };
 
 /// <lhs> <operator> <rhs>
 ///
 /// For example:
 ///   a + b
 ///   a bitor 1
 ///   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;
+    return N->getKind() == NodeKind::BinaryOperatorExpression;
   }
   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) {
-    return NodeKind::UnknownStatement <= N->kind() &&
-           N->kind() <= NodeKind::CompoundStatement;
+    return NodeKind::UnknownStatement <= N->getKind() &&
+           N->getKind() <= NodeKind::CompoundStatement;
   }
 };
 
 /// A statement of an unknown kind, i.e. one not currently handled by the syntax
 /// tree.
 class UnknownStatement final : public Statement {
 public:
   UnknownStatement() : Statement(NodeKind::UnknownStatement) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::UnknownStatement;
+    return N->getKind() == NodeKind::UnknownStatement;
   }
 };
 
 /// E.g. 'int a, b = 10;'
 class DeclarationStatement final : public Statement {
 public:
   DeclarationStatement() : Statement(NodeKind::DeclarationStatement) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::DeclarationStatement;
+    return N->getKind() == NodeKind::DeclarationStatement;
   }
 };
 
 /// The no-op statement, i.e. ';'.
 class EmptyStatement final : public Statement {
 public:
   EmptyStatement() : Statement(NodeKind::EmptyStatement) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::EmptyStatement;
+    return N->getKind() == NodeKind::EmptyStatement;
   }
 };
 
 /// switch (<cond>) <body>
 class SwitchStatement final : public Statement {
 public:
   SwitchStatement() : Statement(NodeKind::SwitchStatement) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::SwitchStatement;
+    return N->getKind() == NodeKind::SwitchStatement;
   }
   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;
+    return N->getKind() == NodeKind::CaseStatement;
   }
   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;
+    return N->getKind() == NodeKind::DefaultStatement;
   }
   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;
+    return N->getKind() == NodeKind::IfStatement;
   }
   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;
+    return N->getKind() == NodeKind::ForStatement;
   }
   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;
+    return N->getKind() == NodeKind::WhileStatement;
   }
   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;
+    return N->getKind() == NodeKind::ContinueStatement;
   }
   Leaf *getContinueKeyword();
 };
 
 /// break;
 class BreakStatement final : public Statement {
 public:
   BreakStatement() : Statement(NodeKind::BreakStatement) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::BreakStatement;
+    return N->getKind() == NodeKind::BreakStatement;
   }
   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;
+    return N->getKind() == NodeKind::ReturnStatement;
   }
   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;
+    return N->getKind() == NodeKind::RangeBasedForStatement;
   }
   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;
+    return N->getKind() == NodeKind::ExpressionStatement;
   }
   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;
+    return N->getKind() == NodeKind::CompoundStatement;
   }
   Leaf *getLbrace();
   /// FIXME: use custom iterator instead of 'vector'.
   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:
   Declaration(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N) {
-    return NodeKind::UnknownDeclaration <= N->kind() &&
-           N->kind() <= NodeKind::TypeAliasDeclaration;
+    return NodeKind::UnknownDeclaration <= N->getKind() &&
+           N->getKind() <= NodeKind::TypeAliasDeclaration;
   }
 };
 
 /// Declaration of an unknown kind, e.g. not yet supported in syntax trees.
 class UnknownDeclaration final : public Declaration {
 public:
   UnknownDeclaration() : Declaration(NodeKind::UnknownDeclaration) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::UnknownDeclaration;
+    return N->getKind() == NodeKind::UnknownDeclaration;
   }
 };
 
 /// A semicolon in the top-level context. Does not declare anything.
 class EmptyDeclaration final : public Declaration {
 public:
   EmptyDeclaration() : Declaration(NodeKind::EmptyDeclaration) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::EmptyDeclaration;
+    return N->getKind() == NodeKind::EmptyDeclaration;
   }
 };
 
 /// 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;
+    return N->getKind() == NodeKind::StaticAssertDeclaration;
   }
   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;
+    return N->getKind() == 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;
+    return N->getKind() == NodeKind::SimpleDeclaration;
   }
   /// FIXME: use custom iterator instead of 'vector'.
   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;
+    return N->getKind() == NodeKind::TemplateDeclaration;
   }
   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;
+    return N->getKind() == NodeKind::ExplicitTemplateInstantiation;
   }
   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;
+    return N->getKind() == NodeKind::NamespaceDefinition;
   }
 };
 
 /// namespace <name> = <namespace-reference>
 class NamespaceAliasDefinition final : public Declaration {
 public:
   NamespaceAliasDefinition()
       : Declaration(NodeKind::NamespaceAliasDefinition) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::NamespaceAliasDefinition;
+    return N->getKind() == NodeKind::NamespaceAliasDefinition;
   }
 };
 
 /// using namespace <name>
 class UsingNamespaceDirective final : public Declaration {
 public:
   UsingNamespaceDirective() : Declaration(NodeKind::UsingNamespaceDirective) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::UsingNamespaceDirective;
+    return N->getKind() == NodeKind::UsingNamespaceDirective;
   }
 };
 
 /// using <scope>::<name>
 /// using typename <scope>::<name>
 class UsingDeclaration final : public Declaration {
 public:
   UsingDeclaration() : Declaration(NodeKind::UsingDeclaration) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::UsingDeclaration;
+    return N->getKind() == NodeKind::UsingDeclaration;
   }
 };
 
 /// using <name> = <type>
 class TypeAliasDeclaration final : public Declaration {
 public:
   TypeAliasDeclaration() : Declaration(NodeKind::TypeAliasDeclaration) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::TypeAliasDeclaration;
+    return N->getKind() == NodeKind::TypeAliasDeclaration;
   }
 };
 
 /// Covers a name, an initializer and a part of the type outside declaration
 /// specifiers. Examples are:
 ///     `*a` in `int *a`
 ///     `a[10]` in `int a[10]`
 ///     `*a = nullptr` in `int *a = nullptr`
 /// Declarators can be unnamed too:
 ///     `**` in `new int**`
 ///     `* = nullptr` in `void foo(int* = nullptr)`
 /// Most declarators you encounter are instances of SimpleDeclarator. They may
 /// contain an inner declarator inside parentheses, we represent it as
 /// ParenDeclarator. E.g.
 ///     `(*a)` in `int (*a) = 10`
 class Declarator : public Tree {
 public:
   Declarator(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N) {
-    return NodeKind::SimpleDeclarator <= N->kind() &&
-           N->kind() <= NodeKind::ParenDeclarator;
+    return NodeKind::SimpleDeclarator <= N->getKind() &&
+           N->getKind() <= NodeKind::ParenDeclarator;
   }
 };
 
 /// A top-level declarator without parentheses. See comment of Declarator for
 /// more details.
 class SimpleDeclarator final : public Declarator {
 public:
   SimpleDeclarator() : Declarator(NodeKind::SimpleDeclarator) {}
   static bool classof(const Node *N) {
-    return N->kind() == NodeKind::SimpleDeclarator;
+    return N->getKind() == NodeKind::SimpleDeclarator;
   }
 };
 
 /// Declarator inside parentheses.
 /// 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;
+    return N->getKind() == NodeKind::ParenDeclarator;
   }
   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;
+    return N->getKind() == NodeKind::ArraySubscript;
   }
   // TODO: add an accessor for the "static" keyword.
   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;
+    return N->getKind() == NodeKind::TrailingReturnType;
   }
   // TODO: add accessors for specifiers.
   Leaf *getArrowToken();
   // FIXME: This should be a `type-id` following the grammar. Fix this once we
   // have a representation of `type-id`s.
   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;
+    return N->getKind() == NodeKind::ParameterDeclarationList;
   }
   std::vector<SimpleDeclaration *> getParameterDeclarations();
   std::vector<List::ElementAndDelimiter<syntax::SimpleDeclaration>>
   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;
+    return N->getKind() == NodeKind::ParametersAndQualifiers;
   }
   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;
+    return N->getKind() == NodeKind::MemberPointer;
   }
 };
 
 } // namespace syntax
 } // namespace clang
 #endif

clang/include/clang/Tooling/Syntax/Tree.h

 
 /// A memory arena for syntax trees. Also tracks the underlying token buffers,
 /// source manager, etc.
 class Arena {
 public:
   Arena(SourceManager &SourceMgr, const LangOptions &LangOpts,
         const TokenBuffer &Tokens);
 
-  const SourceManager &sourceManager() const { return SourceMgr; }
-  const LangOptions &langOptions() const { return LangOpts; }
+  const SourceManager &getSourceManager() const { return SourceMgr; }
+  const LangOptions &getLangOptions() const { return LangOpts; }
 
-  const TokenBuffer &tokenBuffer() const;
-  llvm::BumpPtrAllocator &allocator() { return Allocator; }
+  const TokenBuffer &getTokenBuffer() const;
+  llvm::BumpPtrAllocator &getAllocator() { return Allocator; }
 
   /// Add \p Buffer to the underlying source manager, tokenize it and store the
   /// resulting tokens. Useful when there is a need to materialize tokens that
   /// were not written in user code.
   std::pair<FileID, ArrayRef<Token>>
   lexBuffer(std::unique_ptr<llvm::MemoryBuffer> Buffer);
 
 private:

 /// A node in a syntax tree. Each node is either a Leaf (representing tokens) or
 /// a Tree (representing language constructrs).
 class Node {
 public:
   /// Newly created nodes are detached from a tree, parent and sibling links are
   /// set when the node is added as a child to another one.
   Node(NodeKind Kind);
 
-  NodeKind kind() const { return static_cast<NodeKind>(Kind); }
-  NodeRole role() const { return static_cast<NodeRole>(Role); }
+  NodeKind getKind() const { return static_cast<NodeKind>(Kind); }
+  NodeRole getRole() const { return static_cast<NodeRole>(Role); }
 
   /// Whether the node is detached from a tree, i.e. does not have a parent.
   bool isDetached() const;
   /// Whether the node was created from the AST backed by the source code
   /// rather than added later through mutation APIs or created with factory
   /// functions.
   /// When this flag is true, all subtrees are also original.
   /// This flag is set to false on any modifications to the node or any of its
   /// subtrees, even if this simply involves swapping existing subtrees.
   bool isOriginal() const { return Original; }
   /// If this function return false, the tree cannot be modified because there
   /// is no reasonable way to produce the corresponding textual replacements.
   /// This can happen when the node crosses macro expansion boundaries.
   ///
   /// Note that even if the node is not modifiable, its child nodes can be
   /// modifiable.
   bool canModify() const { return CanModify; }
 
-  const Tree *parent() const { return Parent; }
-  Tree *parent() { return Parent; }
+  const Tree *getParent() const { return Parent; }
+  Tree *getParent() { return Parent; }
 
-  const Node *nextSibling() const { return NextSibling; }
-  Node *nextSibling() { return NextSibling; }
+  const Node *getNextSibling() const { return NextSibling; }
+  Node *getNextSibling() { return NextSibling; }
 
   /// Dumps the structure of a subtree. For debugging and testing purposes.
   std::string dump(const SourceManager &SM) const;
   /// Dumps the tokens forming this subtree.
   std::string dumpTokens(const SourceManager &SM) const;
 
   /// Asserts invariants on this node of the tree and its immediate children.
   /// Will not recurse into the subtree. No-op if NDEBUG is set.

 };
 
 /// A leaf node points to a single token inside the expanded token stream.
 class Leaf final : public Node {
 public:
   Leaf(const Token *T);
   static bool classof(const Node *N);
 
-  const Token *token() const { return Tok; }
+  const Token *getToken() const { return Tok; }
 
 private:
   const Token *Tok;
 };
 
 /// A node that has children and represents a syntactic language construct.
 class Tree : public Node {
 public:
   using Node::Node;
   static bool classof(const Node *N);
 
-  Node *firstChild() { return FirstChild; }
-  const Node *firstChild() const { return FirstChild; }
+  Node *getFirstChild() { return FirstChild; }
+  const Node *getFirstChild() const { return FirstChild; }
 
-  Leaf *firstLeaf();
-  const Leaf *firstLeaf() const {
-    return const_cast<Tree *>(this)->firstLeaf();
+  Leaf *findFirstLeaf();
+  const Leaf *findFirstLeaf() const {
+    return const_cast<Tree *>(this)->findFirstLeaf();
   }
 
-  Leaf *lastLeaf();
-  const Leaf *lastLeaf() const { return const_cast<Tree *>(this)->lastLeaf(); }
+  Leaf *findLastLeaf();
+  const Leaf *findLastLeaf() const {
+    return const_cast<Tree *>(this)->findLastLeaf();
+  }
 
 protected:
   /// Find the first node with a corresponding role.
   Node *findChild(NodeRole R);
 
 private:
   /// Prepend \p Child to the list of children and and sets the parent pointer.
   /// A very low-level operation that does not check any invariants, only used

clang/lib/Tooling/Syntax/BuildTree.cpp

 ///     with 'foldNode'.
 ///
 /// Note that all children are expected to be processed when building a node.
 ///
 /// Call finalize() to finish building the tree and consume the root node.
 class syntax::TreeBuilder {
 public:
   TreeBuilder(syntax::Arena &Arena) : Arena(Arena), Pending(Arena) {
-    for (const auto &T : Arena.tokenBuffer().expandedTokens())
+    for (const auto &T : Arena.getTokenBuffer().expandedTokens())
       LocationToToken.insert({T.location().getRawEncoding(), &T});
   }
 
-  llvm::BumpPtrAllocator &allocator() { return Arena.allocator(); }
-  const SourceManager &sourceManager() const { return Arena.sourceManager(); }
+  llvm::BumpPtrAllocator &allocator() { return Arena.getAllocator(); }
+  const SourceManager &sourceManager() const {
+    return Arena.getSourceManager();
+  }
 
   /// Populate children for \p New node, assuming it covers tokens from \p
   /// Range.
   void foldNode(ArrayRef<syntax::Token> Range, syntax::Tree *New, ASTPtr From) {
     assert(New);
     Pending.foldChildren(Arena, Range, New);
     if (From)
       Mapping.add(From, New);
public:
   void markChild(syntax::Node *N, NodeRole R);
   /// Set role for the syntax node matching \p N.
   void markChild(ASTPtr N, NodeRole R);
   /// Set role for the syntax node matching \p N.
   void markChild(NestedNameSpecifierLoc N, NodeRole R);
 
   /// Finish building the tree and consume the root node.
   syntax::TranslationUnit *finalize() && {
-    auto Tokens = Arena.tokenBuffer().expandedTokens();
+    auto Tokens = Arena.getTokenBuffer().expandedTokens();
     assert(!Tokens.empty());
     assert(Tokens.back().kind() == tok::eof);
 
     // Build the root of the tree, consuming all the children.
     Pending.foldChildren(Arena, Tokens.drop_back(),
-                         new (Arena.allocator()) syntax::TranslationUnit);
+                         new (Arena.getAllocator()) syntax::TranslationUnit);
 
     auto *TU = cast<syntax::TranslationUnit>(std::move(Pending).finalize());
     TU->assertInvariantsRecursive();
     return TU;
   }
 
   /// Finds a token starting at \p L. The token must exist if \p L is valid.
   const syntax::Token *findToken(SourceLocation L) const;
 
   /// Finds the syntax tokens corresponding to the \p SourceRange.
   ArrayRef<syntax::Token> getRange(SourceRange Range) const {
     assert(Range.isValid());
     return getRange(Range.getBegin(), Range.getEnd());
   }
 
   /// Finds the syntax tokens corresponding to the passed source locations.
   /// \p First is the start position of the first token and \p Last is the start
   /// position of the last token.
   ArrayRef<syntax::Token> getRange(SourceLocation First,
                                    SourceLocation Last) const {
     assert(First.isValid());
     assert(Last.isValid());
     assert(First == Last ||
-           Arena.sourceManager().isBeforeInTranslationUnit(First, Last));
+           Arena.getSourceManager().isBeforeInTranslationUnit(First, Last));
     return llvm::makeArrayRef(findToken(First), std::next(findToken(Last)));
   }
 
   ArrayRef<syntax::Token>
   getTemplateRange(const ClassTemplateSpecializationDecl *D) const {
     auto Tokens = getRange(D->getSourceRange());
     return maybeAppendSemicolon(Tokens, D);
   }
withTrailingSemicolon(ArrayRef<syntax::Token> Tokens) const {
     assert(Tokens.back().kind() != tok::eof);
     // We never consume 'eof', so looking at the next token is ok.
     if (Tokens.back().kind() != tok::semi && Tokens.end()->kind() == tok::semi)
       return llvm::makeArrayRef(Tokens.begin(), Tokens.end() + 1);
     return Tokens;
   }
 
   void setRole(syntax::Node *N, NodeRole R) {
-    assert(N->role() == NodeRole::Detached);
+    assert(N->getRole() == NodeRole::Detached);
     N->setRole(R);
   }
 
   /// A collection of trees covering the input tokens.
   /// When created, each tree corresponds to a single token in the file.
   /// Clients call 'foldChildren' to attach one or more subtrees to a parent
   /// node and update the list of trees accordingly.
   ///
   /// Ensures that added nodes properly nest and cover the whole token stream.
   struct Forest {
     Forest(syntax::Arena &A) {
-      assert(!A.tokenBuffer().expandedTokens().empty());
-      assert(A.tokenBuffer().expandedTokens().back().kind() == tok::eof);
+      assert(!A.getTokenBuffer().expandedTokens().empty());
+      assert(A.getTokenBuffer().expandedTokens().back().kind() == tok::eof);
       // Create all leaf nodes.
       // Note that we do not have 'eof' in the tree.
-      for (auto &T : A.tokenBuffer().expandedTokens().drop_back()) {
-        auto *L = new (A.allocator()) syntax::Leaf(&T);
+      for (auto &T : A.getTokenBuffer().expandedTokens().drop_back()) {
+        auto *L = new (A.getAllocator()) syntax::Leaf(&T);
         L->Original = true;
-        L->CanModify = A.tokenBuffer().spelledForExpanded(T).hasValue();
+        L->CanModify = A.getTokenBuffer().spelledForExpanded(T).hasValue();
         Trees.insert(Trees.end(), {&T, L});
       }
     }
 
     void assignRole(ArrayRef<syntax::Token> Range, syntax::NodeRole Role) {
       assert(!Range.empty());
       auto It = Trees.lower_bound(Range.begin());
       assert(It != Trees.end() && "no node found");
       assert(It->first == Range.begin() && "no child with the specified range");
       assert((std::next(It) == Trees.end() ||
               std::next(It)->first == Range.end()) &&
              "no child with the specified range");
-      assert(It->second->role() == NodeRole::Detached &&
+      assert(It->second->getRole() == NodeRole::Detached &&
              "re-assigning role for a child");
       It->second->setRole(Role);
     }
 
     /// Add \p Node to the forest and attach child nodes based on \p Tokens.
     void foldChildren(const syntax::Arena &A, ArrayRef<syntax::Token> Tokens,
                       syntax::Tree *Node) {
       // Attach children to `Node`.
-      assert(Node->firstChild() == nullptr && "node already has children");
+      assert(Node->getFirstChild() == nullptr && "node already has children");
 
       auto *FirstToken = Tokens.begin();
       auto BeginChildren = Trees.lower_bound(FirstToken);
 
       assert((BeginChildren == Trees.end() ||
               BeginChildren->first == FirstToken) &&
              "fold crosses boundaries of existing subtrees");
       auto EndChildren = Trees.lower_bound(Tokens.end());
       assert(
           (EndChildren == Trees.end() || EndChildren->first == Tokens.end()) &&
           "fold crosses boundaries of existing subtrees");
 
       // We need to go in reverse order, because we can only prepend.
       for (auto It = EndChildren; It != BeginChildren; --It) {
         auto *C = std::prev(It)->second;
-        if (C->role() == NodeRole::Detached)
+        if (C->getRole() == NodeRole::Detached)
           C->setRole(NodeRole::Unknown);
         Node->prependChildLowLevel(C);
       }
 
       // Mark that this node came from the AST and is backed by the source code.
       Node->Original = true;
-      Node->CanModify = A.tokenBuffer().spelledForExpanded(Tokens).hasValue();
+      Node->CanModify =
+          A.getTokenBuffer().spelledForExpanded(Tokens).hasValue();
 
       Trees.erase(BeginChildren, EndChildren);
       Trees.insert({FirstToken, Node});
     }
 
     // EXPECTS: all tokens were consumed and are owned by a single root node.
     syntax::Node *finalize() && {
       assert(Trees.size() == 1);
       auto *Root = Trees.begin()->second;
       Trees = {};
       return Root;
     }
 
     std::string str(const syntax::Arena &A) const {
       std::string R;
       for (auto It = Trees.begin(); It != Trees.end(); ++It) {
         unsigned CoveredTokens =
             It != Trees.end()
                 ? (std::next(It)->first - It->first)
-                : A.tokenBuffer().expandedTokens().end() - It->first;
+                : A.getTokenBuffer().expandedTokens().end() - It->first;
 
         R += std::string(
-            formatv("- '{0}' covers '{1}'+{2} tokens\n", It->second->kind(),
-                    It->first->text(A.sourceManager()), CoveredTokens));
-        R += It->second->dump(A.sourceManager());
+            formatv("- '{0}' covers '{1}'+{2} tokens\n", It->second->getKind(),
+                    It->first->text(A.getSourceManager()), CoveredTokens));
+        R += It->second->dump(A.getSourceManager());
       }
       return R;
     }
 
   private:
     /// Maps from the start token to a subtree starting at that token.
     /// Keys in the map are pointers into the array of expanded tokens, so
     /// pointer order corresponds to the order of preprocessor tokens.

clang/lib/Tooling/Syntax/ComputeReplacements.cpp

void run(const syntax::Tree *Root) {
       // Report the last span to the user.
       if (SpanBegin)
         Callback(llvm::makeArrayRef(SpanBegin, SpanEnd), SpanIsOriginal);
     }
 
   private:
     void process(const syntax::Node *N) {
       if (auto *T = dyn_cast<syntax::Tree>(N)) {
-        for (auto *C = T->firstChild(); C != nullptr; C = C->nextSibling())
+        for (auto *C = T->getFirstChild(); C != nullptr;
+             C = C->getNextSibling())
           process(C);
         return;
       }
 
       auto *L = cast<syntax::Leaf>(N);
-      if (SpanEnd == L->token() && SpanIsOriginal == L->isOriginal()) {
+      if (SpanEnd == L->getToken() && SpanIsOriginal == L->isOriginal()) {
         // Extend the current span.
         ++SpanEnd;
         return;
       }
       // Report the current span to the user.
       if (SpanBegin)
         Callback(llvm::makeArrayRef(SpanBegin, SpanEnd), SpanIsOriginal);
       // Start recording a new span.
-      SpanBegin = L->token();
+      SpanBegin = L->getToken();
       SpanEnd = SpanBegin + 1;
       SpanIsOriginal = L->isOriginal();
     }
 
     const syntax::Token *SpanBegin;
     const syntax::Token *SpanEnd;
     bool SpanIsOriginal;
     ProcessTokensFn Callback;
   };
 
   return Enumerator(Callback).run(Root);
 }
 
 syntax::FileRange rangeOfExpanded(const syntax::Arena &A,
                                   llvm::ArrayRef<syntax::Token> Expanded) {
-  auto &Buffer = A.tokenBuffer();
-  auto &SM = A.sourceManager();
+  auto &Buffer = A.getTokenBuffer();
+  auto &SM = A.getSourceManager();
 
   // Check that \p Expanded actually points into expanded tokens.
   assert(Buffer.expandedTokens().begin() <= Expanded.begin());
   assert(Expanded.end() < Buffer.expandedTokens().end());
 
   if (Expanded.empty())
     // (!) empty tokens must always point before end().
     return syntax::FileRange(
         SM, SM.getExpansionLoc(Expanded.begin()->location()), /*Length=*/0);
 
   auto Spelled = Buffer.spelledForExpanded(Expanded);
   assert(Spelled && "could not find spelled tokens for expanded");
   return syntax::Token::range(SM, Spelled->front(), Spelled->back());
 }
 } // namespace
 
 tooling::Replacements
 syntax::computeReplacements(const syntax::Arena &A,
                             const syntax::TranslationUnit &TU) {
-  auto &Buffer = A.tokenBuffer();
-  auto &SM = A.sourceManager();
+  auto &Buffer = A.getTokenBuffer();
+  auto &SM = A.getSourceManager();
 
   tooling::Replacements Replacements;
   // Text inserted by the replacement we are building now.
   std::string Replacement;
   auto emitReplacement = [&](llvm::ArrayRef<syntax::Token> ReplacedRange) {
     if (ReplacedRange.empty() && Replacement.empty())
       return;
     llvm::cantFail(Replacements.add(tooling::Replacement(

clang/lib/Tooling/Syntax/Mutations.cpp

public:
   static void addAfter(syntax::Node *Anchor, syntax::Node *New, NodeRole Role) {
     assert(Anchor != nullptr);
     assert(New->Parent == nullptr);
     assert(New->NextSibling == nullptr);
     assert(!New->isDetached());
     assert(Role != NodeRole::Detached);
 
     New->setRole(Role);
-    auto *P = Anchor->parent();
+    auto *P = Anchor->getParent();
     P->replaceChildRangeLowLevel(Anchor, Anchor, New);
 
     P->assertInvariants();
   }
 
   /// Replace the node, keeping the role.
   static void replace(syntax::Node *Old, syntax::Node *New) {
     assert(Old != nullptr);
     assert(Old->Parent != nullptr);
     assert(Old->canModify());
     assert(New->Parent == nullptr);
     assert(New->NextSibling == nullptr);
     assert(New->isDetached());
 
     New->Role = Old->Role;
-    auto *P = Old->parent();
-    P->replaceChildRangeLowLevel(findPrevious(Old), Old->nextSibling(), New);
+    auto *P = Old->getParent();
+    P->replaceChildRangeLowLevel(findPrevious(Old), Old->getNextSibling(), New);
 
     P->assertInvariants();
   }
 
   /// Completely remove the node from its parent.
   static void remove(syntax::Node *N) {
-    auto *P = N->parent();
-    P->replaceChildRangeLowLevel(findPrevious(N), N->nextSibling(),
+    auto *P = N->getParent();
+    P->replaceChildRangeLowLevel(findPrevious(N), N->getNextSibling(),
                                  /*New=*/nullptr);
 
     P->assertInvariants();
     N->assertInvariants();
   }
 
 private:
   static syntax::Node *findPrevious(syntax::Node *N) {
-    if (N->parent()->firstChild() == N)
+    if (N->getParent()->getFirstChild() == N)
       return nullptr;
-    for (syntax::Node *C = N->parent()->firstChild(); C != nullptr;
-         C = C->nextSibling()) {
-      if (C->nextSibling() == N)
+    for (syntax::Node *C = N->getParent()->getFirstChild(); C != nullptr;
+         C = C->getNextSibling()) {
+      if (C->getNextSibling() == N)
         return C;
     }
     llvm_unreachable("could not find a child node");
   }
 };
 
 void syntax::removeStatement(syntax::Arena &A, syntax::Statement *S) {
   assert(S);
   assert(S->canModify());
 
-  if (isa<CompoundStatement>(S->parent())) {
+  if (isa<CompoundStatement>(S->getParent())) {
     // A child of CompoundStatement can just be safely removed.
     MutationsImpl::remove(S);
     return;
   }
   // For the rest, we have to replace with an empty statement.
   if (isa<EmptyStatement>(S))
     return; // already an empty statement, nothing to do.
 
   MutationsImpl::replace(S, createEmptyStatement(A));
 }

clang/lib/Tooling/Syntax/Nodes.cpp

 }
 
 syntax::Leaf *syntax::CompoundStatement::getLbrace() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
 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);
+  for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
+    assert(C->getRole() == syntax::NodeRole::Statement);
     Children.push_back(cast<syntax::Statement>(C));
   }
   return Children;
 }
 
 syntax::Leaf *syntax::CompoundStatement::getRbrace() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::Expression *syntax::StaticAssertDeclaration::getCondition() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::Condition));
 }
 
 syntax::Expression *syntax::StaticAssertDeclaration::getMessage() {
   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message));
 }
 
 std::vector<syntax::SimpleDeclarator *>
 syntax::SimpleDeclaration::getDeclarators() {
   std::vector<syntax::SimpleDeclarator *> Children;
-  for (auto *C = firstChild(); C; C = C->nextSibling()) {
-    if (C->role() == syntax::NodeRole::Declarator)
+  for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
+    if (C->getRole() == syntax::NodeRole::Declarator)
       Children.push_back(cast<syntax::SimpleDeclarator>(C));
   }
   return Children;
 }
 
 syntax::Leaf *syntax::TemplateDeclaration::getTemplateKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));

clang/lib/Tooling/Syntax/Synthesis.cpp

 
 clang::syntax::Leaf *syntax::createPunctuation(clang::syntax::Arena &A,
                                                clang::tok::TokenKind K) {
   auto Tokens = A.lexBuffer(llvm::MemoryBuffer::getMemBuffer(
                                 clang::tok::getPunctuatorSpelling(K)))
                     .second;
   assert(Tokens.size() == 1);
   assert(Tokens.front().kind() == K);
-  auto *L = new (A.allocator()) clang::syntax::Leaf(Tokens.begin());
+  auto *L = new (A.getAllocator()) clang::syntax::Leaf(Tokens.begin());
   FactoryImpl::setCanModify(L);
   L->assertInvariants();
   return L;
 }
 
 clang::syntax::EmptyStatement *
 syntax::createEmptyStatement(clang::syntax::Arena &A) {
-  auto *S = new (A.allocator()) clang::syntax::EmptyStatement;
+  auto *S = new (A.getAllocator()) clang::syntax::EmptyStatement;
   FactoryImpl::setCanModify(S);
   FactoryImpl::prependChildLowLevel(S, createPunctuation(A, clang::tok::semi),
                                     NodeRole::Unknown);
   S->assertInvariants();
   return S;
 }

clang/lib/Tooling/Syntax/Tree.cpp

 #include <cassert>
 
 using namespace clang;
 
 namespace {
 static void traverse(const syntax::Node *N,
                      llvm::function_ref<void(const syntax::Node *)> Visit) {
   if (auto *T = dyn_cast<syntax::Tree>(N)) {
-    for (auto *C = T->firstChild(); C; C = C->nextSibling())
+    for (auto *C = T->getFirstChild(); C; C = C->getNextSibling())
       traverse(C, Visit);
   }
   Visit(N);
 }
 static void traverse(syntax::Node *N,
                      llvm::function_ref<void(syntax::Node *)> Visit) {
   traverse(static_cast<const syntax::Node *>(N), [&](const syntax::Node *N) {
     Visit(const_cast<syntax::Node *>(N));
   });
 }
 } // namespace
 
 syntax::Arena::Arena(SourceManager &SourceMgr, const LangOptions &LangOpts,
                      const TokenBuffer &Tokens)
     : SourceMgr(SourceMgr), LangOpts(LangOpts), Tokens(Tokens) {}
 
-const syntax::TokenBuffer &syntax::Arena::tokenBuffer() const { return Tokens; }
+const syntax::TokenBuffer &syntax::Arena::getTokenBuffer() const {
+  return Tokens;
+}
 
 std::pair<FileID, ArrayRef<syntax::Token>>
 syntax::Arena::lexBuffer(std::unique_ptr<llvm::MemoryBuffer> Input) {
   auto FID = SourceMgr.createFileID(std::move(Input));
   auto It = ExtraTokens.try_emplace(FID, tokenize(FID, SourceMgr, LangOpts));
   assert(It.second && "duplicate FileID");
   return {FID, It.first->second};
 }
 
 syntax::Leaf::Leaf(const syntax::Token *Tok) : Node(NodeKind::Leaf), Tok(Tok) {
   assert(Tok != nullptr);
 }
 
 bool syntax::Leaf::classof(const Node *N) {
-  return N->kind() == NodeKind::Leaf;
+  return N->getKind() == NodeKind::Leaf;
 }
 
 syntax::Node::Node(NodeKind Kind)
     : Parent(nullptr), NextSibling(nullptr), Kind(static_cast<unsigned>(Kind)),
       Role(0), Original(false), CanModify(false) {
   this->setRole(NodeRole::Detached);
 }
 
-bool syntax::Node::isDetached() const { return role() == NodeRole::Detached; }
+bool syntax::Node::isDetached() const {
+  return getRole() == NodeRole::Detached;
+}
 
 void syntax::Node::setRole(NodeRole NR) {
   this->Role = static_cast<unsigned>(NR);
 }
 
-bool syntax::Tree::classof(const Node *N) { return N->kind() > NodeKind::Leaf; }
+bool syntax::Tree::classof(const Node *N) {
+  return N->getKind() > NodeKind::Leaf;
+}
 
 void syntax::Tree::prependChildLowLevel(Node *Child, NodeRole Role) {
-  assert(Child->role() == NodeRole::Detached);
+  assert(Child->getRole() == NodeRole::Detached);
   assert(Role != NodeRole::Detached);
 
   Child->setRole(Role);
   prependChildLowLevel(Child);
 }
 
 void syntax::Tree::prependChildLowLevel(Node *Child) {
   assert(Child->Parent == nullptr);
   assert(Child->NextSibling == nullptr);
-  assert(Child->role() != NodeRole::Detached);
+  assert(Child->getRole() != NodeRole::Detached);
 
   Child->Parent = this;
   Child->NextSibling = this->FirstChild;
   this->FirstChild = Child;
 }
 
 void syntax::Tree::replaceChildRangeLowLevel(Node *BeforeBegin, Node *End,
                                              Node *New) {
   assert(!BeforeBegin || BeforeBegin->Parent == this);
 
 #ifndef NDEBUG
-  for (auto *N = New; N; N = N->nextSibling()) {
+  for (auto *N = New; N; N = N->getNextSibling()) {
     assert(N->Parent == nullptr);
-    assert(N->role() != NodeRole::Detached && "Roles must be set");
+    assert(N->getRole() != NodeRole::Detached && "Roles must be set");
     // FIXME: sanity-check the role.
   }
 #endif
 
   // Detach old nodes.
-  for (auto *N = !BeforeBegin ? FirstChild : BeforeBegin->nextSibling();
+  for (auto *N = !BeforeBegin ? FirstChild : BeforeBegin->getNextSibling();
        N != End;) {
     auto *Next = N->NextSibling;
 
     N->setRole(NodeRole::Detached);
     N->Parent = nullptr;
     N->NextSibling = nullptr;
     if (N->Original)
       traverse(N, [&](Node *C) { C->Original = false; });
 
     N = Next;
   }
 
   // Attach new nodes.
   if (BeforeBegin)
     BeforeBegin->NextSibling = New ? New : End;
   else
     FirstChild = New ? New : End;
 
   if (New) {
     auto *Last = New;
-    for (auto *N = New; N != nullptr; N = N->nextSibling()) {
+    for (auto *N = New; N != nullptr; N = N->getNextSibling()) {
       Last = N;
       N->Parent = this;
     }
     Last->NextSibling = End;
   }
 
   // Mark the node as modified.
   for (auto *T = this; T && T->Original; T = T->Parent)
     T->Original = false;
 }
 
 namespace {
 static void dumpLeaf(raw_ostream &OS, const syntax::Leaf *L,
                      const SourceManager &SM) {
   assert(L);
-  const auto *Token = L->token();
+  const auto *Token = L->getToken();
   assert(Token);
   // Handle 'eof' separately, calling text() on it produces an empty string.
   if (Token->kind() == tok::eof)
     OS << "<eof>";
   else
     OS << Token->text(SM);
 }
 
 static void dumpNode(raw_ostream &OS, const syntax::Node *N,
                      const SourceManager &SM, std::vector<bool> IndentMask) {
   auto dumpExtraInfo = [&OS](const syntax::Node *N) {
-    if (N->role() != syntax::NodeRole::Unknown)
-      OS << " " << N->role();
+    if (N->getRole() != syntax::NodeRole::Unknown)
+      OS << " " << N->getRole();
     if (!N->isOriginal())
       OS << " synthesized";
     if (!N->canModify())
       OS << " unmodifiable";
   };
 
   assert(N);
   if (const auto *L = dyn_cast<syntax::Leaf>(N)) {
     OS << "'";
     dumpLeaf(OS, L, SM);
     OS << "'";
     dumpExtraInfo(N);
     OS << "\n";
     return;
   }
 
   const auto *T = cast<syntax::Tree>(N);
-  OS << T->kind();
+  OS << T->getKind();
   dumpExtraInfo(N);
   OS << "\n";
 
-  for (const auto *It = T->firstChild(); It; It = It->nextSibling()) {
+  for (const auto *It = T->getFirstChild(); It; It = It->getNextSibling()) {
     for (bool Filled : IndentMask) {
       if (Filled)
         OS << "| ";
       else
         OS << "  ";
     }
-    if (!It->nextSibling()) {
+    if (!It->getNextSibling()) {
       OS << "`-";
       IndentMask.push_back(false);
     } else {
       OS << "|-";
       IndentMask.push_back(true);
     }
     dumpNode(OS, It, SM, IndentMask);
     IndentMask.pop_back();
traverse(this, [&](const syntax::Node *N) {
     }
   });
   return OS.str();
 }
 
 void syntax::Node::assertInvariants() const {
 #ifndef NDEBUG
   if (isDetached())
-    assert(parent() == nullptr);
+    assert(getParent() == nullptr);
   else
-    assert(parent() != nullptr);
+    assert(getParent() != nullptr);
 
   auto *T = dyn_cast<Tree>(this);
   if (!T)
     return;
-  for (auto *C = T->firstChild(); C; C = C->nextSibling()) {
+  for (auto *C = T->getFirstChild(); C; C = C->getNextSibling()) {
     if (T->isOriginal())
       assert(C->isOriginal());
     assert(!C->isDetached());
-    assert(C->parent() == T);
+    assert(C->getParent() == T);
   }
 #endif
 }
 
 void syntax::Node::assertInvariantsRecursive() const {
 #ifndef NDEBUG
   traverse(this, [&](const syntax::Node *N) { N->assertInvariants(); });
 #endif
 }
 
-syntax::Leaf *syntax::Tree::firstLeaf() {
+syntax::Leaf *syntax::Tree::findFirstLeaf() {
   auto *T = this;
-  while (auto *C = T->firstChild()) {
+  while (auto *C = T->getFirstChild()) {
     if (auto *L = dyn_cast<syntax::Leaf>(C))
       return L;
     T = cast<syntax::Tree>(C);
   }
   return nullptr;
 }
 
-syntax::Leaf *syntax::Tree::lastLeaf() {
+syntax::Leaf *syntax::Tree::findLastLeaf() {
   auto *T = this;
-  while (auto *C = T->firstChild()) {
+  while (auto *C = T->getFirstChild()) {
     // Find the last child.
-    while (auto *Next = C->nextSibling())
+    while (auto *Next = C->getNextSibling())
       C = Next;
 
     if (auto *L = dyn_cast<syntax::Leaf>(C))
       return L;
     T = cast<syntax::Tree>(C);
   }
   return nullptr;
 }
 
 syntax::Node *syntax::Tree::findChild(NodeRole R) {
-  for (auto *C = FirstChild; C; C = C->nextSibling()) {
-    if (C->role() == R)
+  for (auto *C = FirstChild; C; C = C->getNextSibling()) {
+    if (C->getRole() == R)
       return C;
   }
   return nullptr;
 }
 
 std::vector<syntax::List::ElementAndDelimiter<syntax::Node>>
 syntax::List::getElementsAsNodesAndDelimiters() {
-  if (!firstChild())
+  if (!getFirstChild())
     return {};
 
   auto children = std::vector<syntax::List::ElementAndDelimiter<Node>>();
   syntax::Node *elementWithoutDelimiter = nullptr;
-  for (auto *C = firstChild(); C; C = C->nextSibling()) {
-    switch (C->role()) {
+  for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
+    switch (C->getRole()) {
     case syntax::NodeRole::ListElement: {
       if (elementWithoutDelimiter) {
         children.push_back({elementWithoutDelimiter, nullptr});
       }
       elementWithoutDelimiter = C;
       break;
     }
     case syntax::NodeRole::ListDelimiter: {
syntax::List::getElementsAsNodesAndDelimiters() {
   }
 
   return children;
 }
 
 // Almost the same implementation of `getElementsAsNodesAndDelimiters` but
 // ignoring delimiters
 std::vector<syntax::Node *> syntax::List::getElementsAsNodes() {
-  if (!firstChild())
+  if (!getFirstChild())
     return {};
 
   auto children = std::vector<syntax::Node *>();
   syntax::Node *elementWithoutDelimiter = nullptr;
-  for (auto *C = firstChild(); C; C = C->nextSibling()) {
-    switch (C->role()) {
+  for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
+    switch (C->getRole()) {
     case syntax::NodeRole::ListElement: {
       if (elementWithoutDelimiter) {
         children.push_back(elementWithoutDelimiter);
       }
       elementWithoutDelimiter = C;
       break;
     }
     case syntax::NodeRole::ListDelimiter: {
case syntax::List::TerminationKind::MaybeTerminated: {
     break;
   }
   }
 
   return children;
 }
 
 clang::tok::TokenKind syntax::List::getDelimiterTokenKind() {
-  switch (this->kind()) {
+  switch (this->getKind()) {
   case NodeKind::NestedNameSpecifier:
     return clang::tok::coloncolon;
   case NodeKind::CallArguments:
   case NodeKind::ParametersAndQualifiers:
     return clang::tok::comma;
   default:
     llvm_unreachable("This is not a subclass of List, thus "
                      "getDelimiterTokenKind() cannot be called");
   }
 }
 
 syntax::List::TerminationKind syntax::List::getTerminationKind() {
-  switch (this->kind()) {
+  switch (this->getKind()) {
   case NodeKind::NestedNameSpecifier:
     return TerminationKind::Terminated;
   case NodeKind::CallArguments:
   case NodeKind::ParametersAndQualifiers:
     return TerminationKind::Separated;
   default:
     llvm_unreachable("This is not a subclass of List, thus "
                      "getTerminationKind() cannot be called");
   }
 }
 
 bool syntax::List::canBeEmpty() {
-  switch (this->kind()) {
+  switch (this->getKind()) {
   case NodeKind::NestedNameSpecifier:
     return false;
   case NodeKind::CallArguments:
     return true;
   case NodeKind::ParametersAndQualifiers:
     return true;
   default:
     llvm_unreachable("This is not a subclass of List, thus canBeEmpty() "
                      "cannot be called");
   }
 }

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

::testing::AssertionResult treeDumpEqual(StringRef Code, StringRef Tree) {
     SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
 
     auto *Root = buildTree(Code, GetParam());
     if (Diags->getClient()->getNumErrors() != 0) {
       return ::testing::AssertionFailure()
              << "Source file has syntax errors, they were printed to the test "
                 "log";
     }
-    auto Actual = StringRef(Root->dump(Arena->sourceManager())).trim().str();
+    auto Actual = StringRef(Root->dump(Arena->getSourceManager())).trim().str();
     // EXPECT_EQ shows the diff between the two strings if they are different.
     EXPECT_EQ(Tree.trim().str(), Actual);
     if (Actual != Tree.trim().str()) {
       return ::testing::AssertionFailure();
     }
     return ::testing::AssertionSuccess();
   }
 
if (AnnotatedRanges.size() != TreeDumps.size()) {
                 "different "
                 "to the number of their corresponding tree dumps.";
     }
     bool Failed = false;
     for (unsigned i = 0; i < AnnotatedRanges.size(); i++) {
       auto *AnnotatedNode = nodeByRange(AnnotatedRanges[i], Root);
       assert(AnnotatedNode);
       auto AnnotatedNodeDump =
-          StringRef(AnnotatedNode->dump(Arena->sourceManager())).trim().str();
+          StringRef(AnnotatedNode->dump(Arena->getSourceManager()))
+              .trim()
+              .str();
       // EXPECT_EQ shows the diff between the two strings if they are different.
       EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump)
           << "Dumps diverged for the code:\n"
           << AnnotatedCode.code().slice(AnnotatedRanges[i].Begin,
                                         AnnotatedRanges[i].End);
       if (AnnotatedNodeDump != TreeDumps[i].trim().str())
         Failed = true;
     }

clang/unittests/Tooling/Syntax/SynthesisTest.cpp

 INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, SyntaxTreeTest,
                         ::testing::ValuesIn(allTestClangConfigs()), );
 
 TEST_P(SyntaxTreeTest, Leaf_Punctuation) {
   buildTree("", GetParam());
 
   auto *C = syntax::createPunctuation(*Arena, tok::comma);
   ASSERT_NE(C, nullptr);
-  EXPECT_EQ(C->token()->kind(), tok::comma);
+  EXPECT_EQ(C->getToken()->kind(), tok::comma);
   EXPECT_TRUE(C->canModify());
   EXPECT_FALSE(C->isOriginal());
   EXPECT_TRUE(C->isDetached());
 }
 
 TEST_P(SyntaxTreeTest, Statement_Empty) {
   buildTree("", GetParam());
 
   auto *S = syntax::createEmptyStatement(*Arena);
   ASSERT_NE(S, nullptr);
   EXPECT_TRUE(S->canModify());
   EXPECT_FALSE(S->isOriginal());
   EXPECT_TRUE(S->isDetached());
 }
 } // namespace

clang/unittests/Tooling/Syntax/TreeTestBase.cpp

 
 using namespace clang;
 using namespace clang::syntax;
 
 namespace {
 ArrayRef<syntax::Token> tokens(syntax::Node *N) {
   assert(N->isOriginal() && "tokens of modified nodes are not well-defined");
   if (auto *L = dyn_cast<syntax::Leaf>(N))
-    return llvm::makeArrayRef(L->token(), 1);
+    return llvm::makeArrayRef(L->getToken(), 1);
   auto *T = cast<syntax::Tree>(N);
-  return llvm::makeArrayRef(T->firstLeaf()->token(),
-                            T->lastLeaf()->token() + 1);
+  return llvm::makeArrayRef(T->findFirstLeaf()->getToken(),
+                            T->findLastLeaf()->getToken() + 1);
 }
 } // namespace
 
 std::vector<TestClangConfig> clang::syntax::allTestClangConfigs() {
   std::vector<TestClangConfig> all_configs;
   for (TestLanguage lang : {Lang_C89, Lang_C99, Lang_CXX03, Lang_CXX11,
                             Lang_CXX14, Lang_CXX17, Lang_CXX20}) {
     TestClangConfig config;
syntax::Node *SyntaxTreeTest::nodeByRange(llvm::Annotations::Range R,
   if (Toks.front().location().isFileID() && Toks.back().location().isFileID() &&
       syntax::Token::range(*SourceMgr, Toks.front(), Toks.back()) ==
           syntax::FileRange(SourceMgr->getMainFileID(), R.Begin, R.End))
     return Root;
 
   auto *T = dyn_cast<syntax::Tree>(Root);
   if (!T)
     return nullptr;
-  for (auto *C = T->firstChild(); C != nullptr; C = C->nextSibling()) {
+  for (auto *C = T->getFirstChild(); C != nullptr; C = C->getNextSibling()) {
     if (auto *Result = nodeByRange(R, C))
       return Result;
   }
   return nullptr;
 }