Fix constructor marshalling for non-blittable array element types (#2474)

manodasanW · Copilot · Sergio0694 · web-flow · commit 3686fea9f4b3 · 2026-06-24T19:55:47.000Z
* Fix constructor marshalling for non-blittable array element types

Activation-factory constructors taking arrays of non-blittable structs,
mapped value types (DateTime/TimeSpan), or HResult/Exception elements
hardcoded nint InlineArray storage and void** CopyToUnmanaged/Dispose
data pointers, so the array marshaller's UnsafeAccessor failed to bind at
runtime (Method not found: ...ArrayMarshaller.Dispose).

Route the constructor's PassArray storage, CopyToUnmanaged, and finally
cleanup through the element-kind-aware helpers (GetArrayElementStorageType
and typed data-pointer/cast selection), mirroring the RCW caller. Add a
TestComponentCSharp constructor and TestNonBlittableArrayConstructor test
covering all three element kinds.

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;

* Address PR feedback: simplify constructor array CopyToUnmanaged cast

Drop the separate dataCastType and derive the cast inline from
dataParamType. Keep the if/else style (matching the RCW caller's
equivalent logic) with the same IDE0045 suppression.

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;

* Refactor ConstructorFactory comments and suppress IDE0045

Replace SuppressMessage attribute with a file-level pragma to disable IDE0045 and adjust comment wording/formatting across ConstructorFactory.FactoryCallbacks.cs. Changes are purely cosmetic (comments, quoting, punctuation) and do not modify runtime behavior or logic.

---------

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
Co-authored-by: Sergio Pedri &lt;sergio0694@live.com&gt;
diff --git a/src/Tests/TestComponentCSharp/Class.cpp b/src/Tests/TestComponentCSharp/Class.cpp
@@ -230,6 +230,23 @@ namespace winrt::TestComponentCSharp::implementation
         _nonBlittableStruct = nonBlittableStruct;
     }
 
+    Class::Class(int32_t intProperty, array_view<TestComponentCSharp::ComposedNonBlittableStruct const> nonBlittableStructs, array_view<winrt::Windows::Foundation::DateTime const> dateTimes, array_view<winrt::hresult const> hresults) :
+        Class(intProperty, L"")
+    {
+        if (nonBlittableStructs.size() > 0)
+        {
+            _nonBlittableStruct = nonBlittableStructs[0];
+        }
+        if (dateTimes.size() > 0)
+        {
+            _dateTime = dateTimes[0];
+        }
+        if (hresults.size() > 0)
+        {
+            _hr = hresults[0];
+        }
+    }
+
     void Class::TypeProperty(Windows::UI::Xaml::Interop::TypeName val)
     {
         _typeProperty = val;
diff --git a/src/Tests/TestComponentCSharp/Class.h b/src/Tests/TestComponentCSharp/Class.h
@@ -100,6 +100,7 @@ namespace winrt::TestComponentCSharp::implementation
         Class(int32_t intProperty);
         Class(int32_t intProperty, hstring const& stringProperty);
         Class(int32_t intProperty, hstring const& stringProperty, ComposedNonBlittableStruct const& nonBlittableStruct);
+        Class(int32_t intProperty, array_view<TestComponentCSharp::ComposedNonBlittableStruct const> nonBlittableStructs, array_view<winrt::Windows::Foundation::DateTime const> dateTimes, array_view<winrt::hresult const> hresults);
         static int32_t StaticIntProperty();
         static void StaticIntProperty(int32_t value);
         static winrt::event_token StaticIntPropertyChanged(Windows::Foundation::EventHandler<int32_t> const& handler);
diff --git a/src/Tests/TestComponentCSharp/TestComponentCSharp.idl b/src/Tests/TestComponentCSharp/TestComponentCSharp.idl
@@ -213,6 +213,8 @@ namespace TestComponentCSharp
         Class(Int32 intProperty, String stringProperty);
         // Activation factory taking a non-blittable struct by value.
         Class(Int32 intProperty, String stringProperty, ComposedNonBlittableStruct nonBlittableStruct);
+        // Activation factory taking arrays of non-blittable struct, mapped value-type, and HResult elements.
+        Class(Int32 intProperty, ComposedNonBlittableStruct[] nonBlittableStructs, Windows.Foundation.DateTime[] dateTimes, Windows.Foundation.HResult[] hresults);
 
         Windows.UI.Xaml.Interop.TypeName TypeProperty{ get; set; };
         String GetTypePropertyAbiName();
diff --git a/src/Tests/UnitTest/TestComponentCSharp_Tests.cs b/src/Tests/UnitTest/TestComponentCSharp_Tests.cs
@@ -2306,6 +2306,33 @@ public void TestNonBlittableStructConstructor()
             Assert.AreEqual(5, instance.IntProperty);
         }
 
+        [TestMethod]
+        public void TestNonBlittableArrayConstructor()
+        {
+            // Activation factory taking arrays of non-blittable struct, mapped value-type, and
+            // HResult/Exception elements by value (constructor PassArray marshalling).
+            var structVal = new ComposedNonBlittableStruct()
+            {
+                blittable = new BlittableStruct() { i32 = 42 },
+                strings = new NonBlittableStringStruct() { str = "I like tacos" },
+                bools = new NonBlittableBoolStruct() { w = true, x = false, y = true, z = false },
+                refs = TestObject.NonBlittableRefStructProperty
+            };
+            var dateTime = new DateTimeOffset(2021, 1, 1, 0, 0, 0, TimeSpan.Zero);
+            var exception = new ArgumentException();
+
+            var instance = new Class(
+                9,
+                new[] { structVal },
+                new[] { dateTime },
+                new Exception[] { exception });
+
+            Assert.AreEqual(9, instance.IntProperty);
+            Assert.AreEqual("I like tacos", instance.ComposedNonBlittableStructProperty.strings.str);
+            Assert.AreEqual(dateTime, instance.DateTimeProperty);
+            Assert.IsNotNull(instance.HResultProperty);
+        }
+
         [TestMethod]
         public void TestBlittableArrays()
         {
diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs
@@ -12,6 +12,8 @@
 using WindowsRuntime.ProjectionWriter.Resolvers;
 using WindowsRuntime.ProjectionWriter.Writers;
 
+#pragma warning disable IDE0045
+
 namespace WindowsRuntime.ProjectionWriter.Factories;
 
 internal static partial class ConstructorFactory
@@ -296,13 +298,14 @@ private sealed class {{callbackName}} : {{baseClass}}
             string raw = p.GetRawName();
             string callName = IdentifierEscaping.EscapeIdentifier(raw);
             ArrayTempNames names = new(raw);
+            string storageT = AbiTypeHelpers.GetArrayElementStorageType(context, szArr.BaseType);
             writer.WriteLine();
             writer.WriteLine(isMultiline: true, $$"""
-                Unsafe.SkipInit(out InlineArray16<nint> {{names.InlineArray}});
-                nint[] {{names.ArrayFromPool}} = null;
-                Span<nint> {{names.Span}} = {{callName}}.Length <= 16
+                Unsafe.SkipInit(out InlineArray16<{{storageT}}> {{names.InlineArray}});
+                {{storageT}}[] {{names.ArrayFromPool}} = null;
+                Span<{{storageT}}> {{names.Span}} = {{callName}}.Length <= 16
                     ? {{names.InlineArray}}[..{{callName}}.Length]
-                    : ({{names.ArrayFromPool}} = global::System.Buffers.ArrayPool<nint>.Shared.Rent({{callName}}.Length));
+                    : ({{names.ArrayFromPool}} = global::System.Buffers.ArrayPool<{{storageT}}>.Shared.Rent({{callName}}.Length));
                 """);
 
             if (szArr.BaseType.IsString())
@@ -467,7 +470,7 @@ private sealed class {{callbackName}} : {{baseClass}}
             }
         }
 
-        // Emit CopyToUnmanaged for non-blittable PassArray params.
+        // Emit 'CopyToUnmanaged' for non-blittable PassArray params
         for (int i = 0; i < paramCount; i++)
         {
             ParameterInfo p = sig.Parameters[i];
@@ -505,14 +508,35 @@ private sealed class {{callbackName}} : {{baseClass}}
             else
             {
                 IndentedTextWriterCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType));
+
+                // Data pointer type must match the array marshaller's 'CopyToUnmanaged' signature
+                string dataParamType;
+
+                if (context.AbiTypeKindResolver.IsMappedAbiValueType(szArr.BaseType))
+                {
+                    dataParamType = AbiTypeHelpers.GetMappedAbiTypeName(szArr.BaseType) + "*";
+                }
+                else if (szArr.BaseType.IsHResultException())
+                {
+                    dataParamType = "global::ABI.System.Exception*";
+                }
+                else if (context.AbiTypeKindResolver.IsNonBlittableStruct(szArr.BaseType))
+                {
+                    dataParamType = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType) + "*";
+                }
+                else
+                {
+                    dataParamType = "void**";
+                }
+
                 UnsafeAccessorFactory.EmitStaticMethod(
                     writer,
                     accessName: "CopyToUnmanaged",
                     returnType: "void",
                     functionName: $"CopyToUnmanaged_{raw}",
                     interopType: ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType),
-                    parameterList: $"ReadOnlySpan<{elementProjected.Format()}> span, uint length, void** data");
-                writer.WriteLine($"CopyToUnmanaged_{raw}(null, {pname}, (uint){pname}.Length, (void**)_{raw});");
+                    parameterList: $"ReadOnlySpan<{elementProjected.Format()}> span, uint length, {dataParamType} data");
+                writer.WriteLine($"CopyToUnmanaged_{raw}(null, {pname}, (uint){pname}.Length, ({dataParamType})_{raw});");
             }
         }
 
@@ -534,7 +558,7 @@ private sealed class {{callbackName}} : {{baseClass}}
 
         if (isComposable)
         {
-            // Composable extras: baseInterface (void*), out innerInterface (void**)
+            // Composable extras: 'baseInterface (void*), out innerInterface (void**)'
             writer.Write("void*, void**, ");
         }
 
@@ -555,12 +579,12 @@ private sealed class {{callbackName}} : {{baseClass}}
                 continue;
             }
 
-            // For enums, cast to underlying type. For bool, cast to byte. For char, cast to ushort.
-            // For string params, use the marshalled HString from the fixed block.
-            // For runtime class / object / generic instance params, use __<name>.GetThisPtrUnsafe().
+            // For enums, cast to underlying type. For 'bool', cast to 'byte'. For 'char', cast to 'ushort'.
+            // For 'string' params, use the marshalled 'HSTRING' from the fixed block.
+            // For runtime class / 'object' / generic instance params, use '__<name>.GetThisPtrUnsafe()'.
             if (context.AbiTypeKindResolver.IsEnumType(p.Type))
             {
-                // No cast needed: function pointer signature uses the projected enum type.
+                // No cast needed: function pointer signature uses the projected enum type
                 writer.Write(pname);
             }
             else if (p.Type is CorLibTypeSignature corlibBool &&
@@ -605,7 +629,7 @@ private sealed class {{callbackName}} : {{baseClass}}
 
         if (isComposable)
         {
-            // Pass __baseInterface.GetThisPtrUnsafe() and &__innerInterface.
+            // Pass '__baseInterface.GetThisPtrUnsafe()' and '&__innerInterface'
             writer.Write(isMultiline: true, """
                 ,
                   __baseInterface.GetThisPtrUnsafe(),
@@ -623,7 +647,7 @@ private sealed class {{callbackName}} : {{baseClass}}
 
         writer.WriteLine("retval = __retval;");
 
-        // Close fixed blocks (innermost first).
+        // Close fixed blocks (innermost first)
         for (int i = 0; i < fixedNesting; i++)
         {
             writer.DecreaseIndent();
@@ -642,8 +666,8 @@ private sealed class {{callbackName}} : {{baseClass}}
                 """);
             writer.IncreaseIndent();
 
-            // Dispose pre-marshalled ABI struct input locals (frees any HSTRING / boxed
-            // reference fields the per-field ConvertToUnmanaged may have allocated).
+            // Dispose pre-marshalled ABI struct input locals (frees any 'HSTRING' / boxed
+            // reference fields the per-field 'ConvertToUnmanaged' may have allocated).
             for (int i = 0; i < paramCount; i++)
             {
                 ParameterInfo p = sig.Parameters[i];
@@ -677,9 +701,28 @@ private sealed class {{callbackName}} : {{baseClass}}
                     continue;
                 }
 
+                // Mapped value types ('DateTime'/'TimeSpan') need no disposal or pool return
+                if (context.AbiTypeKindResolver.IsMappedAbiValueType(szArr.BaseType))
+                {
+                    continue;
+                }
+
                 string raw = p.GetRawName();
                 ArrayTempNames names = new(raw);
 
+                if (szArr.BaseType.IsHResultException())
+                {
+                    // 'HResult' ABI is just an 'int': no per-element 'Dispose', only the pool return
+                    writer.WriteLine();
+                    writer.WriteLine(isMultiline: true, $$"""
+                        if ({{names.ArrayFromPool}} is not null)
+                        {
+                            global::System.Buffers.ArrayPool<global::ABI.System.Exception>.Shared.Return({{names.ArrayFromPool}});
+                        }
+                        """);
+                    continue;
+                }
+
                 if (szArr.BaseType.IsString())
                 {
                     writer.WriteLine();
@@ -699,27 +742,49 @@ private sealed class {{callbackName}} : {{baseClass}}
                 }
                 else
                 {
+                    // Complex structs use a typed <ABI struct>* (no cast), ref types use 'void**'
+                    string disposeDataParamType;
+                    string fixedPtrType;
+                    string disposeCastType;
+
+                    if (context.AbiTypeKindResolver.IsNonBlittableStruct(szArr.BaseType))
+                    {
+                        string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType);
+                        disposeDataParamType = abiStructName + "* data";
+                        fixedPtrType = abiStructName + "*";
+                        disposeCastType = string.Empty;
+                    }
+                    else
+                    {
+                        disposeDataParamType = "void** data";
+                        fixedPtrType = "void*";
+                        disposeCastType = "(void**)";
+                    }
+
                     writer.WriteLine();
                     UnsafeAccessorFactory.EmitStaticMethod(
                         writer,
                         accessName: "Dispose",
                         returnType: "void",
                         functionName: $"Dispose_{raw}",
                         interopType: ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType),
-                        parameterList: "uint length, void** data");
+                        parameterList: $"uint length, {disposeDataParamType}");
                     writer.WriteLine();
                     writer.WriteLine(isMultiline: true, $$"""
-                        fixed(void* _{{raw}} = {{names.Span}})
+                        fixed({{fixedPtrType}} _{{raw}} = {{names.Span}})
                         {
-                            Dispose_{{raw}}(null, (uint) {{names.Span}}.Length, (void**)_{{raw}});
+                            Dispose_{{raw}}(null, (uint) {{names.Span}}.Length, {{disposeCastType}}_{{raw}});
                         }
                         """);
                 }
+
+                // Pool storage type matches the 'InlineArray16<storageT>' setup
+                string poolStorageT = AbiTypeHelpers.GetArrayElementStorageType(context, szArr.BaseType);
                 writer.WriteLine();
                 writer.WriteLine(isMultiline: true, $$"""
                     if ({{names.ArrayFromPool}} is not null)
                     {
-                        global::System.Buffers.ArrayPool<nint>.Shared.Return({{names.ArrayFromPool}});
+                        global::System.Buffers.ArrayPool<{{poolStorageT}}>.Shared.Return({{names.ArrayFromPool}});
                     }
                     """);
             }
