Extended the AST and the parser to support call expressions in default args.

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

src/AST/Expression.cs

@@ -42,9 +42,29 @@ namespace CppSharp.AST
         }
     }
 
-    public class CXXConstructExpr : Expression
+    public class BinaryOperator : Expression
     {
-        public CXXConstructExpr()
+        public BinaryOperator(Expression lhs, Expression rhs, string opcodeStr)
+        {
+            Class = StatementClass.BinaryOperator;
+            LHS = lhs;
+            RHS = rhs;
+            OpcodeStr = opcodeStr;
+        }
+
+        public Expression LHS { get; set; }
+        public Expression RHS { get; set; }
+        public string OpcodeStr { get; set; }
+
+        public override T Visit<T>(IExpressionVisitor<T> visitor)
+        {
+            return visitor.VisitExpression(this);
+        }
+    }
+
+    public class CallExpr : Expression
+    {
+        public CallExpr()
         {
             Arguments = new List<Expression>();
         }
@@ -57,19 +77,14 @@ namespace CppSharp.AST
         }
     }
 
-    public class BinaryOperator : Expression
+    public class CXXConstructExpr : Expression
     {
-        public BinaryOperator(Expression lhs, Expression rhs, string opcodeStr)
+        public CXXConstructExpr()
         {
-            Class = StatementClass.BinaryOperator;
+            Arguments = new List<Expression>();
-            this.LHS = lhs;
-            this.RHS = rhs;
-            this.OpcodeStr = opcodeStr;
         }
 
-        public Expression LHS { get; set; }
+        public List<Expression> Arguments { get; private set; }
-        public Expression RHS { get; set; }
-        public string OpcodeStr { get; set; }
 
         public override T Visit<T>(IExpressionVisitor<T> visitor)
         {

src/Core/Parser/ASTConverter.cs

@@ -932,6 +932,16 @@ namespace CppSharp
                     expression = new AST.BinaryOperator(VisitStatement(binaryOperator.LHS),
                         VisitStatement(binaryOperator.RHS), binaryOperator.OpcodeStr);
                     break;
+                case StatementClass.CallExprClass:
+                    var callExpression = new AST.CallExpr();
+                    var callExpr = CallExpr.__CreateInstance(statement.__Instance);
+                    for (uint i = 0; i < callExpr.ArgumentsCount; i++)
+                    {
+                        var argument = VisitStatement(callExpr.getArguments(i));
+                        callExpression.Arguments.Add(argument);
+                    }
+                    expression = callExpression;
+                    break;
                 case StatementClass.DeclRefExprClass:
                     expression = new AST.BuiltinTypeExpression();
                     expression.Class = AST.StatementClass.DeclarationReference;

src/CppParser/AST.cpp

@@ -488,6 +488,11 @@ BinaryOperator::BinaryOperator(const std::string& str, Expression* lhs, Expressi
 
 DEF_STRING(BinaryOperator, OpcodeStr)
 
+CallExpr::CallExpr(const std::string& str, Declaration* decl)
+    : Expression(str, StatementClass::CallExprClass, decl) {}
+
+DEF_VECTOR(CallExpr, Expression*, Arguments)
+
 CXXConstructExpr::CXXConstructExpr(const std::string& str, Declaration* decl)
     : Expression(str, StatementClass::CXXConstructExprClass, decl) {}
 

src/CppParser/AST.h

@@ -481,6 +481,7 @@ enum class StatementClass
 {
     Any,
     BinaryOperator,
+    CallExprClass,
     DeclRefExprClass,
     CXXConstructExprClass,
     CXXOperatorCallExpr,
@@ -512,6 +513,13 @@ public:
     STRING(OpcodeStr)
 };
 
+class CS_API CallExpr : public Expression
+{
+public:
+    CallExpr(const std::string& str, Declaration* decl);
+    VECTOR(Expression*, Arguments)
+};
+
 class CS_API CXXConstructExpr : public Expression
 {
 public:

src/CppParser/Bindings/CLI/AST.cpp

@@ -2330,6 +2330,59 @@ void CppSharp::Parser::AST::BinaryOperator::RHS::set(CppSharp::Parser::AST::Expr
     ((::CppSharp::CppParser::AST::BinaryOperator*)NativePtr)->RHS = (::CppSharp::CppParser::AST::Expression*)value->NativePtr;
 }
 
+CppSharp::Parser::AST::CallExpr::CallExpr(::CppSharp::CppParser::AST::CallExpr* native)
+    : CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)native)
+{
+}
+
+CppSharp::Parser::AST::CallExpr^ CppSharp::Parser::AST::CallExpr::__CreateInstance(::System::IntPtr native)
+{
+    return ::CppSharp::Parser::AST::CallExpr::__CreateInstance(native, false);
+}
+
+CppSharp::Parser::AST::CallExpr^ CppSharp::Parser::AST::CallExpr::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
+{
+    ::CppSharp::Parser::AST::CallExpr^ result = gcnew ::CppSharp::Parser::AST::CallExpr((::CppSharp::CppParser::AST::CallExpr*) native.ToPointer());
+    result->__ownsNativeInstance = __ownsNativeInstance;
+    return result;
+}
+
+CppSharp::Parser::AST::CallExpr::~CallExpr()
+{
+}
+
+CppSharp::Parser::AST::Expression^ CppSharp::Parser::AST::CallExpr::getArguments(unsigned int i)
+{
+    auto __ret = ((::CppSharp::CppParser::AST::CallExpr*)NativePtr)->getArguments(i);
+    if (__ret == nullptr) return nullptr;
+    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)__ret);
+}
+
+void CppSharp::Parser::AST::CallExpr::addArguments(CppSharp::Parser::AST::Expression^ s)
+{
+    auto arg0 = (::CppSharp::CppParser::AST::Expression*)s->NativePtr;
+    ((::CppSharp::CppParser::AST::CallExpr*)NativePtr)->addArguments(arg0);
+}
+
+void CppSharp::Parser::AST::CallExpr::clearArguments()
+{
+    ((::CppSharp::CppParser::AST::CallExpr*)NativePtr)->clearArguments();
+}
+
+CppSharp::Parser::AST::CallExpr::CallExpr(CppSharp::Parser::AST::CallExpr^ _0)
+    : CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)nullptr)
+{
+    __ownsNativeInstance = true;
+    auto &arg0 = *(::CppSharp::CppParser::AST::CallExpr*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::CallExpr(arg0);
+}
+
+unsigned int CppSharp::Parser::AST::CallExpr::ArgumentsCount::get()
+{
+    auto __ret = ((::CppSharp::CppParser::AST::CallExpr*)NativePtr)->getArgumentsCount();
+    return __ret;
+}
+
 CppSharp::Parser::AST::CXXConstructExpr::CXXConstructExpr(::CppSharp::CppParser::AST::CXXConstructExpr* native)
     : CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)native)
 {

src/CppParser/Bindings/CLI/AST.h

@@ -35,6 +35,7 @@ namespace CppSharp
             ref class BlockContentComment;
             ref class BuiltinType;
             ref class CXXConstructExpr;
+            ref class CallExpr;
             ref class Class;
             ref class ClassLayout;
             ref class ClassTemplate;
@@ -230,11 +231,12 @@ namespace CppSharp
             {
                 Any = 0,
                 BinaryOperator = 1,
-                DeclRefExprClass = 2,
+                CallExprClass = 2,
-                CXXConstructExprClass = 3,
+                DeclRefExprClass = 3,
-                CXXOperatorCallExpr = 4,
+                CXXConstructExprClass = 4,
-                ImplicitCastExpr = 5,
+                CXXOperatorCallExpr = 5,
-                ExplicitCastExpr = 6
+                ImplicitCastExpr = 6,
+                ExplicitCastExpr = 7
             };
 
             public enum struct TemplateSpecializationKind
@@ -1505,6 +1507,29 @@ namespace CppSharp
                 }
             };
 
+            public ref class CallExpr : CppSharp::Parser::AST::Expression
+            {
+            public:
+
+                CallExpr(::CppSharp::CppParser::AST::CallExpr* native);
+                static CallExpr^ __CreateInstance(::System::IntPtr native);
+                static CallExpr^ __CreateInstance(::System::IntPtr native, bool __ownsNativeInstance);
+                CallExpr(CppSharp::Parser::AST::CallExpr^ _0);
+
+                ~CallExpr();
+
+                property unsigned int ArgumentsCount
+                {
+                    unsigned int get();
+                }
+
+                CppSharp::Parser::AST::Expression^ getArguments(unsigned int i);
+
+                void addArguments(CppSharp::Parser::AST::Expression^ s);
+
+                void clearArguments();
+            };
+
             public ref class CXXConstructExpr : CppSharp::Parser::AST::Expression
             {
             public:

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

@@ -136,11 +136,12 @@ namespace CppSharp
             {
                 Any = 0,
                 BinaryOperator = 1,
-                DeclRefExprClass = 2,
+                CallExprClass = 2,
-                CXXConstructExprClass = 3,
+                DeclRefExprClass = 3,
-                CXXOperatorCallExpr = 4,
+                CXXConstructExprClass = 4,
-                ImplicitCastExpr = 5,
+                CXXOperatorCallExpr = 5,
-                ExplicitCastExpr = 6
+                ImplicitCastExpr = 6,
+                ExplicitCastExpr = 7
             }
 
             public enum TemplateSpecializationKind
@@ -4888,6 +4889,123 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class CallExpr : CppSharp.Parser.AST.Expression, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 32)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.StatementClass Class;
+
+                    [FieldOffset(4)]
+                    public global::System.IntPtr Decl;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprC2ERKS2_")]
+                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12getArgumentsEj")]
+                    internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12addArgumentsERPNS1_10ExpressionE")]
+                    internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr14clearArgumentsEv")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr17getArgumentsCountEv")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new CallExpr __CreateInstance(global::System.IntPtr native, bool ownsNativeInstance = false, bool skipVTables = false)
+                {
+                    return new CallExpr((CallExpr.Internal*) native, skipVTables) { __ownsNativeInstance = ownsNativeInstance };
+                }
+
+                public static CallExpr __CreateInstance(CallExpr.Internal native, bool skipVTables = false)
+                {
+                    return new CallExpr(native, skipVTables);
+                }
+
+                private static CallExpr.Internal* __CopyValue(CallExpr.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(32);
+                    CppSharp.Parser.AST.CallExpr.Internal.cctor_2(ret, new global::System.IntPtr(&native));
+                    return (CallExpr.Internal*) ret;
+                }
+
+                private CallExpr(CallExpr.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected CallExpr(CallExpr.Internal* native, bool skipVTables = false)
+                    : base((CppSharp.Parser.AST.Expression.Internal*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public CallExpr(CppSharp.Parser.AST.CallExpr _0)
+                    : this((Internal*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(32);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    var arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance;
+                    Internal.cctor_2((__Instance + __PointerAdjustment), arg0);
+                }
+
+                public CppSharp.Parser.AST.Expression getArguments(uint i)
+                {
+                    var __ret = Internal.getArguments_0((__Instance + __PointerAdjustment), i);
+                    CppSharp.Parser.AST.Expression __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (CppSharp.Parser.AST.Expression.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (CppSharp.Parser.AST.Expression) CppSharp.Parser.AST.Expression.NativeToManagedMap[__ret];
+                    else __result0 = CppSharp.Parser.AST.Expression.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addArguments(CppSharp.Parser.AST.Expression s)
+                {
+                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
+                    Internal.addArguments_0((__Instance + __PointerAdjustment), arg0);
+                }
+
+                public void clearArguments()
+                {
+                    Internal.clearArguments_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint ArgumentsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getArgumentsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
             public unsafe partial class CXXConstructExpr : CppSharp.Parser.AST.Expression, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 32)]

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

@@ -136,11 +136,12 @@ namespace CppSharp
             {
                 Any = 0,
                 BinaryOperator = 1,
-                DeclRefExprClass = 2,
+                CallExprClass = 2,
-                CXXConstructExprClass = 3,
+                DeclRefExprClass = 3,
-                CXXOperatorCallExpr = 4,
+                CXXConstructExprClass = 4,
-                ImplicitCastExpr = 5,
+                CXXOperatorCallExpr = 5,
-                ExplicitCastExpr = 6
+                ImplicitCastExpr = 6,
+                ExplicitCastExpr = 7
             }
 
             public enum TemplateSpecializationKind
@@ -4888,6 +4889,123 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class CallExpr : CppSharp.Parser.AST.Expression, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 44)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.StatementClass Class;
+
+                    [FieldOffset(4)]
+                    public global::System.IntPtr Decl;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??0CallExpr@AST@CppParser@CppSharp@@QAE@ABV0123@@Z")]
+                    internal static extern global::System.IntPtr cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??1CallExpr@AST@CppParser@CppSharp@@QAE@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="?getArguments@CallExpr@AST@CppParser@CppSharp@@QAEPAVExpression@234@I@Z")]
+                    internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="?addArguments@CallExpr@AST@CppParser@CppSharp@@QAEXAAPAVExpression@234@@Z")]
+                    internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="?clearArguments@CallExpr@AST@CppParser@CppSharp@@QAEXXZ")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="?getArgumentsCount@CallExpr@AST@CppParser@CppSharp@@QAEIXZ")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new CallExpr __CreateInstance(global::System.IntPtr native, bool ownsNativeInstance = false, bool skipVTables = false)
+                {
+                    return new CallExpr((CallExpr.Internal*) native, skipVTables) { __ownsNativeInstance = ownsNativeInstance };
+                }
+
+                public static CallExpr __CreateInstance(CallExpr.Internal native, bool skipVTables = false)
+                {
+                    return new CallExpr(native, skipVTables);
+                }
+
+                private static CallExpr.Internal* __CopyValue(CallExpr.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(44);
+                    CppSharp.Parser.AST.CallExpr.Internal.cctor_2(ret, new global::System.IntPtr(&native));
+                    return (CallExpr.Internal*) ret;
+                }
+
+                private CallExpr(CallExpr.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected CallExpr(CallExpr.Internal* native, bool skipVTables = false)
+                    : base((CppSharp.Parser.AST.Expression.Internal*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public CallExpr(CppSharp.Parser.AST.CallExpr _0)
+                    : this((Internal*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(44);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    var arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance;
+                    Internal.cctor_2((__Instance + __PointerAdjustment), arg0);
+                }
+
+                public CppSharp.Parser.AST.Expression getArguments(uint i)
+                {
+                    var __ret = Internal.getArguments_0((__Instance + __PointerAdjustment), i);
+                    CppSharp.Parser.AST.Expression __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (CppSharp.Parser.AST.Expression.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (CppSharp.Parser.AST.Expression) CppSharp.Parser.AST.Expression.NativeToManagedMap[__ret];
+                    else __result0 = CppSharp.Parser.AST.Expression.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addArguments(CppSharp.Parser.AST.Expression s)
+                {
+                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
+                    Internal.addArguments_0((__Instance + __PointerAdjustment), arg0);
+                }
+
+                public void clearArguments()
+                {
+                    Internal.clearArguments_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint ArgumentsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getArgumentsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
             public unsafe partial class CXXConstructExpr : CppSharp.Parser.AST.Expression, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 44)]

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

@@ -136,11 +136,12 @@ namespace CppSharp
             {
                 Any = 0,
                 BinaryOperator = 1,
-                DeclRefExprClass = 2,
+                CallExprClass = 2,
-                CXXConstructExprClass = 3,
+                DeclRefExprClass = 3,
-                CXXOperatorCallExpr = 4,
+                CXXConstructExprClass = 4,
-                ImplicitCastExpr = 5,
+                CXXOperatorCallExpr = 5,
-                ExplicitCastExpr = 6
+                ImplicitCastExpr = 6,
+                ExplicitCastExpr = 7
             }
 
             public enum TemplateSpecializationKind
@@ -4887,6 +4888,123 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class CallExpr : CppSharp.Parser.AST.Expression, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 64)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.StatementClass Class;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr Decl;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprC2ERKS2_")]
+                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12getArgumentsEj")]
+                    internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12addArgumentsERPNS1_10ExpressionE")]
+                    internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr14clearArgumentsEv")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr17getArgumentsCountEv")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new CallExpr __CreateInstance(global::System.IntPtr native, bool ownsNativeInstance = false, bool skipVTables = false)
+                {
+                    return new CallExpr((CallExpr.Internal*) native, skipVTables) { __ownsNativeInstance = ownsNativeInstance };
+                }
+
+                public static CallExpr __CreateInstance(CallExpr.Internal native, bool skipVTables = false)
+                {
+                    return new CallExpr(native, skipVTables);
+                }
+
+                private static CallExpr.Internal* __CopyValue(CallExpr.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(64);
+                    CppSharp.Parser.AST.CallExpr.Internal.cctor_2(ret, new global::System.IntPtr(&native));
+                    return (CallExpr.Internal*) ret;
+                }
+
+                private CallExpr(CallExpr.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected CallExpr(CallExpr.Internal* native, bool skipVTables = false)
+                    : base((CppSharp.Parser.AST.Expression.Internal*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public CallExpr(CppSharp.Parser.AST.CallExpr _0)
+                    : this((Internal*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(64);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    var arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance;
+                    Internal.cctor_2((__Instance + __PointerAdjustment), arg0);
+                }
+
+                public CppSharp.Parser.AST.Expression getArguments(uint i)
+                {
+                    var __ret = Internal.getArguments_0((__Instance + __PointerAdjustment), i);
+                    CppSharp.Parser.AST.Expression __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (CppSharp.Parser.AST.Expression.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (CppSharp.Parser.AST.Expression) CppSharp.Parser.AST.Expression.NativeToManagedMap[__ret];
+                    else __result0 = CppSharp.Parser.AST.Expression.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addArguments(CppSharp.Parser.AST.Expression s)
+                {
+                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
+                    Internal.addArguments_0((__Instance + __PointerAdjustment), arg0);
+                }
+
+                public void clearArguments()
+                {
+                    Internal.clearArguments_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint ArgumentsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getArgumentsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
             public unsafe partial class CXXConstructExpr : CppSharp.Parser.AST.Expression, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 64)]

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

@@ -136,11 +136,12 @@ namespace CppSharp
             {
                 Any = 0,
                 BinaryOperator = 1,
-                DeclRefExprClass = 2,
+                CallExprClass = 2,
-                CXXConstructExprClass = 3,
+                DeclRefExprClass = 3,
-                CXXOperatorCallExpr = 4,
+                CXXConstructExprClass = 4,
-                ImplicitCastExpr = 5,
+                CXXOperatorCallExpr = 5,
-                ExplicitCastExpr = 6
+                ImplicitCastExpr = 6,
+                ExplicitCastExpr = 7
             }
 
             public enum TemplateSpecializationKind
@@ -4887,6 +4888,123 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class CallExpr : CppSharp.Parser.AST.Expression, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 48)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.StatementClass Class;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr Decl;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprC2ERKS2_")]
+                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12getArgumentsEj")]
+                    internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12addArgumentsERPNS1_10ExpressionE")]
+                    internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr14clearArgumentsEv")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr17getArgumentsCountEv")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new CallExpr __CreateInstance(global::System.IntPtr native, bool ownsNativeInstance = false, bool skipVTables = false)
+                {
+                    return new CallExpr((CallExpr.Internal*) native, skipVTables) { __ownsNativeInstance = ownsNativeInstance };
+                }
+
+                public static CallExpr __CreateInstance(CallExpr.Internal native, bool skipVTables = false)
+                {
+                    return new CallExpr(native, skipVTables);
+                }
+
+                private static CallExpr.Internal* __CopyValue(CallExpr.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(48);
+                    CppSharp.Parser.AST.CallExpr.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return (CallExpr.Internal*) ret;
+                }
+
+                private CallExpr(CallExpr.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected CallExpr(CallExpr.Internal* native, bool skipVTables = false)
+                    : base((CppSharp.Parser.AST.Expression.Internal*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public CallExpr(CppSharp.Parser.AST.CallExpr _0)
+                    : this((Internal*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(48);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    var arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance;
+                    Internal.cctor_1((__Instance + __PointerAdjustment), arg0);
+                }
+
+                public CppSharp.Parser.AST.Expression getArguments(uint i)
+                {
+                    var __ret = Internal.getArguments_0((__Instance + __PointerAdjustment), i);
+                    CppSharp.Parser.AST.Expression __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (CppSharp.Parser.AST.Expression.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (CppSharp.Parser.AST.Expression) CppSharp.Parser.AST.Expression.NativeToManagedMap[__ret];
+                    else __result0 = CppSharp.Parser.AST.Expression.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addArguments(CppSharp.Parser.AST.Expression s)
+                {
+                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
+                    Internal.addArguments_0((__Instance + __PointerAdjustment), arg0);
+                }
+
+                public void clearArguments()
+                {
+                    Internal.clearArguments_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint ArgumentsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getArgumentsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
             public unsafe partial class CXXConstructExpr : CppSharp.Parser.AST.Expression, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 48)]

src/CppParser/Parser.cpp

@@ -2625,6 +2625,17 @@ AST::Expression* Parser::WalkExpression(clang::Expr* Expr)
             WalkExpression(BinaryOperator->getLHS()), WalkExpression(BinaryOperator->getRHS()),
             BinaryOperator->getOpcodeStr().str());
     }
+    case Stmt::CallExprClass:
+    {
+        auto CallExpr = cast<clang::CallExpr>(Expr);
+        auto CallExpression = new AST::CallExpr(GetStringFromStatement(Expr),
+            WalkDeclaration(CallExpr->getCalleeDecl()));
+        for (auto arg : CallExpr->arguments())
+        {
+            CallExpression->Arguments.push_back(WalkExpression(arg));
+        }
+        return CallExpression;
+    }
     case Stmt::DeclRefExprClass:
         return new AST::Expression(GetStringFromStatement(Expr), StatementClass::DeclRefExprClass,
             WalkDeclaration(cast<DeclRefExpr>(Expr)->getDecl()));
@@ -2965,6 +2976,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
         break;
     }
     case Decl::CXXConstructor:
+    case Decl::CXXMethod:
     {
         auto MD = cast<CXXMethodDecl>(D);
         Decl = WalkMethodCXX(MD);
@@ -2983,7 +2995,6 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
     // a class already.
     case Decl::CXXDestructor:
     case Decl::CXXConversion:
-    case Decl::CXXMethod:
         break;
     case Decl::Empty:
     case Decl::AccessSpec: