Obsolete managed expression class machinery.

tritao · tritao · commit aa7369254349 · 2019-02-20T01:45:52.000Z
diff --git a/src/AST/Expression.cs b/src/AST/Expression.cs
@@ -4,16 +4,16 @@
 
 namespace CppSharp.AST
 {
-    public abstract class Expression : Statement
+    public abstract class ExpressionObsolete : Statement
     {
         public string DebugText;
 
-        public abstract TV Visit<TV>(IExpressionVisitor<TV> visitor);
+        public abstract TV Visit<TV>(IExpressionVisitorObsolete<TV> visitor);
 
-        public abstract Expression Clone();
+        public abstract ExpressionObsolete Clone();
     }
 
-    public class BuiltinTypeExpression : Expression
+    public class BuiltinTypeExpressionObsolete : ExpressionObsolete
     {
         public long Value { get; set; }
 
@@ -39,14 +39,14 @@ public override string ToString()
             return printAsHex ? "0x" + value : value;
         }
 
-        public override T Visit<T>(IExpressionVisitor<T> visitor)
+        public override T Visit<T>(IExpressionVisitorObsolete<T> visitor)
         {
             return visitor.VisitExpression(this);
         }
 
-        public override Expression Clone()
+        public override ExpressionObsolete Clone()
         {
-            return new BuiltinTypeExpression
+            return new BuiltinTypeExpressionObsolete
             {
                 Value = this.Value,
                 Type = this.Type,
@@ -58,28 +58,28 @@ public override Expression Clone()
         }
     }
 
-    public class BinaryOperator : Expression
+    public class BinaryOperatorObsolete : ExpressionObsolete
     {
-        public BinaryOperator(Expression lhs, Expression rhs, string opcodeStr)
+        public BinaryOperatorObsolete(ExpressionObsolete lhs, ExpressionObsolete rhs, string opcodeStr)
         {
             Class = StatementClass.BinaryOperator;
             LHS = lhs;
             RHS = rhs;
             OpcodeStr = opcodeStr;
         }
 
-        public Expression LHS { get; set; }
-        public Expression RHS { get; set; }
+        public ExpressionObsolete LHS { get; set; }
+        public ExpressionObsolete RHS { get; set; }
         public string OpcodeStr { get; set; }
 
-        public override T Visit<T>(IExpressionVisitor<T> visitor)
+        public override T Visit<T>(IExpressionVisitorObsolete<T> visitor)
         {
             return visitor.VisitExpression(this);
         }
 
-        public override Expression Clone()
+        public override ExpressionObsolete Clone()
         {
-            return new BinaryOperator(LHS.Clone(), RHS.Clone(), OpcodeStr)
+            return new BinaryOperatorObsolete(LHS.Clone(), RHS.Clone(), OpcodeStr)
             {
                 DebugText = this.DebugText,
                 Declaration = this.Declaration,
@@ -88,24 +88,24 @@ public override Expression Clone()
         }
     }
 
-    public class CallExpr : Expression
+    public class CallExprObsolete : ExpressionObsolete
     {
-        public CallExpr()
+        public CallExprObsolete()
         {
             Class = StatementClass.Call;
-            Arguments = new List<Expression>();
+            Arguments = new List<ExpressionObsolete>();
         }
 
-        public List<Expression> Arguments { get; private set; }
+        public List<ExpressionObsolete> Arguments { get; private set; }
 
-        public override T Visit<T>(IExpressionVisitor<T> visitor)
+        public override T Visit<T>(IExpressionVisitorObsolete<T> visitor)
         {
             return visitor.VisitExpression(this);
         }
 
-        public override Expression Clone()
+        public override ExpressionObsolete Clone()
         {
-            var clone = new CallExpr
+            var clone = new CallExprObsolete
             {
                 DebugText = this.DebugText,
                 Declaration = this.Declaration,
@@ -116,24 +116,24 @@ public override Expression Clone()
         }
     }
 
-    public class CXXConstructExpr : Expression
+    public class CXXConstructExprObsolete : ExpressionObsolete
     {
-        public CXXConstructExpr()
+        public CXXConstructExprObsolete()
         {
             Class = StatementClass.ConstructorReference;
-            Arguments = new List<Expression>();
+            Arguments = new List<ExpressionObsolete>();
         }
 
-        public List<Expression> Arguments { get; private set; }
+        public List<ExpressionObsolete> Arguments { get; private set; }
 
-        public override T Visit<T>(IExpressionVisitor<T> visitor)
+        public override T Visit<T>(IExpressionVisitorObsolete<T> visitor)
         {
             return visitor.VisitExpression(this);
         }
 
-        public override Expression Clone()
+        public override ExpressionObsolete Clone()
         {
-            var clone = new CXXConstructExpr
+            var clone = new CXXConstructExprObsolete
             {
                 DebugText = this.DebugText,
                 Declaration = this.Declaration,
@@ -144,8 +144,8 @@ public override Expression Clone()
         }
     }
 
-    public interface IExpressionVisitor<out T>
+    public interface IExpressionVisitorObsolete<out T>
     {
-        T VisitExpression(Expression exp);
+        T VisitExpression(ExpressionObsolete exp);
     }
 }
diff --git a/src/AST/Function.cs b/src/AST/Function.cs
@@ -63,7 +63,7 @@ public Parameter(Parameter p)
         public ParameterUsage Usage { get; set; }
         public bool HasDefaultValue { get; set; }
 
-        public Expression DefaultArgument
+        public ExpressionObsolete DefaultArgument
         {
             get
             {
@@ -77,7 +77,7 @@ public Expression DefaultArgument
             }
         }
 
-        public Expression OriginalDefaultArgument { get; set; }
+        public ExpressionObsolete OriginalDefaultArgument { get; set; }
 
         public bool IsIn => Usage == ParameterUsage.In;
         public bool IsOut => Usage == ParameterUsage.Out;
@@ -100,7 +100,7 @@ public bool IsConst
             get { return DebugText.StartsWith("const ", System.StringComparison.Ordinal); }
         }
 
-        Expression defaultArgument;
+        ExpressionObsolete defaultArgument;
     }
 
     public class ParameterTypeComparer : IEqualityComparer<Parameter>
diff --git a/src/AST/IExpressionPrinter.cs b/src/AST/IExpressionPrinter.cs
@@ -5,7 +5,7 @@ public interface IExpressionPrinter
         string ToString(Type type);
     }
 
-    public interface IExpressionPrinter<out T> : IExpressionPrinter, IExpressionVisitor<T>
+    public interface IExpressionPrinter<out T> : IExpressionPrinter, IExpressionVisitorObsolete<T>
     {
     }
 }
diff --git a/src/AST/LayoutField.cs b/src/AST/LayoutField.cs
@@ -9,7 +9,7 @@ public class LayoutField
         public string Name { get; set; }
         public IntPtr FieldPtr { get; set; }
         public bool IsVTablePtr { get { return FieldPtr == IntPtr.Zero; } }
-        public Expression Expression { get; set; }
+        public ExpressionObsolete Expression { get; set; }
 
         public override string ToString()
         {
diff --git a/src/AST/Template.cs b/src/AST/Template.cs
@@ -93,7 +93,7 @@ public class NonTypeTemplateParameter : Declaration
         /// </summary>
         public bool IsParameterPack { get; set; }
 
-        public Expression DefaultArgument { get; set; }
+        public ExpressionObsolete DefaultArgument { get; set; }
 
         /// <summary>
         /// Get the position of the template parameter within its parameter list.
diff --git a/src/CppParser/Parser.cpp b/src/CppParser/Parser.cpp
@@ -1365,7 +1365,7 @@ NonTypeTemplateParameter* Parser::WalkNonTypeTemplateParameter(const clang::NonT
     NTP->name = GetDeclName(NTTPD);
     HandleDeclaration(NTTPD, NTP);
     if (NTTPD->hasDefaultArgument())
-        NTP->defaultArgument = WalkExpression(NTTPD->getDefaultArgument());
+        NTP->defaultArgument = WalkExpressionObsolete(NTTPD->getDefaultArgument());
     NTP->depth = NTTPD->getDepth();
     NTP->index = NTTPD->getIndex();
     NTP->isParameterPack = NTTPD->isParameterPack();
@@ -2980,9 +2980,9 @@ Parameter* Parser::WalkParameter(const clang::ParmVarDecl* PVD,
     if (PVD->hasDefaultArg() && !PVD->hasUnparsedDefaultArg())
     {
         if (PVD->hasUninstantiatedDefaultArg())
-            P->defaultArgument = WalkExpression(PVD->getUninstantiatedDefaultArg());
+            P->defaultArgument = WalkExpressionObsolete(PVD->getUninstantiatedDefaultArg());
         else
-            P->defaultArgument = WalkExpression(PVD->getDefaultArg());
+            P->defaultArgument = WalkExpressionObsolete(PVD->getDefaultArg());
     }
     HandleDeclaration(PVD, P);
     walkedParameters[PVD] = P;
@@ -3020,10 +3020,10 @@ static bool IsInvalid(clang::Stmt* Body, std::unordered_set<clang::Stmt*>& Bodie
     switch (Body->getStmtClass())
     {
     case clang::Stmt::StmtClass::DeclRefExprClass:
-        D = cast<DeclRefExpr>(Body)->getDecl();
+        D = cast<clang::DeclRefExpr>(Body)->getDecl();
         break;
     case clang::Stmt::StmtClass::MemberExprClass:
-        D = cast<MemberExpr>(Body)->getMemberDecl();
+        D = cast<clang::MemberExpr>(Body)->getMemberDecl();
         break;
     }
     if (D)
@@ -3512,7 +3512,7 @@ void Parser::HandlePreprocessedEntities(Declaration* Decl)
     }
 }
 
-AST::ExpressionObsolete* Parser::WalkExpression(const clang::Expr* Expr)
+AST::ExpressionObsolete* Parser::WalkExpressionObsolete(const clang::Expr* Expr)
 {
     using namespace clang;
 
@@ -3522,7 +3522,7 @@ AST::ExpressionObsolete* Parser::WalkExpression(const clang::Expr* Expr)
     {
         auto BinaryOperator = cast<clang::BinaryOperator>(Expr);
         return new AST::BinaryOperatorObsolete(GetStringFromStatement(Expr),
-            WalkExpression(BinaryOperator->getLHS()), WalkExpression(BinaryOperator->getRHS()),
+            WalkExpressionObsolete(BinaryOperator->getLHS()), WalkExpressionObsolete(BinaryOperator->getRHS()),
             BinaryOperator->getOpcodeStr().str());
     }
     case clang::Stmt::CallExprClass:
@@ -3532,24 +3532,24 @@ AST::ExpressionObsolete* Parser::WalkExpression(const clang::Expr* Expr)
             CallExpr->getCalleeDecl() ? WalkDeclaration(CallExpr->getCalleeDecl()) : 0);
         for (auto arg : CallExpr->arguments())
         {
-            CallExpression->Arguments.push_back(WalkExpression(arg));
+            CallExpression->Arguments.push_back(WalkExpressionObsolete(arg));
         }
         return CallExpression;
     }
     case clang::Stmt::DeclRefExprClass:
         return new AST::ExpressionObsolete(GetStringFromStatement(Expr), StatementClassObsolete::DeclRefExprClass,
-            WalkDeclaration(cast<DeclRefExpr>(Expr)->getDecl()));
+            WalkDeclaration(cast<clang::DeclRefExpr>(Expr)->getDecl()));
     case clang::Stmt::CStyleCastExprClass:
     case clang::Stmt::CXXConstCastExprClass:
     case clang::Stmt::CXXDynamicCastExprClass:
     case clang::Stmt::CXXFunctionalCastExprClass:
     case clang::Stmt::CXXReinterpretCastExprClass:
     case clang::Stmt::CXXStaticCastExprClass:
     case clang::Stmt::ImplicitCastExprClass:
-        return WalkExpression(cast<CastExpr>(Expr)->getSubExprAsWritten());
+        return WalkExpressionObsolete(cast<clang::CastExpr>(Expr)->getSubExprAsWritten());
     case clang::Stmt::CXXOperatorCallExprClass:
     {
-        auto OperatorCallExpr = cast<CXXOperatorCallExpr>(Expr);
+        auto OperatorCallExpr = cast<clang::CXXOperatorCallExpr>(Expr);
         return new AST::ExpressionObsolete(GetStringFromStatement(Expr), StatementClassObsolete::CXXOperatorCallExpr,
             OperatorCallExpr->getCalleeDecl() ? WalkDeclaration(OperatorCallExpr->getCalleeDecl()) : 0);
     }
@@ -3564,11 +3564,11 @@ AST::ExpressionObsolete* Parser::WalkExpression(const clang::Expr* Expr)
             if (TemporaryExpr)
             {
                 auto SubTemporaryExpr = TemporaryExpr->GetTemporaryExpr();
-                auto Cast = dyn_cast<CastExpr>(SubTemporaryExpr);
+                auto Cast = dyn_cast<clang::CastExpr>(SubTemporaryExpr);
                 if (!Cast ||
                     (Cast->getSubExprAsWritten()->getStmtClass() != clang::Stmt::IntegerLiteralClass &&
                      Cast->getSubExprAsWritten()->getStmtClass() != clang::Stmt::CXXNullPtrLiteralExprClass))
-                    return WalkExpression(SubTemporaryExpr);
+                    return WalkExpressionObsolete(SubTemporaryExpr);
                 return new AST::CXXConstructExprObsolete(GetStringFromStatement(Expr),
                     WalkDeclaration(ConstructorExpr->getConstructor()));
             }
@@ -3577,16 +3577,16 @@ AST::ExpressionObsolete* Parser::WalkExpression(const clang::Expr* Expr)
             WalkDeclaration(ConstructorExpr->getConstructor()));
         for (auto arg : ConstructorExpr->arguments())
         {
-            ConstructorExpression->Arguments.push_back(WalkExpression(arg));
+            ConstructorExpression->Arguments.push_back(WalkExpressionObsolete(arg));
         }
         return ConstructorExpression;
     }
     case clang::Stmt::CXXBindTemporaryExprClass:
-        return WalkExpression(cast<CXXBindTemporaryExpr>(Expr)->getSubExpr());
+        return WalkExpressionObsolete(cast<clang::CXXBindTemporaryExpr>(Expr)->getSubExpr());
     case clang::Stmt::CXXDefaultArgExprClass:
-        return WalkExpression(cast<CXXDefaultArgExpr>(Expr)->getExpr());
+        return WalkExpressionObsolete(cast<clang::CXXDefaultArgExpr>(Expr)->getExpr());
     case clang::Stmt::MaterializeTemporaryExprClass:
-        return WalkExpression(cast<MaterializeTemporaryExpr>(Expr)->GetTemporaryExpr());
+        return WalkExpressionObsolete(cast<clang::MaterializeTemporaryExpr>(Expr)->GetTemporaryExpr());
     default:
         break;
     }
diff --git a/src/CppParser/Parser.h b/src/CppParser/Parser.h
@@ -118,7 +118,7 @@ class Parser
     VTableComponent WalkVTableComponent(const clang::VTableComponent& Component);
     PreprocessedEntity* WalkPreprocessedEntity(Declaration* Decl,
         clang::PreprocessedEntity* PPEntity);
-    AST::ExpressionObsolete* WalkExpression(const clang::Expr* Expression);
+    AST::ExpressionObsolete* WalkExpressionObsolete(const clang::Expr* Expression);
     std::string GetStringFromStatement(const clang::Stmt* Statement);
     std::string GetFunctionBody(const clang::FunctionDecl* FD);
 
diff --git a/src/Generator/Generators/CSharp/CSharpExpressionPrinter.cs b/src/Generator/Generators/CSharp/CSharpExpressionPrinter.cs
@@ -8,7 +8,7 @@ namespace CppSharp.Generators.CSharp
 {
     public static class CSharpExpressionPrinterExtensions
     {
-        public static string CSharpValue(this Expression value, CSharpExpressionPrinter printer)
+        public static string CSharpValue(this ExpressionObsolete value, CSharpExpressionPrinter printer)
         {
             return value.Visit(printer);
         }
@@ -37,12 +37,12 @@ public string VisitParameter(Parameter parameter)
             return expression;
         }
 
-        public string VisitExpression(Expression expr)
+        public string VisitExpression(ExpressionObsolete expr)
         {
             switch (expr.Class)
             {
                 case StatementClass.Call:
-                    var callExpr = (CallExpr) expr;
+                    var callExpr = (CallExprObsolete) expr;
                     switch (callExpr.Declaration.GenerationKind)
                     {
                         case GenerationKind.Generate:
@@ -65,7 +65,7 @@ public string VisitExpression(Expression expr)
                         return expr.Declaration.Visit(typePrinter).Type;
                     goto default;
                 case StatementClass.BinaryOperator:
-                    var binaryOperator = (BinaryOperator) expr;
+                    var binaryOperator = (BinaryOperatorObsolete) expr;
 
                     var lhsResult = binaryOperator.LHS.String;
                     if (binaryOperator.LHS.Declaration is Enumeration.Item)
@@ -77,7 +77,7 @@ public string VisitExpression(Expression expr)
 
                     return $"{lhsResult} {binaryOperator.OpcodeStr} {rhsResult}";
                 case StatementClass.ConstructorReference:
-                    var constructorExpr = (CXXConstructExpr) expr;
+                    var constructorExpr = (CXXConstructExprObsolete) expr;
                     if (constructorExpr.Arguments.Count == 1 &&
                         constructorExpr.Arguments[0].Declaration is Enumeration.Item)
                         return constructorExpr.Arguments[0].Declaration.Visit(typePrinter).Type;
diff --git a/src/Generator/Passes/HandleDefaultParamValuesPass.cs b/src/Generator/Passes/HandleDefaultParamValuesPass.cs
diff --git a/src/Parser/ASTConverter.cs b/src/Parser/ASTConverter.cs

Original file line number	Diff line number	Diff line change
`@@ -4,16 +4,16 @@`
`4`	`4`
`5`	`5`	`namespace CppSharp.AST`
`6`	`6`	`{`
`7`		`- public abstract class Expression : Statement`
	`7`	`+ public abstract class ExpressionObsolete : Statement`
`8`	`8`	`{`
`9`	`9`	`public string DebugText;`
`10`	`10`
`11`		`- public abstract TV Visit<TV>(IExpressionVisitor<TV> visitor);`
	`11`	`+ public abstract TV Visit<TV>(IExpressionVisitorObsolete<TV> visitor);`
`12`	`12`
`13`		`- public abstract Expression Clone();`
	`13`	`+ public abstract ExpressionObsolete Clone();`
`14`	`14`	`}`
`15`	`15`
`16`		`- public class BuiltinTypeExpression : Expression`
	`16`	`+ public class BuiltinTypeExpressionObsolete : ExpressionObsolete`
`17`	`17`	`{`
`18`	`18`	`public long Value { get; set; }`
`19`	`19`
`@@ -39,14 +39,14 @@ public override string ToString()`
`39`	`39`	`return printAsHex ? "0x" + value : value;`
`40`	`40`	`}`
`41`	`41`
`42`		`- public override T Visit<T>(IExpressionVisitor<T> visitor)`
	`42`	`+ public override T Visit<T>(IExpressionVisitorObsolete<T> visitor)`
`43`	`43`	`{`
`44`	`44`	`return visitor.VisitExpression(this);`
`45`	`45`	`}`
`46`	`46`
`47`		`- public override Expression Clone()`
	`47`	`+ public override ExpressionObsolete Clone()`
`48`	`48`	`{`
`49`		`- return new BuiltinTypeExpression`
	`49`	`+ return new BuiltinTypeExpressionObsolete`
`50`	`50`	`{`
`51`	`51`	`Value = this.Value,`
`52`	`52`	`Type = this.Type,`
`@@ -58,28 +58,28 @@ public override Expression Clone()`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`		`- public class BinaryOperator : Expression`
	`61`	`+ public class BinaryOperatorObsolete : ExpressionObsolete`
`62`	`62`	`{`
`63`		`- public BinaryOperator(Expression lhs, Expression rhs, string opcodeStr)`
	`63`	`+ public BinaryOperatorObsolete(ExpressionObsolete lhs, ExpressionObsolete rhs, string opcodeStr)`
`64`	`64`	`{`
`65`	`65`	`Class = StatementClass.BinaryOperator;`
`66`	`66`	`LHS = lhs;`
`67`	`67`	`RHS = rhs;`
`68`	`68`	`OpcodeStr = opcodeStr;`
`69`	`69`	`}`
`70`	`70`
`71`		`- public Expression LHS { get; set; }`
`72`		`- public Expression RHS { get; set; }`
	`71`	`+ public ExpressionObsolete LHS { get; set; }`
	`72`	`+ public ExpressionObsolete RHS { get; set; }`
`73`	`73`	`public string OpcodeStr { get; set; }`
`74`	`74`
`75`		`- public override T Visit<T>(IExpressionVisitor<T> visitor)`
	`75`	`+ public override T Visit<T>(IExpressionVisitorObsolete<T> visitor)`
`76`	`76`	`{`
`77`	`77`	`return visitor.VisitExpression(this);`
`78`	`78`	`}`
`79`	`79`
`80`		`- public override Expression Clone()`
	`80`	`+ public override ExpressionObsolete Clone()`
`81`	`81`	`{`
`82`		`- return new BinaryOperator(LHS.Clone(), RHS.Clone(), OpcodeStr)`
	`82`	`+ return new BinaryOperatorObsolete(LHS.Clone(), RHS.Clone(), OpcodeStr)`
`83`	`83`	`{`
`84`	`84`	`DebugText = this.DebugText,`
`85`	`85`	`Declaration = this.Declaration,`
`@@ -88,24 +88,24 @@ public override Expression Clone()`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`		`- public class CallExpr : Expression`
	`91`	`+ public class CallExprObsolete : ExpressionObsolete`
`92`	`92`	`{`
`93`		`- public CallExpr()`
	`93`	`+ public CallExprObsolete()`
`94`	`94`	`{`
`95`	`95`	`Class = StatementClass.Call;`
`96`		`- Arguments = new List<Expression>();`
	`96`	`+ Arguments = new List<ExpressionObsolete>();`
`97`	`97`	`}`
`98`	`98`
`99`		`- public List<Expression> Arguments { get; private set; }`
	`99`	`+ public List<ExpressionObsolete> Arguments { get; private set; }`
`100`	`100`
`101`		`- public override T Visit<T>(IExpressionVisitor<T> visitor)`
	`101`	`+ public override T Visit<T>(IExpressionVisitorObsolete<T> visitor)`
`102`	`102`	`{`
`103`	`103`	`return visitor.VisitExpression(this);`
`104`	`104`	`}`
`105`	`105`
`106`		`- public override Expression Clone()`
	`106`	`+ public override ExpressionObsolete Clone()`
`107`	`107`	`{`
`108`		`- var clone = new CallExpr`
	`108`	`+ var clone = new CallExprObsolete`
`109`	`109`	`{`
`110`	`110`	`DebugText = this.DebugText,`
`111`	`111`	`Declaration = this.Declaration,`
`@@ -116,24 +116,24 @@ public override Expression Clone()`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
`119`		`- public class CXXConstructExpr : Expression`
	`119`	`+ public class CXXConstructExprObsolete : ExpressionObsolete`
`120`	`120`	`{`
`121`		`- public CXXConstructExpr()`
	`121`	`+ public CXXConstructExprObsolete()`
`122`	`122`	`{`
`123`	`123`	`Class = StatementClass.ConstructorReference;`
`124`		`- Arguments = new List<Expression>();`
	`124`	`+ Arguments = new List<ExpressionObsolete>();`
`125`	`125`	`}`
`126`	`126`
`127`		`- public List<Expression> Arguments { get; private set; }`
	`127`	`+ public List<ExpressionObsolete> Arguments { get; private set; }`
`128`	`128`
`129`		`- public override T Visit<T>(IExpressionVisitor<T> visitor)`
	`129`	`+ public override T Visit<T>(IExpressionVisitorObsolete<T> visitor)`
`130`	`130`	`{`
`131`	`131`	`return visitor.VisitExpression(this);`
`132`	`132`	`}`
`133`	`133`
`134`		`- public override Expression Clone()`
	`134`	`+ public override ExpressionObsolete Clone()`
`135`	`135`	`{`
`136`		`- var clone = new CXXConstructExpr`
	`136`	`+ var clone = new CXXConstructExprObsolete`
`137`	`137`	`{`
`138`	`138`	`DebugText = this.DebugText,`
`139`	`139`	`Declaration = this.Declaration,`
`@@ -144,8 +144,8 @@ public override Expression Clone()`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`147`		`- public interface IExpressionVisitor<out T>`
	`147`	`+ public interface IExpressionVisitorObsolete<out T>`
`148`	`148`	`{`
`149`		`- T VisitExpression(Expression exp);`
	`149`	`+ T VisitExpression(ExpressionObsolete exp);`
`150`	`150`	`}`
`151`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public Parameter(Parameter p)`
`63`	`63`	`public ParameterUsage Usage { get; set; }`
`64`	`64`	`public bool HasDefaultValue { get; set; }`
`65`	`65`
`66`		`- public Expression DefaultArgument`
	`66`	`+ public ExpressionObsolete DefaultArgument`
`67`	`67`	`{`
`68`	`68`	`get`
`69`	`69`	`{`
`@@ -77,7 +77,7 @@ public Expression DefaultArgument`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`80`		`- public Expression OriginalDefaultArgument { get; set; }`
	`80`	`+ public ExpressionObsolete OriginalDefaultArgument { get; set; }`
`81`	`81`
`82`	`82`	`public bool IsIn => Usage == ParameterUsage.In;`
`83`	`83`	`public bool IsOut => Usage == ParameterUsage.Out;`
`@@ -100,7 +100,7 @@ public bool IsConst`
`100`	`100`	`get { return DebugText.StartsWith("const ", System.StringComparison.Ordinal); }`
`101`	`101`	`}`
`102`	`102`
`103`		`- Expression defaultArgument;`
	`103`	`+ ExpressionObsolete defaultArgument;`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`public class ParameterTypeComparer : IEqualityComparer<Parameter>`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ public interface IExpressionPrinter`
`5`	`5`	`string ToString(Type type);`
`6`	`6`	`}`
`7`	`7`
`8`		`- public interface IExpressionPrinter<out T> : IExpressionPrinter, IExpressionVisitor<T>`
	`8`	`+ public interface IExpressionPrinter<out T> : IExpressionPrinter, IExpressionVisitorObsolete<T>`
`9`	`9`	`{`
`10`	`10`	`}`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public class LayoutField`
`9`	`9`	`public string Name { get; set; }`
`10`	`10`	`public IntPtr FieldPtr { get; set; }`
`11`	`11`	`public bool IsVTablePtr { get { return FieldPtr == IntPtr.Zero; } }`
`12`		`- public Expression Expression { get; set; }`
	`12`	`+ public ExpressionObsolete Expression { get; set; }`
`13`	`13`
`14`	`14`	`public override string ToString()`
`15`	`15`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace CppSharp.Generators.CSharp`
`8`	`8`	`{`
`9`	`9`	`public static class CSharpExpressionPrinterExtensions`
`10`	`10`	`{`
`11`		`- public static string CSharpValue(this Expression value, CSharpExpressionPrinter printer)`
	`11`	`+ public static string CSharpValue(this ExpressionObsolete value, CSharpExpressionPrinter printer)`
`12`	`12`	`{`
`13`	`13`	`return value.Visit(printer);`
`14`	`14`	`}`
`@@ -37,12 +37,12 @@ public string VisitParameter(Parameter parameter)`
`37`	`37`	`return expression;`
`38`	`38`	`}`
`39`	`39`
`40`		`- public string VisitExpression(Expression expr)`
	`40`	`+ public string VisitExpression(ExpressionObsolete expr)`
`41`	`41`	`{`
`42`	`42`	`switch (expr.Class)`
`43`	`43`	`{`
`44`	`44`	`case StatementClass.Call:`
`45`		`- var callExpr = (CallExpr) expr;`
	`45`	`+ var callExpr = (CallExprObsolete) expr;`
`46`	`46`	`switch (callExpr.Declaration.GenerationKind)`
`47`	`47`	`{`
`48`	`48`	`case GenerationKind.Generate:`
`@@ -65,7 +65,7 @@ public string VisitExpression(Expression expr)`
`65`	`65`	`return expr.Declaration.Visit(typePrinter).Type;`
`66`	`66`	`goto default;`
`67`	`67`	`case StatementClass.BinaryOperator:`
`68`		`- var binaryOperator = (BinaryOperator) expr;`
	`68`	`+ var binaryOperator = (BinaryOperatorObsolete) expr;`
`69`	`69`
`70`	`70`	`var lhsResult = binaryOperator.LHS.String;`
`71`	`71`	`if (binaryOperator.LHS.Declaration is Enumeration.Item)`
`@@ -77,7 +77,7 @@ public string VisitExpression(Expression expr)`
`77`	`77`
`78`	`78`	`return $"{lhsResult} {binaryOperator.OpcodeStr} {rhsResult}";`
`79`	`79`	`case StatementClass.ConstructorReference:`
`80`		`- var constructorExpr = (CXXConstructExpr) expr;`
	`80`	`+ var constructorExpr = (CXXConstructExprObsolete) expr;`
`81`	`81`	`if (constructorExpr.Arguments.Count == 1 &&`
`82`	`82`	`constructorExpr.Arguments[0].Declaration is Enumeration.Item)`
`83`	`83`	`return constructorExpr.Arguments[0].Declaration.Visit(typePrinter).Type;`