Using macros

Still broken due to missing classes

src/CppParser/ASTNodeVisitor.h

@@ -18,528 +18,522 @@
 #include "clang/AST/CommentCommandTraits.h"
 #include "clang/AST/CommentVisitor.h"
 #include "clang/AST/ExprConcepts.h"
+#include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/Type.h"
 
 #include <unordered_set>
 
+#include "Decl.h"
+#include "Stmt.h"
+
 namespace CppSharp::CppParser {
-    namespace AST {
+namespace AST {
-        class Stmt;
+    class Stmt;
+
+    // TODO: Remove this once we have proper type conversions
+    using Decl = Declaration;
+} // namespace AST
+class Parser;
+
+class NodeStreamer
+{
+    bool FirstChild = true;
+    bool TopLevel = true;
+    llvm::SmallVector<std::function<void(bool IsLastChild)>, 32> Pending;
+
+protected:
+    llvm::json::OStream JOS;
+
+public:
+    /// Add a child of the current node.  Calls DoAddChild without arguments
+    template <typename Fn>
+    void AddChild(Fn DoAddChild)
+    {
+        return AddChild("", DoAddChild);
     }
-    class Parser;
 
-    class NodeStreamer
+    /// Add a child of the current node with an optional label.
+    /// Calls DoAddChild without arguments.
+    template <typename Fn>
+    void AddChild(llvm::StringRef Label, Fn DoAddChild)
     {
-        bool FirstChild = true;
+        // If we're at the top level, there's nothing interesting to do; just
-        bool TopLevel = true;
+        // run the dumper.
-        llvm::SmallVector<std::function<void(bool IsLastChild)>, 32> Pending;
+        if (TopLevel)
+        {
+            TopLevel = false;
+            JOS.objectBegin();
 
-    protected:
+            DoAddChild();
-        llvm::json::OStream JOS;
 
-    public:
+            while (!Pending.empty())
-        /// Add a child of the current node.  Calls DoAddChild without arguments
+            {
-        template <typename Fn>
+                Pending.back()(true);
-        void AddChild(Fn DoAddChild)
+                Pending.pop_back();
-        {
+            }
-            return AddChild("", DoAddChild);
+
+            JOS.objectEnd();
+            TopLevel = true;
+            return;
         }
 
-        /// Add a child of the current node with an optional label.
+        // We need to capture an owning-string in the lambda because the lambda
-        /// Calls DoAddChild without arguments.
+        // is invoked in a deferred manner.
-        template <typename Fn>
+        std::string LabelStr(!Label.empty() ? Label : "inner");
-        void AddChild(llvm::StringRef Label, Fn DoAddChild)
+        bool WasFirstChild = FirstChild;
+        auto DumpWithIndent = [=](bool IsLastChild)
         {
-            // If we're at the top level, there's nothing interesting to do; just
+            if (WasFirstChild)
-            // run the dumper.
-            if (TopLevel)
             {
-                TopLevel = false;
+                JOS.attributeBegin(LabelStr);
-                JOS.objectBegin();
+                JOS.arrayBegin();
+            }
 
-                DoAddChild();
+            FirstChild = true;
+            unsigned Depth = Pending.size();
+            JOS.objectBegin();
 
-                while (!Pending.empty())
+            DoAddChild();
-                {
-                    Pending.back()(true);
-                    Pending.pop_back();
-                }
 
-                JOS.objectEnd();
+            // If any children are left, they're the last at their nesting level.
-                TopLevel = true;
+            // Dump those ones out now.
-                return;
+            while (Depth < Pending.size())
-            }
-
-            // We need to capture an owning-string in the lambda because the lambda
-            // is invoked in a deferred manner.
-            std::string LabelStr(!Label.empty() ? Label : "inner");
-            bool WasFirstChild = FirstChild;
-            auto DumpWithIndent = [=](bool IsLastChild)
-            {
-                if (WasFirstChild)
-                {
-                    JOS.attributeBegin(LabelStr);
-                    JOS.arrayBegin();
-                }
-
-                FirstChild = true;
-                unsigned Depth = Pending.size();
-                JOS.objectBegin();
-
-                DoAddChild();
-
-                // If any children are left, they're the last at their nesting level.
-                // Dump those ones out now.
-                while (Depth < Pending.size())
-                {
-                    Pending.back()(true);
-                    this->Pending.pop_back();
-                }
-
-                JOS.objectEnd();
-
-                if (IsLastChild)
-                {
-                    JOS.arrayEnd();
-                    JOS.attributeEnd();
-                }
-            };
-
-            if (FirstChild)
             {
-                Pending.push_back(std::move(DumpWithIndent));
+                Pending.back()(true);
+                this->Pending.pop_back();
             }
-            else
+
+            JOS.objectEnd();
+
+            if (IsLastChild)
             {
-                Pending.back()(false);
+                JOS.arrayEnd();
-                Pending.back() = std::move(DumpWithIndent);
+                JOS.attributeEnd();
             }
-            FirstChild = false;
+        };
-        }
 
-        NodeStreamer(llvm::raw_ostream& OS)
+        if (FirstChild)
-            : JOS(OS, 2)
         {
+            Pending.push_back(std::move(DumpWithIndent));
         }
-    };
+        else
-
-    // Dumps AST nodes in JSON format. There is no implied stability for the
-    // content or format of the dump between major releases of Clang, other than it
-    // being valid JSON output. Further, there is no requirement that the
-    // information dumped is a complete representation of the AST, only that the
-    // information presented is correct.
-    class ASTNodeVisitor
-        : public clang::ConstAttrVisitor<ASTNodeVisitor>,
-          public clang::comments::ConstCommentVisitor<ASTNodeVisitor, void, const clang::comments::FullComment*>,
-          public clang::ConstTemplateArgumentVisitor<ASTNodeVisitor>,
-          public clang::ConstStmtVisitor<ASTNodeVisitor>,
-          public clang::TypeVisitor<ASTNodeVisitor>,
-          public clang::ConstDeclVisitor<ASTNodeVisitor, AST::Declaration*>,
-          public NodeStreamer
-    {
-        friend class ASTNodeDumper;
-
-        using InnerAttrVisitor = ConstAttrVisitor;
-        using InnerCommentVisitor = ConstCommentVisitor;
-        using InnerTemplateArgVisitor = ConstTemplateArgumentVisitor;
-        using InnerStmtVisitor = ConstStmtVisitor;
-        using InnerTypeVisitor = TypeVisitor;
-        using InnerDeclVisitor = ConstDeclVisitor;
-
-    public:
-        ASTNodeVisitor(llvm::raw_ostream& OS, clang::ASTContext& Ctx, Parser& parser)
-            : NodeStreamer(OS)
-            , parser(parser)
-            , SM(Ctx.getSourceManager())
-            , Ctx(Ctx)
-            , NameMangler(Ctx)
-            , PrintPolicy(Ctx.getPrintingPolicy())
-            , Traits(Ctx.getCommentCommandTraits())
-            , LastLocLine(0)
-            , LastLocPresumedLine(0)
         {
-            declMap.reserve(32768);
+            Pending.back()(false);
-            typeMap.reserve(32768);
+            Pending.back() = std::move(DumpWithIndent);
-            stmtMap.reserve(32768);
         }
+        FirstChild = false;
+    }
 
-        void Visit(const clang::Attr* A);
+    NodeStreamer(llvm::raw_ostream& OS)
-        void Visit(const clang::Stmt* S);
+        : JOS(OS, 2)
-        void Visit(const clang::Type* T);
+    {
-        void Visit(clang::QualType T);
+    }
-        AST::Declaration* Visit(const clang::Decl* D);
+};
-        void Visit(clang::TypeLoc TL);
+
-
+// Dumps AST nodes in JSON format. There is no implied stability for the
-        void Visit(const clang::comments::Comment* C, const clang::comments::FullComment* FC);
+// content or format of the dump between major releases of Clang, other than it
-        void Visit(const clang::TemplateArgument& TA, clang::SourceRange R = {}, const clang::Decl* From = nullptr, llvm::StringRef Label = {});
+// being valid JSON output. Further, there is no requirement that the
-        void Visit(const clang::CXXCtorInitializer* Init);
+// information dumped is a complete representation of the AST, only that the
-        // void Visit(const OpenACCClause* C) {}
+// information presented is correct.
-        void Visit(const clang::OMPClause* C) {}
+class ASTNodeVisitor
-        void Visit(const clang::BlockDecl::Capture& C);
+    : public clang::ConstAttrVisitor<ASTNodeVisitor>,
-        void Visit(const clang::GenericSelectionExpr::ConstAssociation& A);
+      public clang::comments::ConstCommentVisitor<ASTNodeVisitor, void, const clang::comments::FullComment*>,
-        void Visit(const clang::concepts::Requirement* R);
+      public clang::ConstTemplateArgumentVisitor<ASTNodeVisitor>,
-        void Visit(const clang::APValue& Value, clang::QualType Ty);
+      public clang::ConstStmtVisitor<ASTNodeVisitor>,
-        void Visit(const clang::ConceptReference*);
+      public clang::TypeVisitor<ASTNodeVisitor>,
-
+      public clang::ConstDeclVisitor<ASTNodeVisitor, AST::Declaration*>,
-        void VisitAliasAttr(const clang::AliasAttr* AA);
+      public NodeStreamer
-        void VisitCleanupAttr(const clang::CleanupAttr* CA);
+{
-        void VisitDeprecatedAttr(const clang::DeprecatedAttr* DA);
+    friend class ASTNodeDumper;
-        void VisitUnavailableAttr(const clang::UnavailableAttr* UA);
+
-        void VisitSectionAttr(const clang::SectionAttr* SA);
+    using InnerAttrVisitor = ConstAttrVisitor;
-        void VisitVisibilityAttr(const clang::VisibilityAttr* VA);
+    using InnerCommentVisitor = ConstCommentVisitor;
-        void VisitTLSModelAttr(const clang::TLSModelAttr* TA);
+    using InnerTemplateArgVisitor = ConstTemplateArgumentVisitor;
-
+    using InnerStmtVisitor = ConstStmtVisitor;
-        void VisitTypedefType(const clang::TypedefType* TT);
+    using InnerTypeVisitor = TypeVisitor;
-        void VisitUsingType(const clang::UsingType* TT);
+    using InnerDeclVisitor = ConstDeclVisitor;
-        void VisitFunctionType(const clang::FunctionType* T);
+
-        void VisitFunctionProtoType(const clang::FunctionProtoType* T);
+public:
-        void VisitRValueReferenceType(const clang::ReferenceType* RT);
+    ASTNodeVisitor(llvm::raw_ostream& OS, clang::ASTContext& Ctx, Parser& parser)
-        void VisitArrayType(const clang::ArrayType* AT);
+        : NodeStreamer(OS)
-        void VisitConstantArrayType(const clang::ConstantArrayType* CAT);
+        , parser(parser)
-        void VisitDependentSizedExtVectorType(const clang::DependentSizedExtVectorType* VT);
+        , SM(Ctx.getSourceManager())
-        void VisitVectorType(const clang::VectorType* VT);
+        , Ctx(Ctx)
-        void VisitUnresolvedUsingType(const clang::UnresolvedUsingType* UUT);
+        , NameMangler(Ctx)
-        void VisitUnaryTransformType(const clang::UnaryTransformType* UTT);
+        , PrintPolicy(Ctx.getPrintingPolicy())
-        void VisitTagType(const clang::TagType* TT);
+        , Traits(Ctx.getCommentCommandTraits())
-        void VisitTemplateTypeParmType(const clang::TemplateTypeParmType* TTPT);
+        , LastLocLine(0)
-        void VisitSubstTemplateTypeParmType(const clang::SubstTemplateTypeParmType* STTPT);
+        , LastLocPresumedLine(0)
-        void VisitSubstTemplateTypeParmPackType(const clang::SubstTemplateTypeParmPackType* T);
+    {
-        void VisitAutoType(const clang::AutoType* AT);
+        declMap.reserve(32768);
-        void VisitTemplateSpecializationType(const clang::TemplateSpecializationType* TST);
+        typeMap.reserve(32768);
-        void VisitInjectedClassNameType(const clang::InjectedClassNameType* ICNT);
+        stmtMap.reserve(32768);
-        void VisitObjCInterfaceType(const clang::ObjCInterfaceType* OIT);
+    }
-        void VisitPackExpansionType(const clang::PackExpansionType* PET);
-        void VisitElaboratedType(const clang::ElaboratedType* ET);
-        void VisitMacroQualifiedType(const clang::MacroQualifiedType* MQT);
-        void VisitMemberPointerType(const clang::MemberPointerType* MPT);
-
-        AST::Declaration* VisitTranslationUnitDecl(const clang::TranslationUnitDecl* D);
-        AST::Declaration* VisitNamedDecl(const clang::NamedDecl* ND);
-        void HandleNamedDecl(AST::Declaration& AST_ND, const clang::NamedDecl* ND);
-        AST::Declaration* VisitTypedefDecl(const clang::TypedefDecl* TD);
-        AST::Declaration* VisitTypeAliasDecl(const clang::TypeAliasDecl* TAD);
-        AST::Declaration* VisitNamespaceDecl(const clang::NamespaceDecl* ND);
-        AST::Declaration* VisitUsingDirectiveDecl(const clang::UsingDirectiveDecl* UDD);
-        AST::Declaration* VisitNamespaceAliasDecl(const clang::NamespaceAliasDecl* NAD);
-        AST::Declaration* VisitUsingDecl(const clang::UsingDecl* UD);
-        AST::Declaration* VisitUsingEnumDecl(const clang::UsingEnumDecl* UED);
-        AST::Declaration* VisitUsingShadowDecl(const clang::UsingShadowDecl* USD);
-        AST::Declaration* VisitVarDecl(const clang::VarDecl* VD);
-        AST::Declaration* VisitFieldDecl(const clang::FieldDecl* FD);
-        AST::Declaration* VisitFunctionDecl(const clang::FunctionDecl* FD);
-        AST::Declaration* VisitEnumDecl(const clang::EnumDecl* ED);
-        AST::Declaration* VisitEnumConstantDecl(const clang::EnumConstantDecl* ECD);
-        AST::Declaration* VisitRecordDecl(const clang::RecordDecl* RD);
-        AST::Declaration* VisitCXXRecordDecl(const clang::CXXRecordDecl* RD);
-        AST::Declaration* VisitHLSLBufferDecl(const clang::HLSLBufferDecl* D);
-        AST::Declaration* VisitTemplateTypeParmDecl(const clang::TemplateTypeParmDecl* D);
-        AST::Declaration* VisitNonTypeTemplateParmDecl(const clang::NonTypeTemplateParmDecl* D);
-        AST::Declaration* VisitTemplateTemplateParmDecl(const clang::TemplateTemplateParmDecl* D);
-        AST::Declaration* VisitLinkageSpecDecl(const clang::LinkageSpecDecl* LSD);
-        AST::Declaration* VisitAccessSpecDecl(const clang::AccessSpecDecl* ASD);
-        AST::Declaration* VisitFriendDecl(const clang::FriendDecl* FD);
-
-        AST::Declaration* VisitObjCIvarDecl(const clang::ObjCIvarDecl* D);
-        AST::Declaration* VisitObjCMethodDecl(const clang::ObjCMethodDecl* D);
-        AST::Declaration* VisitObjCTypeParamDecl(const clang::ObjCTypeParamDecl* D);
-        AST::Declaration* VisitObjCCategoryDecl(const clang::ObjCCategoryDecl* D);
-        AST::Declaration* VisitObjCCategoryImplDecl(const clang::ObjCCategoryImplDecl* D);
-        AST::Declaration* VisitObjCProtocolDecl(const clang::ObjCProtocolDecl* D);
-        AST::Declaration* VisitObjCInterfaceDecl(const clang::ObjCInterfaceDecl* D);
-        AST::Declaration* VisitObjCImplementationDecl(const clang::ObjCImplementationDecl* D);
-        AST::Declaration* VisitObjCCompatibleAliasDecl(const clang::ObjCCompatibleAliasDecl* D);
-        AST::Declaration* VisitObjCPropertyDecl(const clang::ObjCPropertyDecl* D);
-        AST::Declaration* VisitObjCPropertyImplDecl(const clang::ObjCPropertyImplDecl* D);
-        AST::Declaration* VisitBlockDecl(const clang::BlockDecl* D);
-
-        void VisitDeclRefExpr(const clang::DeclRefExpr* DRE);
-        void VisitSYCLUniqueStableNameExpr(const clang::SYCLUniqueStableNameExpr* E);
-        // void VisitOpenACCAsteriskSizeExpr(const OpenACCAsteriskSizeExpr* E) {}
-        void VisitPredefinedExpr(const clang::PredefinedExpr* PE);
-        void VisitUnaryOperator(const clang::UnaryOperator* UO);
-        void VisitBinaryOperator(const clang::BinaryOperator* BO);
-        void VisitCompoundAssignOperator(const clang::CompoundAssignOperator* CAO);
-        void VisitMemberExpr(const clang::MemberExpr* ME);
-        void VisitAtomicExpr(const clang::AtomicExpr* AE);
-        void VisitCXXNewExpr(const clang::CXXNewExpr* NE);
-        void VisitCXXDeleteExpr(const clang::CXXDeleteExpr* DE);
-        void VisitCXXThisExpr(const clang::CXXThisExpr* TE);
-        void VisitCastExpr(const clang::CastExpr* CE);
-        void VisitImplicitCastExpr(const clang::ImplicitCastExpr* ICE);
-        void VisitCallExpr(const clang::CallExpr* CE);
-        void VisitUnaryExprOrTypeTraitExpr(const clang::UnaryExprOrTypeTraitExpr* TTE);
-        void VisitSizeOfPackExpr(const clang::SizeOfPackExpr* SOPE);
-        void VisitUnresolvedLookupExpr(const clang::UnresolvedLookupExpr* ULE);
-        void VisitAddrLabelExpr(const clang::AddrLabelExpr* ALE);
-        void VisitCXXTypeidExpr(const clang::CXXTypeidExpr* CTE);
-        void VisitConstantExpr(const clang::ConstantExpr* CE);
-        void VisitInitListExpr(const clang::InitListExpr* ILE);
-        void VisitGenericSelectionExpr(const clang::GenericSelectionExpr* GSE);
-        void VisitCXXUnresolvedConstructExpr(const clang::CXXUnresolvedConstructExpr* UCE);
-        void VisitCXXConstructExpr(const clang::CXXConstructExpr* CE);
-        void VisitExprWithCleanups(const clang::ExprWithCleanups* EWC);
-        void VisitCXXBindTemporaryExpr(const clang::CXXBindTemporaryExpr* BTE);
-        void VisitMaterializeTemporaryExpr(const clang::MaterializeTemporaryExpr* MTE);
-        void VisitCXXDependentScopeMemberExpr(const clang::CXXDependentScopeMemberExpr* ME);
-        void VisitRequiresExpr(const clang::RequiresExpr* RE);
-        void VisitCXXDefaultArgExpr(const clang::CXXDefaultArgExpr* Node);
-        void VisitCXXDefaultInitExpr(const clang::CXXDefaultInitExpr* Node);
-        void VisitCXXBoolLiteralExpr(const clang::CXXBoolLiteralExpr* BLE);
-
-        void VisitObjCEncodeExpr(const clang::ObjCEncodeExpr* OEE);
-        void VisitObjCMessageExpr(const clang::ObjCMessageExpr* OME);
-        void VisitObjCBoxedExpr(const clang::ObjCBoxedExpr* OBE);
-        void VisitObjCSelectorExpr(const clang::ObjCSelectorExpr* OSE);
-        void VisitObjCProtocolExpr(const clang::ObjCProtocolExpr* OPE);
-        void VisitObjCPropertyRefExpr(const clang::ObjCPropertyRefExpr* OPRE);
-        void VisitObjCSubscriptRefExpr(const clang::ObjCSubscriptRefExpr* OSRE);
-        void VisitObjCIvarRefExpr(const clang::ObjCIvarRefExpr* OIRE);
-        void VisitObjCBoolLiteralExpr(const clang::ObjCBoolLiteralExpr* OBLE);
-
-        void VisitIntegerLiteral(const clang::IntegerLiteral* IL);
-        void VisitCharacterLiteral(const clang::CharacterLiteral* CL);
-        void VisitFixedPointLiteral(const clang::FixedPointLiteral* FPL);
-        void VisitFloatingLiteral(const clang::FloatingLiteral* FL);
-        void VisitStringLiteral(const clang::StringLiteral* SL);
-
-        void VisitIfStmt(const clang::IfStmt* IS);
-        void VisitSwitchStmt(const clang::SwitchStmt* SS);
-        void VisitCaseStmt(const clang::CaseStmt* CS);
-        void VisitLabelStmt(const clang::LabelStmt* LS);
-        void VisitGotoStmt(const clang::GotoStmt* GS);
-        void VisitWhileStmt(const clang::WhileStmt* WS);
-        void VisitObjCAtCatchStmt(const clang::ObjCAtCatchStmt* OACS);
-        void VisitCompoundStmt(const clang::CompoundStmt* IS);
-
-        void VisitNullTemplateArgument(const clang::TemplateArgument& TA);
-        void VisitTypeTemplateArgument(const clang::TemplateArgument& TA);
-        void VisitDeclarationTemplateArgument(const clang::TemplateArgument& TA);
-        void VisitNullPtrTemplateArgument(const clang::TemplateArgument& TA);
-        void VisitIntegralTemplateArgument(const clang::TemplateArgument& TA);
-        void VisitTemplateTemplateArgument(const clang::TemplateArgument& TA);
-        void VisitTemplateExpansionTemplateArgument(const clang::TemplateArgument& TA);
-        void VisitExpressionTemplateArgument(const clang::TemplateArgument& TA);
-        void VisitPackTemplateArgument(const clang::TemplateArgument& TA);
-
-        void visitTextComment(const clang::comments::TextComment* C, const clang::comments::FullComment*);
-        void visitInlineCommandComment(const clang::comments::InlineCommandComment* C, const clang::comments::FullComment*);
-        void visitHTMLStartTagComment(const clang::comments::HTMLStartTagComment* C, const clang::comments::FullComment*);
-        void visitHTMLEndTagComment(const clang::comments::HTMLEndTagComment* C, const clang::comments::FullComment*);
-        void visitBlockCommandComment(const clang::comments::BlockCommandComment* C, const clang::comments::FullComment*);
-        void visitParamCommandComment(const clang::comments::ParamCommandComment* C, const clang::comments::FullComment* FC);
-        void visitTParamCommandComment(const clang::comments::TParamCommandComment* C, const clang::comments::FullComment* FC);
-        void visitVerbatimBlockComment(const clang::comments::VerbatimBlockComment* C, const clang::comments::FullComment*);
-        void visitVerbatimBlockLineComment(const clang::comments::VerbatimBlockLineComment* C, const clang::comments::FullComment*);
-        void visitVerbatimLineComment(const clang::comments::VerbatimLineComment* C, const clang::comments::FullComment*);
-
-    private:
-        void attributeOnlyIfTrue(llvm::StringRef Key, bool Value)
-        {
-            if (Value)
-                JOS.attribute(Key, Value);
-        }
 
-        void writeIncludeStack(clang::PresumedLoc Loc, bool JustFirst = false);
+    void Visit(const clang::Attr* A);
-
+    void Visit(const clang::Stmt* S);
-        // Writes the attributes of a SourceLocation object without.
+    void Visit(const clang::Type* T);
-        void writeBareSourceLocation(clang::SourceLocation Loc, bool IsSpelling, bool addFileInfo);
+    void Visit(clang::QualType T);
-
+    AST::Declaration* Visit(const clang::Decl* D);
-        // Writes the attributes of a SourceLocation to JSON based on its presumed
+    void Visit(clang::TypeLoc TL);
-        // spelling location. If the given location represents a macro invocation,
+
-        // this outputs two sub-objects: one for the spelling and one for the
+    void Visit(const clang::comments::Comment* C, const clang::comments::FullComment* FC);
-        // expansion location.
+    void Visit(const clang::TemplateArgument& TA, clang::SourceRange R = {}, const clang::Decl* From = nullptr, llvm::StringRef Label = {});
-        void writeSourceLocation(clang::SourceLocation Loc, bool addFileInfo = true);
+    void Visit(const clang::CXXCtorInitializer* Init);
-        void writeSourceRange(clang::SourceRange R);
+    // void Visit(const OpenACCClause* C) {}
-        std::string createPointerRepresentation(const void* Ptr);
+    void Visit(const clang::OMPClause* C) {}
-        llvm::json::Object createQualType(clang::QualType QT, bool Desugar = true);
+    void Visit(const clang::BlockDecl::Capture& C);
-        AST::QualifiedType CreateQualifiedType(clang::QualType QT, bool Desugar = true);
+    void Visit(const clang::GenericSelectionExpr::ConstAssociation& A);
-        llvm::json::Object createBareDeclRef(const clang::Decl* D);
+    void Visit(const clang::concepts::Requirement* R);
-        llvm::json::Object createFPOptions(clang::FPOptionsOverride FPO);
+    void Visit(const clang::APValue& Value, clang::QualType Ty);
-        void writeBareDeclRef(const clang::Decl* D);
+    void Visit(const clang::ConceptReference*);
-        llvm::json::Object createCXXRecordDefinitionData(const clang::CXXRecordDecl* RD);
+
-        llvm::json::Object createCXXBaseSpecifier(const clang::CXXBaseSpecifier& BS);
+    void VisitAliasAttr(const clang::AliasAttr* AA);
-        std::string createAccessSpecifier(clang::AccessSpecifier AS);
+    void VisitCleanupAttr(const clang::CleanupAttr* CA);
-        llvm::json::Array createCastPath(const clang::CastExpr* C);
+    void VisitDeprecatedAttr(const clang::DeprecatedAttr* DA);
-
+    void VisitUnavailableAttr(const clang::UnavailableAttr* UA);
-        void writePreviousDeclImpl(...) {}
+    void VisitSectionAttr(const clang::SectionAttr* SA);
-
+    void VisitVisibilityAttr(const clang::VisibilityAttr* VA);
-        template <typename T>
+    void VisitTLSModelAttr(const clang::TLSModelAttr* TA);
-        void writePreviousDeclImpl(const clang::Mergeable<T>* D)
+
-        {
+    void VisitTypedefType(const clang::TypedefType* TT);
-            const T* First = D->getFirstDecl();
+    void VisitUsingType(const clang::UsingType* TT);
-            if (First != D)
+    void VisitFunctionType(const clang::FunctionType* T);
-                JOS.attribute("firstRedecl", createPointerRepresentation(First));
+    void VisitFunctionProtoType(const clang::FunctionProtoType* T);
+    void VisitRValueReferenceType(const clang::ReferenceType* RT);
+    void VisitArrayType(const clang::ArrayType* AT);
+    void VisitConstantArrayType(const clang::ConstantArrayType* CAT);
+    void VisitDependentSizedExtVectorType(const clang::DependentSizedExtVectorType* VT);
+    void VisitVectorType(const clang::VectorType* VT);
+    void VisitUnresolvedUsingType(const clang::UnresolvedUsingType* UUT);
+    void VisitUnaryTransformType(const clang::UnaryTransformType* UTT);
+    void VisitTagType(const clang::TagType* TT);
+    void VisitTemplateTypeParmType(const clang::TemplateTypeParmType* TTPT);
+    void VisitSubstTemplateTypeParmType(const clang::SubstTemplateTypeParmType* STTPT);
+    void VisitSubstTemplateTypeParmPackType(const clang::SubstTemplateTypeParmPackType* T);
+    void VisitAutoType(const clang::AutoType* AT);
+    void VisitTemplateSpecializationType(const clang::TemplateSpecializationType* TST);
+    void VisitInjectedClassNameType(const clang::InjectedClassNameType* ICNT);
+    void VisitObjCInterfaceType(const clang::ObjCInterfaceType* OIT);
+    void VisitPackExpansionType(const clang::PackExpansionType* PET);
+    void VisitElaboratedType(const clang::ElaboratedType* ET);
+    void VisitMacroQualifiedType(const clang::MacroQualifiedType* MQT);
+    void VisitMemberPointerType(const clang::MemberPointerType* MPT);
+
+    AST::Declaration* VisitTranslationUnitDecl(const clang::TranslationUnitDecl* D);
+    AST::Declaration* VisitNamedDecl(const clang::NamedDecl* ND);
+    void HandleNamedDecl(AST::Declaration& AST_ND, const clang::NamedDecl* ND);
+    AST::Declaration* VisitTypedefDecl(const clang::TypedefDecl* TD);
+    AST::Declaration* VisitTypeAliasDecl(const clang::TypeAliasDecl* TAD);
+    AST::Declaration* VisitNamespaceDecl(const clang::NamespaceDecl* ND);
+    AST::Declaration* VisitUsingDirectiveDecl(const clang::UsingDirectiveDecl* UDD);
+    AST::Declaration* VisitNamespaceAliasDecl(const clang::NamespaceAliasDecl* NAD);
+    AST::Declaration* VisitUsingDecl(const clang::UsingDecl* UD);
+    AST::Declaration* VisitUsingEnumDecl(const clang::UsingEnumDecl* UED);
+    AST::Declaration* VisitUsingShadowDecl(const clang::UsingShadowDecl* USD);
+    AST::Declaration* VisitVarDecl(const clang::VarDecl* VD);
+    AST::Declaration* VisitFieldDecl(const clang::FieldDecl* FD);
+    AST::Declaration* VisitFunctionDecl(const clang::FunctionDecl* FD);
+    AST::Declaration* VisitEnumDecl(const clang::EnumDecl* ED);
+    AST::Declaration* VisitEnumConstantDecl(const clang::EnumConstantDecl* ECD);
+    AST::Declaration* VisitRecordDecl(const clang::RecordDecl* RD);
+    AST::Declaration* VisitCXXRecordDecl(const clang::CXXRecordDecl* RD);
+    AST::Declaration* VisitHLSLBufferDecl(const clang::HLSLBufferDecl* D);
+    AST::Declaration* VisitTemplateTypeParmDecl(const clang::TemplateTypeParmDecl* D);
+    AST::Declaration* VisitNonTypeTemplateParmDecl(const clang::NonTypeTemplateParmDecl* D);
+    AST::Declaration* VisitTemplateTemplateParmDecl(const clang::TemplateTemplateParmDecl* D);
+    AST::Declaration* VisitLinkageSpecDecl(const clang::LinkageSpecDecl* LSD);
+    AST::Declaration* VisitAccessSpecDecl(const clang::AccessSpecDecl* ASD);
+    AST::Declaration* VisitFriendDecl(const clang::FriendDecl* FD);
+
+    AST::Declaration* VisitObjCIvarDecl(const clang::ObjCIvarDecl* D);
+    AST::Declaration* VisitObjCMethodDecl(const clang::ObjCMethodDecl* D);
+    AST::Declaration* VisitObjCTypeParamDecl(const clang::ObjCTypeParamDecl* D);
+    AST::Declaration* VisitObjCCategoryDecl(const clang::ObjCCategoryDecl* D);
+    AST::Declaration* VisitObjCCategoryImplDecl(const clang::ObjCCategoryImplDecl* D);
+    AST::Declaration* VisitObjCProtocolDecl(const clang::ObjCProtocolDecl* D);
+    AST::Declaration* VisitObjCInterfaceDecl(const clang::ObjCInterfaceDecl* D);
+    AST::Declaration* VisitObjCImplementationDecl(const clang::ObjCImplementationDecl* D);
+    AST::Declaration* VisitObjCCompatibleAliasDecl(const clang::ObjCCompatibleAliasDecl* D);
+    AST::Declaration* VisitObjCPropertyDecl(const clang::ObjCPropertyDecl* D);
+    AST::Declaration* VisitObjCPropertyImplDecl(const clang::ObjCPropertyImplDecl* D);
+    AST::Declaration* VisitBlockDecl(const clang::BlockDecl* D);
+
+    /*#define DECL(CLASS, BASE)                                                                \
+        void Convert##CLASS##DeclImpl(const clang::CLASS##Decl* Src, AST::CLASS##Decl& Dst); \
+        void Convert##CLASS##Decl(const clang::CLASS##Decl* Src, AST::CLASS##Decl& Dst)      \
+        {                                                                                    \
+            Convert##BASE##Decl(Src, Dst);                                                   \
+            Convert##CLASS##DeclImpl(Src, Dst);                                              \
         }
-
+    #include "clang/AST/DeclNodes.inc"
-        template <typename T>
+
-        void writePreviousDeclImpl(const clang::Redeclarable<T>* D)
+    // Declare Visit*() for all concrete Decl classes.
-        {
+    #define ABSTRACT_DECL(DECL)
-            const T* Prev = D->getPreviousDecl();
+    #define DECL(CLASS, BASE)                                      \
-            if (Prev)
+        void Visit##CLASS##Decl(const CLASS##Decl* D)              \
-                JOS.attribute("previousDecl", createPointerRepresentation(Prev));
+        {                                                          \
+            if (declMap.find(D) != declMap.end())                  \
+                return;                                            \
+                                                                   \
+            auto res = declMap.emplace(D, new AST::CLASS##Decl()); \
+            Convert##CLASS##Decl(D, res.first->second);            \
         }
+    #include "clang/AST/DeclNodes.inc"
+            // The above header #undefs ABSTRACT_DECL and DECL upon exit.*/
+
+#define STMT(CLASS, BASE)                                                \
+    void Convert##CLASS##Impl(const clang::CLASS* Src, AST::CLASS& Dst); \
+    void Convert##CLASS(const clang::CLASS* Src, AST::CLASS& Dst)        \
+    {                                                                    \
+        Convert##BASE(Src, Dst);                                         \
+        Convert##CLASS##Impl(Src, Dst);                                  \
+    }
+#include "StmtNodes.inc"
+
+// Declare Visit*() for all concrete Stmt classes.
+#define ABSTRACT_STMT(STMT)
+#define STMT(CLASS, BASE)                                \
+    void Visit##CLASS(const clang::CLASS* S)             \
+    {                                                    \
+        if (stmtMap.find(D) != stmtMap.end())            \
+            return;                                      \
+                                                         \
+        auto res = stmtMap.emplace(S, new AST::CLASS()); \
+        Convert##CLASS(S, res.first->second);            \
+    }
+#include "StmtNodes.inc"
+    // The above header #undefs ABSTRACT_STMT and STMT upon exit.
+
+    void VisitNullTemplateArgument(const clang::TemplateArgument& TA);
+    void VisitTypeTemplateArgument(const clang::TemplateArgument& TA);
+    void VisitDeclarationTemplateArgument(const clang::TemplateArgument& TA);
+    void VisitNullPtrTemplateArgument(const clang::TemplateArgument& TA);
+    void VisitIntegralTemplateArgument(const clang::TemplateArgument& TA);
+    void VisitTemplateTemplateArgument(const clang::TemplateArgument& TA);
+    void VisitTemplateExpansionTemplateArgument(const clang::TemplateArgument& TA);
+    void VisitExpressionTemplateArgument(const clang::TemplateArgument& TA);
+    void VisitPackTemplateArgument(const clang::TemplateArgument& TA);
+
+    void visitTextComment(const clang::comments::TextComment* C, const clang::comments::FullComment*);
+    void visitInlineCommandComment(const clang::comments::InlineCommandComment* C, const clang::comments::FullComment*);
+    void visitHTMLStartTagComment(const clang::comments::HTMLStartTagComment* C, const clang::comments::FullComment*);
+    void visitHTMLEndTagComment(const clang::comments::HTMLEndTagComment* C, const clang::comments::FullComment*);
+    void visitBlockCommandComment(const clang::comments::BlockCommandComment* C, const clang::comments::FullComment*);
+    void visitParamCommandComment(const clang::comments::ParamCommandComment* C, const clang::comments::FullComment* FC);
+    void visitTParamCommandComment(const clang::comments::TParamCommandComment* C, const clang::comments::FullComment* FC);
+    void visitVerbatimBlockComment(const clang::comments::VerbatimBlockComment* C, const clang::comments::FullComment*);
+    void visitVerbatimBlockLineComment(const clang::comments::VerbatimBlockLineComment* C, const clang::comments::FullComment*);
+    void visitVerbatimLineComment(const clang::comments::VerbatimLineComment* C, const clang::comments::FullComment*);
+
+private:
+    void attributeOnlyIfTrue(llvm::StringRef Key, bool Value)
+    {
+        if (Value)
+            JOS.attribute(Key, Value);
+    }
+
+    void writeIncludeStack(clang::PresumedLoc Loc, bool JustFirst = false);
+
+    // Writes the attributes of a SourceLocation object without.
+    void writeBareSourceLocation(clang::SourceLocation Loc, bool IsSpelling, bool addFileInfo);
+
+    // Writes the attributes of a SourceLocation to JSON based on its presumed
+    // spelling location. If the given location represents a macro invocation,
+    // this outputs two sub-objects: one for the spelling and one for the
+    // expansion location.
+    void writeSourceLocation(clang::SourceLocation Loc, bool addFileInfo = true);
+    void writeSourceRange(clang::SourceRange R);
+    std::string createPointerRepresentation(const void* Ptr);
+    llvm::json::Object createQualType(clang::QualType QT, bool Desugar = true);
+    AST::QualifiedType CreateQualifiedType(clang::QualType QT, bool Desugar = true);
+    llvm::json::Object createBareDeclRef(const clang::Decl* D);
+    llvm::json::Object createFPOptions(clang::FPOptionsOverride FPO);
+    void writeBareDeclRef(const clang::Decl* D);
+    llvm::json::Object createCXXRecordDefinitionData(const clang::CXXRecordDecl* RD);
+    llvm::json::Object createCXXBaseSpecifier(const clang::CXXBaseSpecifier& BS);
+    std::string createAccessSpecifier(clang::AccessSpecifier AS);
+    llvm::json::Array createCastPath(const clang::CastExpr* C);
+
+    void writePreviousDeclImpl(...) {}
+
+    template <typename T>
+    void writePreviousDeclImpl(const clang::Mergeable<T>* D)
+    {
+        const T* First = D->getFirstDecl();
+        if (First != D)
+            JOS.attribute("firstRedecl", createPointerRepresentation(First));
+    }
+
+    template <typename T>
+    void writePreviousDeclImpl(const clang::Redeclarable<T>* D)
+    {
+        const T* Prev = D->getPreviousDecl();
+        if (Prev)
+            JOS.attribute("previousDecl", createPointerRepresentation(Prev));
+    }
 
-        [[nodiscard]] std::string GetMangledName(const clang::NamedDecl& ND) const;
+    [[nodiscard]] std::string GetMangledName(const clang::NamedDecl& ND) const;
-        void ConvertNamedRecord(AST::Declaration& dst, const clang::NamedDecl& src) const;
+    void ConvertNamedRecord(AST::Declaration& dst, const clang::NamedDecl& src) const;
 
-        void addPreviousDeclaration(const clang::Decl* D);
+    void addPreviousDeclaration(const clang::Decl* D);
 
-        llvm::StringRef getCommentCommandName(unsigned CommandID) const;
+    llvm::StringRef getCommentCommandName(unsigned CommandID) const;
 
-        template <typename Fn>
+    template <typename Fn>
-        AST::Declaration* FindOrInsertLazy(const clang::Decl* D, Fn&& inserter)
+    AST::Declaration* FindOrInsertLazy(const clang::Decl* D, Fn&& inserter)
-        {
+    {
-            if (auto it = declMap.find(D); it != declMap.end())
+        if (auto it = declMap.find(D); it != declMap.end())
-                return it->second;
+            return it->second;
 
-            auto res = declMap.emplace(D, std::invoke(inserter));
+        auto res = declMap.emplace(D, std::invoke(inserter));
-            return res.first->second;
+        return res.first->second;
-        }
+    }
 
-        std::unordered_map<const clang::Decl*, AST::Declaration*> declMap;
+    std::unordered_map<const clang::Decl*, AST::Declaration*> declMap;
-        std::unordered_set<const clang::Type*> typeMap;
+    std::unordered_set<const clang::Type*> typeMap;
-        std::unordered_set<const clang::Stmt*> stmtMap;
+    std::unordered_set<const clang::Stmt*> stmtMap;
-
+
-        Parser& parser;
+    Parser& parser;
-        const clang::SourceManager& SM;
+    const clang::SourceManager& SM;
-        clang::ASTContext& Ctx;
+    clang::ASTContext& Ctx;
-        ASTNameMangler NameMangler; // TODO: Remove this, or the parser one
+    ASTNameMangler NameMangler; // TODO: Remove this, or the parser one
-        clang::PrintingPolicy PrintPolicy;
+    clang::PrintingPolicy PrintPolicy;
-        const clang::comments::CommandTraits& Traits;
+    const clang::comments::CommandTraits& Traits;
-        llvm::StringRef LastLocFilename, LastLocPresumedFilename;
+    llvm::StringRef LastLocFilename, LastLocPresumedFilename;
-        unsigned LastLocLine, LastLocPresumedLine;
+    unsigned LastLocLine, LastLocPresumedLine;
-    };
+};
-
+
-    class ASTNodeDumper : public clang::ASTNodeTraverser<ASTNodeDumper, ASTNodeVisitor>
+class ASTNodeDumper : public clang::ASTNodeTraverser<ASTNodeDumper, ASTNodeVisitor>
+{
+public:
+    ASTNodeDumper(llvm::raw_ostream& OS, clang::ASTContext& Ctx, Parser& parser)
+        : NodeVisitor(OS, Ctx, parser)
     {
-    public:
+        setDeserialize(true);
-        ASTNodeDumper(llvm::raw_ostream& OS, clang::ASTContext& Ctx, Parser& parser)
+    }
-            : NodeVisitor(OS, Ctx, parser)
-        {
-            setDeserialize(true);
-        }
 
-        ASTNodeVisitor& doGetNodeDelegate() { return NodeVisitor; }
+    ASTNodeVisitor& doGetNodeDelegate() { return NodeVisitor; }
 
-        void VisitFunctionTemplateDecl(const clang::FunctionTemplateDecl* FTD)
+    void VisitFunctionTemplateDecl(const clang::FunctionTemplateDecl* FTD)
-        {
+    {
-            writeTemplateDecl(FTD, true);
+        writeTemplateDecl(FTD, true);
-        }
+    }
-        void VisitClassTemplateDecl(const clang::ClassTemplateDecl* CTD)
+    void VisitClassTemplateDecl(const clang::ClassTemplateDecl* CTD)
-        {
+    {
-            writeTemplateDecl(CTD, false);
+        writeTemplateDecl(CTD, false);
-        }
+    }
-        void VisitVarTemplateDecl(const clang::VarTemplateDecl* VTD)
+    void VisitVarTemplateDecl(const clang::VarTemplateDecl* VTD)
-        {
+    {
-            writeTemplateDecl(VTD, false);
+        writeTemplateDecl(VTD, false);
-        }
+    }
 
-    private:
+private:
-        template <typename SpecializationDecl>
+    template <typename SpecializationDecl>
-        void writeTemplateDeclSpecialization(const SpecializationDecl* SD, bool DumpExplicitInst, bool DumpRefOnly)
+    void writeTemplateDeclSpecialization(const SpecializationDecl* SD, bool DumpExplicitInst, bool DumpRefOnly)
+    {
+        bool DumpedAny = false;
+        for (const auto* RedeclWithBadType : SD->redecls())
         {
-            bool DumpedAny = false;
+            // FIXME: The redecls() range sometimes has elements of a less-specific
-            for (const auto* RedeclWithBadType : SD->redecls())
+            // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
+            // us TagDecls, and should give CXXRecordDecls).
+            const auto* Redecl = clang::dyn_cast<SpecializationDecl>(RedeclWithBadType);
+            if (!Redecl)
             {
-                // FIXME: The redecls() range sometimes has elements of a less-specific
+                // Found the injected-class-name for a class template. This will be
-                // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
+                // dumped as part of its surrounding class so we don't need to dump it
-                // us TagDecls, and should give CXXRecordDecls).
+                // here.
-                const auto* Redecl = clang::dyn_cast<SpecializationDecl>(RedeclWithBadType);
+                assert(clang::isa<clang::CXXRecordDecl>(RedeclWithBadType) &&
-                if (!Redecl)
+                       "expected an injected-class-name");
-                {
+                continue;
-                    // Found the injected-class-name for a class template. This will be
-                    // dumped as part of its surrounding class so we don't need to dump it
-                    // here.
-                    assert(clang::isa<clang::CXXRecordDecl>(RedeclWithBadType) &&
-                           "expected an injected-class-name");
-                    continue;
-                }
-
-                switch (Redecl->getTemplateSpecializationKind())
-                {
-                    case clang::TSK_ExplicitInstantiationDeclaration:
-                    case clang::TSK_ExplicitInstantiationDefinition:
-                        if (!DumpExplicitInst)
-                            break;
-                        [[fallthrough]];
-                    case clang::TSK_Undeclared:
-                    case clang::TSK_ImplicitInstantiation:
-                        if (DumpRefOnly)
-                            NodeVisitor.AddChild([=]
-                                                 {
-                                                     NodeVisitor.writeBareDeclRef(Redecl);
-                                                 });
-                        else
-                            Visit(Redecl);
-                        DumpedAny = true;
-                        break;
-                    case clang::TSK_ExplicitSpecialization:
-                        break;
-                }
             }
 
-            // Ensure we dump at least one decl for each specialization.
+            switch (Redecl->getTemplateSpecializationKind())
-            if (!DumpedAny)
+            {
-                NodeVisitor.AddChild([=]
+                case clang::TSK_ExplicitInstantiationDeclaration:
-                                     {
+                case clang::TSK_ExplicitInstantiationDefinition:
-                                         NodeVisitor.writeBareDeclRef(SD);
+                    if (!DumpExplicitInst)
-                                     });
+                        break;
+                    [[fallthrough]];
+                case clang::TSK_Undeclared:
+                case clang::TSK_ImplicitInstantiation:
+                    if (DumpRefOnly)
+                        NodeVisitor.AddChild([=]
+                                             {
+                                                 NodeVisitor.writeBareDeclRef(Redecl);
+                                             });
+                    else
+                        Visit(Redecl);
+                    DumpedAny = true;
+                    break;
+                case clang::TSK_ExplicitSpecialization:
+                    break;
+            }
         }
 
-        template <typename TemplateDecl>
+        // Ensure we dump at least one decl for each specialization.
-        void writeTemplateDecl(const TemplateDecl* TD, bool DumpExplicitInst)
+        if (!DumpedAny)
-        {
+            NodeVisitor.AddChild([=]
-            // FIXME: it would be nice to dump template parameters and specializations
+                                 {
-            // to their own named arrays rather than shoving them into the "inner"
+                                     NodeVisitor.writeBareDeclRef(SD);
-            // array. However, template declarations are currently being handled at the
+                                 });
-            // wrong "level" of the traversal hierarchy and so it is difficult to
+    }
-            // achieve without losing information elsewhere.
 
-            dumpTemplateParameters(TD->getTemplateParameters());
+    template <typename TemplateDecl>
+    void writeTemplateDecl(const TemplateDecl* TD, bool DumpExplicitInst)
+    {
+        // FIXME: it would be nice to dump template parameters and specializations
+        // to their own named arrays rather than shoving them into the "inner"
+        // array. However, template declarations are currently being handled at the
+        // wrong "level" of the traversal hierarchy and so it is difficult to
+        // achieve without losing information elsewhere.
 
-            Visit(TD->getTemplatedDecl());
+        dumpTemplateParameters(TD->getTemplateParameters());
 
-            for (const auto* Child : TD->specializations())
+        Visit(TD->getTemplatedDecl());
-                writeTemplateDeclSpecialization(Child, DumpExplicitInst, !TD->isCanonicalDecl());
-        }
 
-        ASTNodeVisitor NodeVisitor;
+        for (const auto* Child : TD->specializations())
-    };
+            writeTemplateDeclSpecialization(Child, DumpExplicitInst, !TD->isCanonicalDecl());
+    }
 
-    class ASTParser : public clang::RecursiveASTVisitor<ASTParser>
+    ASTNodeVisitor NodeVisitor;
-    {
+};
-        bool shouldVisitTemplateInstantiations() const { return true; }
+
-        bool shouldWalkTypesOfTypeLocs() const { return true; }
+class ASTParser : public clang::RecursiveASTVisitor<ASTParser>
-        bool shouldVisitImplicitCode() const { return true; }
+{
-        bool shouldVisitLambdaBody() const { return true; }
+    bool shouldVisitTemplateInstantiations() const { return true; }
-        bool shouldTraversePostOrder() const { return true; }
+    bool shouldWalkTypesOfTypeLocs() const { return true; }
-
+    bool shouldVisitImplicitCode() const { return true; }
-        void HandleNamedDecl(AST::Declaration& AST_ND, const clang::NamedDecl* ND);
+    bool shouldVisitLambdaBody() const { return true; }
-
+    bool shouldTraversePostOrder() const { return true; }
-        bool VisitTranslationUnitDecl(const clang::TranslationUnitDecl* D);
+
-        bool VisitNamedDecl(const clang::NamedDecl* ND);
+    /*void HandleNamedDecl(AST::Declaration& AST_ND, const clang::NamedDecl* ND);
-        bool VisitTypedefDecl(const clang::TypedefDecl* TD);
+
-        bool VisitTypeAliasDecl(const clang::TypeAliasDecl* TAD);
+    bool VisitTranslationUnitDecl(const clang::TranslationUnitDecl* D);
-        bool VisitNamespaceDecl(const clang::NamespaceDecl* ND);
+    bool VisitNamedDecl(const clang::NamedDecl* ND);
-        bool VisitUsingDirectiveDecl(const clang::UsingDirectiveDecl* UDD);
+    bool VisitTypedefDecl(const clang::TypedefDecl* TD);
-        bool VisitNamespaceAliasDecl(const clang::NamespaceAliasDecl* NAD);
+    bool VisitTypeAliasDecl(const clang::TypeAliasDecl* TAD);
-        bool VisitUsingDecl(const clang::UsingDecl* UD);
+    bool VisitNamespaceDecl(const clang::NamespaceDecl* ND);
-        bool VisitUsingEnumDecl(const clang::UsingEnumDecl* UED);
+    bool VisitUsingDirectiveDecl(const clang::UsingDirectiveDecl* UDD);
-        bool VisitUsingShadowDecl(const clang::UsingShadowDecl* USD);
+    bool VisitNamespaceAliasDecl(const clang::NamespaceAliasDecl* NAD);
-        bool VisitVarDecl(const clang::VarDecl* VD);
+    bool VisitUsingDecl(const clang::UsingDecl* UD);
-        bool VisitFieldDecl(const clang::FieldDecl* FD);
+    bool VisitUsingEnumDecl(const clang::UsingEnumDecl* UED);
-        bool VisitFunctionDecl(const clang::FunctionDecl* FD);
+    bool VisitUsingShadowDecl(const clang::UsingShadowDecl* USD);
-        bool VisitEnumDecl(const clang::EnumDecl* ED);
+    bool VisitVarDecl(const clang::VarDecl* VD);
-        bool VisitEnumConstantDecl(const clang::EnumConstantDecl* ECD);
+    bool VisitFieldDecl(const clang::FieldDecl* FD);
-        bool VisitRecordDecl(const clang::RecordDecl* RD);
+    bool VisitFunctionDecl(const clang::FunctionDecl* FD);
-        bool VisitCXXRecordDecl(const clang::CXXRecordDecl* RD);
+    bool VisitEnumDecl(const clang::EnumDecl* ED);
-        bool VisitHLSLBufferDecl(const clang::HLSLBufferDecl* D);
+    bool VisitEnumConstantDecl(const clang::EnumConstantDecl* ECD);
-        bool VisitTemplateTypeParmDecl(const clang::TemplateTypeParmDecl* D);
+    bool VisitRecordDecl(const clang::RecordDecl* RD);
-        bool VisitNonTypeTemplateParmDecl(const clang::NonTypeTemplateParmDecl* D);
+    bool VisitCXXRecordDecl(const clang::CXXRecordDecl* RD);
-        bool VisitTemplateTemplateParmDecl(const clang::TemplateTemplateParmDecl* D);
+    bool VisitHLSLBufferDecl(const clang::HLSLBufferDecl* D);
-        bool VisitLinkageSpecDecl(const clang::LinkageSpecDecl* LSD);
+    bool VisitTemplateTypeParmDecl(const clang::TemplateTypeParmDecl* D);
-        bool VisitAccessSpecDecl(const clang::AccessSpecDecl* ASD);
+    bool VisitNonTypeTemplateParmDecl(const clang::NonTypeTemplateParmDecl* D);
-        bool VisitFriendDecl(const clang::FriendDecl* FD);
+    bool VisitTemplateTemplateParmDecl(const clang::TemplateTemplateParmDecl* D);
-    };
+    bool VisitLinkageSpecDecl(const clang::LinkageSpecDecl* LSD);
+    bool VisitAccessSpecDecl(const clang::AccessSpecDecl* ASD);
+    bool VisitFriendDecl(const clang::FriendDecl* FD);*/
+};
 } // namespace CppSharp::CppParser

src/CppParser/StmtNodes.inc

@@ -0,0 +1,935 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* List of AST nodes of a particular kind                                     *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef ABSTRACT_STMT
+#  define ABSTRACT_STMT(Type) Type
+#endif
+#ifndef STMT_RANGE
+#  define STMT_RANGE(Base, First, Last)
+#endif
+
+#ifndef LAST_STMT_RANGE
+#  define LAST_STMT_RANGE(Base, First, Last) STMT_RANGE(Base, First, Last)
+#endif
+
+#ifndef ASMSTMT
+#  define ASMSTMT(Type, Base) STMT(Type, Base)
+#endif
+ABSTRACT_STMT(ASMSTMT(AsmStmt, Stmt))
+#ifndef GCCASMSTMT
+#  define GCCASMSTMT(Type, Base) ASMSTMT(Type, Base)
+#endif
+GCCASMSTMT(GCCAsmStmt, AsmStmt)
+#undef GCCASMSTMT
+
+#ifndef MSASMSTMT
+#  define MSASMSTMT(Type, Base) ASMSTMT(Type, Base)
+#endif
+MSASMSTMT(MSAsmStmt, AsmStmt)
+#undef MSASMSTMT
+
+STMT_RANGE(AsmStmt, GCCAsmStmt, MSAsmStmt)
+
+#undef ASMSTMT
+
+#ifndef BREAKSTMT
+#  define BREAKSTMT(Type, Base) STMT(Type, Base)
+#endif
+BREAKSTMT(BreakStmt, Stmt)
+#undef BREAKSTMT
+
+#ifndef CXXCATCHSTMT
+#  define CXXCATCHSTMT(Type, Base) STMT(Type, Base)
+#endif
+CXXCATCHSTMT(CXXCatchStmt, Stmt)
+#undef CXXCATCHSTMT
+
+#ifndef CXXFORRANGESTMT
+#  define CXXFORRANGESTMT(Type, Base) STMT(Type, Base)
+#endif
+CXXFORRANGESTMT(CXXForRangeStmt, Stmt)
+#undef CXXFORRANGESTMT
+
+#ifndef CXXTRYSTMT
+#  define CXXTRYSTMT(Type, Base) STMT(Type, Base)
+#endif
+CXXTRYSTMT(CXXTryStmt, Stmt)
+#undef CXXTRYSTMT
+
+#ifndef CAPTUREDSTMT
+#  define CAPTUREDSTMT(Type, Base) STMT(Type, Base)
+#endif
+CAPTUREDSTMT(CapturedStmt, Stmt)
+#undef CAPTUREDSTMT
+
+#ifndef COMPOUNDSTMT
+#  define COMPOUNDSTMT(Type, Base) STMT(Type, Base)
+#endif
+COMPOUNDSTMT(CompoundStmt, Stmt)
+#undef COMPOUNDSTMT
+
+#ifndef CONTINUESTMT
+#  define CONTINUESTMT(Type, Base) STMT(Type, Base)
+#endif
+CONTINUESTMT(ContinueStmt, Stmt)
+#undef CONTINUESTMT
+
+#ifndef CORETURNSTMT
+#  define CORETURNSTMT(Type, Base) STMT(Type, Base)
+#endif
+CORETURNSTMT(CoreturnStmt, Stmt)
+#undef CORETURNSTMT
+
+#ifndef COROUTINEBODYSTMT
+#  define COROUTINEBODYSTMT(Type, Base) STMT(Type, Base)
+#endif
+COROUTINEBODYSTMT(CoroutineBodyStmt, Stmt)
+#undef COROUTINEBODYSTMT
+
+#ifndef DECLSTMT
+#  define DECLSTMT(Type, Base) STMT(Type, Base)
+#endif
+DECLSTMT(DeclStmt, Stmt)
+#undef DECLSTMT
+
+#ifndef DOSTMT
+#  define DOSTMT(Type, Base) STMT(Type, Base)
+#endif
+DOSTMT(DoStmt, Stmt)
+#undef DOSTMT
+
+#ifndef FORSTMT
+#  define FORSTMT(Type, Base) STMT(Type, Base)
+#endif
+FORSTMT(ForStmt, Stmt)
+#undef FORSTMT
+
+#ifndef GOTOSTMT
+#  define GOTOSTMT(Type, Base) STMT(Type, Base)
+#endif
+GOTOSTMT(GotoStmt, Stmt)
+#undef GOTOSTMT
+
+#ifndef IFSTMT
+#  define IFSTMT(Type, Base) STMT(Type, Base)
+#endif
+IFSTMT(IfStmt, Stmt)
+#undef IFSTMT
+
+#ifndef INDIRECTGOTOSTMT
+#  define INDIRECTGOTOSTMT(Type, Base) STMT(Type, Base)
+#endif
+INDIRECTGOTOSTMT(IndirectGotoStmt, Stmt)
+#undef INDIRECTGOTOSTMT
+
+#ifndef MSDEPENDENTEXISTSSTMT
+#  define MSDEPENDENTEXISTSSTMT(Type, Base) STMT(Type, Base)
+#endif
+MSDEPENDENTEXISTSSTMT(MSDependentExistsStmt, Stmt)
+#undef MSDEPENDENTEXISTSSTMT
+
+#ifndef NULLSTMT
+#  define NULLSTMT(Type, Base) STMT(Type, Base)
+#endif
+NULLSTMT(NullStmt, Stmt)
+#undef NULLSTMT
+
+// Removed OMP nodes
+// Removed OBJC nodes
+
+#ifndef RETURNSTMT
+#  define RETURNSTMT(Type, Base) STMT(Type, Base)
+#endif
+RETURNSTMT(ReturnStmt, Stmt)
+#undef RETURNSTMT
+
+#ifndef SEHEXCEPTSTMT
+#  define SEHEXCEPTSTMT(Type, Base) STMT(Type, Base)
+#endif
+SEHEXCEPTSTMT(SEHExceptStmt, Stmt)
+#undef SEHEXCEPTSTMT
+
+#ifndef SEHFINALLYSTMT
+#  define SEHFINALLYSTMT(Type, Base) STMT(Type, Base)
+#endif
+SEHFINALLYSTMT(SEHFinallyStmt, Stmt)
+#undef SEHFINALLYSTMT
+
+#ifndef SEHLEAVESTMT
+#  define SEHLEAVESTMT(Type, Base) STMT(Type, Base)
+#endif
+SEHLEAVESTMT(SEHLeaveStmt, Stmt)
+#undef SEHLEAVESTMT
+
+#ifndef SEHTRYSTMT
+#  define SEHTRYSTMT(Type, Base) STMT(Type, Base)
+#endif
+SEHTRYSTMT(SEHTryStmt, Stmt)
+#undef SEHTRYSTMT
+
+#ifndef SWITCHCASE
+#  define SWITCHCASE(Type, Base) STMT(Type, Base)
+#endif
+ABSTRACT_STMT(SWITCHCASE(SwitchCase, Stmt))
+#ifndef CASESTMT
+#  define CASESTMT(Type, Base) SWITCHCASE(Type, Base)
+#endif
+CASESTMT(CaseStmt, SwitchCase)
+#undef CASESTMT
+
+#ifndef DEFAULTSTMT
+#  define DEFAULTSTMT(Type, Base) SWITCHCASE(Type, Base)
+#endif
+DEFAULTSTMT(DefaultStmt, SwitchCase)
+#undef DEFAULTSTMT
+
+STMT_RANGE(SwitchCase, CaseStmt, DefaultStmt)
+
+#undef SWITCHCASE
+
+#ifndef SWITCHSTMT
+#  define SWITCHSTMT(Type, Base) STMT(Type, Base)
+#endif
+SWITCHSTMT(SwitchStmt, Stmt)
+#undef SWITCHSTMT
+
+#ifndef VALUESTMT
+#  define VALUESTMT(Type, Base) STMT(Type, Base)
+#endif
+ABSTRACT_STMT(VALUESTMT(ValueStmt, Stmt))
+#ifndef ATTRIBUTEDSTMT
+#  define ATTRIBUTEDSTMT(Type, Base) VALUESTMT(Type, Base)
+#endif
+ATTRIBUTEDSTMT(AttributedStmt, ValueStmt)
+#undef ATTRIBUTEDSTMT
+
+#ifndef EXPR
+#  define EXPR(Type, Base) VALUESTMT(Type, Base)
+#endif
+ABSTRACT_STMT(EXPR(Expr, ValueStmt))
+#ifndef ABSTRACTCONDITIONALOPERATOR
+#  define ABSTRACTCONDITIONALOPERATOR(Type, Base) EXPR(Type, Base)
+#endif
+ABSTRACT_STMT(ABSTRACTCONDITIONALOPERATOR(AbstractConditionalOperator, Expr))
+#ifndef BINARYCONDITIONALOPERATOR
+#  define BINARYCONDITIONALOPERATOR(Type, Base) ABSTRACTCONDITIONALOPERATOR(Type, Base)
+#endif
+BINARYCONDITIONALOPERATOR(BinaryConditionalOperator, AbstractConditionalOperator)
+#undef BINARYCONDITIONALOPERATOR
+
+#ifndef CONDITIONALOPERATOR
+#  define CONDITIONALOPERATOR(Type, Base) ABSTRACTCONDITIONALOPERATOR(Type, Base)
+#endif
+CONDITIONALOPERATOR(ConditionalOperator, AbstractConditionalOperator)
+#undef CONDITIONALOPERATOR
+
+STMT_RANGE(AbstractConditionalOperator, BinaryConditionalOperator, ConditionalOperator)
+
+#undef ABSTRACTCONDITIONALOPERATOR
+
+#ifndef ADDRLABELEXPR
+#  define ADDRLABELEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ADDRLABELEXPR(AddrLabelExpr, Expr)
+#undef ADDRLABELEXPR
+
+#ifndef ARRAYINITINDEXEXPR
+#  define ARRAYINITINDEXEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ARRAYINITINDEXEXPR(ArrayInitIndexExpr, Expr)
+#undef ARRAYINITINDEXEXPR
+
+#ifndef ARRAYINITLOOPEXPR
+#  define ARRAYINITLOOPEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ARRAYINITLOOPEXPR(ArrayInitLoopExpr, Expr)
+#undef ARRAYINITLOOPEXPR
+
+#ifndef ARRAYSUBSCRIPTEXPR
+#  define ARRAYSUBSCRIPTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ARRAYSUBSCRIPTEXPR(ArraySubscriptExpr, Expr)
+#undef ARRAYSUBSCRIPTEXPR
+
+#ifndef ARRAYTYPETRAITEXPR
+#  define ARRAYTYPETRAITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ARRAYTYPETRAITEXPR(ArrayTypeTraitExpr, Expr)
+#undef ARRAYTYPETRAITEXPR
+
+#ifndef ASTYPEEXPR
+#  define ASTYPEEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ASTYPEEXPR(AsTypeExpr, Expr)
+#undef ASTYPEEXPR
+
+#ifndef ATOMICEXPR
+#  define ATOMICEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ATOMICEXPR(AtomicExpr, Expr)
+#undef ATOMICEXPR
+
+#ifndef BINARYOPERATOR
+#  define BINARYOPERATOR(Type, Base) EXPR(Type, Base)
+#endif
+BINARYOPERATOR(BinaryOperator, Expr)
+#ifndef COMPOUNDASSIGNOPERATOR
+#  define COMPOUNDASSIGNOPERATOR(Type, Base) BINARYOPERATOR(Type, Base)
+#endif
+COMPOUNDASSIGNOPERATOR(CompoundAssignOperator, BinaryOperator)
+#undef COMPOUNDASSIGNOPERATOR
+
+STMT_RANGE(BinaryOperator, BinaryOperator, CompoundAssignOperator)
+
+#undef BINARYOPERATOR
+
+#ifndef BLOCKEXPR
+#  define BLOCKEXPR(Type, Base) EXPR(Type, Base)
+#endif
+BLOCKEXPR(BlockExpr, Expr)
+#undef BLOCKEXPR
+
+#ifndef CXXBINDTEMPORARYEXPR
+#  define CXXBINDTEMPORARYEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXBINDTEMPORARYEXPR(CXXBindTemporaryExpr, Expr)
+#undef CXXBINDTEMPORARYEXPR
+
+#ifndef CXXBOOLLITERALEXPR
+#  define CXXBOOLLITERALEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXBOOLLITERALEXPR(CXXBoolLiteralExpr, Expr)
+#undef CXXBOOLLITERALEXPR
+
+#ifndef CXXCONSTRUCTEXPR
+#  define CXXCONSTRUCTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXCONSTRUCTEXPR(CXXConstructExpr, Expr)
+#ifndef CXXTEMPORARYOBJECTEXPR
+#  define CXXTEMPORARYOBJECTEXPR(Type, Base) CXXCONSTRUCTEXPR(Type, Base)
+#endif
+CXXTEMPORARYOBJECTEXPR(CXXTemporaryObjectExpr, CXXConstructExpr)
+#undef CXXTEMPORARYOBJECTEXPR
+
+STMT_RANGE(CXXConstructExpr, CXXConstructExpr, CXXTemporaryObjectExpr)
+
+#undef CXXCONSTRUCTEXPR
+
+#ifndef CXXDEFAULTARGEXPR
+#  define CXXDEFAULTARGEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXDEFAULTARGEXPR(CXXDefaultArgExpr, Expr)
+#undef CXXDEFAULTARGEXPR
+
+#ifndef CXXDEFAULTINITEXPR
+#  define CXXDEFAULTINITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXDEFAULTINITEXPR(CXXDefaultInitExpr, Expr)
+#undef CXXDEFAULTINITEXPR
+
+#ifndef CXXDELETEEXPR
+#  define CXXDELETEEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXDELETEEXPR(CXXDeleteExpr, Expr)
+#undef CXXDELETEEXPR
+
+#ifndef CXXDEPENDENTSCOPEMEMBEREXPR
+#  define CXXDEPENDENTSCOPEMEMBEREXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXDEPENDENTSCOPEMEMBEREXPR(CXXDependentScopeMemberExpr, Expr)
+#undef CXXDEPENDENTSCOPEMEMBEREXPR
+
+#ifndef CXXFOLDEXPR
+#  define CXXFOLDEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXFOLDEXPR(CXXFoldExpr, Expr)
+#undef CXXFOLDEXPR
+
+#ifndef CXXINHERITEDCTORINITEXPR
+#  define CXXINHERITEDCTORINITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXINHERITEDCTORINITEXPR(CXXInheritedCtorInitExpr, Expr)
+#undef CXXINHERITEDCTORINITEXPR
+
+#ifndef CXXNEWEXPR
+#  define CXXNEWEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXNEWEXPR(CXXNewExpr, Expr)
+#undef CXXNEWEXPR
+
+#ifndef CXXNOEXCEPTEXPR
+#  define CXXNOEXCEPTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXNOEXCEPTEXPR(CXXNoexceptExpr, Expr)
+#undef CXXNOEXCEPTEXPR
+
+#ifndef CXXNULLPTRLITERALEXPR
+#  define CXXNULLPTRLITERALEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXNULLPTRLITERALEXPR(CXXNullPtrLiteralExpr, Expr)
+#undef CXXNULLPTRLITERALEXPR
+
+#ifndef CXXPARENLISTINITEXPR
+#  define CXXPARENLISTINITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXPARENLISTINITEXPR(CXXParenListInitExpr, Expr)
+#undef CXXPARENLISTINITEXPR
+
+#ifndef CXXPSEUDODESTRUCTOREXPR
+#  define CXXPSEUDODESTRUCTOREXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXPSEUDODESTRUCTOREXPR(CXXPseudoDestructorExpr, Expr)
+#undef CXXPSEUDODESTRUCTOREXPR
+
+#ifndef CXXREWRITTENBINARYOPERATOR
+#  define CXXREWRITTENBINARYOPERATOR(Type, Base) EXPR(Type, Base)
+#endif
+CXXREWRITTENBINARYOPERATOR(CXXRewrittenBinaryOperator, Expr)
+#undef CXXREWRITTENBINARYOPERATOR
+
+#ifndef CXXSCALARVALUEINITEXPR
+#  define CXXSCALARVALUEINITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXSCALARVALUEINITEXPR(CXXScalarValueInitExpr, Expr)
+#undef CXXSCALARVALUEINITEXPR
+
+#ifndef CXXSTDINITIALIZERLISTEXPR
+#  define CXXSTDINITIALIZERLISTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXSTDINITIALIZERLISTEXPR(CXXStdInitializerListExpr, Expr)
+#undef CXXSTDINITIALIZERLISTEXPR
+
+#ifndef CXXTHISEXPR
+#  define CXXTHISEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXTHISEXPR(CXXThisExpr, Expr)
+#undef CXXTHISEXPR
+
+#ifndef CXXTHROWEXPR
+#  define CXXTHROWEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXTHROWEXPR(CXXThrowExpr, Expr)
+#undef CXXTHROWEXPR
+
+#ifndef CXXTYPEIDEXPR
+#  define CXXTYPEIDEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXTYPEIDEXPR(CXXTypeidExpr, Expr)
+#undef CXXTYPEIDEXPR
+
+#ifndef CXXUNRESOLVEDCONSTRUCTEXPR
+#  define CXXUNRESOLVEDCONSTRUCTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXUNRESOLVEDCONSTRUCTEXPR(CXXUnresolvedConstructExpr, Expr)
+#undef CXXUNRESOLVEDCONSTRUCTEXPR
+
+#ifndef CXXUUIDOFEXPR
+#  define CXXUUIDOFEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CXXUUIDOFEXPR(CXXUuidofExpr, Expr)
+#undef CXXUUIDOFEXPR
+
+#ifndef CALLEXPR
+#  define CALLEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CALLEXPR(CallExpr, Expr)
+#ifndef CUDAKERNELCALLEXPR
+#  define CUDAKERNELCALLEXPR(Type, Base) CALLEXPR(Type, Base)
+#endif
+CUDAKERNELCALLEXPR(CUDAKernelCallExpr, CallExpr)
+#undef CUDAKERNELCALLEXPR
+
+#ifndef CXXMEMBERCALLEXPR
+#  define CXXMEMBERCALLEXPR(Type, Base) CALLEXPR(Type, Base)
+#endif
+CXXMEMBERCALLEXPR(CXXMemberCallExpr, CallExpr)
+#undef CXXMEMBERCALLEXPR
+
+#ifndef CXXOPERATORCALLEXPR
+#  define CXXOPERATORCALLEXPR(Type, Base) CALLEXPR(Type, Base)
+#endif
+CXXOPERATORCALLEXPR(CXXOperatorCallExpr, CallExpr)
+#undef CXXOPERATORCALLEXPR
+
+#ifndef USERDEFINEDLITERAL
+#  define USERDEFINEDLITERAL(Type, Base) CALLEXPR(Type, Base)
+#endif
+USERDEFINEDLITERAL(UserDefinedLiteral, CallExpr)
+#undef USERDEFINEDLITERAL
+
+STMT_RANGE(CallExpr, CallExpr, UserDefinedLiteral)
+
+#undef CALLEXPR
+
+#ifndef CASTEXPR
+#  define CASTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ABSTRACT_STMT(CASTEXPR(CastExpr, Expr))
+#ifndef EXPLICITCASTEXPR
+#  define EXPLICITCASTEXPR(Type, Base) CASTEXPR(Type, Base)
+#endif
+ABSTRACT_STMT(EXPLICITCASTEXPR(ExplicitCastExpr, CastExpr))
+#ifndef BUILTINBITCASTEXPR
+#  define BUILTINBITCASTEXPR(Type, Base) EXPLICITCASTEXPR(Type, Base)
+#endif
+BUILTINBITCASTEXPR(BuiltinBitCastExpr, ExplicitCastExpr)
+#undef BUILTINBITCASTEXPR
+
+#ifndef CSTYLECASTEXPR
+#  define CSTYLECASTEXPR(Type, Base) EXPLICITCASTEXPR(Type, Base)
+#endif
+CSTYLECASTEXPR(CStyleCastExpr, ExplicitCastExpr)
+#undef CSTYLECASTEXPR
+
+#ifndef CXXFUNCTIONALCASTEXPR
+#  define CXXFUNCTIONALCASTEXPR(Type, Base) EXPLICITCASTEXPR(Type, Base)
+#endif
+CXXFUNCTIONALCASTEXPR(CXXFunctionalCastExpr, ExplicitCastExpr)
+#undef CXXFUNCTIONALCASTEXPR
+
+#ifndef CXXNAMEDCASTEXPR
+#  define CXXNAMEDCASTEXPR(Type, Base) EXPLICITCASTEXPR(Type, Base)
+#endif
+ABSTRACT_STMT(CXXNAMEDCASTEXPR(CXXNamedCastExpr, ExplicitCastExpr))
+#ifndef CXXADDRSPACECASTEXPR
+#  define CXXADDRSPACECASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
+#endif
+CXXADDRSPACECASTEXPR(CXXAddrspaceCastExpr, CXXNamedCastExpr)
+#undef CXXADDRSPACECASTEXPR
+
+#ifndef CXXCONSTCASTEXPR
+#  define CXXCONSTCASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
+#endif
+CXXCONSTCASTEXPR(CXXConstCastExpr, CXXNamedCastExpr)
+#undef CXXCONSTCASTEXPR
+
+#ifndef CXXDYNAMICCASTEXPR
+#  define CXXDYNAMICCASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
+#endif
+CXXDYNAMICCASTEXPR(CXXDynamicCastExpr, CXXNamedCastExpr)
+#undef CXXDYNAMICCASTEXPR
+
+#ifndef CXXREINTERPRETCASTEXPR
+#  define CXXREINTERPRETCASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
+#endif
+CXXREINTERPRETCASTEXPR(CXXReinterpretCastExpr, CXXNamedCastExpr)
+#undef CXXREINTERPRETCASTEXPR
+
+#ifndef CXXSTATICCASTEXPR
+#  define CXXSTATICCASTEXPR(Type, Base) CXXNAMEDCASTEXPR(Type, Base)
+#endif
+CXXSTATICCASTEXPR(CXXStaticCastExpr, CXXNamedCastExpr)
+#undef CXXSTATICCASTEXPR
+
+STMT_RANGE(CXXNamedCastExpr, CXXAddrspaceCastExpr, CXXStaticCastExpr)
+
+#undef CXXNAMEDCASTEXPR
+
+STMT_RANGE(ExplicitCastExpr, BuiltinBitCastExpr, ObjCBridgedCastExpr)
+
+#undef EXPLICITCASTEXPR
+
+#ifndef IMPLICITCASTEXPR
+#  define IMPLICITCASTEXPR(Type, Base) CASTEXPR(Type, Base)
+#endif
+IMPLICITCASTEXPR(ImplicitCastExpr, CastExpr)
+#undef IMPLICITCASTEXPR
+
+STMT_RANGE(CastExpr, BuiltinBitCastExpr, ImplicitCastExpr)
+
+#undef CASTEXPR
+
+#ifndef CHARACTERLITERAL
+#  define CHARACTERLITERAL(Type, Base) EXPR(Type, Base)
+#endif
+CHARACTERLITERAL(CharacterLiteral, Expr)
+#undef CHARACTERLITERAL
+
+#ifndef CHOOSEEXPR
+#  define CHOOSEEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CHOOSEEXPR(ChooseExpr, Expr)
+#undef CHOOSEEXPR
+
+#ifndef COMPOUNDLITERALEXPR
+#  define COMPOUNDLITERALEXPR(Type, Base) EXPR(Type, Base)
+#endif
+COMPOUNDLITERALEXPR(CompoundLiteralExpr, Expr)
+#undef COMPOUNDLITERALEXPR
+
+#ifndef CONCEPTSPECIALIZATIONEXPR
+#  define CONCEPTSPECIALIZATIONEXPR(Type, Base) EXPR(Type, Base)
+#endif
+CONCEPTSPECIALIZATIONEXPR(ConceptSpecializationExpr, Expr)
+#undef CONCEPTSPECIALIZATIONEXPR
+
+#ifndef CONVERTVECTOREXPR
+#  define CONVERTVECTOREXPR(Type, Base) EXPR(Type, Base)
+#endif
+CONVERTVECTOREXPR(ConvertVectorExpr, Expr)
+#undef CONVERTVECTOREXPR
+
+#ifndef COROUTINESUSPENDEXPR
+#  define COROUTINESUSPENDEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ABSTRACT_STMT(COROUTINESUSPENDEXPR(CoroutineSuspendExpr, Expr))
+#ifndef COAWAITEXPR
+#  define COAWAITEXPR(Type, Base) COROUTINESUSPENDEXPR(Type, Base)
+#endif
+COAWAITEXPR(CoawaitExpr, CoroutineSuspendExpr)
+#undef COAWAITEXPR
+
+#ifndef COYIELDEXPR
+#  define COYIELDEXPR(Type, Base) COROUTINESUSPENDEXPR(Type, Base)
+#endif
+COYIELDEXPR(CoyieldExpr, CoroutineSuspendExpr)
+#undef COYIELDEXPR
+
+STMT_RANGE(CoroutineSuspendExpr, CoawaitExpr, CoyieldExpr)
+
+#undef COROUTINESUSPENDEXPR
+
+#ifndef DECLREFEXPR
+#  define DECLREFEXPR(Type, Base) EXPR(Type, Base)
+#endif
+DECLREFEXPR(DeclRefExpr, Expr)
+#undef DECLREFEXPR
+
+#ifndef DEPENDENTCOAWAITEXPR
+#  define DEPENDENTCOAWAITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+DEPENDENTCOAWAITEXPR(DependentCoawaitExpr, Expr)
+#undef DEPENDENTCOAWAITEXPR
+
+#ifndef DEPENDENTSCOPEDECLREFEXPR
+#  define DEPENDENTSCOPEDECLREFEXPR(Type, Base) EXPR(Type, Base)
+#endif
+DEPENDENTSCOPEDECLREFEXPR(DependentScopeDeclRefExpr, Expr)
+#undef DEPENDENTSCOPEDECLREFEXPR
+
+#ifndef DESIGNATEDINITEXPR
+#  define DESIGNATEDINITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+DESIGNATEDINITEXPR(DesignatedInitExpr, Expr)
+#undef DESIGNATEDINITEXPR
+
+#ifndef DESIGNATEDINITUPDATEEXPR
+#  define DESIGNATEDINITUPDATEEXPR(Type, Base) EXPR(Type, Base)
+#endif
+DESIGNATEDINITUPDATEEXPR(DesignatedInitUpdateExpr, Expr)
+#undef DESIGNATEDINITUPDATEEXPR
+
+#ifndef EXPRESSIONTRAITEXPR
+#  define EXPRESSIONTRAITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+EXPRESSIONTRAITEXPR(ExpressionTraitExpr, Expr)
+#undef EXPRESSIONTRAITEXPR
+
+#ifndef EXTVECTORELEMENTEXPR
+#  define EXTVECTORELEMENTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+EXTVECTORELEMENTEXPR(ExtVectorElementExpr, Expr)
+#undef EXTVECTORELEMENTEXPR
+
+#ifndef FIXEDPOINTLITERAL
+#  define FIXEDPOINTLITERAL(Type, Base) EXPR(Type, Base)
+#endif
+FIXEDPOINTLITERAL(FixedPointLiteral, Expr)
+#undef FIXEDPOINTLITERAL
+
+#ifndef FLOATINGLITERAL
+#  define FLOATINGLITERAL(Type, Base) EXPR(Type, Base)
+#endif
+FLOATINGLITERAL(FloatingLiteral, Expr)
+#undef FLOATINGLITERAL
+
+#ifndef FULLEXPR
+#  define FULLEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ABSTRACT_STMT(FULLEXPR(FullExpr, Expr))
+#ifndef CONSTANTEXPR
+#  define CONSTANTEXPR(Type, Base) FULLEXPR(Type, Base)
+#endif
+CONSTANTEXPR(ConstantExpr, FullExpr)
+#undef CONSTANTEXPR
+
+#ifndef EXPRWITHCLEANUPS
+#  define EXPRWITHCLEANUPS(Type, Base) FULLEXPR(Type, Base)
+#endif
+EXPRWITHCLEANUPS(ExprWithCleanups, FullExpr)
+#undef EXPRWITHCLEANUPS
+
+STMT_RANGE(FullExpr, ConstantExpr, ExprWithCleanups)
+
+#undef FULLEXPR
+
+#ifndef FUNCTIONPARMPACKEXPR
+#  define FUNCTIONPARMPACKEXPR(Type, Base) EXPR(Type, Base)
+#endif
+FUNCTIONPARMPACKEXPR(FunctionParmPackExpr, Expr)
+#undef FUNCTIONPARMPACKEXPR
+
+#ifndef GNUNULLEXPR
+#  define GNUNULLEXPR(Type, Base) EXPR(Type, Base)
+#endif
+GNUNULLEXPR(GNUNullExpr, Expr)
+#undef GNUNULLEXPR
+
+#ifndef GENERICSELECTIONEXPR
+#  define GENERICSELECTIONEXPR(Type, Base) EXPR(Type, Base)
+#endif
+GENERICSELECTIONEXPR(GenericSelectionExpr, Expr)
+#undef GENERICSELECTIONEXPR
+
+#ifndef IMAGINARYLITERAL
+#  define IMAGINARYLITERAL(Type, Base) EXPR(Type, Base)
+#endif
+IMAGINARYLITERAL(ImaginaryLiteral, Expr)
+#undef IMAGINARYLITERAL
+
+#ifndef IMPLICITVALUEINITEXPR
+#  define IMPLICITVALUEINITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+IMPLICITVALUEINITEXPR(ImplicitValueInitExpr, Expr)
+#undef IMPLICITVALUEINITEXPR
+
+#ifndef INITLISTEXPR
+#  define INITLISTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+INITLISTEXPR(InitListExpr, Expr)
+#undef INITLISTEXPR
+
+#ifndef INTEGERLITERAL
+#  define INTEGERLITERAL(Type, Base) EXPR(Type, Base)
+#endif
+INTEGERLITERAL(IntegerLiteral, Expr)
+#undef INTEGERLITERAL
+
+#ifndef LAMBDAEXPR
+#  define LAMBDAEXPR(Type, Base) EXPR(Type, Base)
+#endif
+LAMBDAEXPR(LambdaExpr, Expr)
+#undef LAMBDAEXPR
+
+#ifndef MSPROPERTYREFEXPR
+#  define MSPROPERTYREFEXPR(Type, Base) EXPR(Type, Base)
+#endif
+MSPROPERTYREFEXPR(MSPropertyRefExpr, Expr)
+#undef MSPROPERTYREFEXPR
+
+#ifndef MSPROPERTYSUBSCRIPTEXPR
+#  define MSPROPERTYSUBSCRIPTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+MSPROPERTYSUBSCRIPTEXPR(MSPropertySubscriptExpr, Expr)
+#undef MSPROPERTYSUBSCRIPTEXPR
+
+#ifndef MATERIALIZETEMPORARYEXPR
+#  define MATERIALIZETEMPORARYEXPR(Type, Base) EXPR(Type, Base)
+#endif
+MATERIALIZETEMPORARYEXPR(MaterializeTemporaryExpr, Expr)
+#undef MATERIALIZETEMPORARYEXPR
+
+#ifndef MATRIXSUBSCRIPTEXPR
+#  define MATRIXSUBSCRIPTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+MATRIXSUBSCRIPTEXPR(MatrixSubscriptExpr, Expr)
+#undef MATRIXSUBSCRIPTEXPR
+
+#ifndef MEMBEREXPR
+#  define MEMBEREXPR(Type, Base) EXPR(Type, Base)
+#endif
+MEMBEREXPR(MemberExpr, Expr)
+#undef MEMBEREXPR
+
+#ifndef NOINITEXPR
+#  define NOINITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+NOINITEXPR(NoInitExpr, Expr)
+#undef NOINITEXPR
+
+// Removed OMP nodes
+// Removed OBJC nodes
+
+#ifndef OFFSETOFEXPR
+#  define OFFSETOFEXPR(Type, Base) EXPR(Type, Base)
+#endif
+OFFSETOFEXPR(OffsetOfExpr, Expr)
+#undef OFFSETOFEXPR
+
+#ifndef OPAQUEVALUEEXPR
+#  define OPAQUEVALUEEXPR(Type, Base) EXPR(Type, Base)
+#endif
+OPAQUEVALUEEXPR(OpaqueValueExpr, Expr)
+#undef OPAQUEVALUEEXPR
+
+#ifndef OVERLOADEXPR
+#  define OVERLOADEXPR(Type, Base) EXPR(Type, Base)
+#endif
+ABSTRACT_STMT(OVERLOADEXPR(OverloadExpr, Expr))
+#ifndef UNRESOLVEDLOOKUPEXPR
+#  define UNRESOLVEDLOOKUPEXPR(Type, Base) OVERLOADEXPR(Type, Base)
+#endif
+UNRESOLVEDLOOKUPEXPR(UnresolvedLookupExpr, OverloadExpr)
+#undef UNRESOLVEDLOOKUPEXPR
+
+#ifndef UNRESOLVEDMEMBEREXPR
+#  define UNRESOLVEDMEMBEREXPR(Type, Base) OVERLOADEXPR(Type, Base)
+#endif
+UNRESOLVEDMEMBEREXPR(UnresolvedMemberExpr, OverloadExpr)
+#undef UNRESOLVEDMEMBEREXPR
+
+STMT_RANGE(OverloadExpr, UnresolvedLookupExpr, UnresolvedMemberExpr)
+
+#undef OVERLOADEXPR
+
+#ifndef PACKEXPANSIONEXPR
+#  define PACKEXPANSIONEXPR(Type, Base) EXPR(Type, Base)
+#endif
+PACKEXPANSIONEXPR(PackExpansionExpr, Expr)
+#undef PACKEXPANSIONEXPR
+
+#ifndef PARENEXPR
+#  define PARENEXPR(Type, Base) EXPR(Type, Base)
+#endif
+PARENEXPR(ParenExpr, Expr)
+#undef PARENEXPR
+
+#ifndef PARENLISTEXPR
+#  define PARENLISTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+PARENLISTEXPR(ParenListExpr, Expr)
+#undef PARENLISTEXPR
+
+#ifndef PREDEFINEDEXPR
+#  define PREDEFINEDEXPR(Type, Base) EXPR(Type, Base)
+#endif
+PREDEFINEDEXPR(PredefinedExpr, Expr)
+#undef PREDEFINEDEXPR
+
+#ifndef PSEUDOOBJECTEXPR
+#  define PSEUDOOBJECTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+PSEUDOOBJECTEXPR(PseudoObjectExpr, Expr)
+#undef PSEUDOOBJECTEXPR
+
+#ifndef RECOVERYEXPR
+#  define RECOVERYEXPR(Type, Base) EXPR(Type, Base)
+#endif
+RECOVERYEXPR(RecoveryExpr, Expr)
+#undef RECOVERYEXPR
+
+#ifndef REQUIRESEXPR
+#  define REQUIRESEXPR(Type, Base) EXPR(Type, Base)
+#endif
+REQUIRESEXPR(RequiresExpr, Expr)
+#undef REQUIRESEXPR
+
+#ifndef SYCLUNIQUESTABLENAMEEXPR
+#  define SYCLUNIQUESTABLENAMEEXPR(Type, Base) EXPR(Type, Base)
+#endif
+SYCLUNIQUESTABLENAMEEXPR(SYCLUniqueStableNameExpr, Expr)
+#undef SYCLUNIQUESTABLENAMEEXPR
+
+#ifndef SHUFFLEVECTOREXPR
+#  define SHUFFLEVECTOREXPR(Type, Base) EXPR(Type, Base)
+#endif
+SHUFFLEVECTOREXPR(ShuffleVectorExpr, Expr)
+#undef SHUFFLEVECTOREXPR
+
+#ifndef SIZEOFPACKEXPR
+#  define SIZEOFPACKEXPR(Type, Base) EXPR(Type, Base)
+#endif
+SIZEOFPACKEXPR(SizeOfPackExpr, Expr)
+#undef SIZEOFPACKEXPR
+
+#ifndef SOURCELOCEXPR
+#  define SOURCELOCEXPR(Type, Base) EXPR(Type, Base)
+#endif
+SOURCELOCEXPR(SourceLocExpr, Expr)
+#undef SOURCELOCEXPR
+
+#ifndef STMTEXPR
+#  define STMTEXPR(Type, Base) EXPR(Type, Base)
+#endif
+STMTEXPR(StmtExpr, Expr)
+#undef STMTEXPR
+
+#ifndef STRINGLITERAL
+#  define STRINGLITERAL(Type, Base) EXPR(Type, Base)
+#endif
+STRINGLITERAL(StringLiteral, Expr)
+#undef STRINGLITERAL
+
+#ifndef SUBSTNONTYPETEMPLATEPARMEXPR
+#  define SUBSTNONTYPETEMPLATEPARMEXPR(Type, Base) EXPR(Type, Base)
+#endif
+SUBSTNONTYPETEMPLATEPARMEXPR(SubstNonTypeTemplateParmExpr, Expr)
+#undef SUBSTNONTYPETEMPLATEPARMEXPR
+
+#ifndef SUBSTNONTYPETEMPLATEPARMPACKEXPR
+#  define SUBSTNONTYPETEMPLATEPARMPACKEXPR(Type, Base) EXPR(Type, Base)
+#endif
+SUBSTNONTYPETEMPLATEPARMPACKEXPR(SubstNonTypeTemplateParmPackExpr, Expr)
+#undef SUBSTNONTYPETEMPLATEPARMPACKEXPR
+
+#ifndef TYPETRAITEXPR
+#  define TYPETRAITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+TYPETRAITEXPR(TypeTraitExpr, Expr)
+#undef TYPETRAITEXPR
+
+#ifndef TYPOEXPR
+#  define TYPOEXPR(Type, Base) EXPR(Type, Base)
+#endif
+TYPOEXPR(TypoExpr, Expr)
+#undef TYPOEXPR
+
+#ifndef UNARYEXPRORTYPETRAITEXPR
+#  define UNARYEXPRORTYPETRAITEXPR(Type, Base) EXPR(Type, Base)
+#endif
+UNARYEXPRORTYPETRAITEXPR(UnaryExprOrTypeTraitExpr, Expr)
+#undef UNARYEXPRORTYPETRAITEXPR
+
+#ifndef UNARYOPERATOR
+#  define UNARYOPERATOR(Type, Base) EXPR(Type, Base)
+#endif
+UNARYOPERATOR(UnaryOperator, Expr)
+#undef UNARYOPERATOR
+
+#ifndef VAARGEXPR
+#  define VAARGEXPR(Type, Base) EXPR(Type, Base)
+#endif
+VAARGEXPR(VAArgExpr, Expr)
+#undef VAARGEXPR
+
+STMT_RANGE(Expr, BinaryConditionalOperator, VAArgExpr)
+
+#undef EXPR
+
+#ifndef LABELSTMT
+#  define LABELSTMT(Type, Base) VALUESTMT(Type, Base)
+#endif
+LABELSTMT(LabelStmt, ValueStmt)
+#undef LABELSTMT
+
+STMT_RANGE(ValueStmt, AttributedStmt, LabelStmt)
+
+#undef VALUESTMT
+
+#ifndef WHILESTMT
+#  define WHILESTMT(Type, Base) STMT(Type, Base)
+#endif
+WHILESTMT(WhileStmt, Stmt)
+#undef WHILESTMT
+
+LAST_STMT_RANGE(Stmt, GCCAsmStmt, WhileStmt)
+
+#undef STMT
+#undef STMT_RANGE
+#undef LAST_STMT_RANGE
+#undef ABSTRACT_STMT