Fixed a corner case of a default parameter with a type mapped to an enum.

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

src/AST/Function.cs

@@ -48,6 +48,7 @@ namespace CppSharp.AST
             Kind = p.Kind;
             QualifiedType = p.QualifiedType;
             Usage = p.Usage;
+            OriginalDefaultArgument = p.OriginalDefaultArgument;
             DefaultArgument = p.DefaultArgument;
         }
 
@@ -60,7 +61,21 @@ namespace CppSharp.AST
         public ParameterUsage Usage { get; set; }
         public bool HasDefaultValue { get; set; }
 
-        public Expression DefaultArgument { get; set; }
+        public Expression DefaultArgument
+        {
+            get
+            {
+                return defaultArgument;
+            }
+            set
+            {
+                defaultArgument = value;
+                if (OriginalDefaultArgument == null)
+                    OriginalDefaultArgument = value;
+            }
+        }
+
+        public Expression OriginalDefaultArgument { get; set; }
 
         public bool IsIn => Usage == ParameterUsage.In;
         public bool IsOut => Usage == ParameterUsage.Out;
@@ -82,6 +97,8 @@ namespace CppSharp.AST
         {
             get { return DebugText.StartsWith("const ", System.StringComparison.Ordinal); }
         }
+
+        Expression defaultArgument;
     }
 
     public class ParameterTypeComparer : IEqualityComparer<Parameter>

src/Generator/Passes/ConstructorToConversionOperatorPass.cs

@@ -69,7 +69,11 @@ namespace CppSharp.Passes
                 OperatorKind = operatorKind,
                 IsExplicit = method.IsExplicit
             };
-            conversionOperator.Parameters.Add(new Parameter(parameter) { DefaultArgument = null });
+            conversionOperator.Parameters.Add(new Parameter(parameter)
+                {
+                    DefaultArgument = null,
+                    OriginalDefaultArgument = null
+                });
             ((Class) method.Namespace).Methods.Add(conversionOperator);
             return true;
         }

src/Generator/Passes/HandleDefaultParamValuesPass.cs

@@ -44,7 +44,8 @@ namespace CppSharp.Passes
             foreach (var parameter in function.Parameters.Where(p => p.DefaultArgument != null))
             {
                 var result = parameter.DefaultArgument.String;
-                if (PrintExpression(function, parameter.Type, parameter.DefaultArgument, ref result) == null)
+                if (PrintExpression(function, parameter.Type,
+                        parameter.OriginalDefaultArgument, ref result) == null)
                     overloadIndices.Add(function.Parameters.IndexOf(parameter));
                 if (string.IsNullOrEmpty(result))
                 {
@@ -324,7 +325,7 @@ namespace CppSharp.Passes
             if (function.Parameters.Count != 1)
                 return false;
 
-            var defaultArgument = function.Parameters[0].DefaultArgument;
+            var defaultArgument = function.Parameters[0].OriginalDefaultArgument;
             return defaultArgument is BuiltinTypeExpression &&
                 ((BuiltinTypeExpression) defaultArgument).Value == 0;
         }

tests/CSharp/CSharp.Tests.cs

@@ -214,6 +214,7 @@ public unsafe class CSharpTests : GeneratorTestFixture
             Assert.That(methodsWithDefaultValues.DefaultMappedToEnum(), Is.EqualTo(Flags.Flag3));
             methodsWithDefaultValues.DefaultMappedToZeroEnum();
             methodsWithDefaultValues.DefaultMappedToEnumAssignedWithCtor();
+            methodsWithDefaultValues.DefaultZeroMappedToEnumAssignedWithCtor();
             methodsWithDefaultValues.DefaultImplicitCtorInt();
             methodsWithDefaultValues.DefaultImplicitCtorChar();
             methodsWithDefaultValues.DefaultImplicitCtorFoo();

tests/CSharp/CSharp.cpp

@@ -456,6 +456,10 @@ QRect::QRect(QPoint p, QSize s)
 {
 }
 
+DefaultZeroMappedToEnum::DefaultZeroMappedToEnum(int*)
+{
+}
+
 MethodsWithDefaultValues::QMargins::QMargins(int left, int top, int right, int bottom)
 {
 }
@@ -558,6 +562,10 @@ void MethodsWithDefaultValues::defaultMappedToEnumAssignedWithCtor(QFlags<Flags>
 {
 }
 
+void MethodsWithDefaultValues::defaultZeroMappedToEnumAssignedWithCtor(DefaultZeroMappedToEnum defaultZeroMappedToEnum)
+{
+}
+
 void MethodsWithDefaultValues::defaultImplicitCtorInt(Quux arg)
 {
 }

tests/CSharp/CSharp.cs

@@ -64,6 +64,35 @@ namespace CppSharp.Tests
         }
     }
 
+    [TypeMap("DefaultZeroMappedToEnum")]
+    public class DefaultZeroMappedToEnum : TypeMap
+    {
+        public override string CSharpConstruct()
+        {
+            return string.Empty;
+        }
+
+        public override Type CSharpSignatureType(CSharpTypePrinterContext ctx)
+        {
+            return new TagType(new Enumeration());
+        }
+
+        public override string CSharpSignature(CSharpTypePrinterContext ctx)
+        {
+            return "Flags";
+        }
+
+        public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
+        {
+            ctx.Return.Write(ctx.Parameter.Name);
+        }
+
+        public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
+        {
+            ctx.Return.Write(ctx.ReturnVarName);
+        }
+    }
+
     [TypeMap("QList")]
     public class QList : TypeMap
     {

tests/CSharp/CSharp.h

@@ -373,6 +373,12 @@ namespace lowerCaseNameSpace
     };
 }
 
+class DLL_API DefaultZeroMappedToEnum
+{
+public:
+    DefaultZeroMappedToEnum(int* = 0);
+};
+
 class DLL_API MethodsWithDefaultValues : public Quux
 {
 public:
@@ -409,6 +415,7 @@ public:
     QFlags<Flags> defaultMappedToEnum(const QFlags<Flags>& qFlags = Flags::Flag3);
     void defaultMappedToZeroEnum(QFlags<Flags> qFlags = 0);
     void defaultMappedToEnumAssignedWithCtor(QFlags<Flags> qFlags = QFlags<Flags>());
+    void defaultZeroMappedToEnumAssignedWithCtor(DefaultZeroMappedToEnum defaultZeroMappedToEnum = DefaultZeroMappedToEnum());
     void defaultImplicitCtorInt(Quux arg = 0);
     void defaultImplicitCtorChar(Quux arg = 'a');
     void defaultImplicitCtorFoo(Quux arg = Foo());