Extract types and decls out of `AST.h`.

7 years ago · 7eb7fc2912
3 changed files with 1117 additions and 1089 deletions
--- a/src/CppParser/AST.h
+++ b/src/CppParser/AST.h
--- a/src/CppParser/Decl.h
+++ b/src/CppParser/Decl.h
@ -0,0 +1,792 @@
				@@ -0,0 +1,792 @@
+/************************************************************************
+*
+* CppSharp
+* Licensed under the MIT license.
+*
+************************************************************************/
+
+#pragma once
+
+#include "Helpers.h"
+#include "Sources.h"
+#include "Types.h"
+#include <algorithm>
+
+namespace CppSharp { namespace CppParser { namespace AST {
+
+enum class DeclarationKind
+{
+    DeclarationContext,
+    Typedef,
+    TypeAlias,
+    Parameter,
+    Function,
+    Method,
+    Enumeration,
+    EnumerationItem,
+    Variable,
+    Field,
+    AccessSpecifier,
+    Class,
+    Template,
+    TypeAliasTemplate,
+    ClassTemplate,
+    ClassTemplateSpecialization,
+    ClassTemplatePartialSpecialization,
+    FunctionTemplate,
+    Namespace,
+    PreprocessedEntity,
+    MacroDefinition,
+    MacroExpansion,
+    TranslationUnit,
+    Friend,
+    TemplateTemplateParm,
+    TemplateTypeParm,
+    NonTypeTemplateParm,
+    VarTemplate,
+    VarTemplateSpecialization,
+    VarTemplatePartialSpecialization
+};
+
+#define DECLARE_DECL_KIND(klass, kind) \
+klass();
+
+enum class AccessSpecifier
+{
+    Private,
+    Protected,
+    Public
+};
+
+class DeclarationContext;
+class RawComment;
+class PreprocessedEntity;
+
+class CS_API Declaration
+{
+public:
+    Declaration(DeclarationKind kind);
+    Declaration(const Declaration&);
+    ~Declaration();
+
+    DeclarationKind kind;
+    int maxFieldAlignment;
+    AccessSpecifier access;
+    DeclarationContext* _namespace;
+    SourceLocation location;
+    int lineNumberStart;
+    int lineNumberEnd;
+    std::string name;
+    std::string USR;
+    std::string debugText;
+    bool isIncomplete;
+    bool isDependent;
+    bool isImplicit;
+    bool isInvalid;
+    Declaration* completeDeclaration;
+    unsigned definitionOrder;
+    VECTOR(PreprocessedEntity*, PreprocessedEntities)
+        VECTOR(Declaration*, Redeclarations)
+        void* originalPtr;
+    RawComment* comment;
+};
+
+class Class;
+class Enumeration;
+class Function;
+class TypedefDecl;
+class TypeAlias;
+class Namespace;
+class Template;
+class TypeAliasTemplate;
+class ClassTemplate;
+class FunctionTemplate;
+class Variable;
+class Friend;
+
+class CS_API DeclarationContext : public Declaration
+{
+public:
+    DeclarationContext(DeclarationKind kind);
+
+    CS_IGNORE Declaration* FindAnonymous(const std::string& 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 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 template<typename T> T* FindTemplate(const std::string& 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 Function* FindFunction(const std::string& USR);
+
+    CS_IGNORE TypedefDecl* FindTypedef(const std::string& Name, bool Create = false);
+
+    CS_IGNORE TypeAlias* FindTypeAlias(const std::string& Name, bool Create = false);
+
+    CS_IGNORE Variable* FindVariable(const std::string& USR);
+
+    CS_IGNORE Friend* FindFriend(const std::string& USR);
+
+    VECTOR(Namespace*, Namespaces)
+        VECTOR(Enumeration*, Enums)
+        VECTOR(Function*, Functions)
+        VECTOR(Class*, Classes)
+        VECTOR(Template*, Templates)
+        VECTOR(TypedefDecl*, Typedefs)
+        VECTOR(TypeAlias*, TypeAliases)
+        VECTOR(Variable*, Variables)
+        VECTOR(Friend*, Friends)
+
+        std::map<std::string, Declaration*> anonymous;
+
+    bool isAnonymous;
+};
+
+class CS_API TypedefNameDecl : public Declaration
+{
+public:
+    TypedefNameDecl(DeclarationKind kind);
+    ~TypedefNameDecl();
+    QualifiedType qualifiedType;
+};
+
+class CS_API TypedefDecl : public TypedefNameDecl
+{
+public:
+    DECLARE_DECL_KIND(TypedefDecl, Typedef)
+    ~TypedefDecl();
+};
+
+class CS_API TypeAlias : public TypedefNameDecl
+{
+public:
+    TypeAlias();
+    ~TypeAlias();
+    TypeAliasTemplate* describedAliasTemplate;
+};
+
+class CS_API Friend : public Declaration
+{
+public:
+    DECLARE_DECL_KIND(Friend, Friend)
+    ~Friend();
+    Declaration* declaration;
+};
+
+enum class StatementClass
+{
+    Any,
+    BinaryOperator,
+    CallExprClass,
+    DeclRefExprClass,
+    CXXConstructExprClass,
+    CXXOperatorCallExpr,
+    ImplicitCastExpr,
+    ExplicitCastExpr,
+};
+
+class CS_API Statement
+{
+public:
+    Statement(const std::string& str, StatementClass Class = StatementClass::Any, Declaration* decl = 0);
+    StatementClass _class;
+    Declaration* decl;
+    std::string string;
+};
+
+class CS_API Expression : public Statement
+{
+public:
+    Expression(const std::string& str, StatementClass Class = StatementClass::Any, Declaration* decl = 0);
+};
+
+class Expr;
+
+class CS_API BinaryOperator : public Expression
+{
+public:
+    BinaryOperator(const std::string& str, Expression* lhs, Expression* rhs, const std::string& opcodeStr);
+    ~BinaryOperator();
+    Expression* LHS;
+    Expression* RHS;
+    std::string opcodeStr;
+};
+
+class CS_API CallExpr : public Expression
+{
+public:
+    CallExpr(const std::string& str, Declaration* decl);
+    ~CallExpr();
+    VECTOR(Expression*, Arguments)
+};
+
+class CS_API CXXConstructExpr : public Expression
+{
+public:
+    CXXConstructExpr(const std::string& str, Declaration* decl = 0);
+    ~CXXConstructExpr();
+    VECTOR(Expression*, Arguments)
+};
+
+class CS_API Parameter : public Declaration
+{
+public:
+    Parameter();
+    ~Parameter();
+
+    QualifiedType qualifiedType;
+    bool isIndirect;
+    bool hasDefaultValue;
+    unsigned int index;
+    Expression* defaultArgument;
+    Expr* defaultArgumentNew;
+};
+
+enum class CXXMethodKind
+{
+    Normal,
+    Constructor,
+    Destructor,
+    Conversion,
+    Operator,
+    UsingDirective
+};
+
+enum class CXXOperatorKind
+{
+    None,
+    New,
+    Delete,
+    Array_New,
+    Array_Delete,
+    Plus,
+    Minus,
+    Star,
+    Slash,
+    Percent,
+    Caret,
+    Amp,
+    Pipe,
+    Tilde,
+    Exclaim,
+    Equal,
+    Less,
+    Greater,
+    PlusEqual,
+    MinusEqual,
+    StarEqual,
+    SlashEqual,
+    PercentEqual,
+    CaretEqual,
+    AmpEqual,
+    PipeEqual,
+    LessLess,
+    GreaterGreater,
+    LessLessEqual,
+    GreaterGreaterEqual,
+    EqualEqual,
+    ExclaimEqual,
+    LessEqual,
+    GreaterEqual,
+    Spaceship,
+    AmpAmp,
+    PipePipe,
+    PlusPlus,
+    MinusMinus,
+    Comma,
+    ArrowStar,
+    Arrow,
+    Call,
+    Subscript,
+    Conditional,
+    Coawait
+};
+
+class FunctionTemplateSpecialization;
+
+enum class FriendKind
+{
+    None,
+    Declared,
+    Undeclared
+};
+
+class CS_API Function : public DeclarationContext
+{
+public:
+    Function();
+    ~Function();
+
+    QualifiedType returnType;
+    bool isReturnIndirect;
+    bool hasThisReturn;
+
+    bool isConstExpr;
+    bool isVariadic;
+    bool isInline;
+    bool isPure;
+    bool isDeleted;
+    bool isDefaulted;
+    FriendKind friendKind;
+    CXXOperatorKind operatorKind;
+    std::string mangled;
+    std::string signature;
+    std::string body;
+    CallingConvention callingConvention;
+    VECTOR(Parameter*, Parameters)
+        FunctionTemplateSpecialization* specializationInfo;
+    Function* instantiatedFrom;
+    QualifiedType qualifiedType;
+};
+
+class AccessSpecifierDecl;
+
+enum class RefQualifierKind
+{
+    None,
+    LValue,
+    RValue
+};
+
+class CS_API Method : public Function
+{
+public:
+    Method();
+    ~Method();
+
+    bool isVirtual;
+    bool isStatic;
+    bool isConst;
+    bool isExplicit;
+
+    CXXMethodKind methodKind;
+
+    bool isDefaultConstructor;
+    bool isCopyConstructor;
+    bool isMoveConstructor;
+
+    QualifiedType conversionType;
+    RefQualifierKind refQualifier;
+    VECTOR(Method*, OverriddenMethods)
+};
+
+class CS_API Enumeration : public DeclarationContext
+{
+public:
+    DECLARE_DECL_KIND(Enumeration, Enumeration)
+    ~Enumeration();
+
+    class CS_API Item : public Declaration
+    {
+    public:
+        DECLARE_DECL_KIND(Item, EnumerationItem)
+        Item(const Item&);
+        ~Item();
+        std::string expression;
+        uint64_t value;
+    };
+
+    enum class CS_FLAGS EnumModifiers
+    {
+        Anonymous = 1 << 0,
+        Scoped = 1 << 1,
+        Flags = 1 << 2,
+    };
+
+    EnumModifiers modifiers;
+    Type* type;
+    BuiltinType* builtinType;
+    VECTOR(Item*, Items)
+
+        Item* FindItemByName(const std::string& Name);
+};
+
+class CS_API Variable : public Declaration
+{
+public:
+    DECLARE_DECL_KIND(Variable, Variable)
+    ~Variable();
+    std::string mangled;
+    QualifiedType qualifiedType;
+};
+
+class PreprocessedEntity;
+
+struct CS_API BaseClassSpecifier
+{
+    BaseClassSpecifier();
+    AccessSpecifier access;
+    bool isVirtual;
+    Type* type;
+    int offset;
+};
+
+class Class;
+
+class CS_API Field : public Declaration
+{
+public:
+    DECLARE_DECL_KIND(Field, Field)
+    ~Field();
+    QualifiedType qualifiedType;
+    Class* _class;
+    bool isBitField;
+    unsigned bitWidth;
+};
+
+class CS_API AccessSpecifierDecl : public Declaration
+{
+public:
+    DECLARE_DECL_KIND(AccessSpecifierDecl, AccessSpecifier)
+    ~AccessSpecifierDecl();
+};
+
+enum class CppAbi
+{
+    Itanium,
+    Microsoft,
+    ARM,
+    iOS,
+    iOS64
+};
+
+enum class VTableComponentKind
+{
+    VCallOffset,
+    VBaseOffset,
+    OffsetToTop,
+    RTTI,
+    FunctionPointer,
+    CompleteDtorPointer,
+    DeletingDtorPointer,
+    UnusedFunctionPointer,
+};
+
+struct CS_API VTableComponent
+{
+    VTableComponent();
+    VTableComponentKind kind;
+    unsigned offset;
+    Declaration* declaration;
+};
+
+struct CS_API VTableLayout
+{
+    VTableLayout();
+    VTableLayout(const VTableLayout&);
+    ~VTableLayout();
+    VECTOR(VTableComponent, Components)
+};
+
+struct CS_API VFTableInfo
+{
+    VFTableInfo();
+    VFTableInfo(const VFTableInfo&);
+    uint64_t VBTableIndex;
+    uint32_t VFPtrOffset;
+    uint32_t VFPtrFullOffset;
+    VTableLayout layout;
+};
+
+class CS_API LayoutField
+{
+public:
+    LayoutField();
+    LayoutField(const LayoutField& other);
+    ~LayoutField();
+    unsigned offset;
+    std::string name;
+    QualifiedType qualifiedType;
+    void* fieldPtr;
+};
+
+class Class;
+
+class CS_API LayoutBase
+{
+public:
+    LayoutBase();
+    LayoutBase(const LayoutBase& other);
+    ~LayoutBase();
+    unsigned offset;
+    Class* _class;
+};
+
+struct CS_API ClassLayout
+{
+    ClassLayout();
+    CppAbi ABI;
+    VECTOR(VFTableInfo, VFTables)
+    VTableLayout layout;
+    bool hasOwnVFPtr;
+    long VBPtrOffset;
+    int alignment;
+    int size;
+    int dataSize;
+    VECTOR(LayoutField, Fields)
+    VECTOR(LayoutBase, Bases)
+};
+
+class CS_API Class : public DeclarationContext
+{
+public:
+    Class();
+    ~Class();
+
+    VECTOR(BaseClassSpecifier*, Bases)
+        VECTOR(Field*, Fields)
+        VECTOR(Method*, Methods)
+        VECTOR(AccessSpecifierDecl*, Specifiers)
+
+        bool isPOD;
+    bool isAbstract;
+    bool isUnion;
+    bool isDynamic;
+    bool isPolymorphic;
+    bool hasNonTrivialDefaultConstructor;
+    bool hasNonTrivialCopyConstructor;
+    bool hasNonTrivialDestructor;
+    bool isExternCContext;
+    bool isInjected;
+
+    ClassLayout* layout;
+};
+
+class CS_API Template : public Declaration
+{
+public:
+    Template(DeclarationKind kind);
+    DECLARE_DECL_KIND(Template, Template)
+    Declaration* TemplatedDecl;
+    VECTOR(Declaration*, Parameters)
+};
+
+template<typename T>
+T* DeclarationContext::FindTemplate(const std::string& USR)
+{
+    auto foundTemplate = std::find_if(Templates.begin(), Templates.end(),
+        [&](Template* t) { return t->USR == USR; });
+
+    if (foundTemplate != Templates.end())
+        return static_cast<T*>(*foundTemplate);
+
+    return nullptr;
+}
+
+class CS_API TypeAliasTemplate : public Template
+{
+public:
+    TypeAliasTemplate();
+    ~TypeAliasTemplate();
+};
+
+class CS_API TemplateParameter : public Declaration
+{
+public:
+    TemplateParameter(DeclarationKind kind);
+    ~TemplateParameter();
+    unsigned int depth;
+    unsigned int index;
+    bool isParameterPack;
+};
+
+class CS_API TemplateTemplateParameter : public Template
+{
+public:
+    TemplateTemplateParameter();
+    ~TemplateTemplateParameter();
+
+    bool isParameterPack;
+    bool isPackExpansion;
+    bool isExpandedParameterPack;
+};
+
+class CS_API TypeTemplateParameter : public TemplateParameter
+{
+public:
+    TypeTemplateParameter();
+    TypeTemplateParameter(const TypeTemplateParameter&);
+    ~TypeTemplateParameter();
+
+    QualifiedType defaultArgument;
+};
+
+class CS_API NonTypeTemplateParameter : public TemplateParameter
+{
+public:
+    NonTypeTemplateParameter();
+    NonTypeTemplateParameter(const NonTypeTemplateParameter&);
+    ~NonTypeTemplateParameter();
+    Expression* defaultArgument;
+    Expr* defaultArgumentNew;
+    unsigned int position;
+    bool isPackExpansion;
+    bool isExpandedParameterPack;
+};
+
+class ClassTemplateSpecialization;
+class ClassTemplatePartialSpecialization;
+
+class CS_API ClassTemplate : public Template
+{
+public:
+    ClassTemplate();
+    ~ClassTemplate();
+    VECTOR(ClassTemplateSpecialization*, Specializations)
+        ClassTemplateSpecialization* FindSpecialization(const std::string& usr);
+    ClassTemplatePartialSpecialization* FindPartialSpecialization(const std::string& usr);
+};
+
+enum class TemplateSpecializationKind
+{
+    Undeclared,
+    ImplicitInstantiation,
+    ExplicitSpecialization,
+    ExplicitInstantiationDeclaration,
+    ExplicitInstantiationDefinition
+};
+
+class CS_API ClassTemplateSpecialization : public Class
+{
+public:
+    ClassTemplateSpecialization();
+    ~ClassTemplateSpecialization();
+    ClassTemplate* templatedDecl;
+    VECTOR(TemplateArgument, Arguments)
+        TemplateSpecializationKind specializationKind;
+};
+
+class CS_API ClassTemplatePartialSpecialization : public ClassTemplateSpecialization
+{
+public:
+    ClassTemplatePartialSpecialization();
+    ~ClassTemplatePartialSpecialization();
+};
+
+class CS_API FunctionTemplate : public Template
+{
+public:
+    FunctionTemplate();
+    ~FunctionTemplate();
+    VECTOR(FunctionTemplateSpecialization*, Specializations)
+        FunctionTemplateSpecialization* FindSpecialization(const std::string& usr);
+};
+
+class CS_API FunctionTemplateSpecialization
+{
+public:
+    FunctionTemplateSpecialization();
+    ~FunctionTemplateSpecialization();
+    FunctionTemplate* _template;
+    VECTOR(TemplateArgument, Arguments)
+        Function* specializedFunction;
+    TemplateSpecializationKind specializationKind;
+};
+
+class VarTemplateSpecialization;
+class VarTemplatePartialSpecialization;
+
+class CS_API VarTemplate : public Template
+{
+public:
+    VarTemplate();
+    ~VarTemplate();
+    VECTOR(VarTemplateSpecialization*, Specializations)
+        VarTemplateSpecialization* FindSpecialization(const std::string& usr);
+    VarTemplatePartialSpecialization* FindPartialSpecialization(const std::string& usr);
+};
+
+class CS_API VarTemplateSpecialization : public Variable
+{
+public:
+    VarTemplateSpecialization();
+    ~VarTemplateSpecialization();
+    VarTemplate* templatedDecl;
+    VECTOR(TemplateArgument, Arguments)
+        TemplateSpecializationKind specializationKind;
+};
+
+class CS_API VarTemplatePartialSpecialization : public VarTemplateSpecialization
+{
+public:
+    VarTemplatePartialSpecialization();
+    ~VarTemplatePartialSpecialization();
+};
+
+class CS_API Namespace : public DeclarationContext
+{
+public:
+    Namespace();
+    ~Namespace();
+    bool isInline;
+};
+
+enum class MacroLocation
+{
+    Unknown,
+    ClassHead,
+    ClassBody,
+    FunctionHead,
+    FunctionParameters,
+    FunctionBody,
+};
+
+class CS_API PreprocessedEntity
+{
+public:
+    PreprocessedEntity();
+    MacroLocation macroLocation;
+    void* originalPtr;
+    DeclarationKind kind;
+};
+
+class CS_API MacroDefinition : public PreprocessedEntity
+{
+public:
+    MacroDefinition();
+    ~MacroDefinition();
+    std::string name;
+    std::string expression;
+    int lineNumberStart;
+    int lineNumberEnd;
+};
+
+class CS_API MacroExpansion : public PreprocessedEntity
+{
+public:
+    MacroExpansion();
+    ~MacroExpansion();
+    std::string name;
+    std::string text;
+    MacroDefinition* definition;
+};
+
+class CS_API TranslationUnit : public Namespace
+{
+public:
+    TranslationUnit();
+    ~TranslationUnit();
+    std::string fileName;
+    bool isSystemHeader;
+    VECTOR(MacroDefinition*, Macros)
+};
+
+class CS_API ASTContext
+{
+public:
+    ASTContext();
+    ~ASTContext();
+    TranslationUnit* FindOrCreateModule(std::string File);
+    VECTOR(TranslationUnit*, TranslationUnits)
+};
+
+} } }
--- a/src/CppParser/Types.h
+++ b/src/CppParser/Types.h
@ -0,0 +1,322 @@
				@@ -0,0 +1,322 @@
+/************************************************************************
+*
+* CppSharp
+* Licensed under the MIT license.
+*
+************************************************************************/
+
+#pragma once
+
+#include "Helpers.h"
+
+namespace CppSharp { namespace CppParser { namespace AST {
+
+enum class TypeKind
+{
+    Tag,
+    Array,
+    Function,
+    Pointer,
+    MemberPointer,
+    Typedef,
+    Attributed,
+    Decayed,
+    TemplateSpecialization,
+    DependentTemplateSpecialization,
+    TemplateParameter,
+    TemplateParameterSubstitution,
+    InjectedClassName,
+    DependentName,
+    PackExpansion,
+    Builtin,
+    UnaryTransform,
+    Vector
+};
+
+#define DECLARE_TYPE_KIND(kind) \
+kind##Type();
+
+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
+{
+    QualifiedType();
+    Type* type;
+    TypeQualifiers qualifiers;
+};
+
+class Declaration;
+
+class CS_API TagType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(Tag)
+    Declaration* declaration;
+};
+
+class CS_API ArrayType : public Type
+{
+public:
+    enum class ArraySize
+    {
+        Constant,
+        Variable,
+        Dependent,
+        Incomplete
+    };
+
+    DECLARE_TYPE_KIND(Array)
+    QualifiedType qualifiedType;
+    ArraySize sizeType;
+    long size;
+    long elementSize;
+};
+
+class Parameter;
+
+enum class CallingConvention
+{
+    Default,
+    C,
+    StdCall,
+    ThisCall,
+    FastCall,
+    Unknown
+};
+
+enum class ExceptionSpecType
+{
+    None,
+    DynamicNone,
+    Dynamic,
+    MSAny,
+    BasicNoexcept,
+    DependentNoexcept,
+    NoexceptFalse,
+    NoexceptTrue,
+    Unevaluated,
+    Uninstantiated,
+    Unparsed
+};
+
+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:
+    enum struct TypeModifier
+    {
+        Value,
+        Pointer,
+        LVReference,
+        RVReference
+    };
+
+    DECLARE_TYPE_KIND(Pointer)
+    QualifiedType qualifiedPointee;
+    TypeModifier modifier;
+};
+
+class CS_API MemberPointerType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(MemberPointer)
+    QualifiedType pointee;
+};
+
+class TypedefNameDecl;
+
+class CS_API TypedefType : public Type
+{
+public:
+    TypedefType();
+    TypedefNameDecl* declaration;
+};
+
+class CS_API AttributedType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(Attributed)
+    QualifiedType modified;
+    QualifiedType equivalent;
+};
+
+class CS_API DecayedType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(Decayed)
+    QualifiedType decayed;
+    QualifiedType original;
+    QualifiedType pointee;
+};
+
+struct CS_API TemplateArgument
+{
+    TemplateArgument();
+
+    enum struct ArgumentKind
+    {
+        Type,
+        Declaration,
+        NullPtr,
+        Integral,
+        Template,
+        TemplateExpansion,
+        Expression,
+        Pack
+    };
+
+    ArgumentKind kind;
+    QualifiedType type;
+    Declaration* declaration;
+    long integral;
+};
+
+class Template;
+
+class CS_API TemplateSpecializationType : public Type
+{
+public:
+    TemplateSpecializationType();
+    TemplateSpecializationType(const TemplateSpecializationType&);
+    ~TemplateSpecializationType();
+
+    VECTOR(TemplateArgument, Arguments)
+        Template* _template;
+    QualifiedType desugared;
+};
+
+class CS_API DependentTemplateSpecializationType : public Type
+{
+public:
+    DependentTemplateSpecializationType();
+    DependentTemplateSpecializationType(const DependentTemplateSpecializationType&);
+    ~DependentTemplateSpecializationType();
+
+    VECTOR(TemplateArgument, Arguments)
+        QualifiedType desugared;
+};
+
+class TypeTemplateParameter;
+
+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:
+    DECLARE_TYPE_KIND(TemplateParameterSubstitution)
+    QualifiedType replacement;
+    TemplateParameterType* replacedParameter;
+};
+
+class Class;
+
+class CS_API InjectedClassNameType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(InjectedClassName)
+    QualifiedType injectedSpecializationType;
+    Class* _class;
+};
+
+class CS_API DependentNameType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(DependentName)
+    ~DependentNameType();
+    QualifiedType qualifier;
+    std::string identifier;
+};
+
+class CS_API PackExpansionType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(PackExpansion)
+};
+
+class CS_API UnaryTransformType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(UnaryTransform)
+    QualifiedType desugared;
+    QualifiedType baseType;
+};
+
+class CS_API VectorType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(Vector)
+    QualifiedType elementType;
+    unsigned numElements;
+};
+
+enum class PrimitiveType
+{
+    Null,
+    Void,
+    Bool,
+    WideChar,
+    Char,
+    SChar,
+    UChar,
+    Char16,
+    Char32,
+    Short,
+    UShort,
+    Int,
+    UInt,
+    Long,
+    ULong,
+    LongLong,
+    ULongLong,
+    Int128,
+    UInt128,
+    Half,
+    Float,
+    Double,
+    LongDouble,
+    Float128,
+    IntPtr
+};
+
+class CS_API BuiltinType : public Type
+{
+public:
+    DECLARE_TYPE_KIND(Builtin)
+    PrimitiveType type;
+};
+
+} } }