Use (Un)ManagedValuesSource.Length as length condition in marshalling and unmarshalling loops (#118190)

Instead of assuming the Span returned from Get(Un)ManagedValuesSource is the same length as the length parameter, use the length of the span returned from the marshaller methods in the for loop condition. This allows the marshaller to recognize native values that have a different length than expected. In particular, if an array parameter is null, allow the ArrayMarshaller to return empty spans.

Also, updates the Array, Span, ReadOnlySpan, and PointerArray marshallers to check for null unmanaged values when creating unmanaged source/destination spans.

Co-authored-by: Aaron Robinson <[email protected]>

Author: jtschuster

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshalling/ArrayMarshaller.cs

@@ -58,7 +58,12 @@ public static ReadOnlySpan<T> GetManagedValuesSource(T[]? managed)
         /// <param name="numElements">The unmanaged element count.</param>
         /// <returns>The <see cref="Span{TUnmanagedElement}"/> of unmanaged elements.</returns>
         public static Span<TUnmanagedElement> GetUnmanagedValuesDestination(TUnmanagedElement* unmanaged, int numElements)
-            => new Span<TUnmanagedElement>(unmanaged, numElements);
+        {
+            if (unmanaged is null)
+                return [];
+
+            return new Span<TUnmanagedElement>(unmanaged, numElements);
+        }
 
         /// <summary>
         /// Allocates memory for the managed representation of the array.
@@ -89,7 +94,12 @@ public static Span<T> GetManagedValuesDestination(T[]? managed)
         /// <param name="numElements">The unmanaged element count.</param>
         /// <returns>The <see cref="ReadOnlySpan{TUnmanagedElement}"/> containing the unmanaged elements to marshal.</returns>
         public static ReadOnlySpan<TUnmanagedElement> GetUnmanagedValuesSource(TUnmanagedElement* unmanagedValue, int numElements)
-            => new ReadOnlySpan<TUnmanagedElement>(unmanagedValue, numElements);
+        {
+            if (unmanagedValue is null)
+                return [];
+
+            return new ReadOnlySpan<TUnmanagedElement>(unmanagedValue, numElements);
+        }
 
         /// <summary>
         /// Frees memory for the unmanaged array.

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshalling/PointerArrayMarshaller.cs

@@ -59,7 +59,12 @@ public static ReadOnlySpan<IntPtr> GetManagedValuesSource(T*[]? managed)
         /// <param name="numElements">The unmanaged element count.</param>
         /// <returns>The <see cref="Span{TUnmanagedElement}"/> of unmanaged elements.</returns>
         public static Span<TUnmanagedElement> GetUnmanagedValuesDestination(TUnmanagedElement* unmanaged, int numElements)
-            => new Span<TUnmanagedElement>(unmanaged, numElements);
+        {
+            if (unmanaged is null)
+                return [];
+
+            return new Span<TUnmanagedElement>(unmanaged, numElements);
+        }
 
         /// <summary>
         /// Allocates memory for the managed representation of the array.
@@ -90,7 +95,12 @@ public static Span<IntPtr> GetManagedValuesDestination(T*[]? managed)
         /// <param name="numElements">The unmanaged element count.</param>
         /// <returns>The <see cref="ReadOnlySpan{TUnmanagedElement}"/> containing the unmanaged elements to marshal.</returns>
         public static ReadOnlySpan<TUnmanagedElement> GetUnmanagedValuesSource(TUnmanagedElement* unmanagedValue, int numElements)
-            => new ReadOnlySpan<TUnmanagedElement>(unmanagedValue, numElements);
+        {
+            if (unmanagedValue is null)
+                return [];
+
+            return new ReadOnlySpan<TUnmanagedElement>(unmanagedValue, numElements);
+        }
 
         /// <summary>
         /// Frees memory for the unmanaged array.

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshalling/ReadOnlySpanMarshaller.cs

@@ -69,7 +69,12 @@ public static ReadOnlySpan<T> GetManagedValuesSource(ReadOnlySpan<T> managed)
             /// <param name="numElements">The number of elements that will be copied into the memory block.</param>
             /// <returns>A span over the unmanaged memory that can contain the specified number of elements.</returns>
             public static Span<TUnmanagedElement> GetUnmanagedValuesDestination(TUnmanagedElement* unmanaged, int numElements)
-                => new Span<TUnmanagedElement>(unmanaged, numElements);
+            {
+                if (unmanaged == null)
+                    return [];
+
+                return new Span<TUnmanagedElement>(unmanaged, numElements);
+            }
         }
 
         /// <summary>
@@ -201,6 +206,9 @@ public ReadOnlySpan<T> ToManaged()
             /// <returns>A span over unmanaged values of the array.</returns>
             public ReadOnlySpan<TUnmanagedElement> GetUnmanagedValuesSource(int numElements)
             {
+                if (_unmanagedArray is null)
+                    return [];
+
                 return new ReadOnlySpan<TUnmanagedElement>(_unmanagedArray, numElements);
             }
 

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshalling/SpanMarshaller.cs

@@ -63,7 +63,12 @@ public static ReadOnlySpan<T> GetManagedValuesSource(Span<T> managed)
         /// <param name="numElements">The number of elements that will be copied into the memory block.</param>
         /// <returns>A span over the unmanaged memory that can contain the specified number of elements.</returns>
         public static Span<TUnmanagedElement> GetUnmanagedValuesDestination(TUnmanagedElement* unmanaged, int numElements)
-            => new Span<TUnmanagedElement>(unmanaged, numElements);
+        {
+            if (unmanaged == null)
+                return [];
+
+            return new Span<TUnmanagedElement>(unmanaged, numElements);
+        }
 
         /// <summary>
         /// Allocates space to store the managed elements.
@@ -94,7 +99,12 @@ public static Span<T> GetManagedValuesDestination(Span<T> managed)
         /// <param name="numElements">The number of elements in the unmanaged collection.</param>
         /// <returns>A span over the native collection elements.</returns>
         public static ReadOnlySpan<TUnmanagedElement> GetUnmanagedValuesSource(TUnmanagedElement* unmanaged, int numElements)
-            => new ReadOnlySpan<TUnmanagedElement>(unmanaged, numElements);
+        {
+            if (unmanaged == null)
+                return [];
+
+            return new ReadOnlySpan<TUnmanagedElement>(unmanaged, numElements);
+        }
 
         /// <summary>
         /// Frees the allocated unmanaged memory.

src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ElementsMarshalling.cs

@@ -39,7 +39,6 @@ protected ElementsMarshalling(IElementsMarshallingCollectionSource collectionSou
         /// </code>
         /// </summary>
         public StatementSyntax GenerateClearUnmanagedDestination(StubIdentifierContext context)
-
         {
             // <GetUnmanagedValuesDestination>.Clear();
             return MethodInvocationStatement(
@@ -284,7 +283,7 @@ public override StatementSyntax GenerateMarshalStatement(StubIdentifierContext c
             statements.Add(GenerateContentsMarshallingStatement(
                     context,
                     MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
-                        IdentifierName(MarshallerHelpers.GetManagedSpanIdentifier(CollectionSource.TypeInfo, context)),
+                        IdentifierName(managedSpanIdentifier),
                         IdentifierName("Length")),
                     elementMarshaller,
                     StubIdentifierContext.Stage.Marshal));
@@ -295,7 +294,6 @@ public override StatementSyntax GenerateUnmarshalStatement(StubIdentifierContext
         {
             string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(CollectionSource.TypeInfo, context);
             string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(CollectionSource.TypeInfo, context);
-            string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(CollectionSource.TypeInfo, context);
 
             // ReadOnlySpan<TUnmanagedElement> <nativeSpan> = <GetUnmanagedValuesSource>
             // Span<T> <managedSpan> = <GetManagedValuesDestination>
@@ -311,7 +309,9 @@ public override StatementSyntax GenerateUnmarshalStatement(StubIdentifierContext
                     CollectionSource.GetManagedValuesDestination(context)),
                 GenerateContentsMarshallingStatement(
                     context,
-                    IdentifierName(numElementsIdentifier),
+                    MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
+                        IdentifierName(nativeSpanIdentifier),
+                        IdentifierName("Length")),
                     elementMarshaller,
                     StubIdentifierContext.Stage.UnmarshalCapture, StubIdentifierContext.Stage.Unmarshal));
         }
@@ -356,7 +356,9 @@ public override StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalSta
                 unmanagedValuesDeclaration,
                 GenerateContentsMarshallingStatement(
                     context,
-                    IdentifierName(numElementsIdentifier),
+                    MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
+                        IdentifierName(managedSpanIdentifier),
+                        IdentifierName("Length")),
                     elementMarshaller,
                     StubIdentifierContext.Stage.UnmarshalCapture, StubIdentifierContext.Stage.Unmarshal));
         }
@@ -460,7 +462,9 @@ public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalState
                 managedValuesDestination,
                 GenerateContentsMarshallingStatement(
                     context,
-                    IdentifierName(numElementsIdentifier),
+                    MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
+                        IdentifierName(nativeSpanIdentifier),
+                        IdentifierName("Length")),
                     new FreeAlwaysOwnedOriginalValueGenerator(elementMarshaller),
                     stagesToGenerate));
         }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/INullArrayTests.cs

@@ -0,0 +1,206 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+using SharedTypes.ComInterfaces;
+using SharedTypes;
+using Xunit;
+using System.Runtime.CompilerServices;
+
+namespace ComInterfaceGenerator.Tests
+{
+    /// <summary>
+    /// Tests for edge cases involving null arrays when their length parameters are non-zero.
+    /// This addresses https://github.com/dotnet/runtime/issues/118135
+    /// </summary>
+    public unsafe partial class INullArrayTests
+    {
+        private static INullArrayCases CreateTestInterface()
+        {
+            INullArrayCases originalObject = new INullArrayCasesImpl();
+            ComWrappers cw = new StrategyBasedComWrappers();
+            nint ptr = cw.GetOrCreateComInterfaceForObject(originalObject, CreateComInterfaceFlags.None);
+            object obj = cw.GetOrCreateObjectForComInstance(ptr, CreateObjectFlags.None);
+            return (INullArrayCases)obj;
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(10)]
+        [InlineData(int.MaxValue)]
+        public void SingleNullArray_DoesNotCrash(int length)
+        {
+            var testInterface = CreateTestInterface();
+
+            // Should not throw or crash
+            testInterface.SingleNullArrayWithLength(length, null);
+        }
+
+        [Fact]
+        public void SingleNullArray_WithValidArray_WorksNormally()
+        {
+            var testInterface = CreateTestInterface();
+            int[] array = new int[5];
+
+            testInterface.SingleNullArrayWithLength(5, array);
+
+            Assert.Equal(new int[] { 0, 2, 4, 6, 8 }, array);
+        }
+
+        [Fact]
+        public void MultipleArrays_SomeNull_DoesNotCrash()
+        {
+            var testInterface = CreateTestInterface();
+            int[] array1 = new int[3];
+            int[] array3 = new int[3];
+
+            testInterface.MultipleArraysSharedLength(3, array1, null, array3);
+
+            Assert.Equal(new int[] { 0, 1, 2 }, array1);
+            Assert.Equal(new int[] { 0, 100, 200 }, array3);
+        }
+
+        [Fact]
+        public void MultipleArrays_AllNull_DoesNotCrash()
+        {
+            var testInterface = CreateTestInterface();
+
+            testInterface.MultipleArraysSharedLength(5, null, null, null);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(10)]
+        [InlineData(int.MaxValue)]
+        public void NonBlittableArray_Null_DoesNotCrash(int length)
+        {
+            var testInterface = CreateTestInterface();
+
+            testInterface.NonBlittableNullArray(length, null);
+        }
+
+        [Fact]
+        public void NonBlittableArray_ValidArray_WorksNormally()
+        {
+            var testInterface = CreateTestInterface();
+            var array = new IntStructWrapper[3];
+
+            testInterface.NonBlittableNullArray(3, array);
+
+            Assert.Equal(0, array[0].Value);
+            Assert.Equal(3, array[1].Value);
+            Assert.Equal(6, array[2].Value);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(10)]
+        [InlineData(int.MaxValue)]
+        public void SpanNull_DoesNotCrash(int length)
+        {
+            var testInterface = CreateTestInterface();
+
+            Span<int> span = new Span<int>(null, 0);
+            testInterface.SpanNullCase(length, ref span);
+            Assert.True(default == span);
+        }
+
+        [Fact]
+        public void SpanValid_WorksNormally()
+        {
+            var testInterface = CreateTestInterface();
+
+            var span = new Span<int>(new int[5]);
+            testInterface.SpanNullCase(5, ref span);
+
+            Assert.Equal(0, span[0]);
+            Assert.Equal(5, span[1]);
+            Assert.Equal(10, span[2]);
+            Assert.Equal(15, span[3]);
+            Assert.Equal(20, span[4]);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(10)]
+        [InlineData(int.MaxValue)]
+        public void SpanNonBlittable_Null_DoesNotCrash(int length)
+        {
+            var testInterface = CreateTestInterface();
+            Span<IntStructWrapper> span = new Span<IntStructWrapper>(null, 0);
+            testInterface.SpanNonBlittableNullCase(length, ref span);
+            Assert.True(default == span);
+        }
+
+        [Fact]
+        public void SpanNonBlittable_Valid_WorksNormally()
+        {
+            var testInterface = CreateTestInterface();
+
+            var span = new Span<IntStructWrapper>(new IntStructWrapper[3]);
+            testInterface.SpanNonBlittableNullCase(3, ref span);
+
+            Assert.Equal(0, span[0].Value);
+            Assert.Equal(7, span[1].Value);
+            Assert.Equal(14, span[2].Value);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(10)]
+        [InlineData(int.MaxValue)]
+        public void InputOnlyArray_Null_DoesNotCrash(int length)
+        {
+            var testInterface = CreateTestInterface();
+
+            testInterface.InOnlyNullArray(length, null);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(10)]
+        [InlineData(int.MaxValue)]
+        public void OutputOnlyArray_Null_DoesNotCrash(int length)
+        {
+            var testInterface = CreateTestInterface();
+
+            testInterface.OutOnlyNullArray(length, null);
+        }
+
+        [Fact]
+        public void OutputOnlyArray_Valid_WorksNormally()
+        {
+            var testInterface = CreateTestInterface();
+            var array = new int[3];
+
+            testInterface.OutOnlyNullArray(3, array);
+
+            Assert.Equal(new int[] { 1000, 1001, 1002 }, array);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(10)]
+        [InlineData(int.MaxValue)]
+        public void ReferenceArray_Null_DoesNotCrash(int length)
+        {
+            var testInterface = CreateTestInterface();
+
+            testInterface.ReferenceArrayNullCase(length, null);
+        }
+
+        [Fact]
+        public void ReferenceArray_ValidArray_WorksNormally()
+        {
+            var testInterface = CreateTestInterface();
+            string[] array = new string[3];
+
+            testInterface.ReferenceArrayNullCase(3, array);
+
+            Assert.Equal(new string[] { "Item 0", "Item 1", "Item 2" }, array);
+        }
+    }
+}