Implement the non-blittable type marshalling proposal

DllImportGenerator/DllImportGenerator.IntegrationTests/NonBlittableStructTests.cs

@@ -0,0 +1,79 @@
+using System.Runtime.InteropServices;
+
+using SharedTypes;
+
+using Xunit;
+
+namespace DllImportGenerator.IntegrationTests
+{
+    partial class NativeExportsNE
+    {
+        [GeneratedDllImport(nameof(NativeExportsNE), EntryPoint = "stringcontainer_deepduplicate")]
+        public static partial void DeepDuplicateStrings(StringContainer strings, out StringContainer pStringsOut);
+
+        [GeneratedDllImport(nameof(NativeExportsNE), EntryPoint = "get_long_bytes_as_double")]
+        public static partial double GetLongBytesAsDouble([MarshalUsing(typeof(DoubleToLongMarshaler))] double d);
+
+        [GeneratedDllImport(nameof(NativeExportsNE), EntryPoint = "negate_bools")]
+        public static partial void NegateBools(
+            BoolStruct boolStruct,
+            out BoolStruct pBoolStructOut);
+
+        [GeneratedDllImport(nameof(NativeExportsNE), EntryPoint = "double_int_ref")]
+        public static partial IntWrapper DoubleIntRef(IntWrapper pInt);
+    }
+
+    public class NonBlittableStructTests
+    {
+        [Fact]
+        public void NonBlittableStructWithFree()
+        {
+            var stringContainer = new StringContainer
+            {
+                str1 = "Foo",
+                str2 = "Bar"
+            };
+
+            NativeExportsNE.DeepDuplicateStrings(stringContainer, out var stringContainer2);
+
+            Assert.Equal(stringContainer, stringContainer2);
+        }
+
+        [Fact]
+        public void MarshalUsing()
+        {
+            double d = 1234.56789;
+
+            Assert.Equal(d, NativeExportsNE.GetLongBytesAsDouble(d));
+        }
+
+        [Fact]
+        public void NonBlittableStructWithoutAllocation()
+        {
+            var boolStruct = new BoolStruct
+            {
+                b1 = true,
+                b2 = false,
+                b3 = true
+            };
+
+            NativeExportsNE.NegateBools(boolStruct, out BoolStruct boolStructNegated);
+
+            Assert.Equal(!boolStruct.b1, boolStructNegated.b1);
+            Assert.Equal(!boolStruct.b2, boolStructNegated.b2);
+            Assert.Equal(!boolStruct.b3, boolStructNegated.b3);
+        }
+
+        [Fact]
+        public void GetPinnableReferenceMarshalling()
+        {
+            int originalValue = 42;
+            var wrapper = new IntWrapper { i = originalValue };
+
+            var retVal = NativeExportsNE.DoubleIntRef(wrapper);
+
+            Assert.Equal(originalValue * 2, wrapper.i);
+            Assert.Equal(originalValue * 2, retVal.i);
+        }
+    }
+}

DllImportGenerator/DllImportGenerator.UnitTests/CodeSnippets.cs

@@ -311,6 +311,20 @@ partial class Test
         out {typeName} pOut);
 }}";
 
+        /// <summary>
+        /// Declaration with parameters.
+        /// </summary>
+        public static string BasicParametersAndModifiersNoRef(string typeName) => @$"
+using System.Runtime.InteropServices;
+partial class Test
+{{
+    [GeneratedDllImport(""DoesNotExist"")]
+    public static partial {typeName} Method(
+        {typeName} p,
+        in {typeName} pIn,
+        out {typeName} pOut);
+}}";
+
         public static string BasicParametersAndModifiers<T>() => BasicParametersAndModifiers(typeof(T).ToString());
 
         /// <summary>
@@ -446,5 +460,285 @@ public static partial void Method(
 }}";
 
         public static string ArrayParameterWithNestedMarshalInfo<T>(UnmanagedType nestedMarshalType) => ArrayParameterWithNestedMarshalInfo(typeof(T).ToString(), nestedMarshalType);
+        public static string CustomStructMarshallingParametersAndModifiers = BasicParametersAndModifiers("S") + @"
+[NativeMarshalling(typeof(Native))]
+struct S
+{
+    public bool b;
+}
+
+struct Native
+{
+    private int i;
+    public Native(S s)
+    {
+        i = s.b ? 1 : 0;
+    }
+
+    public S ToManaged() => new S { b = i != 0 };
+}
+";
+
+        public static string CustomStructMarshallingStackallocParametersAndModifiersNoRef = BasicParametersAndModifiersNoRef("S") + @"
+[NativeMarshalling(typeof(Native))]
+struct S
+{
+    public bool b;
+}
+
+struct Native
+{
+    private int i;
+    public Native(S s, System.Span<byte> b)
+    {
+        i = s.b ? 1 : 0;
+    }
+
+    public S ToManaged() => new S { b = i != 0 };
+
+    public const int StackBufferSize = 1;
+}
+";
+        public static string CustomStructMarshallingStackallocOnlyRefParameter = BasicParameterWithByRefModifier("ref", "S") + @"
+[NativeMarshalling(typeof(Native))]
+struct S
+{
+    public bool b;
+}
+
+struct Native
+{
+    private int i;
+    public Native(S s, System.Span<byte> b)
+    {
+        i = s.b ? 1 : 0;
+    }
+
+    public S ToManaged() => new S { b = i != 0 };
+
+    public const int StackBufferSize = 1;
+}
+";
+        public static string CustomStructMarshallingOptionalStackallocParametersAndModifiers = BasicParametersAndModifiers("S") + @"
+[NativeMarshalling(typeof(Native))]
+struct S
+{
+    public bool b;
+}
+
+struct Native
+{
+    private int i;
+    public Native(S s, System.Span<byte> b)
+    {
+        i = s.b ? 1 : 0;
+    }
+    public Native(S s)
+    {
+        i = s.b ? 1 : 0;
+    }
+
+    public S ToManaged() => new S { b = i != 0 };
+
+    public const int StackBufferSize = 1;
+}
+";
+
+        public static string CustomStructMarshallingStackallocValuePropertyParametersAndModifiersNoRef = BasicParametersAndModifiersNoRef("S") + @"
+[NativeMarshalling(typeof(Native))]
+struct S
+{
+    public bool b;
+}
+
+struct Native
+{
+    public Native(S s, System.Span<byte> b)
+    {
+        Value = s.b ? 1 : 0;
+    }
+
+    public S ToManaged() => new S { b = Value != 0 };
+
+    public int Value { get; set; }
+
+    public const int StackBufferSize = 1;
+}
+";
+        public static string CustomStructMarshallingValuePropertyParametersAndModifiers = BasicParametersAndModifiers("S") + @"
+[NativeMarshalling(typeof(Native))]
+struct S
+{
+    public bool b;
+}
+
+struct Native
+{
+    public Native(S s)
+    {
+        Value = s.b ? 1 : 0;
+    }
+
+    public S ToManaged() => new S { b = Value != 0 };
+
+    public int Value { get; set; }
+}
+";
+        public static string CustomStructMarshallingPinnableParametersAndModifiers = BasicParametersAndModifiers("S") + @"
+[NativeMarshalling(typeof(Native))]
+class S
+{
+    public int i;
+
+    public ref int GetPinnableReference() => ref i;
+}
+
+unsafe struct Native
+{
+    private int* ptr;
+    public Native(S s)
+    {
+        ptr = (int*)Marshal.AllocHGlobal(sizeof(int));
+        *ptr = s.i;
+    }
+
+    public S ToManaged() => new S { i = *ptr };
+
+    public nint Value
+    {
+        get => (nint)ptr;
+        set => ptr = (int*)value;
+    }
+}
+";
+
+        public static string CustomStructMarshallingByRefValuePropertyIn = @"
+using System.Runtime.InteropServices;
+
+[NativeMarshalling(typeof(Native))]
+class S
+{
+    public byte c;
+}
+
+unsafe struct Native
+{
+    private S value;
+
+    public Native(S s) : this()
+    {
+        value = s;
+    }
+
+    public ref byte Value { get => ref value.c; }
+}
+
+partial class Test
+{
+    [GeneratedDllImport(""DoesNotExist"")]
+    public static partial void Method(
+        S s,
+        in S sIn);
+}
+";
+
+        public static string CustomStructMarshallingByRefValuePropertyRefOutReturn = @"
+using System.Runtime.InteropServices;
+
+[NativeMarshalling(typeof(Native))]
+class S
+{
+    public byte c;
+}
+
+unsafe struct Native
+{
+    private S value;
+
+    public Native(S s) : this()
+    {
+        value = s;
+    }
+
+    public ref byte Value { get => ref value.c; }
+}
+
+partial class Test
+{
+    [GeneratedDllImport(""DoesNotExist"")]
+    public static partial S Method(
+        ref S sRef,
+        out S sOut);
+}
+";
+
+        public static string BasicParameterWithByRefModifier(string byRefKind, string typeName) => @$"
+using System.Runtime.InteropServices;
+partial class Test
+{{
+    [GeneratedDllImport(""DoesNotExist"")]
+    public static partial void Method(
+        {byRefKind} {typeName} p);
+}}";
+
+        public static string BasicReturnType(string typeName) => @$"
+using System.Runtime.InteropServices;
+partial class Test
+{{
+    [GeneratedDllImport(""DoesNotExist"")]
+    public static partial {typeName} Method();
+}}";
+
+        public static string CustomStructMarshallingManagedToNativeOnlyOutParameter => BasicParameterWithByRefModifier("out", "S")  + @"
+[NativeMarshalling(typeof(Native))]
+[StructLayout(LayoutKind.Sequential)]
+struct S
+{
+    public bool b;
+}
+
+struct Native
+{
+    private int i;
+    public Native(S s)
+    {
+        i = s.b ? 1 : 0;
+    }
+}
+";
+
+        public static string CustomStructMarshallingManagedToNativeOnlyReturnValue => BasicReturnType("S")  + @"
+[NativeMarshalling(typeof(Native))]
+[StructLayout(LayoutKind.Sequential)]
+struct S
+{
+    public bool b;
+}
+
+struct Native
+{
+    private int i;
+    public Native(S s)
+    {
+        i = s.b ? 1 : 0;
+    }
+}
+";
+
+        public static string CustomStructMarshallingNativeToManagedOnlyInParameter => BasicParameterWithByRefModifier("in", "S")  + @"
+[NativeMarshalling(typeof(Native))]
+struct S
+{
+    public bool b;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+struct Native
+{
+    private int i;
+    public S ToManaged() => new S { b = i != 0 };
+}
+";
+
     }
 }