diff --git a/clang/include/clang/CMakeLists.txt b/clang/include/clang/CMakeLists.txt
index 0dc9ea5ed8ac8..feb81f0686cac 100644
--- a/clang/include/clang/CMakeLists.txt
+++ b/clang/include/clang/CMakeLists.txt
@@ -5,4 +5,3 @@ add_subdirectory(Parse)
 add_subdirectory(Sema)
 add_subdirectory(Serialization)
 add_subdirectory(StaticAnalyzer/Checkers)
-add_subdirectory(Tooling/Syntax)
diff --git a/clang/include/clang/Tooling/Syntax/CMakeLists.txt b/clang/include/clang/Tooling/Syntax/CMakeLists.txt
deleted file mode 100644
index a740015de3654..0000000000000
--- a/clang/include/clang/Tooling/Syntax/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-clang_tablegen(Nodes.inc -gen-clang-syntax-node-list
-  SOURCE Nodes.td
-  TARGET ClangSyntaxNodeList)
-
diff --git a/clang/include/clang/Tooling/Syntax/Nodes.h b/clang/include/clang/Tooling/Syntax/Nodes.h
index ed170beb75c83..33ed2ec5c3495 100644
--- a/clang/include/clang/Tooling/Syntax/Nodes.h
+++ b/clang/include/clang/Tooling/Syntax/Nodes.h
@@ -35,8 +35,82 @@ namespace syntax {
 /// blocks of enumerator constants must correspond to the inheritance hierarchy
 /// of syntax::Node.
 enum class NodeKind : uint16_t {
-#define CONCRETE_NODE(Kind, Base) Kind,
-#include "clang/Tooling/Syntax/Nodes.inc"
+  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,
 };
 /// For debugging purposes.
 raw_ostream &operator<<(raw_ostream &OS, NodeKind K);
@@ -120,7 +194,9 @@ class SimpleDeclarator;
 class TranslationUnit final : public Tree {
 public:
   TranslationUnit() : Tree(NodeKind::TranslationUnit) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::TranslationUnit;
+  }
 };
 
 /// A base class for all expressions. Note that expressions are not statements,
@@ -128,7 +204,10 @@ class TranslationUnit final : public Tree {
 class Expression : public Tree {
 public:
   Expression(NodeKind K) : Tree(K) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return NodeKind::UnknownExpression <= N->getKind() &&
+           N->getKind() <= NodeKind::CallExpression;
+  }
 };
 
 /// A sequence of these specifiers make a `nested-name-specifier`.
@@ -136,7 +215,12 @@ class Expression : public Tree {
 class NameSpecifier : public Tree {
 public:
   NameSpecifier(NodeKind K) : Tree(K) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    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
@@ -146,7 +230,9 @@ class NameSpecifier : public Tree {
 class GlobalNameSpecifier final : public NameSpecifier {
 public:
   GlobalNameSpecifier() : NameSpecifier(NodeKind::GlobalNameSpecifier) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::GlobalNameSpecifier;
+  }
 };
 
 /// A name specifier holding a decltype, of the form: `decltype ( expression ) `
@@ -154,7 +240,9 @@ class GlobalNameSpecifier final : public NameSpecifier {
 class DecltypeNameSpecifier final : public NameSpecifier {
 public:
   DecltypeNameSpecifier() : NameSpecifier(NodeKind::DecltypeNameSpecifier) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::DecltypeNameSpecifier;
+  }
 };
 
 /// A identifier name specifier, of the form `identifier`
@@ -163,7 +251,9 @@ class IdentifierNameSpecifier final : public NameSpecifier {
 public:
   IdentifierNameSpecifier()
       : NameSpecifier(NodeKind::IdentifierNameSpecifier) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::IdentifierNameSpecifier;
+  }
 };
 
 /// A name specifier with a simple-template-id, of the form `template_opt
@@ -173,7 +263,9 @@ class SimpleTemplateNameSpecifier final : public NameSpecifier {
 public:
   SimpleTemplateNameSpecifier()
       : NameSpecifier(NodeKind::SimpleTemplateNameSpecifier) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::SimpleTemplateNameSpecifier;
+  }
 };
 
 /// Models a `nested-name-specifier`. C++ [expr.prim.id.qual]
@@ -181,7 +273,9 @@ class SimpleTemplateNameSpecifier final : public NameSpecifier {
 class NestedNameSpecifier final : public List {
 public:
   NestedNameSpecifier() : List(NodeKind::NestedNameSpecifier) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() <= NodeKind::NestedNameSpecifier;
+  }
   std::vector<NameSpecifier *> getSpecifiers();
   std::vector<List::ElementAndDelimiter<syntax::NameSpecifier>>
   getSpecifiersAndDoubleColons();
@@ -192,7 +286,9 @@ class NestedNameSpecifier final : public List {
 class UnqualifiedId final : public Tree {
 public:
   UnqualifiedId() : Tree(NodeKind::UnqualifiedId) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::UnqualifiedId;
+  }
 };
 
 /// Models an `id-expression`, e.g. `std::vector<int>::size`.
@@ -205,7 +301,9 @@ class UnqualifiedId final : public Tree {
 class IdExpression final : public Expression {
 public:
   IdExpression() : Expression(NodeKind::IdExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::IdExpression;
+  }
   NestedNameSpecifier *getQualifier();
   Leaf *getTemplateKeyword();
   UnqualifiedId *getUnqualifiedId();
@@ -216,14 +314,18 @@ class IdExpression final : public Expression {
 class UnknownExpression final : public Expression {
 public:
   UnknownExpression() : Expression(NodeKind::UnknownExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    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);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ThisExpression;
+  }
   Leaf *getThisKeyword();
 };
 
@@ -235,7 +337,9 @@ class ThisExpression final : public Expression {
 class CallArguments final : public List {
 public:
   CallArguments() : List(NodeKind::CallArguments) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() <= NodeKind::CallArguments;
+  }
   std::vector<Expression *> getArguments();
   std::vector<List::ElementAndDelimiter<Expression>> getArgumentsAndCommas();
 };
@@ -247,7 +351,9 @@ class CallArguments final : public List {
 class CallExpression final : public Expression {
 public:
   CallExpression() : Expression(NodeKind::CallExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::CallExpression;
+  }
   Expression *getCallee();
   Leaf *getOpenParen();
   CallArguments *getArguments();
@@ -259,7 +365,9 @@ class CallExpression final : public Expression {
 class ParenExpression final : public Expression {
 public:
   ParenExpression() : Expression(NodeKind::ParenExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ParenExpression;
+  }
   Leaf *getOpenParen();
   Expression *getSubExpression();
   Leaf *getCloseParen();
@@ -276,7 +384,9 @@ class ParenExpression final : public Expression {
 class MemberExpression final : public Expression {
 public:
   MemberExpression() : Expression(NodeKind::MemberExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::MemberExpression;
+  }
   Expression *getObject();
   Leaf *getAccessToken();
   Leaf *getTemplateKeyword();
@@ -287,7 +397,18 @@ class MemberExpression final : public Expression {
 class LiteralExpression : public Expression {
 public:
   LiteralExpression(NodeKind K) : Expression(K) {}
-  static bool classof(const Node *N);
+  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;
+  }
   Leaf *getLiteralToken();
 };
 
@@ -296,7 +417,9 @@ class IntegerLiteralExpression final : public LiteralExpression {
 public:
   IntegerLiteralExpression()
       : LiteralExpression(NodeKind::IntegerLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::IntegerLiteralExpression;
+  }
 };
 
 /// Expression for character literals. C++ [lex.ccon]
@@ -304,7 +427,9 @@ class CharacterLiteralExpression final : public LiteralExpression {
 public:
   CharacterLiteralExpression()
       : LiteralExpression(NodeKind::CharacterLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::CharacterLiteralExpression;
+  }
 };
 
 /// Expression for floating-point literals. C++ [lex.fcon]
@@ -312,7 +437,9 @@ class FloatingLiteralExpression final : public LiteralExpression {
 public:
   FloatingLiteralExpression()
       : LiteralExpression(NodeKind::FloatingLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::FloatingLiteralExpression;
+  }
 };
 
 /// Expression for string-literals. C++ [lex.string]
@@ -320,7 +447,9 @@ class StringLiteralExpression final : public LiteralExpression {
 public:
   StringLiteralExpression()
       : LiteralExpression(NodeKind::StringLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::StringLiteralExpression;
+  }
 };
 
 /// Expression for boolean literals. C++ [lex.bool]
@@ -328,14 +457,18 @@ class BoolLiteralExpression final : public LiteralExpression {
 public:
   BoolLiteralExpression()
       : LiteralExpression(NodeKind::BoolLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    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);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::CxxNullPtrExpression;
+  }
 };
 
 /// Expression for user-defined literal. C++ [lex.ext]
@@ -347,7 +480,12 @@ class CxxNullPtrExpression final : public LiteralExpression {
 class UserDefinedLiteralExpression : public LiteralExpression {
 public:
   UserDefinedLiteralExpression(NodeKind K) : LiteralExpression(K) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    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]
@@ -357,7 +495,9 @@ class IntegerUserDefinedLiteralExpression final
   IntegerUserDefinedLiteralExpression()
       : UserDefinedLiteralExpression(
             NodeKind::IntegerUserDefinedLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::IntegerUserDefinedLiteralExpression;
+  }
 };
 
 /// Expression for user-defined-floating-point-literal. C++ [lex.ext]
@@ -367,7 +507,9 @@ class FloatUserDefinedLiteralExpression final
   FloatUserDefinedLiteralExpression()
       : UserDefinedLiteralExpression(
             NodeKind::FloatUserDefinedLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::FloatUserDefinedLiteralExpression;
+  }
 };
 
 /// Expression for user-defined-character-literal. C++ [lex.ext]
@@ -377,7 +519,9 @@ class CharUserDefinedLiteralExpression final
   CharUserDefinedLiteralExpression()
       : UserDefinedLiteralExpression(
             NodeKind::CharUserDefinedLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::CharUserDefinedLiteralExpression;
+  }
 };
 
 /// Expression for user-defined-string-literal. C++ [lex.ext]
@@ -387,14 +531,19 @@ class StringUserDefinedLiteralExpression final
   StringUserDefinedLiteralExpression()
       : UserDefinedLiteralExpression(
             NodeKind::StringUserDefinedLiteralExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    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);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::PrefixUnaryOperatorExpression ||
+           N->getKind() == NodeKind::PostfixUnaryOperatorExpression;
+  }
   Leaf *getOperatorToken();
   Expression *getOperand();
 };
@@ -412,7 +561,9 @@ class PrefixUnaryOperatorExpression final : public UnaryOperatorExpression {
 public:
   PrefixUnaryOperatorExpression()
       : UnaryOperatorExpression(NodeKind::PrefixUnaryOperatorExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::PrefixUnaryOperatorExpression;
+  }
 };
 
 /// <operand> <operator>
@@ -424,7 +575,9 @@ class PostfixUnaryOperatorExpression final : public UnaryOperatorExpression {
 public:
   PostfixUnaryOperatorExpression()
       : UnaryOperatorExpression(NodeKind::PostfixUnaryOperatorExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::PostfixUnaryOperatorExpression;
+  }
 };
 
 /// <lhs> <operator> <rhs>
@@ -437,7 +590,9 @@ class PostfixUnaryOperatorExpression final : public UnaryOperatorExpression {
 class BinaryOperatorExpression final : public Expression {
 public:
   BinaryOperatorExpression() : Expression(NodeKind::BinaryOperatorExpression) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::BinaryOperatorExpression;
+  }
   Expression *getLhs();
   Leaf *getOperatorToken();
   Expression *getRhs();
@@ -448,7 +603,10 @@ class BinaryOperatorExpression final : public Expression {
 class Statement : public Tree {
 public:
   Statement(NodeKind K) : Tree(K) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return NodeKind::UnknownStatement <= N->getKind() &&
+           N->getKind() <= NodeKind::CompoundStatement;
+  }
 };
 
 /// A statement of an unknown kind, i.e. one not currently handled by the syntax
@@ -456,28 +614,36 @@ class Statement : public Tree {
 class UnknownStatement final : public Statement {
 public:
   UnknownStatement() : Statement(NodeKind::UnknownStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    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);
+  static bool classof(const Node *N) {
+    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);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::EmptyStatement;
+  }
 };
 
 /// switch (<cond>) <body>
 class SwitchStatement final : public Statement {
 public:
   SwitchStatement() : Statement(NodeKind::SwitchStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::SwitchStatement;
+  }
   Leaf *getSwitchKeyword();
   Statement *getBody();
 };
@@ -486,7 +652,9 @@ class SwitchStatement final : public Statement {
 class CaseStatement final : public Statement {
 public:
   CaseStatement() : Statement(NodeKind::CaseStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::CaseStatement;
+  }
   Leaf *getCaseKeyword();
   Expression *getCaseValue();
   Statement *getBody();
@@ -496,7 +664,9 @@ class CaseStatement final : public Statement {
 class DefaultStatement final : public Statement {
 public:
   DefaultStatement() : Statement(NodeKind::DefaultStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::DefaultStatement;
+  }
   Leaf *getDefaultKeyword();
   Statement *getBody();
 };
@@ -506,7 +676,9 @@ class DefaultStatement final : public Statement {
 class IfStatement final : public Statement {
 public:
   IfStatement() : Statement(NodeKind::IfStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::IfStatement;
+  }
   Leaf *getIfKeyword();
   Statement *getThenStatement();
   Leaf *getElseKeyword();
@@ -517,7 +689,9 @@ class IfStatement final : public Statement {
 class ForStatement final : public Statement {
 public:
   ForStatement() : Statement(NodeKind::ForStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ForStatement;
+  }
   Leaf *getForKeyword();
   Statement *getBody();
 };
@@ -526,7 +700,9 @@ class ForStatement final : public Statement {
 class WhileStatement final : public Statement {
 public:
   WhileStatement() : Statement(NodeKind::WhileStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::WhileStatement;
+  }
   Leaf *getWhileKeyword();
   Statement *getBody();
 };
@@ -535,7 +711,9 @@ class WhileStatement final : public Statement {
 class ContinueStatement final : public Statement {
 public:
   ContinueStatement() : Statement(NodeKind::ContinueStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ContinueStatement;
+  }
   Leaf *getContinueKeyword();
 };
 
@@ -543,7 +721,9 @@ class ContinueStatement final : public Statement {
 class BreakStatement final : public Statement {
 public:
   BreakStatement() : Statement(NodeKind::BreakStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::BreakStatement;
+  }
   Leaf *getBreakKeyword();
 };
 
@@ -552,7 +732,9 @@ class BreakStatement final : public Statement {
 class ReturnStatement final : public Statement {
 public:
   ReturnStatement() : Statement(NodeKind::ReturnStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ReturnStatement;
+  }
   Leaf *getReturnKeyword();
   Expression *getReturnValue();
 };
@@ -561,7 +743,9 @@ class ReturnStatement final : public Statement {
 class RangeBasedForStatement final : public Statement {
 public:
   RangeBasedForStatement() : Statement(NodeKind::RangeBasedForStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::RangeBasedForStatement;
+  }
   Leaf *getForKeyword();
   Statement *getBody();
 };
@@ -571,7 +755,9 @@ class RangeBasedForStatement final : public Statement {
 class ExpressionStatement final : public Statement {
 public:
   ExpressionStatement() : Statement(NodeKind::ExpressionStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ExpressionStatement;
+  }
   Expression *getExpression();
 };
 
@@ -579,7 +765,9 @@ class ExpressionStatement final : public Statement {
 class CompoundStatement final : public Statement {
 public:
   CompoundStatement() : Statement(NodeKind::CompoundStatement) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::CompoundStatement;
+  }
   Leaf *getLbrace();
   /// FIXME: use custom iterator instead of 'vector'.
   std::vector<Statement *> getStatements();
@@ -593,21 +781,28 @@ class CompoundStatement final : public Statement {
 class Declaration : public Tree {
 public:
   Declaration(NodeKind K) : Tree(K) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    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);
+  static bool classof(const Node *N) {
+    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);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::EmptyDeclaration;
+  }
 };
 
 /// static_assert(<condition>, <message>)
@@ -615,7 +810,9 @@ class EmptyDeclaration final : public Declaration {
 class StaticAssertDeclaration final : public Declaration {
 public:
   StaticAssertDeclaration() : Declaration(NodeKind::StaticAssertDeclaration) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::StaticAssertDeclaration;
+  }
   Expression *getCondition();
   Expression *getMessage();
 };
@@ -626,13 +823,17 @@ class LinkageSpecificationDeclaration final : public Declaration {
 public:
   LinkageSpecificationDeclaration()
       : Declaration(NodeKind::LinkageSpecificationDeclaration) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::LinkageSpecificationDeclaration;
+  }
 };
 
 class DeclaratorList final : public List {
 public:
   DeclaratorList() : List(NodeKind::DeclaratorList) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::DeclaratorList;
+  }
   std::vector<SimpleDeclarator *> getDeclarators();
   std::vector<List::ElementAndDelimiter<syntax::SimpleDeclarator>>
   getDeclaratorsAndCommas();
@@ -644,7 +845,9 @@ class DeclaratorList final : public List {
 class SimpleDeclaration final : public Declaration {
 public:
   SimpleDeclaration() : Declaration(NodeKind::SimpleDeclaration) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::SimpleDeclaration;
+  }
   /// FIXME: use custom iterator instead of 'vector'.
   std::vector<SimpleDeclarator *> getDeclarators();
 };
@@ -653,7 +856,9 @@ class SimpleDeclaration final : public Declaration {
 class TemplateDeclaration final : public Declaration {
 public:
   TemplateDeclaration() : Declaration(NodeKind::TemplateDeclaration) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::TemplateDeclaration;
+  }
   Leaf *getTemplateKeyword();
   Declaration *getDeclaration();
 };
@@ -667,7 +872,9 @@ class ExplicitTemplateInstantiation final : public Declaration {
 public:
   ExplicitTemplateInstantiation()
       : Declaration(NodeKind::ExplicitTemplateInstantiation) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ExplicitTemplateInstantiation;
+  }
   Leaf *getTemplateKeyword();
   Leaf *getExternKeyword();
   Declaration *getDeclaration();
@@ -677,7 +884,9 @@ class ExplicitTemplateInstantiation final : public Declaration {
 class NamespaceDefinition final : public Declaration {
 public:
   NamespaceDefinition() : Declaration(NodeKind::NamespaceDefinition) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::NamespaceDefinition;
+  }
 };
 
 /// namespace <name> = <namespace-reference>
@@ -685,14 +894,18 @@ class NamespaceAliasDefinition final : public Declaration {
 public:
   NamespaceAliasDefinition()
       : Declaration(NodeKind::NamespaceAliasDefinition) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::NamespaceAliasDefinition;
+  }
 };
 
 /// using namespace <name>
 class UsingNamespaceDirective final : public Declaration {
 public:
   UsingNamespaceDirective() : Declaration(NodeKind::UsingNamespaceDirective) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::UsingNamespaceDirective;
+  }
 };
 
 /// using <scope>::<name>
@@ -700,14 +913,18 @@ class UsingNamespaceDirective final : public Declaration {
 class UsingDeclaration final : public Declaration {
 public:
   UsingDeclaration() : Declaration(NodeKind::UsingDeclaration) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::UsingDeclaration;
+  }
 };
 
 /// using <name> = <type>
 class TypeAliasDeclaration final : public Declaration {
 public:
   TypeAliasDeclaration() : Declaration(NodeKind::TypeAliasDeclaration) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::TypeAliasDeclaration;
+  }
 };
 
 /// Covers a name, an initializer and a part of the type outside declaration
@@ -725,7 +942,10 @@ class TypeAliasDeclaration final : public Declaration {
 class Declarator : public Tree {
 public:
   Declarator(NodeKind K) : Tree(K) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return NodeKind::SimpleDeclarator <= N->getKind() &&
+           N->getKind() <= NodeKind::ParenDeclarator;
+  }
 };
 
 /// A top-level declarator without parentheses. See comment of Declarator for
@@ -733,7 +953,9 @@ class Declarator : public Tree {
 class SimpleDeclarator final : public Declarator {
 public:
   SimpleDeclarator() : Declarator(NodeKind::SimpleDeclarator) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::SimpleDeclarator;
+  }
 };
 
 /// Declarator inside parentheses.
@@ -742,7 +964,9 @@ class SimpleDeclarator final : public Declarator {
 class ParenDeclarator final : public Declarator {
 public:
   ParenDeclarator() : Declarator(NodeKind::ParenDeclarator) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ParenDeclarator;
+  }
   Leaf *getLparen();
   Leaf *getRparen();
 };
@@ -754,7 +978,9 @@ class ParenDeclarator final : public Declarator {
 class ArraySubscript final : public Tree {
 public:
   ArraySubscript() : Tree(NodeKind::ArraySubscript) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ArraySubscript;
+  }
   // TODO: add an accessor for the "static" keyword.
   Leaf *getLbracket();
   Expression *getSize();
@@ -766,7 +992,9 @@ class ArraySubscript final : public Tree {
 class TrailingReturnType final : public Tree {
 public:
   TrailingReturnType() : Tree(NodeKind::TrailingReturnType) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    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
@@ -779,7 +1007,9 @@ class TrailingReturnType final : public Tree {
 class ParameterDeclarationList final : public List {
 public:
   ParameterDeclarationList() : List(NodeKind::ParameterDeclarationList) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ParameterDeclarationList;
+  }
   std::vector<SimpleDeclaration *> getParameterDeclarations();
   std::vector<List::ElementAndDelimiter<syntax::SimpleDeclaration>>
   getParametersAndCommas();
@@ -799,7 +1029,9 @@ class ParameterDeclarationList final : public List {
 class ParametersAndQualifiers final : public Tree {
 public:
   ParametersAndQualifiers() : Tree(NodeKind::ParametersAndQualifiers) {}
-  static bool classof(const Node *N);
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::ParametersAndQualifiers;
+  }
   Leaf *getLparen();
   ParameterDeclarationList *getParameters();
   Leaf *getRparen();
@@ -811,18 +1043,10 @@ class ParametersAndQualifiers final : public Tree {
 class MemberPointer final : public Tree {
 public:
   MemberPointer() : Tree(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;                                     \
+  static bool classof(const Node *N) {
+    return N->getKind() == NodeKind::MemberPointer;
   }
-#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
diff --git a/clang/include/clang/Tooling/Syntax/Nodes.td b/clang/include/clang/Tooling/Syntax/Nodes.td
deleted file mode 100644
index bd12457df3c27..0000000000000
--- a/clang/include/clang/Tooling/Syntax/Nodes.td
+++ /dev/null
@@ -1,106 +0,0 @@
-//===- 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> {}
diff --git a/clang/include/clang/Tooling/Syntax/Syntax.td b/clang/include/clang/Tooling/Syntax/Syntax.td
deleted file mode 100644
index 2e1d69190e42c..0000000000000
--- a/clang/include/clang/Tooling/Syntax/Syntax.td
+++ /dev/null
@@ -1,40 +0,0 @@
-//===- 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.
diff --git a/clang/lib/Tooling/Syntax/Nodes.cpp b/clang/lib/Tooling/Syntax/Nodes.cpp
index 0be9f1f03add6..b4d1cfd75ac56 100644
--- a/clang/lib/Tooling/Syntax/Nodes.cpp
+++ b/clang/lib/Tooling/Syntax/Nodes.cpp
@@ -630,7 +630,3 @@ 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"
diff --git a/clang/lib/Tooling/Syntax/Tree.cpp b/clang/lib/Tooling/Syntax/Tree.cpp
index 07ee13e313f50..fca2be5361cf1 100644
--- a/clang/lib/Tooling/Syntax/Tree.cpp
+++ b/clang/lib/Tooling/Syntax/Tree.cpp
@@ -52,6 +52,10 @@ 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),
@@ -67,6 +71,10 @@ 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);
@@ -337,6 +345,18 @@ const syntax::Node *syntax::Tree::findChild(NodeRole R) const {
   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())
diff --git a/clang/utils/TableGen/CMakeLists.txt b/clang/utils/TableGen/CMakeLists.txt
index 26589ec7e1ce8..41f15e2d79091 100644
--- a/clang/utils/TableGen/CMakeLists.txt
+++ b/clang/utils/TableGen/CMakeLists.txt
@@ -14,7 +14,6 @@ add_tablegen(clang-tblgen CLANG
   ClangOpenCLBuiltinEmitter.cpp
   ClangOptionDocEmitter.cpp
   ClangSACheckersEmitter.cpp
-  ClangSyntaxEmitter.cpp
   ClangTypeNodesEmitter.cpp
   MveEmitter.cpp
   NeonEmitter.cpp
diff --git a/clang/utils/TableGen/ClangSyntaxEmitter.cpp b/clang/utils/TableGen/ClangSyntaxEmitter.cpp
deleted file mode 100644
index d5ef7c97c0847..0000000000000
--- a/clang/utils/TableGen/ClangSyntaxEmitter.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//===- 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";
-}
diff --git a/clang/utils/TableGen/TableGen.cpp b/clang/utils/TableGen/TableGen.cpp
index 12d4ba6d47d13..1d6ef8065bb81 100644
--- a/clang/utils/TableGen/TableGen.cpp
+++ b/clang/utils/TableGen/TableGen.cpp
@@ -55,7 +55,6 @@ enum ActionType {
   GenClangTypeWriter,
   GenClangOpcodes,
   GenClangSACheckers,
-  GenClangSyntaxNodeList,
   GenClangCommentHTMLTags,
   GenClangCommentHTMLTagsProperties,
   GenClangCommentHTMLNamedCharacterReferences,
@@ -167,8 +166,6 @@ cl::opt<ActionType> Action(
                    "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"),
@@ -359,9 +356,6 @@ bool ClangTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
   case GenClangOpenCLBuiltins:
     EmitClangOpenCLBuiltins(Records, OS);
     break;
-  case GenClangSyntaxNodeList:
-    EmitClangSyntaxNodeList(Records, OS);
-    break;
   case GenArmNeon:
     EmitNeon(Records, OS);
     break;
diff --git a/clang/utils/TableGen/TableGenBackends.h b/clang/utils/TableGen/TableGenBackends.h
index 47e552327cb19..9717903ba52c6 100644
--- a/clang/utils/TableGen/TableGenBackends.h
+++ b/clang/utils/TableGen/TableGenBackends.h
@@ -83,9 +83,6 @@ 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);