Node Visitor WIP

src/Core/Diagnostics.cs

@@ -128,7 +128,9 @@ namespace CppSharp
             {
                 Console.WriteLine(message);
             }
-            Debug.WriteLine(message);
+
+            // Super slow, don't use this for now
+            // Debug.WriteLine(message);
         }
 
         public void PushIndent(int level)

src/CppParser/ASTNodeVisitor.h

@@ -0,0 +1,545 @@
+/************************************************************************
+ *
+ * CppSharp
+ * Licensed under the simplified BSD license. All rights reserved.
+ *
+ ************************************************************************/
+
+#pragma once
+#include <llvm/Support/JSON.h>
+
+#include "ASTNameMangler.h"
+#include "Types.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTDumperUtils.h"
+#include "clang/AST/ASTNodeTraverser.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/AttrVisitor.h"
+#include "clang/AST/CommentCommandTraits.h"
+#include "clang/AST/CommentVisitor.h"
+#include "clang/AST/ExprConcepts.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/AST/Type.h"
+
+#include <unordered_set>
+
+namespace CppSharp::CppParser {
+    namespace AST {
+        class Stmt;
+    }
+    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);
+        }
+
+        /// 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)
+        {
+            // If we're at the top level, there's nothing interesting to do; just
+            // run the dumper.
+            if (TopLevel)
+            {
+                TopLevel = false;
+                JOS.objectBegin();
+
+                DoAddChild();
+
+                while (!Pending.empty())
+                {
+                    Pending.back()(true);
+                    Pending.pop_back();
+                }
+
+                JOS.objectEnd();
+                TopLevel = true;
+                return;
+            }
+
+            // 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));
+            }
+            else
+            {
+                Pending.back()(false);
+                Pending.back() = std::move(DumpWithIndent);
+            }
+            FirstChild = false;
+        }
+
+        NodeStreamer(llvm::raw_ostream& OS)
+            : JOS(OS, 2)
+        {
+        }
+    };
+
+    // 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);
+            typeMap.reserve(32768);
+            stmtMap.reserve(32768);
+        }
+
+        void Visit(const clang::Attr* A);
+        void Visit(const clang::Stmt* S);
+        void Visit(const clang::Type* T);
+        void Visit(clang::QualType T);
+        AST::Declaration* Visit(const clang::Decl* D);
+        void Visit(clang::TypeLoc TL);
+
+        void Visit(const clang::comments::Comment* C, const clang::comments::FullComment* FC);
+        void Visit(const clang::TemplateArgument& TA, clang::SourceRange R = {}, const clang::Decl* From = nullptr, llvm::StringRef Label = {});
+        void Visit(const clang::CXXCtorInitializer* Init);
+        // void Visit(const OpenACCClause* C) {}
+        void Visit(const clang::OMPClause* C) {}
+        void Visit(const clang::BlockDecl::Capture& C);
+        void Visit(const clang::GenericSelectionExpr::ConstAssociation& A);
+        void Visit(const clang::concepts::Requirement* R);
+        void Visit(const clang::APValue& Value, clang::QualType Ty);
+        void Visit(const clang::ConceptReference*);
+
+        void VisitAliasAttr(const clang::AliasAttr* AA);
+        void VisitCleanupAttr(const clang::CleanupAttr* CA);
+        void VisitDeprecatedAttr(const clang::DeprecatedAttr* DA);
+        void VisitUnavailableAttr(const clang::UnavailableAttr* UA);
+        void VisitSectionAttr(const clang::SectionAttr* SA);
+        void VisitVisibilityAttr(const clang::VisibilityAttr* VA);
+        void VisitTLSModelAttr(const clang::TLSModelAttr* TA);
+
+        void VisitTypedefType(const clang::TypedefType* TT);
+        void VisitUsingType(const clang::UsingType* TT);
+        void VisitFunctionType(const clang::FunctionType* T);
+        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);
+
+        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);
+
+        // 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;
+        void ConvertNamedRecord(AST::Declaration& dst, const clang::NamedDecl& src) const;
+
+        void addPreviousDeclaration(const clang::Decl* D);
+
+        llvm::StringRef getCommentCommandName(unsigned CommandID) const;
+
+        template <typename Fn>
+        AST::Declaration* FindOrInsertLazy(const clang::Decl* D, Fn&& inserter)
+        {
+            if (auto it = declMap.find(D); it != declMap.end())
+                return it->second;
+
+            auto res = declMap.emplace(D, std::invoke(inserter));
+            return res.first->second;
+        }
+
+        std::unordered_map<const clang::Decl*, AST::Declaration*> declMap;
+        std::unordered_set<const clang::Type*> typeMap;
+        std::unordered_set<const clang::Stmt*> stmtMap;
+
+        Parser& parser;
+        const clang::SourceManager& SM;
+        clang::ASTContext& Ctx;
+        ASTNameMangler NameMangler; // TODO: Remove this, or the parser one
+        clang::PrintingPolicy PrintPolicy;
+        const clang::comments::CommandTraits& Traits;
+        llvm::StringRef LastLocFilename, LastLocPresumedFilename;
+        unsigned LastLocLine, LastLocPresumedLine;
+    };
+
+    class ASTNodeDumper : public clang::ASTNodeTraverser<ASTNodeDumper, ASTNodeVisitor>
+    {
+    public:
+        ASTNodeDumper(llvm::raw_ostream& OS, clang::ASTContext& Ctx, Parser& parser)
+            : NodeVisitor(OS, Ctx, parser)
+        {
+            setDeserialize(true);
+        }
+
+        ASTNodeVisitor& doGetNodeDelegate() { return NodeVisitor; }
+
+        void VisitFunctionTemplateDecl(const clang::FunctionTemplateDecl* FTD)
+        {
+            writeTemplateDecl(FTD, true);
+        }
+        void VisitClassTemplateDecl(const clang::ClassTemplateDecl* CTD)
+        {
+            writeTemplateDecl(CTD, false);
+        }
+        void VisitVarTemplateDecl(const clang::VarTemplateDecl* VTD)
+        {
+            writeTemplateDecl(VTD, false);
+        }
+
+    private:
+        template <typename SpecializationDecl>
+        void writeTemplateDeclSpecialization(const SpecializationDecl* SD, bool DumpExplicitInst, bool DumpRefOnly)
+        {
+            bool DumpedAny = false;
+            for (const auto* RedeclWithBadType : SD->redecls())
+            {
+                // FIXME: The redecls() range sometimes has elements of a less-specific
+                // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
+                // us TagDecls, and should give CXXRecordDecls).
+                const auto* Redecl = clang::dyn_cast<SpecializationDecl>(RedeclWithBadType);
+                if (!Redecl)
+                {
+                    // 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.
+            if (!DumpedAny)
+                NodeVisitor.AddChild([=]
+                                     {
+                                         NodeVisitor.writeBareDeclRef(SD);
+                                     });
+        }
+
+        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.
+
+            dumpTemplateParameters(TD->getTemplateParameters());
+
+            Visit(TD->getTemplatedDecl());
+
+            for (const auto* Child : TD->specializations())
+                writeTemplateDeclSpecialization(Child, DumpExplicitInst, !TD->isCanonicalDecl());
+        }
+
+        ASTNodeVisitor NodeVisitor;
+    };
+
+    class ASTParser : public clang::RecursiveASTVisitor<ASTParser>
+    {
+        bool shouldVisitTemplateInstantiations() const { return true; }
+        bool shouldWalkTypesOfTypeLocs() const { return true; }
+        bool shouldVisitImplicitCode() const { return true; }
+        bool shouldVisitLambdaBody() const { return true; }
+        bool shouldTraversePostOrder() const { return true; }
+
+        void HandleNamedDecl(AST::Declaration& AST_ND, const clang::NamedDecl* ND);
+
+        bool VisitTranslationUnitDecl(const clang::TranslationUnitDecl* D);
+        bool VisitNamedDecl(const clang::NamedDecl* ND);
+        bool VisitTypedefDecl(const clang::TypedefDecl* TD);
+        bool VisitTypeAliasDecl(const clang::TypeAliasDecl* TAD);
+        bool VisitNamespaceDecl(const clang::NamespaceDecl* ND);
+        bool VisitUsingDirectiveDecl(const clang::UsingDirectiveDecl* UDD);
+        bool VisitNamespaceAliasDecl(const clang::NamespaceAliasDecl* NAD);
+        bool VisitUsingDecl(const clang::UsingDecl* UD);
+        bool VisitUsingEnumDecl(const clang::UsingEnumDecl* UED);
+        bool VisitUsingShadowDecl(const clang::UsingShadowDecl* USD);
+        bool VisitVarDecl(const clang::VarDecl* VD);
+        bool VisitFieldDecl(const clang::FieldDecl* FD);
+        bool VisitFunctionDecl(const clang::FunctionDecl* FD);
+        bool VisitEnumDecl(const clang::EnumDecl* ED);
+        bool VisitEnumConstantDecl(const clang::EnumConstantDecl* ECD);
+        bool VisitRecordDecl(const clang::RecordDecl* RD);
+        bool VisitCXXRecordDecl(const clang::CXXRecordDecl* RD);
+        bool VisitHLSLBufferDecl(const clang::HLSLBufferDecl* D);
+        bool VisitTemplateTypeParmDecl(const clang::TemplateTypeParmDecl* D);
+        bool VisitNonTypeTemplateParmDecl(const clang::NonTypeTemplateParmDecl* D);
+        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/Decl.h

@@ -11,6 +11,7 @@
 #include "Sources.h"
 #include "Types.h"
 #include <algorithm>
+#include <unordered_map>
 
 namespace CppSharp {
 namespace CppParser {
@@ -82,6 +83,7 @@ namespace AST {
         int lineNumberStart;
         int lineNumberEnd;
         std::string name;
+        std::string mangledName;
         std::string USR;
         std::string debugText;
         bool isIncomplete;
@@ -89,6 +91,9 @@ namespace AST {
         bool isImplicit;
         bool isInvalid;
         bool isDeprecated;
+        bool isHidden;
+        bool isUsed;
+        bool isReferenced;
         Declaration* completeDeclaration;
         unsigned definitionOrder;
         VECTOR(PreprocessedEntity*, PreprocessedEntities)
@@ -115,32 +120,32 @@ namespace AST {
     public:
         DeclarationContext(DeclarationKind kind);
 
-        CS_IGNORE Declaration* FindAnonymous(const std::string& USR);
+        CS_IGNORE Declaration* FindAnonymous(const std::string_view& USR);
 
-        CS_IGNORE Namespace* FindNamespace(const std::string& Name);
-        CS_IGNORE Namespace* FindNamespace(const std::vector<std::string>&);
-        CS_IGNORE Namespace* FindCreateNamespace(const std::string& Name);
+        CS_IGNORE Namespace* FindNamespace(const std::string_view& name);
+        CS_IGNORE Namespace* FindNamespace(const std::vector<std::string_view>&);
+        CS_IGNORE Namespace& FindCreateNamespace(const std::string_view& Name);
 
-        CS_IGNORE Class* CreateClass(const std::string& Name, bool IsComplete);
-        CS_IGNORE Class* FindClass(const void* OriginalPtr, const std::string& Name, bool IsComplete);
-        CS_IGNORE Class* FindClass(const void* OriginalPtr, const std::string& Name, bool IsComplete, bool Create);
+        CS_IGNORE Class* CreateClass(const std::string_view& Name, bool IsComplete);
+        CS_IGNORE Class* FindClass(const void* OriginalPtr, const std::string_view& Name, bool IsComplete);
+        CS_IGNORE Class* FindClass(const void* OriginalPtr, const std::string_view& Name, bool IsComplete, bool Create);
 
         CS_IGNORE template <typename T>
-        T* FindTemplate(const std::string& USR);
+        T* FindTemplate(const std::string_view& USR);
 
         CS_IGNORE Enumeration* FindEnum(const void* OriginalPtr);
-        CS_IGNORE Enumeration* FindEnum(const std::string& Name, bool Create = false);
-        CS_IGNORE Enumeration* FindEnumWithItem(const std::string& Name);
+        CS_IGNORE Enumeration* FindEnum(const std::string_view& Name, bool Create = false);
+        CS_IGNORE Enumeration* FindEnumWithItem(const std::string_view& Name);
 
-        CS_IGNORE Function* FindFunction(const std::string& USR);
+        CS_IGNORE Function* FindFunction(const std::string_view& USR);
 
-        CS_IGNORE TypedefDecl* FindTypedef(const std::string& Name, bool Create = false);
+        CS_IGNORE TypedefDecl* FindTypedef(const std::string_view& Name, bool Create = false);
 
-        CS_IGNORE TypeAlias* FindTypeAlias(const std::string& Name, bool Create = false);
+        CS_IGNORE TypeAlias* FindTypeAlias(const std::string_view& Name, bool Create = false);
 
-        CS_IGNORE Variable* FindVariable(const std::string& USR);
+        CS_IGNORE Variable* FindVariable(const std::string_view& USR);
 
-        CS_IGNORE Friend* FindFriend(const std::string& USR);
+        CS_IGNORE Friend* FindFriend(const std::string_view& USR);
 
         VECTOR(Namespace*, Namespaces)
         VECTOR(Enumeration*, Enums)
@@ -152,7 +157,7 @@ namespace AST {
         VECTOR(Variable*, Variables)
         VECTOR(Friend*, Friends)
 
-        std::map<std::string, Declaration*> anonymous;
+        std::map<std::string, Declaration*, std::less<>> anonymous;
 
         bool isAnonymous;
     };
@@ -203,7 +208,7 @@ namespace AST {
     class CS_API StatementObsolete
     {
     public:
-        StatementObsolete(const std::string& str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration* decl = 0);
+        StatementObsolete(const std::string& str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration* decl = nullptr);
         StatementClassObsolete _class;
         Declaration* decl;
         std::string string;
@@ -212,7 +217,7 @@ namespace AST {
     class CS_API ExpressionObsolete : public StatementObsolete
     {
     public:
-        ExpressionObsolete(const std::string& str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration* decl = 0);
+        ExpressionObsolete(const std::string& str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration* decl = nullptr);
     };
 
     class Expr;
@@ -238,7 +243,7 @@ namespace AST {
     class CS_API CXXConstructExprObsolete : public ExpressionObsolete
     {
     public:
-        CXXConstructExprObsolete(const std::string& str, Declaration* decl = 0);
+        CXXConstructExprObsolete(const std::string& str, Declaration* decl = nullptr);
         ~CXXConstructExprObsolete();
         VECTOR(ExpressionObsolete*, Arguments)
     };
@@ -417,7 +422,7 @@ namespace AST {
         BuiltinType* builtinType;
         VECTOR(Item*, Items)
 
-        Item* FindItemByName(const std::string& Name);
+        Item* FindItemByName(const std::string_view& Name);
     };
 
     class CS_API Variable : public Declaration
@@ -611,10 +616,10 @@ namespace AST {
     };
 
     template <typename T>
-    T* DeclarationContext::FindTemplate(const std::string& USR)
+    T* DeclarationContext::FindTemplate(const std::string_view& USR)
     {
-        auto foundTemplate = std::find_if(Templates.begin(), Templates.end(),
-                                          [&](Template* t)
+        auto foundTemplate = std::find_if(Templates.cbegin(), Templates.cend(),
+                                          [&](const Template* t)
                                           {
                                               return t->USR == USR;
                                           });
@@ -782,6 +787,7 @@ namespace AST {
         Namespace();
         ~Namespace();
         bool isInline;
+        bool isNested;
     };
 
     enum class MacroLocation

src/CppParser/Parser.cpp

@@ -59,6 +59,7 @@
 #include <Driver/ToolChains/MSVC.h>
 
 #include "ASTNameMangler.h"
+#include "ASTNodeVisitor.h"
 
 #if defined(__APPLE__) || defined(__linux__)
 #ifndef _GNU_SOURCE
@@ -514,12 +515,6 @@ std::string Parser::GetDeclMangledName(const clang::Decl* D) const
     if (ND->isTemplated())
         return {};
 
-    /*bool CanMangle = isa<FunctionDecl>(D) || isa<VarDecl>(D)
-        || isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D);
-
-    if (!CanMangle)
-        return {};*/
-
     // FIXME: There are likely other contexts in which it makes no sense to ask
     // for a mangled name.
     if (isa<RequiresExprBodyDecl>(ND->getDeclContext()))
@@ -2125,7 +2120,7 @@ Field* Parser::WalkFieldCXX(const clang::FieldDecl* FD, Class* Class)
 
 //-----------------------------------//
 
-TranslationUnit* Parser::GetTranslationUnit(clang::SourceLocation Loc,
+TranslationUnit* Parser::GetOrCreateTranslationUnit(clang::SourceLocation Loc,
                                                     SourceLocationKind* Kind)
 {
     using namespace clang;
@@ -2171,12 +2166,12 @@ TranslationUnit* Parser::GetTranslationUnit(clang::SourceLocation Loc,
 
 //-----------------------------------//
 
-TranslationUnit* Parser::GetTranslationUnit(const clang::Decl* D)
+TranslationUnit* Parser::GetOrCreateTranslationUnit(const clang::Decl* D)
 {
     clang::SourceLocation Loc = D->getLocation();
 
     SourceLocationKind Kind;
-    TranslationUnit* Unit = GetTranslationUnit(Loc, &Kind);
+    TranslationUnit* Unit = GetOrCreateTranslationUnit(Loc, &Kind);
 
     return Unit;
 }
@@ -2190,13 +2185,13 @@ DeclarationContext* Parser::GetNamespace(const clang::Decl* D,
 
     // If the declaration is at global scope, just early exit.
     if (Context->isTranslationUnit())
-        return GetTranslationUnit(D);
+        return GetOrCreateTranslationUnit(D);
 
     auto NS = walkedNamespaces[Context];
     if (NS)
         return NS;
 
-    TranslationUnit* Unit = GetTranslationUnit(cast<Decl>(Context));
+    TranslationUnit* Unit = GetOrCreateTranslationUnit(cast<Decl>(Context));
 
     // Else we need to do a more expensive check to get all the namespaces,
     // and then perform a reverse iteration to get the namespaces in order.
@@ -2230,8 +2225,7 @@ DeclarationContext* Parser::GetNamespace(const clang::Decl* D,
                 if (ND->isAnonymousNamespace())
                     break;
 
-                auto Name = ND->getName();
-                DC = DC->FindCreateNamespace(Name.str());
+                DC = &DC->FindCreateNamespace(ND->getName());
                 ((Namespace*)DC)->isAnonymous = ND->isAnonymousNamespace();
                 ((Namespace*)DC)->isInline = ND->isInline();
                 HandleDeclaration(ND, DC);
@@ -3889,7 +3883,7 @@ PreprocessedEntity* Parser::WalkPreprocessedEntity(
         return nullptr;
 
     Entity->originalPtr = PPEntity;
-    auto Namespace = GetTranslationUnit(PPEntity->getSourceRange().getBegin());
+    auto Namespace = GetOrCreateTranslationUnit(PPEntity->getSourceRange().getBegin());
 
     if (Decl->kind == DeclarationKind::TranslationUnit)
     {
@@ -4402,7 +4396,7 @@ Declaration* Parser::WalkDeclaration(const clang::Decl* D)
         }
         case Decl::TranslationUnit:
         {
-            Decl = GetTranslationUnit(D);
+            Decl = GetOrCreateTranslationUnit(D);
             break;
         }
         case Decl::Namespace:
@@ -4676,6 +4670,15 @@ void SemaConsumer::HandleTranslationUnit(clang::ASTContext& Ctx)
     if (Unit->originalPtr == nullptr)
         Unit->originalPtr = (void*)FileEntry;
 
+    std::string Text;
+    Text.reserve(200000000);
+    {
+        llvm::raw_string_ostream OS(Text);
+
+        ASTNodeDumper Dumper(OS, Ctx, Parser);
+        Dumper.Visit(TU);
+    }
+
     Parser.WalkAST(TU);
 }
 

src/CppParser/Parser.h

@@ -97,8 +97,8 @@ namespace CppSharp { namespace CppParser {
         void WalkVariable(const clang::VarDecl* VD, AST::Variable* Var);
         AST::Friend* WalkFriend(const clang::FriendDecl* FD);
         AST::RawComment* WalkRawComment(const clang::RawComment* RC);
-        AST::Type* WalkType(clang::QualType QualType, const clang::TypeLoc* TL = 0, bool DesugarType = false);
-        AST::TemplateArgument WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateArgumentLoc* ArgLoc = 0);
+        AST::Type* WalkType(clang::QualType QualType, const clang::TypeLoc* TL = nullptr, bool DesugarType = false);
+        AST::TemplateArgument WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateArgumentLoc* ArgLoc = nullptr);
         AST::TemplateTemplateParameter* WalkTemplateTemplateParameter(const clang::TemplateTemplateParmDecl* TTP);
         AST::TypeTemplateParameter* WalkTypeTemplateParameter(const clang::TemplateTypeParmDecl* TTPD);
         AST::NonTypeTemplateParameter* WalkNonTypeTemplateParameter(const clang::NonTypeTemplateParmDecl* TTPD);
@@ -116,7 +116,7 @@ namespace CppSharp { namespace CppParser {
         std::vector<AST::TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, TypeLoc* TSTL);
         std::vector<AST::TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, const clang::ASTTemplateArgumentListInfo* TSTL);
         void WalkVTable(const clang::CXXRecordDecl* RD, AST::Class* C);
-        AST::QualifiedType GetQualifiedType(clang::QualType qual, const clang::TypeLoc* TL = 0);
+        AST::QualifiedType GetQualifiedType(clang::QualType qual, const clang::TypeLoc* TL = nullptr);
         void ReadClassLayout(AST::Class* Class, const clang::RecordDecl* RD, clang::CharUnits Offset, bool IncludeVirtualBases);
         AST::LayoutField WalkVTablePointer(AST::Class* Class, const clang::CharUnits& Offset, const std::string& prefix);
         AST::VTableLayout WalkVTableLayout(const clang::VTableLayout& VTLayout);
@@ -150,9 +150,9 @@ namespace CppSharp { namespace CppParser {
         bool GetDeclText(clang::SourceRange SR, std::string& Text);
         bool HasLayout(const clang::RecordDecl* Record);
 
-        AST::TranslationUnit* GetTranslationUnit(clang::SourceLocation Loc,
-                                                 SourceLocationKind* Kind = 0);
-        AST::TranslationUnit* GetTranslationUnit(const clang::Decl* D);
+        AST::TranslationUnit* GetOrCreateTranslationUnit(clang::SourceLocation Loc,
+                                                         SourceLocationKind* Kind = nullptr);
+        AST::TranslationUnit* GetOrCreateTranslationUnit(const clang::Decl* D);
 
         AST::DeclarationContext* GetNamespace(const clang::Decl* D, const clang::DeclContext* Ctx);
         AST::DeclarationContext* GetNamespace(const clang::Decl* D);

src/CppParser/ParserGen/ParserGen.cs

@@ -28,6 +28,8 @@ namespace CppSharp
             Kind = kind;
             Triple = triple;
             IsGnuCpp11Abi = isGnuCpp11Abi;
+
+            Diagnostics.Level = DiagnosticKind.Debug;
         }
 
         static string GetSourceDirectory(string dir)

src/CppParser/Types.h

@@ -9,10 +9,10 @@
 
 #include "Helpers.h"
 
-namespace CppSharp { namespace CppParser { namespace AST {
+namespace CppSharp::CppParser::AST {
 
-    enum class TypeKind
-    {
+enum class TypeKind
+{
     Tag,
     Array,
     Function,
@@ -32,47 +32,49 @@ namespace CppSharp { namespace CppParser { namespace AST {
     UnaryTransform,
     UnresolvedUsing,
     Vector
-    };
+};
 
 #define DECLARE_TYPE_KIND(kind) \
     kind##Type();
 
-    class CS_API Type
-    {
-    public:
+class CS_API Type
+{
+public:
     Type(TypeKind kind);
     Type(const Type&);
 
     TypeKind kind;
-        bool isDependent;
-    };
-
-    struct CS_API TypeQualifiers
-    {
-        bool isConst;
-        bool isVolatile;
-        bool isRestrict;
-    };
-
-    struct CS_API QualifiedType
-    {
+    bool isDependent = false;
+};
+
+struct CS_API TypeQualifiers
+{
+    bool isConst = false;
+    bool isVolatile = false;
+    bool isRestrict = false;
+};
+
+struct CS_API QualifiedType
+{
     QualifiedType();
-        Type* type;
+    Type* type = nullptr;
+    Type* desugaredType = nullptr;
+    void* typeAliasDeclId = nullptr;
     TypeQualifiers qualifiers;
-    };
+};
 
-    class Declaration;
+class Declaration;
 
-    class CS_API TagType : public Type
-    {
-    public:
+class CS_API TagType : public Type
+{
+public:
     DECLARE_TYPE_KIND(Tag)
     Declaration* declaration;
-    };
+};
 
-    class CS_API ArrayType : public Type
-    {
-    public:
+class CS_API ArrayType : public Type
+{
+public:
     enum class ArraySize
     {
         Constant,
@@ -86,22 +88,22 @@ namespace CppSharp { namespace CppParser { namespace AST {
     ArraySize sizeType;
     long size;
     long elementSize;
-    };
+};
 
-    class Parameter;
+class Parameter;
 
-    enum class CallingConvention
-    {
+enum class CallingConvention
+{
     Default,
     C,
     StdCall,
     ThisCall,
     FastCall,
     Unknown
-    };
+};
 
-    enum class ExceptionSpecType
-    {
+enum class ExceptionSpecType
+{
     None,
     DynamicNone,
     Dynamic,
@@ -113,22 +115,22 @@ namespace CppSharp { namespace CppParser { namespace AST {
     Unevaluated,
     Uninstantiated,
     Unparsed
-    };
+};
 
-    class CS_API FunctionType : public Type
-    {
-    public:
+class CS_API FunctionType : public Type
+{
+public:
     DECLARE_TYPE_KIND(Function)
     ~FunctionType();
     QualifiedType returnType;
     CallingConvention callingConvention;
     ExceptionSpecType exceptionSpecType;
     VECTOR(Parameter*, Parameters)
-    };
+};
 
-    class CS_API PointerType : public Type
-    {
-    public:
+class CS_API PointerType : public Type
+{
+public:
     enum struct TypeModifier
     {
         Value,
@@ -140,43 +142,43 @@ namespace CppSharp { namespace CppParser { namespace AST {
     DECLARE_TYPE_KIND(Pointer)
     QualifiedType qualifiedPointee;
     TypeModifier modifier;
-    };
+};
 
-    class CS_API MemberPointerType : public Type
-    {
-    public:
+class CS_API MemberPointerType : public Type
+{
+public:
     DECLARE_TYPE_KIND(MemberPointer)
     QualifiedType pointee;
-    };
+};
 
-    class TypedefNameDecl;
+class TypedefNameDecl;
 
-    class CS_API TypedefType : public Type
-    {
-    public:
+class CS_API TypedefType : public Type
+{
+public:
     TypedefType();
     TypedefNameDecl* declaration;
-    };
+};
 
-    class CS_API AttributedType : public Type
-    {
-    public:
+class CS_API AttributedType : public Type
+{
+public:
     DECLARE_TYPE_KIND(Attributed)
     QualifiedType modified;
     QualifiedType equivalent;
-    };
+};
 
-    class CS_API DecayedType : public Type
-    {
-    public:
+class CS_API DecayedType : public Type
+{
+public:
     DECLARE_TYPE_KIND(Decayed)
     QualifiedType decayed;
     QualifiedType original;
     QualifiedType pointee;
-    };
+};
 
-    struct CS_API TemplateArgument
-    {
+struct CS_API TemplateArgument
+{
     TemplateArgument();
 
     enum struct ArgumentKind
@@ -195,13 +197,13 @@ namespace CppSharp { namespace CppParser { namespace AST {
     QualifiedType type;
     Declaration* declaration;
     long integral;
-    };
+};
 
-    class Template;
+class Template;
 
-    class CS_API TemplateSpecializationType : public Type
-    {
-    public:
+class CS_API TemplateSpecializationType : public Type
+{
+public:
     TemplateSpecializationType();
     TemplateSpecializationType(const TemplateSpecializationType&);
     ~TemplateSpecializationType();
@@ -209,92 +211,92 @@ namespace CppSharp { namespace CppParser { namespace AST {
     VECTOR(TemplateArgument, Arguments)
     Template* _template;
     QualifiedType desugared;
-    };
+};
 
-    class CS_API DependentTemplateSpecializationType : public Type
-    {
-    public:
+class CS_API DependentTemplateSpecializationType : public Type
+{
+public:
     DependentTemplateSpecializationType();
     DependentTemplateSpecializationType(const DependentTemplateSpecializationType&);
     ~DependentTemplateSpecializationType();
 
     VECTOR(TemplateArgument, Arguments)
     QualifiedType desugared;
-    };
+};
 
-    class TypeTemplateParameter;
+class TypeTemplateParameter;
 
-    class CS_API TemplateParameterType : public Type
-    {
-    public:
+class CS_API TemplateParameterType : public Type
+{
+public:
     DECLARE_TYPE_KIND(TemplateParameter)
     ~TemplateParameterType();
     TypeTemplateParameter* parameter;
     unsigned int depth;
     unsigned int index;
     bool isParameterPack;
-    };
+};
 
-    class CS_API TemplateParameterSubstitutionType : public Type
-    {
-    public:
+class CS_API TemplateParameterSubstitutionType : public Type
+{
+public:
     DECLARE_TYPE_KIND(TemplateParameterSubstitution)
     QualifiedType replacement;
     TemplateParameterType* replacedParameter;
-    };
+};
 
-    class Class;
+class Class;
 
-    class CS_API InjectedClassNameType : public Type
-    {
-    public:
+class CS_API InjectedClassNameType : public Type
+{
+public:
     DECLARE_TYPE_KIND(InjectedClassName)
     QualifiedType injectedSpecializationType;
     Class* _class;
-    };
+};
 
-    class CS_API DependentNameType : public Type
-    {
-    public:
+class CS_API DependentNameType : public Type
+{
+public:
     DECLARE_TYPE_KIND(DependentName)
     ~DependentNameType();
     QualifiedType qualifier;
     std::string identifier;
-    };
+};
 
-    class CS_API PackExpansionType : public Type
-    {
-    public:
+class CS_API PackExpansionType : public Type
+{
+public:
     DECLARE_TYPE_KIND(PackExpansion)
-    };
+};
 
-    class CS_API UnaryTransformType : public Type
-    {
-    public:
+class CS_API UnaryTransformType : public Type
+{
+public:
     DECLARE_TYPE_KIND(UnaryTransform)
     QualifiedType desugared;
     QualifiedType baseType;
-    };
+};
 
-    class UnresolvedUsingTypename;
+class UnresolvedUsingTypename;
 
-    class CS_API UnresolvedUsingType : public Type
-    {
-    public:
+class CS_API UnresolvedUsingType : public Type
+{
+public:
     DECLARE_TYPE_KIND(UnresolvedUsing)
     UnresolvedUsingTypename* declaration;
-    };
+};
 
-    class CS_API VectorType : public Type
-    {
-    public:
+class CS_API VectorType : public Type
+{
+public:
     DECLARE_TYPE_KIND(Vector)
     QualifiedType elementType;
     unsigned numElements;
-    };
+};
 
-    enum class PrimitiveType
-    {
+enum class PrimitiveType
+{
     Null,
     Void,
     Bool,
@@ -320,13 +322,13 @@ namespace CppSharp { namespace CppParser { namespace AST {
     LongDouble,
     Float128,
     IntPtr
-    };
+};
 
-    class CS_API BuiltinType : public Type
-    {
-    public:
+class CS_API BuiltinType : public Type
+{
+public:
     DECLARE_TYPE_KIND(Builtin)
     PrimitiveType type;
-    };
+};
 
-}}} // namespace CppSharp::CppParser::AST
+} // namespace CppSharp::CppParser::AST

src/Generator.Tests/GeneratorTest.cs

@@ -28,6 +28,7 @@ namespace CppSharp.Utils
             options.Quiet = true;
             options.GenerateDebugOutput = true;
             options.CheckSymbols = true;
+            driver.ParserOptions.SkipSystemHeaders = false;
             var testModule = options.AddModule(name);
 
             Diagnostics.Message("");