Implement the non-blittable type marshalling proposal #302

jkoritzinsky · 2020-11-04T22:33:38Z

Implement the marshaller defined in the StructMarshalling.md design doc.

Additionally, extend the design to support a Value property that returns a byref (currently works for by value and in parameters only).

Example generated code is included below.

Native type without Value property

Struct definition:

[NativeMarshalling(typeof(Native))]
struct S
{
    public bool b;
}

struct Native
{
    private int value;
    public Native(S s)
    {
        value = s.b ? 1 : 0;
    }

    public S ToManaged() => new S { b = value != 0 };
}

Generated code:

partial class Test
{
    public static partial global::S Method(global::S p, in global::S pIn, ref global::S pRef, out global::S pOut)
    {
        unsafe
        {
            global::Native __p_gen_native = default;
            global::Native __pIn_gen_native = default;
            global::Native __pRef_gen_native = default;
            pOut = default;
            global::Native __pOut_gen_native = default;
            global::S __retVal = default;
            global::Native __retVal_gen_native = default;
            //
            // Marshal
            //
            __p_gen_native = new global::Native(p);
            __pIn_gen_native = new global::Native(pIn);
            __pRef_gen_native = new global::Native(pRef);
            //
            // Invoke
            //
            __retVal_gen_native = Method__PInvoke__(__p_gen_native, &__pIn_gen_native, &__pRef_gen_native, &__pOut_gen_native);
            //
            // Unmarshal
            //
            __retVal = __retVal_gen_native.ToManaged();
            pRef = __pRef_gen_native.ToManaged();
            pOut = __pOut_gen_native.ToManaged();
            return __retVal;
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe global::Native Method__PInvoke__(global::Native p, global::Native*pIn, global::Native*pRef, global::Native*pOut);
}

Native type with Value property

Struct definition:

[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; }
}

Generated code:

partial class Test
{
    public static partial global::S Method(global::S p, in global::S pIn, ref global::S pRef, out global::S pOut)
    {
        unsafe
        {
            nint __pIn_gen_native = default;
            nint __pRef_gen_native = default;
            pOut = default;
            nint __pOut_gen_native = default;
            global::S __retVal = default;
            nint __retVal_gen_native = default;
            //
            // Setup
            //
            global::Native __retVal_gen_native__marshaler = default;
            global::Native __pIn_gen_native__marshaler = default;
            global::Native __pRef_gen_native__marshaler = default;
            global::Native __pOut_gen_native__marshaler = default;
            //
            // Marshal
            //
            __pIn_gen_native__marshaler = new global::Native(pIn);
            __pIn_gen_native = __pIn_gen_native__marshaler.Value;
            __pRef_gen_native__marshaler = new global::Native(pRef);
            __pRef_gen_native = __pRef_gen_native__marshaler.Value;
            //
            // Invoke
            //
            fixed (void *__p_gen_native = p)
            {
                __retVal_gen_native = Method__PInvoke__((nint)__p_gen_native, &__pIn_gen_native, &__pRef_gen_native, &__pOut_gen_native);
            }

            //
            // Unmarshal
            //
            __retVal_gen_native__marshaler.Value = __retVal_gen_native;
            __retVal = __retVal_gen_native__marshaler.ToManaged();
            __pRef_gen_native__marshaler.Value = __pRef_gen_native;
            pRef = __pRef_gen_native__marshaler.ToManaged();
            __pOut_gen_native__marshaler.Value = __pOut_gen_native;
            pOut = __pOut_gen_native__marshaler.ToManaged();
            return __retVal;
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe nint Method__PInvoke__(nint p, nint*pIn, nint*pRef, nint*pOut);
}

Native type with stackalloc support and no Value property

Struct definition:

[NativeMarshalling(typeof(Native))]
struct S
{
    public bool b;
}

struct Native
{
    private int value;
    public Native(S s, System.Span<byte> b)
    {
        value = s.b ? 1 : 0;
    }

    public S ToManaged() => new S { b = value != 0 };

    public const int StackBufferSize = 1;
}

Generated code:

partial class Test
{
    public static partial global::S Method(global::S p, in global::S pIn, out global::S pOut)
    {
        unsafe
        {
            global::Native __p_gen_native = default;
            global::Native __pIn_gen_native = default;
            pOut = default;
            global::Native __pOut_gen_native = default;
            global::S __retVal = default;
            global::Native __retVal_gen_native = default;
            //
            // Marshal
            //
            byte *p__stackptr = stackalloc byte[global::Native.StackBufferSize];
            __p_gen_native = new global::Native(p, new System.Span<byte>(p__stackptr, global::Native.StackBufferSize));
            byte *pIn__stackptr = stackalloc byte[global::Native.StackBufferSize];
            __pIn_gen_native = new global::Native(pIn, new System.Span<byte>(pIn__stackptr, global::Native.StackBufferSize));
            //
            // Invoke
            //
            __retVal_gen_native = Method__PInvoke__(__p_gen_native, &__pIn_gen_native, &__pOut_gen_native);
            //
            // Unmarshal
            //
            __retVal = __retVal_gen_native.ToManaged();
            pOut = __pOut_gen_native.ToManaged();
            return __retVal;
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe global::Native Method__PInvoke__(global::Native p, global::Native*pIn, global::Native*pOut);
}

Native type with stackalloc support and Value property

Struct definition:

[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;
}

Generated code:

partial class Test
{
    public static partial global::S Method(global::S p, in global::S pIn, out global::S pOut)
    {
        unsafe
        {
            int __p_gen_native = default;
            int __pIn_gen_native = default;
            pOut = default;
            int __pOut_gen_native = default;
            global::S __retVal = default;
            int __retVal_gen_native = default;
            //
            // Setup
            //
            global::Native __retVal_gen_native__marshaler = default;
            global::Native __p_gen_native__marshaler = default;
            global::Native __pIn_gen_native__marshaler = default;
            global::Native __pOut_gen_native__marshaler = default;
            //
            // Marshal
            //
            byte *p__stackptr = stackalloc byte[global::Native.StackBufferSize];
            __p_gen_native__marshaler = new global::Native(p, new System.Span<byte>(p__stackptr, global::Native.StackBufferSize));
            __p_gen_native = __p_gen_native__marshaler.Value;
            byte *pIn__stackptr = stackalloc byte[global::Native.StackBufferSize];
            __pIn_gen_native__marshaler = new global::Native(pIn, new System.Span<byte>(pIn__stackptr, global::Native.StackBufferSize));
            __pIn_gen_native = __pIn_gen_native__marshaler.Value;
            //
            // Invoke
            //
            __retVal_gen_native = Method__PInvoke__(__p_gen_native, &__pIn_gen_native, &__pOut_gen_native);
            //
            // Unmarshal
            //
            __retVal_gen_native__marshaler.Value = __retVal_gen_native;
            __retVal = __retVal_gen_native__marshaler.ToManaged();
            __pOut_gen_native__marshaler.Value = __pOut_gen_native;
            pOut = __pOut_gen_native__marshaler.ToManaged();
            return __retVal;
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe int Method__PInvoke__(int p, int *pIn, int *pOut);
}

Native type with Managed GetPinnableReference optimization

Struct definition:

[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;
    }
}

Generated code:

partial class Test
{
    public static partial global::S Method(global::S p, in global::S pIn, ref global::S pRef, out global::S pOut)
    {
        unsafe
        {
            nint __pIn_gen_native = default;
            nint __pRef_gen_native = default;
            pOut = default;
            nint __pOut_gen_native = default;
            global::S __retVal = default;
            nint __retVal_gen_native = default;
            //
            // Setup
            //
            global::Native __retVal_gen_native__marshaler = default;
            global::Native __pIn_gen_native__marshaler = default;
            global::Native __pRef_gen_native__marshaler = default;
            global::Native __pOut_gen_native__marshaler = default;
            //
            // Marshal
            //
            __pIn_gen_native__marshaler = new global::Native(pIn);
            __pIn_gen_native = __pIn_gen_native__marshaler.Value;
            __pRef_gen_native__marshaler = new global::Native(pRef);
            __pRef_gen_native = __pRef_gen_native__marshaler.Value;
            //
            // Invoke
            //
            fixed (void *__p_gen_native = p)
            {
                __retVal_gen_native = Method__PInvoke__((nint)__p_gen_native, &__pIn_gen_native, &__pRef_gen_native, &__pOut_gen_native);
            }

            //
            // Unmarshal
            //
            __retVal_gen_native__marshaler.Value = __retVal_gen_native;
            __retVal = __retVal_gen_native__marshaler.ToManaged();
            __pRef_gen_native__marshaler.Value = __pRef_gen_native;
            pRef = __pRef_gen_native__marshaler.ToManaged();
            __pOut_gen_native__marshaler.Value = __pOut_gen_native;
            pOut = __pOut_gen_native__marshaler.ToManaged();
            return __retVal;
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe nint Method__PInvoke__(nint p, nint*pIn, nint*pRef, nint*pOut);
}

Native type with GetPinnableReference method

Struct definition:

class S
{
    public byte c;
}

unsafe ref struct Native
{
    private byte* ptr;
    private Span<byte> stackBuffer;

    public Native(S s) : this()
    {
        ptr = (byte*)Marshal.AllocCoTaskMem(sizeof(byte));
        *ptr = s.c;
    }

    public Native(S s, Span<byte> buffer) : this()
    {
        stackBuffer = buffer;
        stackBuffer[0] = s.c;
    }

    public ref byte GetPinnableReference() => ref (ptr != null ? ref *ptr : ref stackBuffer.GetPinnableReference());

    public S ToManaged()
    {
        return new S { c = *ptr };
    }

    public byte* Value
    {
        get => ptr != null ? ptr : throw new InvalidOperationException();
        set => ptr = value;
    }

    public void FreeNative()
    {
        if (ptr != null)
        {
            Marshal.FreeCoTaskMem((IntPtr)ptr);
        }
    }

    public const int StackBufferSize = 1;
}

Generated code:

partial class Test
{
    public static partial void Method(global::S s, in global::S sIn)
    {
        unsafe
        {
            //
            // Setup
            //
            global::Native __s_gen_native__marshaler = default;
            global::Native __sIn_gen_native__marshaler = default;
            try
            {
                //
                // Marshal
                //
                byte *s__stackptr = stackalloc byte[global::Native.StackBufferSize];
                __s_gen_native__marshaler = new global::Native(s, new System.Span<byte>(s__stackptr, global::Native.StackBufferSize));
                byte *sIn__stackptr = stackalloc byte[global::Native.StackBufferSize];
                __sIn_gen_native__marshaler = new global::Native(sIn, new System.Span<byte>(sIn__stackptr, global::Native.StackBufferSize));
                //
                // Invoke
                //
                fixed (byte *__s_gen_native = &__s_gen_native__marshaler.GetPinnableReference())
                {
                    fixed (byte *__sIn_gen_native = &__sIn_gen_native__marshaler.GetPinnableReference())
                    {
                        Method__PInvoke__(__s_gen_native, &__sIn_gen_native);
                    }
                }
            }
            finally
            {
                //
                // Cleanup
                //
                __s_gen_native__marshaler.FreeNative();
                __sIn_gen_native__marshaler.FreeNative();
            }
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe void Method__PInvoke__(byte *s, byte **sIn);
}

…riction that the stack buffer passed in must be stack allocated. This enables us to conditionally stack alloc depending on used stack space in the future.

jkotas · 2020-11-05T00:13:16Z

DllImportGenerator/DllImportGenerator.UnitTests/CodeSnippets.cs

+    public bool b;
+}
+
+struct Native


It would be nice to try to establish naming convention for these and use it here. Native is very generic and it does not scale to have more than one in the given namespace.

I agree that we need to establish a naming convention for these types, but I don't think we need to do that immediately. We'll need to do it when we decide we want to support generating the native types for structs.

DllImportGenerator/DllImportGenerator.UnitTests/CodeSnippets.cs

jkotas · 2020-11-05T00:21:57Z

DllImportGenerator/DllImportGenerator.UnitTests/CodeSnippets.cs

+
+    public S ToManaged() => new S { b = Value != 0 };
+
+    public int Value { get; set; }


Native type with Value property

To reduce number of locals, I may be nice to pass the Value in directly for the simple case, e.g.:

__retVal_gen_native = Method__PInvoke__(__p_gen_native__marshaler.Value, ...);

jkotas · 2020-11-05T00:29:22Z

DllImportGenerator/DllImportGenerator/Marshalling/CustomNativeTypeMarshaler.cs

+
+                        if (scenarioSupportsStackalloc && (!info.IsByRef || info.RefKind == RefKind.In))
+                        {
+                            // stackalloc byte[<_nativeLocalType>.StackBufferSize]


We should set the no-zero init flag on the method - if it is not set globally on the assembly already.

@jkotas Is the intent here avoid the cost of zero initialing the stack space?

I'd prefer to do this in a follow up PR. This PR is quite large as it is.

…elab into non-blittable-struct-marshaler

DllImportGenerator/TestAssets/SharedTypes/SharedTypes.csproj

DllImportGenerator/DllImportGenerator/Marshalling/MarshallingGenerator.cs

DllImportGenerator/designs/StructMarshalling.md

…ing a byref return Value property.

jkoritzinsky · 2020-11-13T00:14:33Z

So I've encountered a slight hiccup with the design we have for enabling users to use the stackalloc optimization.

Given the following example managed and native type:

using System.Runtime.InteropServices;
using System;

class S
{
    public byte c;
}

unsafe ref struct Native
{
    private byte* ptr;
    private Span<byte> stackBuffer;

    public Native(S s) : this()
    {
        ptr = (byte*)Marshal.AllocCoTaskMem(sizeof(byte));
        *ptr = s.c;
    }

    public Native(S s, Span<byte> buffer) : this()
    {
        stackBuffer = buffer;
        stackBuffer[0] = s.c;
    }

    public ref byte GetPinnableReference() => ref (ptr != null ? ref *ptr : ref stackBuffer.GetPinnableReference());

    public S ToManaged()
    {
        return new S { c = *ptr };
    }

    public byte* Value
    {
        get => ptr != null ? ptr : throw new InvalidOperationException();
        set => ptr = value;
    }

    public void FreeNative()
    {
        if (ptr != null)
        {
            Marshal.FreeCoTaskMem((IntPtr)ptr);
        }
    }

    public const int StackBufferSize = 1;
}

The following code is generated:

partial class Test
{
    public static void Method(global::S s, in global::S sIn)
    {
        unsafe
        {
            //
            // Setup
            //
            global::Native __s_gen_native__marshaler = default;
            global::Native __sIn_gen_native__marshaler = default;
            //
            // Marshal
            //
            __s_gen_native__marshaler = new global::Native(s, stackalloc byte[global::Native.StackBufferSize]);
            __sIn_gen_native__marshaler = new global::Native(sIn, stackalloc byte[global::Native.StackBufferSize]);
            //
            // Invoke
            //
            fixed (byte *__s_gen_native = &__s_gen_native__marshaler.GetPinnableReference())
            {
                fixed (byte *__sIn_gen_native = &__sIn_gen_native__marshaler.GetPinnableReference())
                {
                    Method__PInvoke__(__s_gen_native, &__sIn_gen_native);
                }
            }

            //
            // Cleanup
            //
            __s_gen_native__marshaler.FreeNative();
            __sIn_gen_native__marshaler.FreeNative();
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe void Method__PInvoke__(byte *s, byte **sIn);
}

This causes a compile error because __s_gen_native__marshaler is allowed to escape the method based on its declaration, but the stackalloc'd Span cannot. The pattern I've seen to fix this is to create an instance of the struct at declaration time with a 0-length stackalloc (application in our scenario shown below), but I'm not a big fan of this workaround, so I'm looking for alternative ideas on how to solve this problem.

- global::Native __s_gen_native__marshaler = default;
+ global::Native __s_gen_native__marshaler = new global::Native(default, stackalloc byte[0]);

jkotas · 2020-11-13T00:34:25Z

Assign it directly?

global::Native __s_gen_native__marshaler = new global::Native(s, stackalloc byte[global::Native.StackBufferSize]);

jkoritzinsky · 2020-11-13T00:43:49Z

We can do that today, but once we start emitting the try and finally blocks to actually support cleanup in exceptional scenarios, that approach breaks down.

We can't just declare the variable in the try block, because then we won't be able to do cleanup. We can't declare the variable outside the try block and only assign it in the try block because then in the finally it would be considered unassigned and the lifetime error would still happen. And we can't just assign it outside of the try block because then we'd risk leaking resources if another struct that marshals via stack allocation (and as such is assigned outside of the try block) fails and throws an exception.

elinor-fung · 2020-11-13T01:06:00Z

Raw pointer for the stackalloc and explicitly construct the Span over it (I think I've seen this in parts of the runtime libraries)?

byte* __s_gen_native__stackPtr = stackalloc byte[global::Native.StackBufferSize];
__s_gen_native__marshaler = new global::Native(s, new Span<byte>(__s_gen_native__stackPtr, global::Native.StackBufferSize));

stephentoub · 2020-11-13T01:24:47Z

The pattern I've seen to fix this is to create an instance of the struct at declaration time with a 0-length stackalloc (application in our scenario shown below), but I'm not a big fan of this workaround

That's what the language folks recommend until a better solution is available.
CC: @jaredpar

jkoritzinsky · 2020-11-13T01:26:58Z

Raw pointer for the stackalloc and explicitly construct the Span over it (I think I've seen this in parts of the runtime libraries)?
byte* __s_gen_native__stackPtr = stackalloc byte[global::Native.StackBufferSize];
__s_gen_native__marshaler = new global::Native(s, new Span<byte>(__s_gen_native__stackPtr, global::Native.StackBufferSize));

That should work and doesn’t look that bad! I’ll try that.

…time issues.

…elab into non-blittable-struct-marshaler

Signed-off-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

DllImportGenerator/DllImportGenerator/Marshalling/CustomNativeTypeMarshaler.cs

elinor-fung · 2020-11-16T19:46:54Z

Could you also update the example generated code in the description to reflect the latest?

jkoritzinsky · 2020-11-16T20:06:42Z

Updated the generated code examples.

DllImportGenerator/DllImportGenerator.UnitTests/Compiles.cs

DllImportGenerator/designs/StructMarshalling.md

DllImportGenerator/DllImportGenerator.IntegrationTests/NonBlittableStructTests.cs

DllImportGenerator/DllImportGenerator/Marshalling/MarshallingGenerator.cs

DllImportGenerator/DllImportGenerator/Marshalling/CustomNativeTypeMarshaler.cs

DllImportGenerator/DllImportGenerator.UnitTests/CodeSnippets.cs

…ng and has a Value property being passed in such a way that pinning cannot be used but data needs to be marshalled to native (pass by ref).

…nd in this repo.

jkoritzinsky · 2020-11-18T23:00:47Z

Does anyone have any more comments/requested changes?

elinor-fung

Yay!

DllImportGenerator/DllImportGenerator.IntegrationTests/NonBlittableStructTests.cs

elinor-fung · 2020-11-19T01:42:24Z

DllImportGenerator/DllImportGenerator.UnitTests/ManualTypeMarshallingAnalyzerTests.cs

+}";
+
+            await VerifyCS.VerifyAnalyzerAsync(source,
+                VerifyCS.Diagnostic(NativeTypeMustBePointerSizedRule).WithSpan(22, 5, 22, 71).WithArguments("ref byte", "S"),


The analyzer testing APIs support marking up the source text with expected diagnostics. For the tests in roslyn-analyzers, the general guideline is to use the markup if possible.

If doing argument validation, you still need to create/pass in the expected diagnostics, but I do find it simpler to at least not have to deal with the span line/column numbers. GeneratedDllImportAnalyzerTests has some tests that use the markup just for the location and combine it with the argument validation.

Not advocating for switching them all in this change - just for future reference.

I'll do this in a follow up PR

DllImportGenerator/DllImportGenerator/Marshalling/CustomNativeTypeMarshaler.cs

AaronRobinsonMSFT · 2020-11-19T02:31:43Z

LGTM. I did a quick run through again. I don't see anything that is concerning.

Signed-off-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

…lab#302) Commit migrated from dotnet/runtimelab@fee212a

jkoritzinsky added 6 commits November 3, 2020 11:37

First pass adding custom type marshaller.

edcfded

Add support for a byref Value property and remove implementation rest…

40c8b87

…riction that the stack buffer passed in must be stack allocated. This enables us to conditionally stack alloc depending on used stack space in the future.

Add some negative tests for the custom native type marshalling.

fcdaa86

Don't use stackalloc constructor if refkind is 'ref'.

086ef1c

Add integration tests for non-blittable structs.

f66d1d8

Add more tests

481bca3

jkoritzinsky added the area-DllImportGenerator Source Generated stubs for P/Invokes in C# label Nov 4, 2020

jkoritzinsky requested review from AaronRobinsonMSFT and elinor-fung November 4, 2020 22:33

jkotas reviewed Nov 5, 2020

View reviewed changes

DllImportGenerator/DllImportGenerator.UnitTests/CodeSnippets.cs Show resolved Hide resolved

jkotas reviewed Nov 5, 2020

View reviewed changes

Merge branch 'feature/DllImportGenerator' of github.com:dotnet/runtim…

60362ac

…elab into non-blittable-struct-marshaler

AaronRobinsonMSFT mentioned this pull request Nov 9, 2020

Source generation of ILStub for DllImport dotnet/runtime#43060

Closed

50 tasks

elinor-fung reviewed Nov 10, 2020

View reviewed changes

DllImportGenerator/TestAssets/SharedTypes/SharedTypes.csproj Outdated Show resolved Hide resolved

DllImportGenerator/DllImportGenerator/Marshalling/MarshallingGenerator.cs Outdated Show resolved Hide resolved

DllImportGenerator/designs/StructMarshalling.md Outdated Show resolved Hide resolved

jkoritzinsky added 3 commits November 12, 2020 15:33

Allow a GetPinnableReference call on the native type instead of allow…

e26027d

…ing a byref return Value property.

Add missing cast.

7d729e1

Call GetPinnableReference.

e2e2f0e

jkoritzinsky added 5 commits November 13, 2020 15:35

Assign stackalloc to pointer before creating span to work around life…

b661b48

…time issues.

Merge branch 'feature/DllImportGenerator' of github.com:dotnet/runtim…

433275e

…elab into non-blittable-struct-marshaler

Add custom message for errors.

32c6336

Merge branch 'feature/DllImportGenerator' of github.com:dotnet/runtim…

7116872

…elab into non-blittable-struct-marshaler

Fix simple flags logic error.

f0b8241

Signed-off-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

AaronRobinsonMSFT reviewed Nov 16, 2020

View reviewed changes

DllImportGenerator/DllImportGenerator/Marshalling/CustomNativeTypeMarshaler.cs Outdated Show resolved Hide resolved

DllImportGenerator/DllImportGenerator/Marshalling/CustomNativeTypeMarshaler.cs Outdated Show resolved Hide resolved

elinor-fung reviewed Nov 17, 2020

View reviewed changes

DllImportGenerator/DllImportGenerator.UnitTests/CodeSnippets.cs Show resolved Hide resolved

jkoritzinsky added 7 commits November 16, 2020 17:46

Move tests to CompileFails.cs

4fae329

Add analyzer error for ref Value property.

b359225

Update comments.

563d39f

Add simple MarshalUsing test

dfd4e26

Add more tests. Fix a bug with using a marshaller that supports pinni…

8bc0d70

…ng and has a Value property being passed in such a way that pinning cannot be used but data needs to be marshalled to native (pass by ref).

Fix typo in DNNE type hint attribute.

af8b53f

Unify on boolean operators at the start of a line instead of at the e…

cba7503

…nd in this repo.

elinor-fung approved these changes Nov 19, 2020

View reviewed changes

Minor cleanup

5be8022

jkoritzinsky force-pushed the non-blittable-struct-marshaler branch from 1c2618f to 5be8022 Compare November 19, 2020 18:26

Rename tests.

28c1c58

Signed-off-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

jkoritzinsky merged commit fee212a into dotnet:feature/DllImportGenerator Nov 19, 2020

jkoritzinsky deleted the non-blittable-struct-marshaler branch November 19, 2020 18:50

jkoritzinsky added a commit to jkoritzinsky/runtime that referenced this pull request Sep 20, 2021

Implement the non-blittable type marshalling proposal (dotnet/runtime…

80349fb

…lab#302) Commit migrated from dotnet/runtimelab@fee212a

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Implement the non-blittable type marshalling proposal #302

Implement the non-blittable type marshalling proposal #302

jkoritzinsky commented Nov 4, 2020 •

edited

Loading

jkotas Nov 5, 2020

jkoritzinsky Nov 9, 2020

jkotas Nov 5, 2020

jkotas Nov 5, 2020

AaronRobinsonMSFT Nov 5, 2020

jkotas Nov 5, 2020

jkoritzinsky Nov 18, 2020

jkoritzinsky commented Nov 13, 2020

jkotas commented Nov 13, 2020

jkoritzinsky commented Nov 13, 2020

elinor-fung commented Nov 13, 2020

stephentoub commented Nov 13, 2020

jkoritzinsky commented Nov 13, 2020

elinor-fung commented Nov 16, 2020

jkoritzinsky commented Nov 16, 2020

jkoritzinsky commented Nov 18, 2020

elinor-fung left a comment

elinor-fung Nov 19, 2020

jkoritzinsky Nov 19, 2020

AaronRobinsonMSFT commented Nov 19, 2020


		public S ToManaged() => new S { b = Value != 0 };

		public int Value { get; set; }

Implement the non-blittable type marshalling proposal #302

Implement the non-blittable type marshalling proposal #302

Conversation

jkoritzinsky commented Nov 4, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jkoritzinsky commented Nov 13, 2020

jkotas commented Nov 13, 2020

jkoritzinsky commented Nov 13, 2020

elinor-fung commented Nov 13, 2020

stephentoub commented Nov 13, 2020

jkoritzinsky commented Nov 13, 2020

elinor-fung commented Nov 16, 2020

jkoritzinsky commented Nov 16, 2020

jkoritzinsky commented Nov 18, 2020

elinor-fung left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AaronRobinsonMSFT commented Nov 19, 2020

jkoritzinsky commented Nov 4, 2020 •

edited

Loading