Obsoleted all hand-written types for expressions.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/CppParser/AST.cpp

@@ -566,42 +566,42 @@ Friend::Friend() : CppSharp::CppParser::AST::Declaration(DeclarationKind::Friend
 Friend::~Friend() {}
 
 
-Statement::Statement(const std::string& str, StatementClass stmtClass, Declaration* decl) : string(str), _class(stmtClass), decl(decl) {}
+StatementObsolete::StatementObsolete(const std::string& str, StatementClassObsolete stmtClass, Declaration* decl) : string(str), _class(stmtClass), decl(decl) {}
 
-Expression::Expression(const std::string& str, StatementClass stmtClass, Declaration* decl)
-    : Statement(str, stmtClass, decl) {}
+ExpressionObsolete::ExpressionObsolete(const std::string& str, StatementClassObsolete stmtClass, Declaration* decl)
+    : StatementObsolete(str, stmtClass, decl) {}
 
-BinaryOperator::BinaryOperator(const std::string& str, Expression* lhs, Expression* rhs, const std::string& opcodeStr)
-    : Expression(str, StatementClass::BinaryOperator), LHS(lhs), RHS(rhs), opcodeStr(opcodeStr) {}
+BinaryOperatorObsolete::BinaryOperatorObsolete(const std::string& str, ExpressionObsolete* lhs, ExpressionObsolete* rhs, const std::string& opcodeStr)
+    : ExpressionObsolete(str, StatementClassObsolete::BinaryOperator), LHS(lhs), RHS(rhs), opcodeStr(opcodeStr) {}
 
-BinaryOperator::~BinaryOperator()
+BinaryOperatorObsolete::~BinaryOperatorObsolete()
 {
     delete LHS;
     delete RHS;
 }
 
 
-CallExpr::CallExpr(const std::string& str, Declaration* decl)
-    : Expression(str, StatementClass::CallExprClass, decl) {}
+CallExprObsolete::CallExprObsolete(const std::string& str, Declaration* decl)
+    : ExpressionObsolete(str, StatementClassObsolete::CallExprClass, decl) {}
 
-CallExpr::~CallExpr()
+CallExprObsolete::~CallExprObsolete()
 {
     for (auto& arg : Arguments)
         delete arg;
 }
 
-DEF_VECTOR(CallExpr, Expression*, Arguments)
+DEF_VECTOR(CallExprObsolete, ExpressionObsolete*, Arguments)
 
-CXXConstructExpr::CXXConstructExpr(const std::string& str, Declaration* decl)
-    : Expression(str, StatementClass::CXXConstructExprClass, decl) {}
+CXXConstructExprObsolete::CXXConstructExprObsolete(const std::string& str, Declaration* decl)
+    : ExpressionObsolete(str, StatementClassObsolete::CXXConstructExprClass, decl) {}
 
-CXXConstructExpr::~CXXConstructExpr()
+CXXConstructExprObsolete::~CXXConstructExprObsolete()
 {
     for (auto& arg : Arguments)
         delete arg;
 }
 
-DEF_VECTOR(CXXConstructExpr, Expression*, Arguments)
+DEF_VECTOR(CXXConstructExprObsolete, ExpressionObsolete*, Arguments)
 
 Parameter::Parameter() : Declaration(DeclarationKind::Parameter),
     isIndirect(false), hasDefaultValue(false), defaultArgument(0) {}
@@ -613,14 +613,14 @@ Parameter::~Parameter()
         // HACK: see https://github.com/mono/CppSharp/issues/598
         switch (defaultArgument->_class)
         {
-        case StatementClass::BinaryOperator:
-            delete static_cast<BinaryOperator*>(defaultArgument);
+        case StatementClassObsolete::BinaryOperator:
+            delete static_cast<BinaryOperatorObsolete*>(defaultArgument);
             break;
-        case StatementClass::CallExprClass:
-            delete static_cast<CallExpr*>(defaultArgument);
+        case StatementClassObsolete::CallExprClass:
+            delete static_cast<CallExprObsolete*>(defaultArgument);
             break;
-        case StatementClass::CXXConstructExprClass:
-            delete static_cast<CXXConstructExpr*>(defaultArgument);
+        case StatementClassObsolete::CXXConstructExprClass:
+            delete static_cast<CXXConstructExprObsolete*>(defaultArgument);
             break;
         default:
             delete defaultArgument;

src/CppParser/Bindings/CLI/CppParser.cpp

@@ -6,6 +6,7 @@
 // ----------------------------------------------------------------------------
 #include "CppParser.h"
 #include "AST.h"
+#include "Decl.h"
 #include "Target.h"
 
 using namespace System;

src/CppParser/Bindings/CLI/Sources.cpp

@@ -41,3 +41,68 @@ void CppSharp::Parser::SourceLocation::ID::set(unsigned int value)
     __ID = value;
 }
 
+CppSharp::Parser::SourceRange::SourceRange(::CppSharp::CppParser::SourceRange* native)
+    : __ownsNativeInstance(false)
+{
+    NativePtr = native;
+}
+
+CppSharp::Parser::SourceRange^ CppSharp::Parser::SourceRange::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::SourceRange((::CppSharp::CppParser::SourceRange*) native.ToPointer());
+}
+
+CppSharp::Parser::SourceRange::~SourceRange()
+{
+    delete NativePtr;
+}
+
+CppSharp::Parser::SourceRange::SourceRange()
+{
+    __ownsNativeInstance = true;
+    NativePtr = new ::CppSharp::CppParser::SourceRange();
+}
+
+CppSharp::Parser::SourceRange::SourceRange(CppSharp::Parser::SourceRange^ _0)
+{
+    __ownsNativeInstance = true;
+    if (ReferenceEquals(_0, nullptr))
+        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
+    auto &__arg0 = *(::CppSharp::CppParser::SourceRange*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::SourceRange(__arg0);
+}
+
+System::IntPtr CppSharp::Parser::SourceRange::__Instance::get()
+{
+    return System::IntPtr(NativePtr);
+}
+
+void CppSharp::Parser::SourceRange::__Instance::set(System::IntPtr object)
+{
+    NativePtr = (::CppSharp::CppParser::SourceRange*)object.ToPointer();
+}
+
+CppSharp::Parser::SourceLocation CppSharp::Parser::SourceRange::BeginLoc::get()
+{
+    return CppSharp::Parser::SourceLocation((::CppSharp::CppParser::SourceLocation*)&((::CppSharp::CppParser::SourceRange*)NativePtr)->beginLoc);
+}
+
+void CppSharp::Parser::SourceRange::BeginLoc::set(CppSharp::Parser::SourceLocation value)
+{
+    auto _marshal0 = ::CppSharp::CppParser::SourceLocation();
+    _marshal0.ID = value.ID;
+    ((::CppSharp::CppParser::SourceRange*)NativePtr)->beginLoc = _marshal0;
+}
+
+CppSharp::Parser::SourceLocation CppSharp::Parser::SourceRange::EndLoc::get()
+{
+    return CppSharp::Parser::SourceLocation((::CppSharp::CppParser::SourceLocation*)&((::CppSharp::CppParser::SourceRange*)NativePtr)->endLoc);
+}
+
+void CppSharp::Parser::SourceRange::EndLoc::set(CppSharp::Parser::SourceLocation value)
+{
+    auto _marshal0 = ::CppSharp::CppParser::SourceLocation();
+    _marshal0.ID = value.ID;
+    ((::CppSharp::CppParser::SourceRange*)NativePtr)->endLoc = _marshal0;
+}
+

src/CppParser/Bindings/CLI/Sources.h

@@ -13,6 +13,7 @@ namespace CppSharp
 {
     namespace Parser
     {
+        ref class SourceRange;
         value struct SourceLocation;
     }
 }
@@ -40,5 +41,40 @@ namespace CppSharp
         private:
             unsigned int __ID;
         };
+
+        public ref class SourceRange : ICppInstance
+        {
+        public:
+
+            property ::CppSharp::CppParser::SourceRange* NativePtr;
+            property System::IntPtr __Instance
+            {
+                virtual System::IntPtr get();
+                virtual void set(System::IntPtr instance);
+            }
+
+            SourceRange(::CppSharp::CppParser::SourceRange* native);
+            static SourceRange^ __CreateInstance(::System::IntPtr native);
+            SourceRange();
+
+            SourceRange(CppSharp::Parser::SourceRange^ _0);
+
+            ~SourceRange();
+
+            property CppSharp::Parser::SourceLocation BeginLoc
+            {
+                CppSharp::Parser::SourceLocation get();
+                void set(CppSharp::Parser::SourceLocation);
+            }
+
+            property CppSharp::Parser::SourceLocation EndLoc
+            {
+                CppSharp::Parser::SourceLocation get();
+                void set(CppSharp::Parser::SourceLocation);
+            }
+
+        protected:
+            bool __ownsNativeInstance;
+        };
     }
 }

src/CppParser/Bindings/CLI/Types.h

@@ -0,0 +1,820 @@
+// ----------------------------------------------------------------------------
+// <auto-generated>
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+// </auto-generated>
+// ----------------------------------------------------------------------------
+#pragma once
+
+#include "CppSharp.h"
+#include <Types.h>
+
+namespace CppSharp
+{
+    namespace Parser
+    {
+        namespace AST
+        {
+            enum struct CallingConvention;
+            enum struct ExceptionSpecType;
+            enum struct PrimitiveType;
+            enum struct TypeKind;
+            ref class ArrayType;
+            ref class AttributedType;
+            ref class BuiltinType;
+            ref class Class;
+            ref class DecayedType;
+            ref class Declaration;
+            ref class DependentNameType;
+            ref class DependentTemplateSpecializationType;
+            ref class FunctionType;
+            ref class InjectedClassNameType;
+            ref class MemberPointerType;
+            ref class PackExpansionType;
+            ref class Parameter;
+            ref class PointerType;
+            ref class QualifiedType;
+            ref class TagType;
+            ref class Template;
+            ref class TemplateArgument;
+            ref class TemplateParameterSubstitutionType;
+            ref class TemplateParameterType;
+            ref class TemplateSpecializationType;
+            ref class Type;
+            ref class TypeQualifiers;
+            ref class TypeTemplateParameter;
+            ref class TypedefNameDecl;
+            ref class TypedefType;
+            ref class UnaryTransformType;
+            ref class VectorType;
+        }
+    }
+}
+
+namespace CppSharp
+{
+    namespace Parser
+    {
+        namespace AST
+        {
+            public enum struct TypeKind
+            {
+                Tag = 0,
+                Array = 1,
+                Function = 2,
+                Pointer = 3,
+                MemberPointer = 4,
+                Typedef = 5,
+                Attributed = 6,
+                Decayed = 7,
+                TemplateSpecialization = 8,
+                DependentTemplateSpecialization = 9,
+                TemplateParameter = 10,
+                TemplateParameterSubstitution = 11,
+                InjectedClassName = 12,
+                DependentName = 13,
+                PackExpansion = 14,
+                Builtin = 15,
+                UnaryTransform = 16,
+                Vector = 17
+            };
+
+            public enum struct CallingConvention
+            {
+                Default = 0,
+                C = 1,
+                StdCall = 2,
+                ThisCall = 3,
+                FastCall = 4,
+                Unknown = 5
+            };
+
+            public enum struct PrimitiveType
+            {
+                Null = 0,
+                Void = 1,
+                Bool = 2,
+                WideChar = 3,
+                Char = 4,
+                SChar = 5,
+                UChar = 6,
+                Char16 = 7,
+                Char32 = 8,
+                Short = 9,
+                UShort = 10,
+                Int = 11,
+                UInt = 12,
+                Long = 13,
+                ULong = 14,
+                LongLong = 15,
+                ULongLong = 16,
+                Int128 = 17,
+                UInt128 = 18,
+                Half = 19,
+                Float = 20,
+                Double = 21,
+                LongDouble = 22,
+                Float128 = 23,
+                IntPtr = 24
+            };
+
+            public enum struct ExceptionSpecType
+            {
+                None = 0,
+                DynamicNone = 1,
+                Dynamic = 2,
+                MSAny = 3,
+                BasicNoexcept = 4,
+                DependentNoexcept = 5,
+                NoexceptFalse = 6,
+                NoexceptTrue = 7,
+                Unevaluated = 8,
+                Uninstantiated = 9,
+                Unparsed = 10
+            };
+
+            public ref class Type : ICppInstance
+            {
+            public:
+
+                property ::CppSharp::CppParser::AST::Type* NativePtr;
+                property System::IntPtr __Instance
+                {
+                    virtual System::IntPtr get();
+                    virtual void set(System::IntPtr instance);
+                }
+
+                Type(::CppSharp::CppParser::AST::Type* native);
+                static Type^ __CreateInstance(::System::IntPtr native);
+                Type(CppSharp::Parser::AST::TypeKind kind);
+
+                Type(CppSharp::Parser::AST::Type^ _0);
+
+                ~Type();
+
+                property CppSharp::Parser::AST::TypeKind Kind
+                {
+                    CppSharp::Parser::AST::TypeKind get();
+                    void set(CppSharp::Parser::AST::TypeKind);
+                }
+
+                property bool IsDependent
+                {
+                    bool get();
+                    void set(bool);
+                }
+
+                static operator CppSharp::Parser::AST::Type^(CppSharp::Parser::AST::TypeKind kind);
+
+            protected:
+                bool __ownsNativeInstance;
+            };
+
+            public ref class TypeQualifiers : ICppInstance
+            {
+            public:
+
+                property ::CppSharp::CppParser::AST::TypeQualifiers* NativePtr;
+                property System::IntPtr __Instance
+                {
+                    virtual System::IntPtr get();
+                    virtual void set(System::IntPtr instance);
+                }
+
+                TypeQualifiers(::CppSharp::CppParser::AST::TypeQualifiers* native);
+                static TypeQualifiers^ __CreateInstance(::System::IntPtr native);
+                TypeQualifiers(CppSharp::Parser::AST::TypeQualifiers^ _0);
+
+                TypeQualifiers();
+
+                ~TypeQualifiers();
+
+                property bool IsConst
+                {
+                    bool get();
+                    void set(bool);
+                }
+
+                property bool IsVolatile
+                {
+                    bool get();
+                    void set(bool);
+                }
+
+                property bool IsRestrict
+                {
+                    bool get();
+                    void set(bool);
+                }
+
+            protected:
+                bool __ownsNativeInstance;
+            };
+
+            public ref class QualifiedType : ICppInstance
+            {
+            public:
+
+                property ::CppSharp::CppParser::AST::QualifiedType* NativePtr;
+                property System::IntPtr __Instance
+                {
+                    virtual System::IntPtr get();
+                    virtual void set(System::IntPtr instance);
+                }
+
+                QualifiedType(::CppSharp::CppParser::AST::QualifiedType* native);
+                static QualifiedType^ __CreateInstance(::System::IntPtr native);
+                QualifiedType();
+
+                QualifiedType(CppSharp::Parser::AST::QualifiedType^ _0);
+
+                ~QualifiedType();
+
+                property CppSharp::Parser::AST::Type^ Type
+                {
+                    CppSharp::Parser::AST::Type^ get();
+                    void set(CppSharp::Parser::AST::Type^);
+                }
+
+                property CppSharp::Parser::AST::TypeQualifiers^ Qualifiers
+                {
+                    CppSharp::Parser::AST::TypeQualifiers^ get();
+                    void set(CppSharp::Parser::AST::TypeQualifiers^);
+                }
+
+            protected:
+                bool __ownsNativeInstance;
+            };
+
+            public ref class TagType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                TagType(::CppSharp::CppParser::AST::TagType* native);
+                static TagType^ __CreateInstance(::System::IntPtr native);
+                TagType();
+
+                TagType(CppSharp::Parser::AST::TagType^ _0);
+
+                ~TagType();
+
+                property CppSharp::Parser::AST::Declaration^ Declaration
+                {
+                    CppSharp::Parser::AST::Declaration^ get();
+                    void set(CppSharp::Parser::AST::Declaration^);
+                }
+            };
+
+            public ref class ArrayType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                enum struct ArraySize
+                {
+                    Constant = 0,
+                    Variable = 1,
+                    Dependent = 2,
+                    Incomplete = 3
+                };
+
+                ArrayType(::CppSharp::CppParser::AST::ArrayType* native);
+                static ArrayType^ __CreateInstance(::System::IntPtr native);
+                ArrayType();
+
+                ArrayType(CppSharp::Parser::AST::ArrayType^ _0);
+
+                ~ArrayType();
+
+                property CppSharp::Parser::AST::QualifiedType^ QualifiedType
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::ArrayType::ArraySize SizeType
+                {
+                    CppSharp::Parser::AST::ArrayType::ArraySize get();
+                    void set(CppSharp::Parser::AST::ArrayType::ArraySize);
+                }
+
+                property long Size
+                {
+                    long get();
+                    void set(long);
+                }
+
+                property long ElementSize
+                {
+                    long get();
+                    void set(long);
+                }
+            };
+
+            public ref class FunctionType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                FunctionType(::CppSharp::CppParser::AST::FunctionType* native);
+                static FunctionType^ __CreateInstance(::System::IntPtr native);
+                FunctionType();
+
+                FunctionType(CppSharp::Parser::AST::FunctionType^ _0);
+
+                ~FunctionType();
+
+                property CppSharp::Parser::AST::QualifiedType^ ReturnType
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::CallingConvention CallingConvention
+                {
+                    CppSharp::Parser::AST::CallingConvention get();
+                    void set(CppSharp::Parser::AST::CallingConvention);
+                }
+
+                property CppSharp::Parser::AST::ExceptionSpecType ExceptionSpecType
+                {
+                    CppSharp::Parser::AST::ExceptionSpecType get();
+                    void set(CppSharp::Parser::AST::ExceptionSpecType);
+                }
+
+                property System::Collections::Generic::List<CppSharp::Parser::AST::Parameter^>^ Parameters
+                {
+                    System::Collections::Generic::List<CppSharp::Parser::AST::Parameter^>^ get();
+                    void set(System::Collections::Generic::List<CppSharp::Parser::AST::Parameter^>^);
+                }
+
+                property unsigned int ParametersCount
+                {
+                    unsigned int get();
+                }
+
+                CppSharp::Parser::AST::Parameter^ GetParameters(unsigned int i);
+
+                void AddParameters(CppSharp::Parser::AST::Parameter^ s);
+
+                void ClearParameters();
+            };
+
+            public ref class PointerType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                enum struct TypeModifier
+                {
+                    Value = 0,
+                    Pointer = 1,
+                    LVReference = 2,
+                    RVReference = 3
+                };
+
+                PointerType(::CppSharp::CppParser::AST::PointerType* native);
+                static PointerType^ __CreateInstance(::System::IntPtr native);
+                PointerType();
+
+                PointerType(CppSharp::Parser::AST::PointerType^ _0);
+
+                ~PointerType();
+
+                property CppSharp::Parser::AST::QualifiedType^ QualifiedPointee
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::PointerType::TypeModifier Modifier
+                {
+                    CppSharp::Parser::AST::PointerType::TypeModifier get();
+                    void set(CppSharp::Parser::AST::PointerType::TypeModifier);
+                }
+            };
+
+            public ref class MemberPointerType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                MemberPointerType(::CppSharp::CppParser::AST::MemberPointerType* native);
+                static MemberPointerType^ __CreateInstance(::System::IntPtr native);
+                MemberPointerType();
+
+                MemberPointerType(CppSharp::Parser::AST::MemberPointerType^ _0);
+
+                ~MemberPointerType();
+
+                property CppSharp::Parser::AST::QualifiedType^ Pointee
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+            };
+
+            public ref class TypedefType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                TypedefType(::CppSharp::CppParser::AST::TypedefType* native);
+                static TypedefType^ __CreateInstance(::System::IntPtr native);
+                TypedefType();
+
+                TypedefType(CppSharp::Parser::AST::TypedefType^ _0);
+
+                ~TypedefType();
+
+                property CppSharp::Parser::AST::TypedefNameDecl^ Declaration
+                {
+                    CppSharp::Parser::AST::TypedefNameDecl^ get();
+                    void set(CppSharp::Parser::AST::TypedefNameDecl^);
+                }
+            };
+
+            public ref class AttributedType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                AttributedType(::CppSharp::CppParser::AST::AttributedType* native);
+                static AttributedType^ __CreateInstance(::System::IntPtr native);
+                AttributedType();
+
+                AttributedType(CppSharp::Parser::AST::AttributedType^ _0);
+
+                ~AttributedType();
+
+                property CppSharp::Parser::AST::QualifiedType^ Modified
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::QualifiedType^ Equivalent
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+            };
+
+            public ref class DecayedType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                DecayedType(::CppSharp::CppParser::AST::DecayedType* native);
+                static DecayedType^ __CreateInstance(::System::IntPtr native);
+                DecayedType();
+
+                DecayedType(CppSharp::Parser::AST::DecayedType^ _0);
+
+                ~DecayedType();
+
+                property CppSharp::Parser::AST::QualifiedType^ Decayed
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::QualifiedType^ Original
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::QualifiedType^ Pointee
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+            };
+
+            public ref class TemplateArgument : ICppInstance
+            {
+            public:
+
+                enum struct ArgumentKind
+                {
+                    Type = 0,
+                    Declaration = 1,
+                    NullPtr = 2,
+                    Integral = 3,
+                    Template = 4,
+                    TemplateExpansion = 5,
+                    Expression = 6,
+                    Pack = 7
+                };
+
+                property ::CppSharp::CppParser::AST::TemplateArgument* NativePtr;
+                property System::IntPtr __Instance
+                {
+                    virtual System::IntPtr get();
+                    virtual void set(System::IntPtr instance);
+                }
+
+                TemplateArgument(::CppSharp::CppParser::AST::TemplateArgument* native);
+                static TemplateArgument^ __CreateInstance(::System::IntPtr native);
+                TemplateArgument();
+
+                TemplateArgument(CppSharp::Parser::AST::TemplateArgument^ _0);
+
+                ~TemplateArgument();
+
+                property CppSharp::Parser::AST::TemplateArgument::ArgumentKind Kind
+                {
+                    CppSharp::Parser::AST::TemplateArgument::ArgumentKind get();
+                    void set(CppSharp::Parser::AST::TemplateArgument::ArgumentKind);
+                }
+
+                property CppSharp::Parser::AST::QualifiedType^ Type
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::Declaration^ Declaration
+                {
+                    CppSharp::Parser::AST::Declaration^ get();
+                    void set(CppSharp::Parser::AST::Declaration^);
+                }
+
+                property long Integral
+                {
+                    long get();
+                    void set(long);
+                }
+
+            protected:
+                bool __ownsNativeInstance;
+            };
+
+            public ref class TemplateSpecializationType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                TemplateSpecializationType(::CppSharp::CppParser::AST::TemplateSpecializationType* native);
+                static TemplateSpecializationType^ __CreateInstance(::System::IntPtr native);
+                TemplateSpecializationType();
+
+                TemplateSpecializationType(CppSharp::Parser::AST::TemplateSpecializationType^ _0);
+
+                ~TemplateSpecializationType();
+
+                property System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ Arguments
+                {
+                    System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ get();
+                    void set(System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^);
+                }
+
+                property CppSharp::Parser::AST::Template^ Template
+                {
+                    CppSharp::Parser::AST::Template^ get();
+                    void set(CppSharp::Parser::AST::Template^);
+                }
+
+                property CppSharp::Parser::AST::QualifiedType^ Desugared
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property unsigned int ArgumentsCount
+                {
+                    unsigned int get();
+                }
+
+                CppSharp::Parser::AST::TemplateArgument^ GetArguments(unsigned int i);
+
+                void AddArguments(CppSharp::Parser::AST::TemplateArgument^ s);
+
+                void ClearArguments();
+            };
+
+            public ref class DependentTemplateSpecializationType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                DependentTemplateSpecializationType(::CppSharp::CppParser::AST::DependentTemplateSpecializationType* native);
+                static DependentTemplateSpecializationType^ __CreateInstance(::System::IntPtr native);
+                DependentTemplateSpecializationType();
+
+                DependentTemplateSpecializationType(CppSharp::Parser::AST::DependentTemplateSpecializationType^ _0);
+
+                ~DependentTemplateSpecializationType();
+
+                property System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ Arguments
+                {
+                    System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ get();
+                    void set(System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^);
+                }
+
+                property CppSharp::Parser::AST::QualifiedType^ Desugared
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property unsigned int ArgumentsCount
+                {
+                    unsigned int get();
+                }
+
+                CppSharp::Parser::AST::TemplateArgument^ GetArguments(unsigned int i);
+
+                void AddArguments(CppSharp::Parser::AST::TemplateArgument^ s);
+
+                void ClearArguments();
+            };
+
+            public ref class TemplateParameterType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                TemplateParameterType(::CppSharp::CppParser::AST::TemplateParameterType* native);
+                static TemplateParameterType^ __CreateInstance(::System::IntPtr native);
+                TemplateParameterType();
+
+                TemplateParameterType(CppSharp::Parser::AST::TemplateParameterType^ _0);
+
+                ~TemplateParameterType();
+
+                property CppSharp::Parser::AST::TypeTemplateParameter^ Parameter
+                {
+                    CppSharp::Parser::AST::TypeTemplateParameter^ get();
+                    void set(CppSharp::Parser::AST::TypeTemplateParameter^);
+                }
+
+                property unsigned int Depth
+                {
+                    unsigned int get();
+                    void set(unsigned int);
+                }
+
+                property unsigned int Index
+                {
+                    unsigned int get();
+                    void set(unsigned int);
+                }
+
+                property bool IsParameterPack
+                {
+                    bool get();
+                    void set(bool);
+                }
+            };
+
+            public ref class TemplateParameterSubstitutionType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                TemplateParameterSubstitutionType(::CppSharp::CppParser::AST::TemplateParameterSubstitutionType* native);
+                static TemplateParameterSubstitutionType^ __CreateInstance(::System::IntPtr native);
+                TemplateParameterSubstitutionType();
+
+                TemplateParameterSubstitutionType(CppSharp::Parser::AST::TemplateParameterSubstitutionType^ _0);
+
+                ~TemplateParameterSubstitutionType();
+
+                property CppSharp::Parser::AST::QualifiedType^ Replacement
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::TemplateParameterType^ ReplacedParameter
+                {
+                    CppSharp::Parser::AST::TemplateParameterType^ get();
+                    void set(CppSharp::Parser::AST::TemplateParameterType^);
+                }
+            };
+
+            public ref class InjectedClassNameType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                InjectedClassNameType(::CppSharp::CppParser::AST::InjectedClassNameType* native);
+                static InjectedClassNameType^ __CreateInstance(::System::IntPtr native);
+                InjectedClassNameType();
+
+                InjectedClassNameType(CppSharp::Parser::AST::InjectedClassNameType^ _0);
+
+                ~InjectedClassNameType();
+
+                property CppSharp::Parser::AST::QualifiedType^ InjectedSpecializationType
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::Class^ Class
+                {
+                    CppSharp::Parser::AST::Class^ get();
+                    void set(CppSharp::Parser::AST::Class^);
+                }
+            };
+
+            public ref class DependentNameType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                DependentNameType(::CppSharp::CppParser::AST::DependentNameType* native);
+                static DependentNameType^ __CreateInstance(::System::IntPtr native);
+                DependentNameType();
+
+                DependentNameType(CppSharp::Parser::AST::DependentNameType^ _0);
+
+                ~DependentNameType();
+
+                property CppSharp::Parser::AST::QualifiedType^ Qualifier
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property System::String^ Identifier
+                {
+                    System::String^ get();
+                    void set(System::String^);
+                }
+            };
+
+            public ref class PackExpansionType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                PackExpansionType(::CppSharp::CppParser::AST::PackExpansionType* native);
+                static PackExpansionType^ __CreateInstance(::System::IntPtr native);
+                PackExpansionType();
+
+                PackExpansionType(CppSharp::Parser::AST::PackExpansionType^ _0);
+
+                ~PackExpansionType();
+            };
+
+            public ref class UnaryTransformType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                UnaryTransformType(::CppSharp::CppParser::AST::UnaryTransformType* native);
+                static UnaryTransformType^ __CreateInstance(::System::IntPtr native);
+                UnaryTransformType();
+
+                UnaryTransformType(CppSharp::Parser::AST::UnaryTransformType^ _0);
+
+                ~UnaryTransformType();
+
+                property CppSharp::Parser::AST::QualifiedType^ Desugared
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property CppSharp::Parser::AST::QualifiedType^ BaseType
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+            };
+
+            public ref class VectorType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                VectorType(::CppSharp::CppParser::AST::VectorType* native);
+                static VectorType^ __CreateInstance(::System::IntPtr native);
+                VectorType();
+
+                VectorType(CppSharp::Parser::AST::VectorType^ _0);
+
+                ~VectorType();
+
+                property CppSharp::Parser::AST::QualifiedType^ ElementType
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+
+                property unsigned int NumElements
+                {
+                    unsigned int get();
+                    void set(unsigned int);
+                }
+            };
+
+            public ref class BuiltinType : CppSharp::Parser::AST::Type
+            {
+            public:
+
+                BuiltinType(::CppSharp::CppParser::AST::BuiltinType* native);
+                static BuiltinType^ __CreateInstance(::System::IntPtr native);
+                BuiltinType();
+
+                BuiltinType(CppSharp::Parser::AST::BuiltinType^ _0);
+
+                ~BuiltinType();
+
+                property CppSharp::Parser::AST::PrimitiveType Type
+                {
+                    CppSharp::Parser::AST::PrimitiveType get();
+                    void set(CppSharp::Parser::AST::PrimitiveType);
+                }
+            };
+        }
+    }
+}

src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/Std.cs

@@ -585,7 +585,7 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 12)]
-        public unsafe partial struct __Internalc__N_std_N___1_S_vector_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_N___1_S_allocator__S0_
+        public unsafe partial struct __Internalc__N_std_N___1_S_vector_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_N___1_S_allocator__S0_
         {
             [FieldOffset(0)]
             internal global::System.IntPtr __begin_;

src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/Std.cs

@@ -294,7 +294,7 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 12)]
-        public unsafe partial struct __Internalc__N_std_S__Compressed_pair____N_std_S_allocator_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S__Vector_val____N_std_S__Simple_types__S1__Vb1
+        public unsafe partial struct __Internalc__N_std_S__Compressed_pair____N_std_S_allocator_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S__Vector_val____N_std_S__Simple_types__S1__Vb1
         {
             [FieldOffset(0)]
             internal global::Std.VectorVal.__Internal _Myval2;
@@ -823,10 +823,10 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 12)]
-        public unsafe partial struct __Internalc__N_std_S_vector_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S_allocator__S0_
+        public unsafe partial struct __Internalc__N_std_S_vector_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S_allocator__S0_
         {
             [FieldOffset(0)]
-            internal global::Std.CompressedPair.__Internalc__N_std_S__Compressed_pair____N_std_S_allocator_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S__Vector_val____N_std_S__Simple_types__S1__Vb1 _Mypair;
+            internal global::Std.CompressedPair.__Internalc__N_std_S__Compressed_pair____N_std_S_allocator_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S__Vector_val____N_std_S__Simple_types__S1__Vb1 _Mypair;
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 12)]

src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/Std.cs

@@ -585,7 +585,7 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_N___1_S_vector_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_N___1_S_allocator__S0_
+        public unsafe partial struct __Internalc__N_std_N___1_S_vector_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_N___1_S_allocator__S0_
         {
             [FieldOffset(0)]
             internal global::System.IntPtr __begin_;

src/CppParser/Bindings/CSharp/x86_64-linux-gnu-cxx11abi/Std.cs

@@ -283,7 +283,7 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_S_vector_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S_allocator__S0_
+        public unsafe partial struct __Internalc__N_std_S_vector_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S_allocator__S0_
         {
             [FieldOffset(0)]
             internal global::Std.VectorBase.VectorImpl.__Internal _M_impl;
@@ -545,7 +545,7 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_S__Vector_base_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S_allocator__S0_
+        public unsafe partial struct __Internalc__N_std_S__Vector_base_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S_allocator__S0_
         {
             [FieldOffset(0)]
             internal global::Std.VectorBase.VectorImpl.__Internal _M_impl;
@@ -655,8 +655,6 @@ namespace Std
 {
     public enum RbTreeColor : uint
     {
-        S_red = 0,
-        S_black = 1
     }
 
     namespace RbTree

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Std.cs

@@ -283,7 +283,7 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_S_vector_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S_allocator__S0_
+        public unsafe partial struct __Internalc__N_std_S_vector_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S_allocator__S0_
         {
             [FieldOffset(0)]
             internal global::Std.VectorBase.VectorImpl.__Internal _M_impl;
@@ -545,7 +545,7 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_S__Vector_base_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S_allocator__S0_
+        public unsafe partial struct __Internalc__N_std_S__Vector_base_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S_allocator__S0_
         {
             [FieldOffset(0)]
             internal global::Std.VectorBase.VectorImpl.__Internal _M_impl;
@@ -655,8 +655,6 @@ namespace Std
 {
     public enum RbTreeColor : uint
     {
-        S_red = 0,
-        S_black = 1
     }
 
     namespace RbTree

src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/Std.cs

@@ -294,7 +294,7 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_S__Compressed_pair____N_std_S_allocator_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S__Vector_val____N_std_S__Simple_types__S1__Vb1
+        public unsafe partial struct __Internalc__N_std_S__Compressed_pair____N_std_S_allocator_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S__Vector_val____N_std_S__Simple_types__S1__Vb1
         {
             [FieldOffset(0)]
             internal global::Std.VectorVal.__Internal _Myval2;
@@ -823,10 +823,10 @@ namespace Std
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_S_vector_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S_allocator__S0_
+        public unsafe partial struct __Internalc__N_std_S_vector_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S_allocator__S0_
         {
             [FieldOffset(0)]
-            internal global::Std.CompressedPair.__Internalc__N_std_S__Compressed_pair____N_std_S_allocator_____N_CppSharp_N_CppParser_N_AST_S_Expression___N_std_S__Vector_val____N_std_S__Simple_types__S1__Vb1 _Mypair;
+            internal global::Std.CompressedPair.__Internalc__N_std_S__Compressed_pair____N_std_S_allocator_____N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete___N_std_S__Vector_val____N_std_S__Simple_types__S1__Vb1 _Mypair;
         }
 
         [StructLayout(LayoutKind.Explicit, Size = 24)]

src/CppParser/Decl.h

@@ -182,7 +182,7 @@ public:
     Declaration* declaration;
 };
 
-enum class StatementClass
+enum class StatementClassObsolete
 {
     Any,
     BinaryOperator,
@@ -194,47 +194,47 @@ enum class StatementClass
     ExplicitCastExpr,
 };
 
-class CS_API Statement
+class CS_API StatementObsolete
 {
 public:
-    Statement(const std::string& str, StatementClass Class = StatementClass::Any, Declaration* decl = 0);
-    StatementClass _class;
+    StatementObsolete(const std::string& str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration* decl = 0);
+    StatementClassObsolete _class;
     Declaration* decl;
     std::string string;
 };
 
-class CS_API Expression : public Statement
+class CS_API ExpressionObsolete : public StatementObsolete
 {
 public:
-    Expression(const std::string& str, StatementClass Class = StatementClass::Any, Declaration* decl = 0);
+    ExpressionObsolete(const std::string& str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration* decl = 0);
 };
 
 class Expr;
 
-class CS_API BinaryOperator : public Expression
+class CS_API BinaryOperatorObsolete : public ExpressionObsolete
 {
 public:
-    BinaryOperator(const std::string& str, Expression* lhs, Expression* rhs, const std::string& opcodeStr);
-    ~BinaryOperator();
-    Expression* LHS;
-    Expression* RHS;
+    BinaryOperatorObsolete(const std::string& str, ExpressionObsolete* lhs, ExpressionObsolete* rhs, const std::string& opcodeStr);
+    ~BinaryOperatorObsolete();
+    ExpressionObsolete* LHS;
+    ExpressionObsolete* RHS;
     std::string opcodeStr;
 };
 
-class CS_API CallExpr : public Expression
+class CS_API CallExprObsolete : public ExpressionObsolete
 {
 public:
-    CallExpr(const std::string& str, Declaration* decl);
-    ~CallExpr();
-    VECTOR(Expression*, Arguments)
+    CallExprObsolete(const std::string& str, Declaration* decl);
+    ~CallExprObsolete();
+    VECTOR(ExpressionObsolete*, Arguments)
 };
 
-class CS_API CXXConstructExpr : public Expression
+class CS_API CXXConstructExprObsolete : public ExpressionObsolete
 {
 public:
-    CXXConstructExpr(const std::string& str, Declaration* decl = 0);
-    ~CXXConstructExpr();
-    VECTOR(Expression*, Arguments)
+    CXXConstructExprObsolete(const std::string& str, Declaration* decl = 0);
+    ~CXXConstructExprObsolete();
+    VECTOR(ExpressionObsolete*, Arguments)
 };
 
 class CS_API Parameter : public Declaration
@@ -247,7 +247,7 @@ public:
     bool isIndirect;
     bool hasDefaultValue;
     unsigned int index;
-    Expression* defaultArgument;
+    ExpressionObsolete* defaultArgument;
     Expr* defaultArgumentNew;
 };
 
@@ -626,7 +626,7 @@ public:
     NonTypeTemplateParameter();
     NonTypeTemplateParameter(const NonTypeTemplateParameter&);
     ~NonTypeTemplateParameter();
-    Expression* defaultArgument;
+    ExpressionObsolete* defaultArgument;
     Expr* defaultArgumentNew;
     unsigned int position;
     bool isPackExpansion;

src/CppParser/Parser.cpp

@@ -3512,7 +3512,7 @@ void Parser::HandlePreprocessedEntities(Declaration* Decl)
     }
 }
 
-AST::Expression* Parser::WalkExpression(const clang::Expr* Expr)
+AST::ExpressionObsolete* Parser::WalkExpression(const clang::Expr* Expr)
 {
     using namespace clang;
 
@@ -3521,14 +3521,14 @@ AST::Expression* Parser::WalkExpression(const clang::Expr* Expr)
     case clang::Stmt::BinaryOperatorClass:
     {
         auto BinaryOperator = cast<clang::BinaryOperator>(Expr);
-        return new AST::BinaryOperator(GetStringFromStatement(Expr),
+        return new AST::BinaryOperatorObsolete(GetStringFromStatement(Expr),
             WalkExpression(BinaryOperator->getLHS()), WalkExpression(BinaryOperator->getRHS()),
             BinaryOperator->getOpcodeStr().str());
     }
     case clang::Stmt::CallExprClass:
     {
         auto CallExpr = cast<clang::CallExpr>(Expr);
-        auto CallExpression = new AST::CallExpr(GetStringFromStatement(Expr),
+        auto CallExpression = new AST::CallExprObsolete(GetStringFromStatement(Expr),
             CallExpr->getCalleeDecl() ? WalkDeclaration(CallExpr->getCalleeDecl()) : 0);
         for (auto arg : CallExpr->arguments())
         {
@@ -3537,7 +3537,7 @@ AST::Expression* Parser::WalkExpression(const clang::Expr* Expr)
         return CallExpression;
     }
     case clang::Stmt::DeclRefExprClass:
-        return new AST::Expression(GetStringFromStatement(Expr), StatementClass::DeclRefExprClass,
+        return new AST::ExpressionObsolete(GetStringFromStatement(Expr), StatementClassObsolete::DeclRefExprClass,
             WalkDeclaration(cast<DeclRefExpr>(Expr)->getDecl()));
     case clang::Stmt::CStyleCastExprClass:
     case clang::Stmt::CXXConstCastExprClass:
@@ -3550,7 +3550,7 @@ AST::Expression* Parser::WalkExpression(const clang::Expr* Expr)
     case clang::Stmt::CXXOperatorCallExprClass:
     {
         auto OperatorCallExpr = cast<CXXOperatorCallExpr>(Expr);
-        return new AST::Expression(GetStringFromStatement(Expr), StatementClass::CXXOperatorCallExpr,
+        return new AST::ExpressionObsolete(GetStringFromStatement(Expr), StatementClassObsolete::CXXOperatorCallExpr,
             OperatorCallExpr->getCalleeDecl() ? WalkDeclaration(OperatorCallExpr->getCalleeDecl()) : 0);
     }
     case clang::Stmt::CXXConstructExprClass:
@@ -3569,11 +3569,11 @@ AST::Expression* Parser::WalkExpression(const clang::Expr* Expr)
                     (Cast->getSubExprAsWritten()->getStmtClass() != clang::Stmt::IntegerLiteralClass &&
                      Cast->getSubExprAsWritten()->getStmtClass() != clang::Stmt::CXXNullPtrLiteralExprClass))
                     return WalkExpression(SubTemporaryExpr);
-                return new AST::CXXConstructExpr(GetStringFromStatement(Expr),
+                return new AST::CXXConstructExprObsolete(GetStringFromStatement(Expr),
                     WalkDeclaration(ConstructorExpr->getConstructor()));
             }
         }
-        auto ConstructorExpression = new AST::CXXConstructExpr(GetStringFromStatement(Expr),
+        auto ConstructorExpression = new AST::CXXConstructExprObsolete(GetStringFromStatement(Expr),
             WalkDeclaration(ConstructorExpr->getConstructor()));
         for (auto arg : ConstructorExpr->arguments())
         {
@@ -3596,8 +3596,8 @@ AST::Expression* Parser::WalkExpression(const clang::Expr* Expr)
         Expr->getStmtClass() != clang::Stmt::UnaryExprOrTypeTraitExprClass &&
         !Expr->isValueDependent() &&
         Expr->EvaluateAsInt(integer, c->getASTContext()))
-        return new AST::Expression(integer.Val.getInt().toString(10));
-    return new AST::Expression(GetStringFromStatement(Expr));
+        return new AST::ExpressionObsolete(integer.Val.getInt().toString(10));
+    return new AST::ExpressionObsolete(GetStringFromStatement(Expr));
 }
 
 std::string Parser::GetStringFromStatement(const clang::Stmt* Statement)

src/CppParser/Parser.h

@@ -118,7 +118,7 @@ private:
     VTableComponent WalkVTableComponent(const clang::VTableComponent& Component);
     PreprocessedEntity* WalkPreprocessedEntity(Declaration* Decl,
         clang::PreprocessedEntity* PPEntity);
-    AST::Expression* WalkExpression(const clang::Expr* Expression);
+    AST::ExpressionObsolete* WalkExpression(const clang::Expr* Expression);
     std::string GetStringFromStatement(const clang::Stmt* Statement);
     std::string GetFunctionBody(const clang::FunctionDecl* FD);
 

src/Parser/ASTConverter.cs

@@ -1121,7 +1121,7 @@ namespace CppSharp
             return _param;
         }
 
-        private AST.Expression VisitStatement(Statement statement)
+        private AST.Expression VisitStatement(StatementObsolete statement)
         {
             if (statement == null)
                 return null;
@@ -1129,14 +1129,14 @@ namespace CppSharp
             AST.Expression expression;
             switch (statement.Class)
             {
-                case StatementClass.BinaryOperator:
-                    var binaryOperator = BinaryOperator.__CreateInstance(statement.__Instance);
+                case StatementClassObsolete.BinaryOperator:
+                    var binaryOperator = BinaryOperatorObsolete.__CreateInstance(statement.__Instance);
                     expression = new AST.BinaryOperator(VisitStatement(binaryOperator.LHS),
                         VisitStatement(binaryOperator.RHS), binaryOperator.OpcodeStr);
                     break;
-                case StatementClass.CallExprClass:
+                case StatementClassObsolete.CallExprClass:
                     var callExpression = new AST.CallExpr();
-                    var callExpr = CallExpr.__CreateInstance(statement.__Instance);
+                    var callExpr = CallExprObsolete.__CreateInstance(statement.__Instance);
                     for (uint i = 0; i < callExpr.ArgumentsCount; i++)
                     {
                         var argument = VisitStatement(callExpr.GetArguments(i));
@@ -1144,17 +1144,17 @@ namespace CppSharp
                     }
                     expression = callExpression;
                     break;
-                case StatementClass.DeclRefExprClass:
+                case StatementClassObsolete.DeclRefExprClass:
                     expression = new AST.BuiltinTypeExpression();
                     expression.Class = AST.StatementClass.DeclarationReference;
                     break;
-                case StatementClass.CXXOperatorCallExpr:
+                case StatementClassObsolete.CXXOperatorCallExpr:
                     expression = new AST.BuiltinTypeExpression();
                     expression.Class = AST.StatementClass.CXXOperatorCall;
                     break;
-                case StatementClass.CXXConstructExprClass:
+                case StatementClassObsolete.CXXConstructExprClass:
                     var constructorExpression = new AST.CXXConstructExpr();
-                    var constructorExpr = CXXConstructExpr.__CreateInstance(statement.__Instance);
+                    var constructorExpr = CXXConstructExprObsolete.__CreateInstance(statement.__Instance);
                     for (uint i = 0; i < constructorExpr.ArgumentsCount; i++)
                     {
                         var argument = VisitStatement(constructorExpr.GetArguments(i));