[Syntax] Add minimal TableGen for syntax nodes. NFC

[sammccall]

Summary

So far, only used to generate Kind and implement classof().

My plan is to have this general-purpose Nodes.inc in the style of AST
DeclNodes.inc etc, and additionally a special-purpose backend generating
the actual class definitions. But baby steps...

[sammccall]

clang/lib/Tooling/Syntax/Tree.cpp

434

OK, this is not *quite* NFC:

• before this patch, List::classof(DeclaratorList*) incorrectly returned false ,now it's true...
• ...which uncovered these unhandled cases

I'll split these changes into another patch and land that first.

[gribozavr2]

clang/include/clang/Tooling/Syntax/Syntax.td

10

21

I'd suggest to add this point later if we decide to do it.

42

List is already defined in Nodes.td FWIW.

clang/utils/TableGen/ClangSyntaxEmitter.cpp

20

I personally usually avoid writing about plans in comments, but up to you.

[gribozavr2]

clang/include/clang/Tooling/Syntax/Syntax.td

32

"Records derived from NodeType correspond to syntax tree node types."

[hokein]

clang/utils/TableGen/ClangSyntaxEmitter.cpp

108

By looking at the existing tablegen patterns, I think we should invoke emitSourceFileHeader to emit the head file comments for the generated .inc file.

clang/include/clang/CMakeLists.txt

 add_subdirectory(AST)
 add_subdirectory(Basic)
 add_subdirectory(Driver)
 add_subdirectory(Parse)
 add_subdirectory(Sema)
 add_subdirectory(Serialization)
 add_subdirectory(StaticAnalyzer/Checkers)
+add_subdirectory(Tooling/Syntax)

clang/include/clang/Tooling/Syntax/CMakeLists.txt

+clang_tablegen(Nodes.inc -gen-clang-syntax-node-list
+  SOURCE Nodes.td
+  TARGET ClangSyntaxNodeList)
+

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

 #include "llvm/Support/raw_ostream.h"
 namespace clang {
 namespace syntax {
 
 /// A kind of a syntax node, used for implementing casts. The ordering and
 /// blocks of enumerator constants must correspond to the inheritance hierarchy
 /// of syntax::Node.
 enum class NodeKind : uint16_t {
-  Leaf,
-  TranslationUnit,
-
-  // Expressions.
-  UnknownExpression,
-  PrefixUnaryOperatorExpression,
-  PostfixUnaryOperatorExpression,
-  BinaryOperatorExpression,
-  ParenExpression,
-  IntegerLiteralExpression,
-  CharacterLiteralExpression,
-  FloatingLiteralExpression,
-  StringLiteralExpression,
-  BoolLiteralExpression,
-  CxxNullPtrExpression,
-  IntegerUserDefinedLiteralExpression,
-  FloatUserDefinedLiteralExpression,
-  CharUserDefinedLiteralExpression,
-  StringUserDefinedLiteralExpression,
-  IdExpression,
-  MemberExpression,
-  ThisExpression,
-  CallExpression,
-
-  // Statements.
-  UnknownStatement,
-  DeclarationStatement,
-  EmptyStatement,
-  SwitchStatement,
-  CaseStatement,
-  DefaultStatement,
-  IfStatement,
-  ForStatement,
-  WhileStatement,
-  ContinueStatement,
-  BreakStatement,
-  ReturnStatement,
-  RangeBasedForStatement,
-  ExpressionStatement,
-  CompoundStatement,
-
-  // Declarations.
-  UnknownDeclaration,
-  EmptyDeclaration,
-  StaticAssertDeclaration,
-  LinkageSpecificationDeclaration,
-  SimpleDeclaration,
-  TemplateDeclaration,
-  ExplicitTemplateInstantiation,
-  NamespaceDefinition,
-  NamespaceAliasDefinition,
-  UsingNamespaceDirective,
-  UsingDeclaration,
-  TypeAliasDeclaration,
-
-  // Declarators.
-  SimpleDeclarator,
-  ParenDeclarator,
-
-  ArraySubscript,
-  TrailingReturnType,
-  ParametersAndQualifiers,
-  MemberPointer,
-  UnqualifiedId,
-
-  // Lists
-  DeclaratorList,
-  ParameterDeclarationList,
-  CallArguments,
-  NestedNameSpecifier,
-
-  // Name Specifiers.
-  GlobalNameSpecifier,
-  DecltypeNameSpecifier,
-  IdentifierNameSpecifier,
-  SimpleTemplateNameSpecifier,
+#define CONCRETE_NODE(Kind, Base) Kind,
+#include "clang/Tooling/Syntax/Nodes.inc"
 };
 /// For debugging purposes.
 raw_ostream &operator<<(raw_ostream &OS, NodeKind K);
 
 /// A relation between a parent and child node, e.g. 'left-hand-side of
 /// a binary expression'. Used for implementing accessors.
 ///
 /// In general `NodeRole`s should be named the same as their accessors.

 raw_ostream &operator<<(raw_ostream &OS, NodeRole R);
 
 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->getKind() == NodeKind::TranslationUnit;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() &&
-           N->getKind() <= NodeKind::CallExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::GlobalNameSpecifier ||
-           N->getKind() == NodeKind::DecltypeNameSpecifier ||
-           N->getKind() == NodeKind::IdentifierNameSpecifier ||
-           N->getKind() == NodeKind::SimpleTemplateNameSpecifier;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::GlobalNameSpecifier;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::DecltypeNameSpecifier;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::IdentifierNameSpecifier;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::SimpleTemplateNameSpecifier;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() <= NodeKind::NestedNameSpecifier;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::UnqualifiedId;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::IdExpression;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::UnknownExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::ThisExpression;
-  }
+  static bool classof(const Node *N);
   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->getKind() <= NodeKind::CallArguments;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::CallExpression;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::ParenExpression;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::MemberExpression;
-  }
+  static bool classof(const Node *N);
   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->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;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::IntegerLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::CharacterLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::FloatingLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::StringLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::BoolLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::CxxNullPtrExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::IntegerUserDefinedLiteralExpression ||
-           N->getKind() == NodeKind::FloatUserDefinedLiteralExpression ||
-           N->getKind() == NodeKind::CharUserDefinedLiteralExpression ||
-           N->getKind() == NodeKind::StringUserDefinedLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::IntegerUserDefinedLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::FloatUserDefinedLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::CharUserDefinedLiteralExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::StringUserDefinedLiteralExpression;
-  }
+  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->getKind() == NodeKind::PrefixUnaryOperatorExpression ||
-           N->getKind() == NodeKind::PostfixUnaryOperatorExpression;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::PrefixUnaryOperatorExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// <operand> <operator>
 ///
 /// For example:
 ///   a++
 ///   b--
 class PostfixUnaryOperatorExpression final : public UnaryOperatorExpression {
 public:
   PostfixUnaryOperatorExpression()
       : UnaryOperatorExpression(NodeKind::PostfixUnaryOperatorExpression) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::PostfixUnaryOperatorExpression;
-  }
+  static bool classof(const Node *N);
 };
 
 /// <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->getKind() == NodeKind::BinaryOperatorExpression;
-  }
+  static bool classof(const Node *N);
   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->getKind() &&
-           N->getKind() <= NodeKind::CompoundStatement;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::UnknownStatement;
-  }
+  static bool classof(const Node *N);
 };
 
 /// E.g. 'int a, b = 10;'
 class DeclarationStatement final : public Statement {
 public:
   DeclarationStatement() : Statement(NodeKind::DeclarationStatement) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::DeclarationStatement;
-  }
+  static bool classof(const Node *N);
 };
 
 /// The no-op statement, i.e. ';'.
 class EmptyStatement final : public Statement {
 public:
   EmptyStatement() : Statement(NodeKind::EmptyStatement) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::EmptyStatement;
-  }
+  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->getKind() == NodeKind::SwitchStatement;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::CaseStatement;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::DefaultStatement;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::IfStatement;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::ForStatement;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::WhileStatement;
-  }
+  static bool classof(const Node *N);
   Leaf *getWhileKeyword();
   Statement *getBody();
 };
 
 /// continue;
 class ContinueStatement final : public Statement {
 public:
   ContinueStatement() : Statement(NodeKind::ContinueStatement) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::ContinueStatement;
-  }
+  static bool classof(const Node *N);
   Leaf *getContinueKeyword();
 };
 
 /// break;
 class BreakStatement final : public Statement {
 public:
   BreakStatement() : Statement(NodeKind::BreakStatement) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::BreakStatement;
-  }
+  static bool classof(const Node *N);
   Leaf *getBreakKeyword();
 };
 
 /// return <expr>;
 /// return;
 class ReturnStatement final : public Statement {
 public:
   ReturnStatement() : Statement(NodeKind::ReturnStatement) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::ReturnStatement;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::RangeBasedForStatement;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::ExpressionStatement;
-  }
+  static bool classof(const Node *N);
   Expression *getExpression();
 };
 
 /// { statement1; statement2; … }
 class CompoundStatement final : public Statement {
 public:
   CompoundStatement() : Statement(NodeKind::CompoundStatement) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::CompoundStatement;
-  }
+  static bool classof(const Node *N);
   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->getKind() &&
-           N->getKind() <= NodeKind::TypeAliasDeclaration;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::UnknownDeclaration;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::EmptyDeclaration;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::StaticAssertDeclaration;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::LinkageSpecificationDeclaration;
-  }
+  static bool classof(const Node *N);
 };
 
 class DeclaratorList final : public List {
 public:
   DeclaratorList() : List(NodeKind::DeclaratorList) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::DeclaratorList;
-  }
+  static bool classof(const Node *N);
   std::vector<SimpleDeclarator *> getDeclarators();
   std::vector<List::ElementAndDelimiter<syntax::SimpleDeclarator>>
   getDeclaratorsAndCommas();
 };
 
 /// 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->getKind() == NodeKind::SimpleDeclaration;
-  }
+  static bool classof(const Node *N);
   /// 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->getKind() == NodeKind::TemplateDeclaration;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::ExplicitTemplateInstantiation;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::NamespaceDefinition;
-  }
+  static bool classof(const Node *N);
 };
 
 /// namespace <name> = <namespace-reference>
 class NamespaceAliasDefinition final : public Declaration {
 public:
   NamespaceAliasDefinition()
       : Declaration(NodeKind::NamespaceAliasDefinition) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::NamespaceAliasDefinition;
-  }
+  static bool classof(const Node *N);
 };
 
 /// using namespace <name>
 class UsingNamespaceDirective final : public Declaration {
 public:
   UsingNamespaceDirective() : Declaration(NodeKind::UsingNamespaceDirective) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::UsingNamespaceDirective;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::UsingDeclaration;
-  }
+  static bool classof(const Node *N);
 };
 
 /// using <name> = <type>
 class TypeAliasDeclaration final : public Declaration {
 public:
   TypeAliasDeclaration() : Declaration(NodeKind::TypeAliasDeclaration) {}
-  static bool classof(const Node *N) {
-    return N->getKind() == NodeKind::TypeAliasDeclaration;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() &&
-           N->getKind() <= NodeKind::ParenDeclarator;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::SimpleDeclarator;
-  }
+  static bool classof(const Node *N);
 };
 
 /// 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->getKind() == NodeKind::ParenDeclarator;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::ArraySubscript;
-  }
+  static bool classof(const Node *N);
   // 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->getKind() == NodeKind::TrailingReturnType;
-  }
+  static bool classof(const Node *N);
   // 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->getKind() == NodeKind::ParameterDeclarationList;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::ParametersAndQualifiers;
-  }
+  static bool classof(const Node *N);
   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->getKind() == NodeKind::MemberPointer;
-  }
+  static bool classof(const Node *N);
 };
 
+#define CONCRETE_NODE(Kind, Base)                                              \
+  inline bool Kind::classof(const Node *N) {                                   \
+    return N->getKind() == NodeKind::Kind;                                     \
+  }
+#define ABSTRACT_NODE(Kind, Base, First, Last)                                 \
+  inline bool Kind::classof(const Node *N) {                                   \
+    return N->getKind() >= NodeKind::First && N->getKind() <= NodeKind::Last;  \
+  }
+#include "clang/Tooling/Syntax/Nodes.inc"
+
 } // namespace syntax
 } // namespace clang
 #endif

clang/include/clang/Tooling/Syntax/Nodes.td

+//===- Nodes.td - Node types in the Syntax Tree grammar -------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines concrete nodes in the syntax tree.
+// The archetypes they fall into (Sequence, List etc) are defined in Syntax.td.
+//
+// The C++ classes for the archetypes themselves are written by hand, and the
+// concrete node classes will be generated. Migration to TableGen is not
+// complete, so currently there is a mix of generated and hand-authored code.
+//
+//===----------------------------------------------------------------------===//
+
+include "clang/Tooling/Syntax/Syntax.td"
+
+def Node : External<?> {}
+def Leaf : External<Node> {}
+def Tree : External<Node> {}
+
+def TranslationUnit : External<Tree> {}
+
+def Expression : External<Tree> {}
+def UnknownExpression : External<Expression> {}
+def UnaryOperatorExpression : External<Tree> {}
+def PrefixUnaryOperatorExpression : External<UnaryOperatorExpression> {}
+def PostfixUnaryOperatorExpression : External<UnaryOperatorExpression> {}
+def BinaryOperatorExpression : External<Expression> {}
+def ParenExpression : External<Expression> {}
+def LiteralExpression : External<Expression> {}
+def IntegerLiteralExpression : External<LiteralExpression> {}
+def CharacterLiteralExpression : External<LiteralExpression> {}
+def FloatingLiteralExpression : External<LiteralExpression> {}
+def StringLiteralExpression : External<LiteralExpression> {}
+def BoolLiteralExpression : External<LiteralExpression> {}
+def CxxNullPtrExpression : External<LiteralExpression> {}
+def UserDefinedLiteralExpression : External<LiteralExpression> {}
+def IntegerUserDefinedLiteralExpression : External<UserDefinedLiteralExpression> {}
+def FloatUserDefinedLiteralExpression : External<UserDefinedLiteralExpression> {}
+def CharUserDefinedLiteralExpression : External<UserDefinedLiteralExpression> {}
+def StringUserDefinedLiteralExpression : External<UserDefinedLiteralExpression> {}
+def IdExpression : External<Expression> {}
+def MemberExpression : External<Expression> {}
+def ThisExpression : External<Expression> {}
+def CallExpression : External<Expression> {}
+
+// Statements.
+def Statement : External<Tree> {}
+def UnknownStatement : External<Statement> {}
+def DeclarationStatement : External<Statement> {}
+def EmptyStatement : External<Statement> {}
+def SwitchStatement : External<Statement> {}
+def CaseStatement : External<Statement> {}
+def DefaultStatement : External<Statement> {}
+def IfStatement : External<Statement> {}
+def ForStatement : External<Statement> {}
+def WhileStatement : External<Statement> {}
+def ContinueStatement : External<Statement> {}
+def BreakStatement : External<Statement> {}
+def ReturnStatement : External<Statement> {}
+def RangeBasedForStatement : External<Statement> {}
+def ExpressionStatement : External<Statement> {}
+def CompoundStatement : External<Statement> {}
+
+// Declarations.
+def Declaration : External<Tree> {}
+def UnknownDeclaration : External<Declaration> {}
+def EmptyDeclaration : External<Declaration> {}
+def StaticAssertDeclaration : External<Declaration> {}
+def LinkageSpecificationDeclaration : External<Declaration> {}
+def SimpleDeclaration : External<Declaration> {}
+def TemplateDeclaration : External<Declaration> {}
+def ExplicitTemplateInstantiation : External<Declaration> {}
+def NamespaceDefinition : External<Declaration> {}
+def NamespaceAliasDefinition : External<Declaration> {}
+def UsingNamespaceDirective : External<Declaration> {}
+def UsingDeclaration : External<Declaration> {}
+def TypeAliasDeclaration : External<Declaration> {}
+
+// Declarators.
+def Declarator : External<Tree> {}
+def SimpleDeclarator : External<Declarator> {}
+def ParenDeclarator : External<Declarator> {}
+
+def ArraySubscript : External<Tree> {}
+def TrailingReturnType : External<Tree> {}
+def ParametersAndQualifiers : External<Tree> {}
+def MemberPointer : External<Tree> {}
+def UnqualifiedId : External<Tree> {}
+
+// Lists
+def List : External<Tree> {}
+def DeclaratorList : External<List> {}
+def ParameterDeclarationList : External<List> {}
+def CallArguments : External<List> {}
+def NestedNameSpecifier : External<List> {}
+
+// Name Specifiers.
+def NameSpecifier : External<Tree> {}
+def GlobalNameSpecifier : External<NameSpecifier> {}
+def DecltypeNameSpecifier : External<NameSpecifier> {}
+def IdentifierNameSpecifier : External<NameSpecifier> {}
+def SimpleTemplateNameSpecifier : External<NameSpecifier> {}

clang/include/clang/Tooling/Syntax/Syntax.td

+//===- Syntax.td - TableGen metamodel for syntax::Node hierarchy ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// The tree representation of the is C++ syntax is quite regular.
+//
+// There are 4 archetypes of nodes in the syntax tree:
+//  - Leaves, owning exactly one token. (syntax::Leaf)
+//  - Sequences, with a fixed list of children that should appear in order.
+//    The concrete node defines a Role sequence which identifies the children.
+//    The type of child in each role is also constrained.
+//  - Lists, with children in alternating Element/Delimiter roles. (syntax::List)
+//    The concrete node defines the element type, delimiters are always leaves.
+//  - Alternatives, where several different node types are allowed.
+//    These are modeled as abstract types with inheritance (e.g. Declaration).
+//
+// This file defines TableGen classes modelling these archetypes.
+// The concrete nodes are defined in terms of these classes in Nodes.td.
+//
+// The C++ classes for the archetypes themselves are written by hand, and the
+// concrete node classes will be generated. Migration to TableGen is not
+// complete, so currently there is a mix of generated and hand-authored code.
+//
+//===----------------------------------------------------------------------===//
+
+// Defs derived from NodeType correspond to syntax tree node types.
+class NodeType {
+  // The NodeType that this node is derived from in the Node class hierarchy.
+  NodeType base = ?;
+}
+
+// A node type which is defined in Nodes.h rather than by generated code.
+// We merely specify the inheritance hierarchy here.
+class External<NodeType base_> : NodeType { let base = base_; }
+
+// FIXME: add sequence, list, and alternative archetypes.

clang/lib/Tooling/Syntax/Nodes.cpp

syntax::Leaf *syntax::ParametersAndQualifiers::getRparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::TrailingReturnType *
 syntax::ParametersAndQualifiers::getTrailingReturn() {
   return cast_or_null<syntax::TrailingReturnType>(
       findChild(syntax::NodeRole::TrailingReturn));
 }
+
+#define NODE(Kind, Parent)                                                     \
+  static_assert(sizeof(syntax::Kind) > 0, "Missing Node subclass definition");
+#include "clang/Tooling/Syntax/Nodes.inc"

clang/lib/Tooling/Syntax/Tree.cpp

syntax::Arena::lexBuffer(std::unique_ptr<llvm::MemoryBuffer> Input) {
   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->getKind() == NodeKind::Leaf;
-}
-
 syntax::Node::Node(NodeKind Kind)
     : Parent(nullptr), NextSibling(nullptr), PreviousSibling(nullptr),
       Kind(static_cast<unsigned>(Kind)), Role(0), Original(false),
       CanModify(false) {
   this->setRole(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->getKind() > NodeKind::Leaf;
-}
-
 void syntax::Tree::appendChildLowLevel(Node *Child, NodeRole Role) {
   assert(Child->getRole() == NodeRole::Detached);
   assert(Role != NodeRole::Detached);
 
   Child->setRole(Role);
   appendChildLowLevel(Child);
 }
 

 const syntax::Node *syntax::Tree::findChild(NodeRole R) const {
   for (const Node &C : getChildren()) {
     if (C.getRole() == R)
       return &C;
   }
   return nullptr;
 }
 
-bool syntax::List::classof(const syntax::Node *N) {
-  switch (N->getKind()) {
-  case syntax::NodeKind::NestedNameSpecifier:
-  case syntax::NodeKind::CallArguments:
-  case syntax::NodeKind::ParameterDeclarationList:
-  case syntax::NodeKind::DeclaratorList:
-    return true;
-  default:
-    return false;
-  }
-}
-
 std::vector<syntax::List::ElementAndDelimiter<syntax::Node>>
 syntax::List::getElementsAsNodesAndDelimiters() {
   if (!getFirstChild())
     return {};
 
   std::vector<syntax::List::ElementAndDelimiter<Node>> Children;
   syntax::Node *ElementWithoutDelimiter = nullptr;
   for (Node &C : getChildren()) {

 }
 
 clang::tok::TokenKind syntax::List::getDelimiterTokenKind() const {
   switch (this->getKind()) {
   case NodeKind::NestedNameSpecifier:
     return clang::tok::coloncolon;
   case NodeKind::CallArguments:
   case NodeKind::ParameterDeclarationList:
   case NodeKind::DeclaratorList:
     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() const {

clang/utils/TableGen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS Support)
 
 add_tablegen(clang-tblgen CLANG
   ASTTableGen.cpp
   ClangASTNodesEmitter.cpp
   ClangASTPropertiesEmitter.cpp
   ClangAttrEmitter.cpp
   ClangCommentCommandInfoEmitter.cpp
   ClangCommentHTMLNamedCharacterReferenceEmitter.cpp
   ClangCommentHTMLTagsEmitter.cpp
   ClangDataCollectorsEmitter.cpp
   ClangDiagnosticsEmitter.cpp
   ClangOpcodesEmitter.cpp
   ClangOpenCLBuiltinEmitter.cpp
   ClangOptionDocEmitter.cpp
   ClangSACheckersEmitter.cpp
+  ClangSyntaxEmitter.cpp
   ClangTypeNodesEmitter.cpp
   MveEmitter.cpp
   NeonEmitter.cpp
   SveEmitter.cpp
   TableGen.cpp
   )
 set_target_properties(clang-tblgen PROPERTIES FOLDER "Clang tablegenning")

clang/utils/TableGen/ClangSyntaxEmitter.cpp

+//===- ClangSyntaxEmitter.cpp - Generate clang Syntax Tree nodes ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// These backends consume the definitions of Syntax Tree nodes.
+// See clang/include/clang/Tooling/Syntax/{Syntax,Nodes}.td
+//
+// The -gen-clang-syntax-node-list backend produces a .inc with macro calls
+//   NODE(Kind, BaseKind)
+//   ABSTRACT_NODE(Type, Base, FirstKind, LastKind)
+// similar to those for AST nodes such as AST/DeclNodes.inc.
+//
+// In future, the class definitions will be produced by additional backends.
+//
+//===----------------------------------------------------------------------===//
+#include "TableGenBackends.h"
+
+#include <deque>
+
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
+
+namespace {
+
+// The class hierarchy of Node types.
+// We assemble this in order to be able to define the NodeKind enum in a
+// stable and useful way, where abstract Node subclasses correspond to ranges.
+class Hierarchy {
+public:
+  Hierarchy(const llvm::RecordKeeper &Records) {
+    for (llvm::Record *T : Records.getAllDerivedDefinitions("NodeType"))
+      add(T);
+    for (llvm::Record *Derived : Records.getAllDerivedDefinitions("NodeType"))
+      if (llvm::Record *Base = Derived->getValueAsOptionalDef("base"))
+        link(Derived, Base);
+    for (NodeType &N : AllTypes)
+      llvm::sort(N.Derived, [](const NodeType *L, const NodeType *R) {
+        return L->Record->getName() < R->Record->getName();
+      });
+  }
+
+  struct NodeType {
+    const llvm::Record *Record = nullptr;
+    const NodeType *Base = nullptr;
+    std::vector<const NodeType *> Derived;
+    llvm::StringRef name() const { return Record->getName(); }
+  };
+
+  NodeType &get(llvm::StringRef Name = "Node") {
+    auto NI = ByName.find(Name);
+    assert(NI != ByName.end() && "no such node");
+    return *NI->second;
+  }
+
+private:
+  void add(const llvm::Record *R) {
+    AllTypes.emplace_back();
+    AllTypes.back().Record = R;
+    assert(ByName.try_emplace(R->getName(), &AllTypes.back()).second &&
+           "Duplicate node name");
+  }
+
+  void link(const llvm::Record *Derived, const llvm::Record *Base) {
+    auto &CN = get(Derived->getName()), &PN = get(Base->getName());
+    assert(CN.Base == nullptr && "setting base twice");
+    PN.Derived.push_back(&CN);
+    CN.Base = &PN;
+  }
+
+  std::deque<NodeType> AllTypes;
+  llvm::DenseMap<llvm::StringRef, NodeType *> ByName;
+};
+
+const Hierarchy::NodeType &firstConcrete(const Hierarchy::NodeType &N) {
+  return N.Derived.empty() ? N : firstConcrete(*N.Derived.front());
+}
+const Hierarchy::NodeType &lastConcrete(const Hierarchy::NodeType &N) {
+  return N.Derived.empty() ? N : lastConcrete(*N.Derived.back());
+}
+
+void emitNodeList(const Hierarchy::NodeType &N, llvm::raw_ostream &OS) {
+  // Don't emit ABSTRACT_NODE for node itself, which has no parent.
+  if (N.Base != nullptr) {
+    if (N.Derived.empty())
+      OS << llvm::formatv("CONCRETE_NODE({0},{1})\n", N.name(), N.Base->name());
+    else
+      OS << llvm::formatv("ABSTRACT_NODE({0},{1},{2},{3})\n", N.name(),
+                          N.Base->name(), firstConcrete(N).name(),
+                          lastConcrete(N).name());
+  }
+  for (const auto *C : N.Derived)
+    emitNodeList(*C, OS);
+}
+
+} // namespace
+
+void clang::EmitClangSyntaxNodeList(llvm::RecordKeeper &Records,
+                                    llvm::raw_ostream &OS) {
+  llvm::emitSourceFileHeader("Syntax tree node list", OS);
+  OS << "// Generated from " << Records.getInputFilename() << "\n";
+  OS << R"cpp(
+#ifndef NODE
+#define NODE(Kind, Base)
+#endif
+
+#ifndef CONCRETE_NODE
+#define CONCRETE_NODE(Kind, Base) NODE(Kind, Base)
+#endif
+
+#ifndef ABSTRACT_NODE
+#define ABSTRACT_NODE(Kind, Base, First, Last) NODE(Kind, Base)
+#endif
+
+)cpp";
+  emitNodeList(Hierarchy(Records).get(), OS);
+  OS << R"cpp(
+#undef NODE
+#undef CONCRETE_NODE
+#undef ABSTRACT_NODE
+)cpp";
+}

clang/utils/TableGen/TableGen.cpp

enum ActionType {
   GenClangCommentNodes,
   GenClangDeclNodes,
   GenClangStmtNodes,
   GenClangTypeNodes,
   GenClangTypeReader,
   GenClangTypeWriter,
   GenClangOpcodes,
   GenClangSACheckers,
+  GenClangSyntaxNodeList,
   GenClangCommentHTMLTags,
   GenClangCommentHTMLTagsProperties,
   GenClangCommentHTMLNamedCharacterReferences,
   GenClangCommentCommandInfo,
   GenClangCommentCommandList,
   GenClangOpenCLBuiltins,
   GenArmNeon,
   GenArmFP16,
cl::values(
         clEnumValN(GenClangTypeReader, "gen-clang-type-reader",
                    "Generate Clang AbstractTypeReader class"),
         clEnumValN(GenClangTypeWriter, "gen-clang-type-writer",
                    "Generate Clang AbstractTypeWriter class"),
         clEnumValN(GenClangOpcodes, "gen-clang-opcodes",
                    "Generate Clang constexpr interpreter opcodes"),
         clEnumValN(GenClangSACheckers, "gen-clang-sa-checkers",
                    "Generate Clang Static Analyzer checkers"),
+        clEnumValN(GenClangSyntaxNodeList, "gen-clang-syntax-node-list",
+                   "Generate list of Clang Syntax Tree node types"),
         clEnumValN(GenClangCommentHTMLTags, "gen-clang-comment-html-tags",
                    "Generate efficient matchers for HTML tag "
                    "names that are used in documentation comments"),
         clEnumValN(GenClangCommentHTMLTagsProperties,
                    "gen-clang-comment-html-tags-properties",
                    "Generate efficient matchers for HTML tag "
                    "properties"),
         clEnumValN(GenClangCommentHTMLNamedCharacterReferences,
case GenClangCommentCommandInfo:
     EmitClangCommentCommandInfo(Records, OS);
     break;
   case GenClangCommentCommandList:
     EmitClangCommentCommandList(Records, OS);
     break;
   case GenClangOpenCLBuiltins:
     EmitClangOpenCLBuiltins(Records, OS);
     break;
+  case GenClangSyntaxNodeList:
+    EmitClangSyntaxNodeList(Records, OS);
+    break;
   case GenArmNeon:
     EmitNeon(Records, OS);
     break;
   case GenArmFP16:
     EmitFP16(Records, OS);
     break;
   case GenArmBF16:
     EmitBF16(Records, OS);

clang/utils/TableGen/TableGenBackends.h

void EmitClangCommentHTMLNamedCharacterReferences(llvm::RecordKeeper &Records,
                                                   llvm::raw_ostream &OS);
 
 void EmitClangCommentCommandInfo(llvm::RecordKeeper &Records,
                                  llvm::raw_ostream &OS);
 void EmitClangCommentCommandList(llvm::RecordKeeper &Records,
                                  llvm::raw_ostream &OS);
 void EmitClangOpcodes(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
+void EmitClangSyntaxNodeList(llvm::RecordKeeper &Records,
+                             llvm::raw_ostream &OS);
+
 void EmitNeon(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitFP16(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitBF16(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeonSema(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeonTest(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeon2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeonSema2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeonTest2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);