Add opt-in support for GeneratedComInterface/ComImport RCW interop

src/libraries/System.Runtime.InteropServices/src/ILLink/ILLink.Substitutions.xml

@@ -0,0 +1,7 @@
+<linker>
+  <assembly fullname="System.Runtime.InteropServices">
+    <type fullname="System.Runtime.InteropServices.Marshalling.ComObject" feature="System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop" featurevalue="false">
+      <method signature="System.Boolean get_ComImportInteropEnabled()" body="stub" value="false" />
+    </type>
+  </assembly>
+</linker>

src/libraries/System.Runtime.InteropServices/src/System.Runtime.InteropServices.csproj

@@ -32,6 +32,7 @@
     <Compile Include="System\Runtime\InteropServices\ImportedFromTypeLibAttribute.cs" />
     <Compile Include="System\Runtime\InteropServices\ManagedToNativeComInteropStubAttribute.cs" />
     <Compile Include="System\Runtime\InteropServices\Marshalling\ComExposedClassAttribute.cs" />
+    <Compile Include="System\Runtime\InteropServices\Marshalling\ComImportInteropInterfaceDetailsStrategy.cs" />
     <Compile Include="System\Runtime\InteropServices\Marshalling\UniqueComInterfaceMarshaller.cs" />
     <Compile Include="System\Runtime\InteropServices\Marshalling\ComInterfaceMarshaller.cs" />
     <Compile Include="System\Runtime\InteropServices\Marshalling\ComObject.cs" />
@@ -71,6 +72,10 @@
     <Compile Include="$(CommonPath)System\Obsoletions.cs" Link="Common\System\Obsoletions.cs" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ILLinkSubstitutionsXmls Include="$(ILLinkDirectory)ILLink.Substitutions.xml" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="$(CoreLibProject)" />
     <ProjectReference Include="$(LibrariesProjectRoot)System.Collections.Concurrent\src\System.Collections.Concurrent.csproj" />

src/libraries/System.Runtime.InteropServices/src/System/Runtime/InteropServices/Marshalling/ComImportInteropInterfaceDetailsStrategy.cs

@@ -0,0 +1,149 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.Marshalling
+{
+    [RequiresDynamicCode("Enabling interop between source-generated and runtime-generated COM requires dynamic code generation.")]
+    internal sealed class ComImportInteropInterfaceDetailsStrategy : IIUnknownInterfaceDetailsStrategy
+    {
+        public static readonly IIUnknownInterfaceDetailsStrategy Instance = new ComImportInteropInterfaceDetailsStrategy();
+
+        private readonly ConditionalWeakTable<Type, Type> _forwarderInterfaceCache = new();
+
+        // TODO: Support exposing ComImport interfaces through StrategyBasedComWrappers?
+        public IComExposedDetails? GetComExposedTypeDetails(RuntimeTypeHandle type) => DefaultIUnknownInterfaceDetailsStrategy.Instance.GetComExposedTypeDetails(type);
+
+        [UnconditionalSuppressMessage("Trimming", "IL2065", Justification = "Runtime-based COM interop is not supported with trimming enabled.")]
+        [UnconditionalSuppressMessage("Trimming", "IL2067", Justification = "Runtime-based COM interop is not supported with trimming enabled.")]
+        [UnconditionalSuppressMessage("Trimming", "IL2070", Justification = "Runtime-based COM interop is not supported with trimming enabled.")]
+        [UnconditionalSuppressMessage("Trimming", "IL2075", Justification = "Runtime-based COM interop is not supported with trimming enabled.")]
+        public IIUnknownDerivedDetails? GetIUnknownDerivedDetails(RuntimeTypeHandle type)
+        {
+            Type runtimeType = Type.GetTypeFromHandle(type)!;
+            if (!runtimeType.IsImport)
+            {
+                return DefaultIUnknownInterfaceDetailsStrategy.Instance.GetIUnknownDerivedDetails(type);
+            }
+
+            Type implementationType = _forwarderInterfaceCache.GetValue(runtimeType, runtimeType =>
+            {
+                AssemblyBuilder assembly = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("ComImportForwarder"), AssemblyBuilderAccess.RunAndCollect);
+                ModuleBuilder module = assembly.DefineDynamicModule("ComImportForwarder");
+
+                ConstructorInfo ignoresAccessChecksToAttributeConstructor = GetIgnoresAccessChecksToAttributeConstructor(module);
+
+                assembly.SetCustomAttribute(new CustomAttributeBuilder(ignoresAccessChecksToAttributeConstructor, new object[] { typeof(IComImportAdapter).Assembly.GetName().Name! }));
+
+                TypeBuilder implementation = module.DefineType("InterfaceForwarder", TypeAttributes.Interface | TypeAttributes.Abstract, parent: null, interfaces: runtimeType.GetInterfaces());
+                implementation.AddInterfaceImplementation(runtimeType);
+                implementation.SetCustomAttribute(new CustomAttributeBuilder(typeof(DynamicInterfaceCastableImplementationAttribute).GetConstructor(Array.Empty<Type>())!, Array.Empty<object>()));
+
+                foreach (Type iface in implementation.GetInterfaces())
+                {
+                    assembly.SetCustomAttribute(new CustomAttributeBuilder(ignoresAccessChecksToAttributeConstructor, new object[] { iface.Assembly.GetName().Name! }));
+                    foreach (MethodInfo method in iface.GetMethods())
+                    {
+                        ParameterInfo[] parameters = method.GetParameters();
+                        var parameterTypes = new Type[parameters.Length];
+                        for (int i = 0; i < parameters.Length; i++)
+                        {
+                            parameterTypes[i] = parameters[i].ParameterType;
+                        }
+                        MethodBuilder builder = implementation.DefineMethod(method.Name, MethodAttributes.Private | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.Virtual, method.ReturnType, parameterTypes);
+                        ILGenerator il = builder.GetILGenerator();
+                        il.Emit(OpCodes.Ldarg_0);
+                        il.Emit(OpCodes.Castclass, typeof(IComImportAdapter));
+                        il.Emit(OpCodes.Callvirt, IComImportAdapter.GetRuntimeCallableWrapperMethod);
+                        il.Emit(OpCodes.Castclass, iface);
+                        for (int i = 0; i < parameters.Length; i++)
+                        {
+                            il.Emit(OpCodes.Ldarg, i + 1);
+                        }
+                        il.Emit(OpCodes.Callvirt, method);
+                        il.Emit(OpCodes.Ret);
+                        implementation.DefineMethodOverride(builder, method);
+                    }
+                }
+
+                return implementation.CreateType();
+            });
+
+            return new ComImportDetails(runtimeType.GUID, implementationType);
+        }
+
+        private static ConstructorInfo GetIgnoresAccessChecksToAttributeConstructor(ModuleBuilder moduleBuilder)
+        {
+            var magicAttribute = EmitIgnoresAccessChecksToAttribute(moduleBuilder);
+            return magicAttribute.GetConstructor(new Type[] { typeof(string) })!;
+        }
+
+        [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
+        private static Type EmitIgnoresAccessChecksToAttribute(ModuleBuilder moduleBuilder)
+        {
+            var tb = moduleBuilder.DefineType(
+                "System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute",
+                TypeAttributes.NotPublic,
+                typeof(Attribute));
+
+            var attributeUsage = new CustomAttributeBuilder(
+                s_attributeUsageCtor,
+                new object[] { AttributeTargets.Assembly },
+                new PropertyInfo[] { s_attributeUsageAllowMultipleProperty },
+                new object[] { false });
+            tb.SetCustomAttribute(attributeUsage);
+
+            var cb = tb.DefineConstructor(
+                MethodAttributes.Public |
+                MethodAttributes.HideBySig |
+                MethodAttributes.SpecialName |
+                MethodAttributes.RTSpecialName,
+                CallingConventions.Standard,
+                new Type[] { typeof(string) });
+            cb.DefineParameter(1, ParameterAttributes.None, "assemblyName");
+
+            var il = cb.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_0);
+            il.Emit(OpCodes.Call, s_attributeBaseClassCtor);
+            il.Emit(OpCodes.Ret);
+
+            return tb.CreateType()!;
+        }
+
+        /// <summary>
+        /// The <see cref="Attribute()"/> constructor.
+        /// </summary>
+        private static readonly ConstructorInfo s_attributeBaseClassCtor = typeof(Attribute).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0];
+
+        /// <summary>
+        /// The <see cref="AttributeUsageAttribute(AttributeTargets)"/> constructor.
+        /// </summary>
+        private static readonly ConstructorInfo s_attributeUsageCtor = typeof(AttributeUsageAttribute).GetConstructor(new Type[] { typeof(AttributeTargets) })!;
+
+        /// <summary>
+        /// The <see cref="AttributeUsageAttribute.AllowMultiple"/> property.
+        /// </summary>
+        private static readonly PropertyInfo s_attributeUsageAllowMultipleProperty = typeof(AttributeUsageAttribute).GetProperty(nameof(AttributeUsageAttribute.AllowMultiple))!;
+
+        private sealed class ComImportDetails(Guid iid, Type implementation) : IIUnknownDerivedDetails
+        {
+            public Guid Iid { get; } = iid;
+
+            public Type Implementation { get; } = implementation;
+
+            public unsafe void** ManagedVirtualMethodTable => null;
+        }
+
+        internal interface IComImportAdapter
+        {
+            internal static readonly MethodInfo GetRuntimeCallableWrapperMethod = typeof(IComImportAdapter).GetMethod(nameof(GetRuntimeCallableWrapper))!;
+
+            object GetRuntimeCallableWrapper();
+        }
+    }
+}

src/libraries/System.Runtime.InteropServices/src/System/Runtime/InteropServices/Marshalling/ComObject.cs

@@ -5,16 +5,22 @@
 // This API need to be exposed to implement the COM source generator in one form or another.
 
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.InteropServices.Marshalling
 {
     /// <summary>
     /// Base class for all COM source generated Runtime Callable Wrapper (RCWs).
     /// </summary>
-    public sealed unsafe class ComObject : IDynamicInterfaceCastable, IUnmanagedVirtualMethodTableProvider
+    public sealed unsafe class ComObject : IDynamicInterfaceCastable, IUnmanagedVirtualMethodTableProvider, ComImportInteropInterfaceDetailsStrategy.IComImportAdapter
     {
+        internal static bool ComImportInteropEnabled { get; } = AppContext.TryGetSwitch("System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop", out bool enabled) ? enabled : false;
+
         private readonly void* _instancePointer;
 
+        private readonly object? _runtimeCallableWrapper;
+
         /// <summary>
         /// Initialize ComObject instance.
         /// </summary>
@@ -28,6 +34,10 @@ internal ComObject(IIUnknownInterfaceDetailsStrategy interfaceDetailsStrategy, I
             IUnknownStrategy = iunknownStrategy;
             CacheStrategy = cacheStrategy;
             _instancePointer = IUnknownStrategy.CreateInstancePointer(thisPointer);
+            if (OperatingSystem.IsWindows() && ComImportInteropEnabled)
+            {
+                _runtimeCallableWrapper = Marshal.GetObjectForIUnknown((nint)thisPointer);
+            }
         }
 
         ~ComObject()
@@ -135,5 +145,10 @@ VirtualMethodTableInfo IUnmanagedVirtualMethodTableProvider.GetVirtualMethodTabl
 
             return new(result.ThisPtr, result.Table);
         }
+
+        object ComImportInteropInterfaceDetailsStrategy.IComImportAdapter.GetRuntimeCallableWrapper()
+        {
+            return _runtimeCallableWrapper!;
+        }
     }
 }

src/libraries/System.Runtime.InteropServices/src/System/Runtime/InteropServices/Marshalling/StrategyBasedComWrappers.cs

@@ -2,7 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.Versioning;
 
 namespace System.Runtime.InteropServices.Marshalling
 {
@@ -17,7 +20,15 @@ public class StrategyBasedComWrappers : ComWrappers
 
         protected static IIUnknownCacheStrategy CreateDefaultCacheStrategy() => new DefaultCaching();
 
-        protected virtual IIUnknownInterfaceDetailsStrategy GetOrCreateInterfaceDetailsStrategy() => DefaultIUnknownInterfaceDetailsStrategy;
+        [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "The member with the attribute is in a IsDynamicCodeSupported block.")]
+        protected virtual IIUnknownInterfaceDetailsStrategy GetOrCreateInterfaceDetailsStrategy()
+        {
+            if (RuntimeFeature.IsDynamicCodeSupported && OperatingSystem.IsWindows() && ComObject.ComImportInteropEnabled)
+            {
+                return ComImportInteropInterfaceDetailsStrategy.Instance;
+            }
+            return DefaultIUnknownInterfaceDetailsStrategy;
+        }
 
         protected virtual IIUnknownStrategy GetOrCreateIUnknownStrategy() => DefaultIUnknownStrategy;
 

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/ComInterfaceGenerator.Tests.csproj

@@ -8,6 +8,7 @@
     <!-- These tests pull the attributes from Ancillary.Interop, so we don't need to include the attribute sources in this assembly. -->
     <IncludeLibraryImportGeneratorSources>false</IncludeLibraryImportGeneratorSources>
     <ReferencesNativeExports>true</ReferencesNativeExports>
+    <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
   </PropertyGroup>
 
   <ItemGroup>

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

@@ -0,0 +1,79 @@
+// 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.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using Microsoft.DotNet.RemoteExecutor;
+using SharedTypes.ComInterfaces;
+using Xunit;
+
+namespace ComInterfaceGenerator.Tests
+{
+    [ConditionalClass(typeof(GeneratedComInterfaceComImportInteropTests), nameof(IsSupported))]
+    public unsafe partial class GeneratedComInterfaceComImportInteropTests
+    {
+        public static bool IsSupported =>
+            RemoteExecutor.IsSupported
+            && PlatformDetection.IsWindows
+            && PlatformDetection.IsNotMonoRuntime
+            && PlatformDetection.IsNotNativeAot;
+
+        [LibraryImport(NativeExportsNE.NativeExportsNE_Binary, EntryPoint = "new_get_and_set_int")]
+        private static partial IGetAndSetInt NewNativeObject();
+
+        [ComImport]
+        [Guid(_guid)]
+        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        [SuppressMessage("Interoperability", "SYSLIB1096:Convert to 'GeneratedComInterface'", Justification = "This interface is for us to test interop between GeneratedComInterface and ComImport.")]
+        internal interface IGetAndSetIntComImport
+        {
+            int GetInt();
+
+            public void SetInt(int x);
+
+            public const string _guid = "2c3f9903-b586-46b1-881b-adfce9af47b1";
+        }
+
+        [Fact]
+        public void CallComImportInterfaceMethodsOnGeneratedComObject()
+        {
+            using var _ = RemoteExecutor.Invoke(() =>
+            {
+                IGetAndSetInt obj = NewNativeObject();
+#pragma warning disable SYSLIB1099 // Casting between a 'ComImport' type and a source-generated COM type is not supported
+                IGetAndSetIntComImport runtimeObj = (IGetAndSetIntComImport)obj;
+#pragma warning restore SYSLIB1099 // Casting between a 'ComImport' type and a source-generated COM type is not supported
+                obj.SetInt(1234);
+                Assert.Equal(1234, runtimeObj.GetInt());
+                runtimeObj.SetInt(4321);
+                Assert.Equal(4321, obj.GetInt());
+
+            }, new RemoteInvokeOptions
+            {
+                RuntimeConfigurationOptions =
+                {
+                    { "System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop", true }
+                }
+            });
+        }
+
+        [Fact]
+        public void CallComImportInterfaceMethodsOnGeneratedComObject_FeatureFalse_Fails()
+        {
+            using var _ = RemoteExecutor.Invoke(() =>
+            {
+                IGetAndSetInt obj = NewNativeObject();
+#pragma warning disable SYSLIB1099 // Casting between a 'ComImport' type and a source-generated COM type is not supported
+                Assert.Throws<InvalidCastException>(() => (IGetAndSetIntComImport)obj);
+#pragma warning restore SYSLIB1099 // Casting between a 'ComImport' type and a source-generated COM type is not supported
+            }, new RemoteInvokeOptions
+            {
+                RuntimeConfigurationOptions =
+                {
+                    { "System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop", false }
+                }
+            });
+        }
+    }
+}

src/libraries/System.Runtime.InteropServices/tests/TrimmingTests/GeneratedComInterfaceComImportInteropTrimmed.cs

@@ -0,0 +1,56 @@
+// 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.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+Type comObject = RemoveTypeTrimAnalysis(typeof(ComObject));
+
+// Ensure that the interop details strategy and all of its nested types are fully trimmed away.
+if (GetTypeWithoutTrimAnalysis("System.Runtime.InteropServices.Marshalling.ComImportInteropInterfaceDetailsStrategy", comObject.Assembly) != null)
+{
+    return -1;
+}
+
+// Ensure that the ComInterop object field is trimmed away as well.
+if (comObject.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Any(f => f.Name == "_runtimeCallableWrapper"))
+{
+    return -2;
+}
+
+var comWrappers = new StrategyBasedComWrappers();
+
+var managedObject = new ComClass();
+var nativeObject = comWrappers.GetOrCreateComInterfaceForObject(managedObject, CreateComInterfaceFlags.None);
+var wrapper = comWrappers.GetOrCreateObjectForComInstance(nativeObject, CreateObjectFlags.None);
+Marshal.Release(nativeObject);
+
+// We can't use the wrapper as trimming tests don't reference the source generators from the live ref pack
+// due to how we construct it. Tracking this issue as https://github.com/dotnet/runtime/issues/87582.
+return 100;
+
+[MethodImpl(MethodImplOptions.NoInlining)]
+static Type RemoveTypeTrimAnalysis(Type type) => type;
+
+[MethodImpl(MethodImplOptions.NoInlining)]
+static Type GetTypeWithoutTrimAnalysis(string typeName, Assembly assembly)
+{
+    return assembly.GetType(typeName, throwOnError: false);
+}
+
+[GeneratedComInterface]
+[Guid("ad358058-2b72-4801-8d98-043d44dc42c4")]
+partial interface IComInterface
+{
+    int Method();
+}
+
+[GeneratedComClass]
+partial class ComClass : IComInterface
+{
+    public int Method() => 100;
+}