generate calls to cctor when passing paramters by value

Author: Fabio Anderegg

src/Generator/Generators/CSharp/CSharpMarshal.cs

@@ -767,11 +767,35 @@ private void MarshalRefClass(Class @class)
             {
                 if (Context.Parameter.IsIndirect)
                 {
-                    Context.Before.WriteLine($"if (ReferenceEquals({Context.Parameter.Name}, null))");
-                    Context.Before.WriteLineIndent(
-                        $@"throw new global::System.ArgumentNullException(""{
-                            Context.Parameter.Name}"", ""Cannot be null because it is passed by value."");");
-                    Context.Return.Write(paramInstance);
+                    Method cctor = @class.HasNonTrivialCopyConstructor ? @class.Methods.First(c => c.IsCopyConstructor) : null;
+                    if (cctor != null && cctor.IsGenerated)
+                    {
+                        Context.Before.WriteLine($"if (ReferenceEquals({Context.Parameter.Name}, null))");
+                        Context.Before.WriteLineIndent(
+                            $@"throw new global::System.ArgumentNullException(""{
+                                Context.Parameter.Name}"", ""Cannot be null because it is passed by value."");");
+
+                        var nativeClass = typePrinter.PrintNative(@class);
+                        var cctorName = CSharpSources.GetFunctionNativeIdentifier(Context.Context, cctor);
+                        Context.Before.WriteLine($"byte* __{Context.Parameter.Name}Memory = stackalloc byte[sizeof({nativeClass})];");
+                        Context.Before.WriteLine($"__IntPtr __{Context.Parameter.Name}Ptr = (__IntPtr)__{Context.Parameter.Name}Memory;");
+                        Context.Before.WriteLine($"{nativeClass}.{cctorName}(__{Context.Parameter.Name}Ptr, {Context.Parameter.Name}.__Instance);");
+                        Context.Return.Write($"__{Context.Parameter.Name}Ptr");
+
+                        if (Context.Context.ParserOptions.IsItaniumLikeAbi && @class.HasNonTrivialDestructor)
+                        {
+                            Method dtor = @class.Destructors.FirstOrDefault();
+                            if (dtor != null)
+                            {
+                                // todo: virtual destructors?
+                                Context.Cleanup.WriteLine($"{nativeClass}.dtor(__{Context.Parameter.Name}Ptr);");
+                            }
+                        }
+                    }
+                    else
+                    {
+                        Context.Return.Write(paramInstance);
+                    }
                 }
                 else
                 {

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -3436,6 +3436,12 @@ public static string GetFunctionIdentifier(Function function)
 
         public string GetFunctionNativeIdentifier(Function function,
             bool isForDelegate = false)
+        {
+            return GetFunctionNativeIdentifier(Context, function, isForDelegate);
+        }
+
+        public static string GetFunctionNativeIdentifier(BindingContext context, Function function,
+            bool isForDelegate = false)
         {
             var identifier = new StringBuilder();
 
@@ -3466,12 +3472,12 @@ public string GetFunctionNativeIdentifier(Function function,
                 identifier.Append(Helpers.GetSuffixFor(specialization));
 
             var internalParams = function.GatherInternalParams(
-                Context.ParserOptions.IsItaniumLikeAbi);
+                context.ParserOptions.IsItaniumLikeAbi);
             var overloads = function.Namespace.GetOverloads(function)
                 .Where(f => (!f.Ignore ||
                     (f.OriginalFunction != null && !f.OriginalFunction.Ignore)) &&
                     (isForDelegate || internalParams.SequenceEqual(
-                        f.GatherInternalParams(Context.ParserOptions.IsItaniumLikeAbi),
+                        f.GatherInternalParams(context.ParserOptions.IsItaniumLikeAbi),
                     new MarshallingParamComparer()))).ToList();
             var index = -1;
             if (overloads.Count > 1)

tests/CSharp/CSharp.Tests.cs

@@ -1984,4 +1984,19 @@ public void TestCallByValueCppToCSharpPointer()
         Assert.That(RuleOfThreeTester.CopyConstructorCalls, Is.EqualTo(0));
         Assert.That(RuleOfThreeTester.CopyAssignmentCalls, Is.EqualTo(0));
     }
+
+    [Test]
+    public void TestObjectPassByValue1451()
+    {
+        using (var s = new Issue1451())
+        {
+            s.A = 500;
+            Assert.IsTrue(CSharp.CSharp.TestObjectPassByValue(s));
+            Assert.That(s.A, Is.EqualTo(500));
+        }
+
+        Assert.That(Issue1451.ConstructorCalls, Is.EqualTo(1));
+        Assert.That(Issue1451.CopyConstructorCalls, Is.EqualTo(1));
+        Assert.That(Issue1451.DestructorCalls, Is.EqualTo(2));
+    }
 }

tests/CSharp/CSharp.cpp

@@ -1750,3 +1750,30 @@ void CallCallByValueInterfacePointer(CallByValueInterface* interface)
     RuleOfThreeTester value;
     interface->CallByPointer(&value);
 }
+
+int Issue1451::constructorCalls = 0;
+int Issue1451::destructorCalls = 0;
+int Issue1451::copyConstructorCalls = 0;
+
+Issue1451::Issue1451()
+{
+    a = 0;
+    constructorCalls++;
+}
+
+Issue1451::Issue1451(const Issue1451& other)
+{
+    a = other.a;
+    copyConstructorCalls++;
+}
+
+Issue1451::~Issue1451()
+{
+    destructorCalls++;
+}
+
+bool TestObjectPassByValue(Issue1451 s)
+{
+    s.a = 99999;
+    return true;
+}

tests/CSharp/CSharp.h

@@ -1582,3 +1582,16 @@ struct DLL_API CallByValueInterface {
 void DLL_API CallCallByValueInterfaceValue(CallByValueInterface*);
 void DLL_API CallCallByValueInterfaceReference(CallByValueInterface*);
 void DLL_API CallCallByValueInterfacePointer(CallByValueInterface*);
+
+struct DLL_API Issue1451 {
+    int a;
+    static int constructorCalls;
+    static int destructorCalls;
+    static int copyConstructorCalls;
+
+    Issue1451();
+    ~Issue1451();
+    Issue1451(const Issue1451& other);
+};
+
+bool DLL_API TestObjectPassByValue(Issue1451 s);