CSharp: More default parameter fixes (#1747)

- Expression generation for `ConstructorReference` now also recursively
calls `VisitExpression` for the argument if only one argument is
detected. This allows correct overload generation for functions taking
a variable as the default parameter value.
- Default parameters of pointer-to-enumeration types are now correctly
generated similar to primitive types.

src/AST/TypeExtensions.cs

@@ -92,6 +92,25 @@
             return ptr.Pointee.IsPrimitiveType(primitive);
         }
 
+        public static bool IsPointerToEnum(this Type t)
+        {
+            var ptr = t as PointerType;
+            if (ptr == null)
+                return false;
+            return ptr.Pointee.IsEnumType();
+        }
+
+        public static bool IsPointerToEnum(this Type t, out Enumeration @enum)
+        {
+            var ptr = t as PointerType;
+            if (ptr == null)
+            {
+                @enum = null;
+                return false;
+            }
+            return ptr.Pointee.TryGetEnum(out @enum);
+        }
+
         public static bool IsPointerTo<T>(this Type t, out T type) where T : Type
         {
             var pointee = t.GetPointee();

src/Generator/Generators/CSharp/CSharpExpressionPrinter.cs

@@ -68,8 +68,8 @@ namespace CppSharp.Generators.CSharp
                 case StatementClass.ConstructorReference:
                     var constructorExpr = (CXXConstructExprObsolete)expr;
                     if (constructorExpr.Arguments.Count == 1 &&
-                        constructorExpr.Arguments[0].Declaration is Enumeration.Item)
-                        return constructorExpr.Arguments[0].Declaration.Visit(typePrinter).Type;
+                        constructorExpr.Arguments[0].Class != StatementClass.Any)
+                        return VisitExpression(constructorExpr.Arguments[0]);
                     goto default;
                 default:
                     return expr.String;

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -2783,7 +2783,7 @@ internal static{(@new ? " new" : string.Empty)} {printedClass} __GetInstance({Ty
 
         private string OverloadParamNameWithDefValue(Parameter p, ref int index)
         {
-            return p.Type.IsPointerToPrimitiveType() && p.Usage == ParameterUsage.InOut && p.HasDefaultValue
+            return (p.Type.IsPointerToPrimitiveType() || p.Type.IsPointerToEnum()) && p.Usage == ParameterUsage.InOut && p.HasDefaultValue
                 ? "ref param" + index++
                 : ExpressionPrinter.VisitParameter(p);
         }
@@ -2802,13 +2802,15 @@ internal static{(@new ? " new" : string.Empty)} {printedClass} __GetInstance({Ty
             for (int i = 0, j = 0; i < function.Parameters.Count; i++)
             {
                 var parameter = function.Parameters[i];
-                PrimitiveType primitiveType;
+                PrimitiveType primitiveType = PrimitiveType.Null;
+                Enumeration enumeration = null;
                 if (parameter.Kind == ParameterKind.Regular && parameter.Ignore &&
-                    parameter.Type.IsPointerToPrimitiveType(out primitiveType) &&
+                        (parameter.Type.IsPointerToPrimitiveType(out primitiveType) ||
+                        parameter.Type.IsPointerToEnum(out enumeration)) &&
                     parameter.Usage == ParameterUsage.InOut && parameter.HasDefaultValue)
                 {
                     var pointeeType = ((PointerType)parameter.Type).Pointee.ToString();
-                    WriteLine($@"{pointeeType} param{j++} = {(primitiveType == PrimitiveType.Bool ? "false" : "0")};");
+                    WriteLine($@"{pointeeType} param{j++} = {(primitiveType == PrimitiveType.Bool ? "false" : $"({pointeeType})0")};");
                 }
             }
 

tests/dotnet/CSharp/CSharp.Tests.cs

@@ -346,6 +346,10 @@ public unsafe class CSharpTests
             methodsWithDefaultValues.DefaultWithSpecialization();
             methodsWithDefaultValues.DefaultOverloadedImplicitCtor();
             methodsWithDefaultValues.DefaultWithParamNamedSameAsMethod(5);
+            Assert.That(methodsWithDefaultValues.DefaultIntAssignedAnEnumWithBinaryOperatorAndFlags(), Is.EqualTo((int)(Bar.Items.Item1 | Bar.Items.Item2)));
+            Assert.That(methodsWithDefaultValues.DefaultWithConstantFlags(), Is.EqualTo(CSharp.CSharp.ConstFlag1 | CSharp.CSharp.ConstFlag2 | CSharp.CSharp.ConstFlag3));
+            Assert.IsTrue(methodsWithDefaultValues.DefaultWithPointerToEnum());
+            Assert.AreEqual(CSharp.CSharp.DefaultSmallPODInstance.__Instance, methodsWithDefaultValues.DefaultWithNonPrimitiveType().__Instance);
         }
     }
 

tests/dotnet/CSharp/CSharp.cpp

@@ -568,6 +568,8 @@ MethodsWithDefaultValues::QMargins::QMargins(int left, int top, int right, int b
 {
 }
 
+struct SmallPOD DefaultSmallPODInstance;
+
 const char* MethodsWithDefaultValues::stringConstant = "test";
 int MethodsWithDefaultValues::intConstant = 5;
 
@@ -808,6 +810,26 @@ int MethodsWithDefaultValues::DefaultWithParamNamedSameAsMethod(int DefaultWithP
     return 1;
 }
 
+int MethodsWithDefaultValues::defaultIntAssignedAnEnumWithBinaryOperatorAndFlags(int f)
+{
+    return f;
+}
+
+int MethodsWithDefaultValues::defaultWithConstantFlags(int f)
+{
+    return f;
+}
+
+bool MethodsWithDefaultValues::defaultWithPointerToEnum(UntypedFlags* f1, int* f2)
+{
+    return (f1 == NULL || *f1 == (UntypedFlags)0) && (f2 == NULL || *f2 == 0);
+}
+
+SmallPOD* MethodsWithDefaultValues::defaultWithNonPrimitiveType(SmallPOD& pod)
+{
+    return &pod;
+}
+
 int MethodsWithDefaultValues::getA()
 {
     return m_foo.A;

tests/dotnet/CSharp/CSharp.h

@@ -405,6 +405,12 @@ enum class Empty : unsigned long long int
 class _ClassWithLeadingUnderscore {
 };
 
+const int ConstFlag1 = 1;
+const int ConstFlag2 = 2;
+const int ConstFlag3 = 4;
+
+extern DLL_API struct SmallPOD DefaultSmallPODInstance;
+
 class DLL_API MethodsWithDefaultValues : public Quux
 {
 public:
@@ -480,6 +486,10 @@ public:
     void defaultWithSpecialization(IndependentFields<int> specialization = IndependentFields<int>());
     void defaultOverloadedImplicitCtor(P p);
     void defaultOverloadedImplicitCtor(Qux q = Qux());
+    int defaultIntAssignedAnEnumWithBinaryOperatorAndFlags(int f = Bar::Item1 | Bar::Item2);
+    int defaultWithConstantFlags(int f = ConstFlag1 | ConstFlag2 | ConstFlag3);
+    bool defaultWithPointerToEnum(UntypedFlags* f1 = NULL, int* f2 = NULL);
+    SmallPOD* defaultWithNonPrimitiveType(SmallPOD& pod = DefaultSmallPODInstance);
     int DefaultWithParamNamedSameAsMethod(int DefaultWithParamNamedSameAsMethod, const Foo& defaultArg = Foo());
     int getA();
 private:

tests/dotnet/Common/Common.cpp

@@ -1274,11 +1274,3 @@ extern "C"
         return s;
     }
 } // extern "C"
-
-void DLL_API FunctionWithFlagsAsDefaultParameter(int defaultParam)
-{
-}
-
-void DLL_API FunctionWithConstFlagsAsDefaultParameter(int defaultParam)
-{
-}

tests/dotnet/Common/Common.h

@@ -1567,11 +1567,3 @@ extern "C"
     DLL_API void takeConflictName(struct system* self);
     DLL_API struct system freeFunctionReturnByValue();
 } // extern "C"
-
-void DLL_API FunctionWithFlagsAsDefaultParameter(int defaultParam = A | B);
-
-const int ConstFlag1 = 1;
-const int ConstFlag2 = 2;
-const int ConstFlag3 = 4;
-
-void DLL_API FunctionWithConstFlagsAsDefaultParameter(int defaultParam = ConstFlag1 | ConstFlag2 | ConstFlag3);