Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add opt-in support for GeneratedComInterface/ComImport RCW interop #87583

Merged
merged 21 commits into from
Jul 18, 2023
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
21 commits
Select commit Hold shift + click to select a range
4c34ffb
Add initial implementation of GeneratedComInterface/ComImport RCW int…
jkoritzinsky Jun 13, 2023
34f4120
Actually define the .override entry for the dynamically emitted imple…
jkoritzinsky Jun 14, 2023
5500bde
Interfaces don't have parents.
jkoritzinsky Jun 14, 2023
bb808ac
Add basic test for the RCW interop scenario and fix various IL emit i…
jkoritzinsky Jun 14, 2023
9d09747
Suppress a diagnostic that fixing would make the test useless.
jkoritzinsky Jun 14, 2023
971a2a5
Add a linker test and a feature flag to ensure that the ComImport int…
jkoritzinsky Jun 14, 2023
dcd4402
Add negative test
jkoritzinsky Jun 14, 2023
5406981
PR feedback and fix build.
jkoritzinsky Jun 16, 2023
b058b40
Merge branch 'main' into com-adoption-configuration-rcw
jkoritzinsky Jun 19, 2023
d0c0b3e
Update the trimming test project template to allow unsafe blocks and …
jkoritzinsky Jun 20, 2023
9e915fc
Merge branch 'main' into com-adoption-configuration-rcw
jkoritzinsky Jun 21, 2023
670799a
Update src/libraries/System.Runtime.InteropServices/src/System/Runtim…
jkoritzinsky Jun 23, 2023
af91b01
PR feedback.
jkoritzinsky Jun 28, 2023
3124755
Remove suppression and fix fallback for COM interop flag.
jkoritzinsky Jun 28, 2023
cc068b3
Disable the warning with a pragma again for Vitek.
jkoritzinsky Jun 29, 2023
e680980
Merge branch 'main' into com-adoption-configuration-rcw
jkoritzinsky Jun 29, 2023
7f36032
Change back to an unconditional suppress to get the PR green again.
jkoritzinsky Jul 12, 2023
c42589d
Implement feedback on form factor attributes.
jkoritzinsky Jul 13, 2023
682ba71
Refactor strategy selection to avoid non-windows failures.
jkoritzinsky Jul 13, 2023
35f25a8
Redo how we set suppressions to make sure they always are "needed".
jkoritzinsky Jul 14, 2023
3b5ae8b
PR feedback and handle custom modifiers.
jkoritzinsky Jul 17, 2023
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
27 changes: 27 additions & 0 deletions docs/design/libraries/ComInterfaceGenerator/Compatibility.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,27 @@
# Semantic Compatibility

Documentation on compatibility guidance and the current state. The version headings act as a rolling delta between the previous version.

## .NET 8

### Interface base types

IUnknown-derived interfaces are supported. IDispatch-based interfaces are disallowed. The default is IUnknown-derived (in comparison to the built-in support's default of IDispatch-derived).

### Marshalling rules

The marshalling rules are identical to LibraryImportGenerator's support.

### Interface inheritance

Interface inheritance is supported for up to one COM-based interface type. Unlike the built-in COM interop system, base interface methods do **NOT** need to be redefined. The source generator discovers the members from the base interface and generates the derived interface members at appropriate offsets.

The generator also generates shadow members in the derived interface for each base interface member. The shadow members have default implementations that call the base interface member, but the emitted code for the "COM Object Wrapper" implementation will override the shadow members with a call to the underlying COM interface member on the current interface. This shadow member support helps reduce `QueryInterface` overhead in interface inheritance scenarios.

### Interop with `ComImport`

Source-generated COM will provide limited opt-in interop with `ComImport`-based COM interop. In particular, the following scenarios are supported:

- Casting a "Com Object Wrapper" created using `StrategyBasedComWrappers` to a `ComImport`-based interface type.

This support is achieved through some internal interfaces and reflection-emit to shim a `DynamicInterfaceCastableImplementation` of a `ComImport` interface to use the built-in runtime interop marshalling support. The core of this experience is implemented by the `System.Runtime.InteropServices.Marshalling.ComImportInteropInterfaceDetailsStrategy` class.
1 change: 1 addition & 0 deletions eng/testing/linker/project.csproj.template
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@
<PublishAot>{PublishAot}</PublishAot>
<AppHostSourcePath>{AppHostSourcePath}</AppHostSourcePath>
<SingleFileHostSourcePath>{SingleFileHostSourcePath}</SingleFileHostSourcePath>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>

<!-- wasm specific -->
<MonoAOTCompilerDir>{MonoAOTCompilerDir}</MonoAOTCompilerDir>
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,10 @@
<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>
<type fullname="System.Runtime.InteropServices.Marshalling.ComObject" feature="System.Runtime.InteropServices.BuiltInComInterop.IsSupported" featurevalue="false">
<method signature="System.Boolean get_BuiltInComSupported()" body="stub" value="false" />
</type>
</assembly>
</linker>
Original file line number Diff line number Diff line change
Expand Up @@ -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\ComInterfaceOptions.cs" />
<Compile Include="System\Runtime\InteropServices\Marshalling\UniqueComInterfaceMarshaller.cs" />
<Compile Include="System\Runtime\InteropServices\Marshalling\ComInterfaceMarshaller.cs" />
Expand Down Expand Up @@ -72,6 +73,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" />
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,198 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;

namespace System.Runtime.InteropServices.Marshalling
{
/// <summary>
jkoritzinsky marked this conversation as resolved.
Show resolved Hide resolved
/// An interface details strategy that enables discovering both interfaces defined with source-generated COM (i.e. <see cref="GeneratedComInterfaceAttribute"/> and <see cref="IUnknownDerivedAttribute{T, TImpl}"/>) and built-in COM (i.e. <see cref="ComImportAttribute"/>).
/// </summary>
/// <remarks>
/// This strategy is meant for intermediary adoption scenarios and is not compatible with trimming or NativeAOT by design. Since built-in COM is not trim friendly or AOT-compatible, these restrictions are okay.
/// This strategy only supports "COM Object Wrapper" scenarios, so casting a COM object wrapper to a <see cref="ComImportAttribute"/>-attributed type. It does not support exposing a <see cref="ComImportAttribute"/>-attributed type as an additional interface on a managed object wrapper.
/// The strategy provides <see cref="DynamicInterfaceCastableImplementationAttribute"/>-based implementations of <see cref="ComImportAttribute"/>-attributed interfaces by dynamically generating an interface using <see cref="System.Reflection.Emit"/> that has the following shape:
/// <code>
/// [assembly:IgnoresAccessChecksTo("AssemblyContainingIComInterface")]
/// [assembly:IgnoresAccessChecksTo("AssemblyContainingRetType")]
/// [assembly:IgnoresAccessChecksTo("AssemblyContainingArgType1")]
/// [assembly:IgnoresAccessChecksTo("AssemblyContainingArgType2")]
/// // One attribute per containing assembly of each type used in each method signature of the interface.
///
/// namespace System.Runtime.CompilerServices
/// {
/// [AssemblyUsage(AttributeTargets.Assembly, AllowMultiple = true)]
/// internal class IgnoresAccessChecksToAttribute : Attribute
/// {
/// public IgnoresAccessChecksToAttribute(string assemblyName) { }
/// }
/// }
///
/// [DynamicInterfaceCastableImplementation]
/// interface InterfaceForwarder : IComInterface
/// {
/// RetType IComInterface.Method1(ArgType1 arg1, ArgType2 arg2, ...)
/// {
/// return ((IComInterface)((IComImportAdapter)this).GetRuntimeCallableWrapper())(arg1, arg2, ...);
/// }
/// }
/// </code>
///
/// This mechanism allows source-generated COM interop to allow using built-in COM interfaces with runtime-defined marshalling behavior with minimal work on the source-generated COM interop side.
/// Additionally, by scoping the majority of the logic to this class, we make this logic more easily trimmable.
///
/// We emit the <c>IgnoresAccessChecksToAttribute</c> to enable casting to internal <see cref="ComImportAttribute"/> types, which is a very common scenario (most <see cref="ComImportAttribute"/> types are internal).
/// </remarks>
[RequiresDynamicCode("Enabling interop between source-generated and built-in COM is not supported when trimming is enabled.")]
[RequiresUnreferencedCode("Enabling interop between source-generated and built-in 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);

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"), runtimeType.IsCollectible ? AssemblyBuilderAccess.RunAndCollect : AssemblyBuilderAccess.Run);
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())
{
Type[] returnTypeOptionalModifiers = method.ReturnParameter.GetOptionalCustomModifiers();
Type[] returnTypeRequiredModifiers = method.ReturnParameter.GetRequiredCustomModifiers();
ParameterInfo[] parameters = method.GetParameters();
var parameterTypes = new Type[parameters.Length];
var parameterOptionalModifiers = new Type[parameters.Length][];
var parameterRequiredModifiers = new Type[parameters.Length][];
for (int i = 0; i < parameters.Length; i++)
{
parameterTypes[i] = parameters[i].ParameterType;
parameterOptionalModifiers[i] = parameters[i].GetOptionalCustomModifiers();
parameterRequiredModifiers[i] = parameters[i].GetRequiredCustomModifiers();
}
MethodBuilder builder = implementation.DefineMethod(method.Name, MethodAttributes.Private | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.Virtual, CallingConventions.HasThis, method.ReturnType, returnTypeRequiredModifiers, returnTypeOptionalModifiers, parameterTypes, parameterRequiredModifiers, parameterOptionalModifiers);
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)
{
Type attributeType = EmitIgnoresAccessChecksToAttribute(moduleBuilder);
return attributeType.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[] { true });
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;
}

/// <summary>
/// This interface enables a COM Object Wrapper (such as <see cref="ComObject"/>) to provide a built-in COM object to enable integration between built-in COM objects and
/// other COM interop systems like source-generated COM.
/// </summary>
internal interface IComImportAdapter
jkoritzinsky marked this conversation as resolved.
Show resolved Hide resolved
{
internal static readonly MethodInfo GetRuntimeCallableWrapperMethod = typeof(IComImportAdapter).GetMethod(nameof(GetRuntimeCallableWrapper))!;

/// <summary>
/// Gets the built-in COM object that corresponds to the same underlying COM object as this wrapper.
/// </summary>
/// <returns>The built-in RCW</returns>
/// <remarks>The returned object must be an object such that a call to <see cref="Marshal.IsComObject(object)"/> would return true.</remarks>
object GetRuntimeCallableWrapper();
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -5,16 +5,23 @@
// 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 BuiltInComSupported { get; } = AppContext.TryGetSwitch("System.Runtime.InteropServices.BuiltInComInterop.IsSupported", out bool supported) ? supported : true;
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Could this use Marshal.IsBuiltInComSupported? That is implemented such that runtimes that don't support built-in COM at all return false regardless of the feature switch.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

That API isn't exposed outside of CoreLib (we never made it public). I should be able to make it exposed enough for System.Runtime.InteropServices to see it I think without making it public if we would prefer.

internal static bool ComImportInteropEnabled { get; } = AppContext.TryGetSwitch("System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop", out bool enabled) ? enabled : false;
jkoritzinsky marked this conversation as resolved.
Show resolved Hide resolved

private readonly void* _instancePointer;

private readonly object? _runtimeCallableWrapper;
jkoritzinsky marked this conversation as resolved.
Show resolved Hide resolved

/// <summary>
/// Initialize ComObject instance.
/// </summary>
Expand All @@ -28,6 +35,11 @@ internal ComObject(IIUnknownInterfaceDetailsStrategy interfaceDetailsStrategy, I
IUnknownStrategy = iunknownStrategy;
CacheStrategy = cacheStrategy;
_instancePointer = IUnknownStrategy.CreateInstancePointer(thisPointer);
if (OperatingSystem.IsWindows() && BuiltInComSupported && ComImportInteropEnabled)
{
_runtimeCallableWrapper = Marshal.GetObjectForIUnknown((nint)thisPointer);
Debug.Assert(Marshal.IsComObject(_runtimeCallableWrapper));
}
}

~ComObject()
Expand Down Expand Up @@ -135,5 +147,11 @@ VirtualMethodTableInfo IUnmanagedVirtualMethodTableProvider.GetVirtualMethodTabl

return new(result.ThisPtr, result.Table);
}

object ComImportInteropInterfaceDetailsStrategy.IComImportAdapter.GetRuntimeCallableWrapper()
jkoritzinsky marked this conversation as resolved.
Show resolved Hide resolved
{
Debug.Assert(_runtimeCallableWrapper != null);
return _runtimeCallableWrapper;
}
}
}
Loading
Loading