Fix IL2087 trim warning in 'ObjectReferenceWithContext<T>' (#1577)

* Fix trim warning for '_iid' in 'ObjectReference<T>'

* Remove duplicate IID definition

* Validate that input 'iid' arguments are not empty

* Optimize 'CreateForCurrentContext' on NAOT

* Fix generated 'ActivateInstance<I>' method

* Fix trim warning in 'IMarshal' in Windows SDK

* Skip closure allocation in ObjectReferenceWithContext<T> (#1587)

* Skip closure allocation in ObjectReferenceWithContext<T>

* Remove even more closure allocations in ObjectReferenceWithContext<T> (#1589)

* Skip closures for 'Context.CallInContext' calls

* Use function pointers instead of delegates

* Move context lambda to FOH

Author: Sergio0694

src/WinRT.Runtime/ActivationFactory.cs

@@ -110,7 +110,7 @@ private DllModule(string fileName, IntPtr moduleHandle, void* getActivationFacto
                     int hr = _GetActivationFactory(MarshalString.GetAbi(ref __runtimeClassId), &instancePtr);
                     if (hr == 0)
                     {
-                        var objRef = ObjectReference<IUnknownVftbl>.Attach(ref instancePtr);
+                        var objRef = ObjectReference<IUnknownVftbl>.Attach(ref instancePtr, IID.IID_IUnknown);
                         return (objRef, hr);
                     }
                     else
@@ -169,7 +169,7 @@ public static unsafe (ObjectReference<I> obj, int hr) GetActivationFactory<I>(st
                     int hr = Platform.RoGetActivationFactory(MarshalString.GetAbi(ref __runtimeClassId), &iid, &instancePtr);
                     if (hr == 0)
                     {
-                        var objRef = ObjectReference<I>.Attach(ref instancePtr);
+                        var objRef = ObjectReference<I>.Attach(ref instancePtr, iid);
                         return (objRef, hr);
                     }
                     else
@@ -327,7 +327,7 @@ private static IObjectReference GetFromActivationHandler(string typeName, Guid i
                     instancePtr = activationHandler(typeName, iid);
                     if (instancePtr != IntPtr.Zero)
                     {
-                        return ObjectReference<IUnknownVftbl>.Attach(ref instancePtr);
+                        return ObjectReference<IUnknownVftbl>.Attach(ref instancePtr, iid);
                     }
                 }
                 finally

src/WinRT.Runtime/AgileReference.cs

@@ -67,7 +67,7 @@ internal unsafe AgileReference(IntPtr thisPtr)
                     &iid,
                     thisPtr,
                     &agileReference));
-                _agileReference = ObjectReference<IUnknownVftbl>.Attach(ref agileReference);
+                _agileReference = ObjectReference<IUnknownVftbl>.Attach(ref agileReference, IID.IID_IUnknown);
             }
             catch (TypeLoadException)
             {
@@ -94,7 +94,7 @@ protected virtual void Dispose(bool disposing)
                     {
                         Git.RevokeInterfaceFromGlobal(_cookie);
                     }
-                    catch(ArgumentException)
+                    catch (ArgumentException)
                     {
                         // Revoking cookie from GIT table may fail if apartment is gone.
                     }
@@ -106,7 +106,7 @@ protected virtual void Dispose(bool disposing)
         private static unsafe IGlobalInterfaceTable GetGitTable()
         {
             Guid gitClsid = CLSID_StdGlobalInterfaceTable;
-            Guid gitIid = ABI.WinRT.Interop.IGlobalInterfaceTable.IID;
+            Guid gitIid = IID.IID_IGlobalInterfaceTable;
             IntPtr gitPtr = default;
 
             try

src/WinRT.Runtime/ComWrappersSupport.cs

@@ -113,9 +113,12 @@ internal unsafe static bool IsFreeThreaded(IObjectReference objRef)
 
         public static IObjectReference GetObjectReferenceForInterface(IntPtr externalComObject)
         {
-            return GetObjectReferenceForInterface<IUnknownVftbl>(externalComObject);
+            return GetObjectReferenceForInterface<IUnknownVftbl>(externalComObject, IID.IID_IUnknown);
         }
 
+#if NET
+        [RequiresUnreferencedCode(AttributeMessages.GenericRequiresUnreferencedCodeMessage)]
+#endif
         public static ObjectReference<T> GetObjectReferenceForInterface<T>(IntPtr externalComObject)
         {
             if (externalComObject == IntPtr.Zero)
@@ -1162,7 +1165,7 @@ internal InspectableInfo(Type type, Guid[] iids)
         internal static ObjectReference<T> CreateCCWForObject<T>(object obj, Guid iid)
         {
             IntPtr ccw = CreateCCWForObjectForABI(obj, iid);
-            return ObjectReference<T>.Attach(ref ccw);
+            return ObjectReference<T>.Attach(ref ccw, iid);
         }
 
         internal static ObjectReferenceValue CreateCCWForObjectForMarshaling(object obj, Guid iid)

src/WinRT.Runtime/ComWrappersSupport.net5.cs

@@ -616,7 +616,7 @@ private static object CreateObject(IntPtr externalComObject)
                 }
                 else if (Marshal.QueryInterface(externalComObject, ref inspectableIID, out ptr) == 0)
                 {
-                    var inspectableObjRef = ComWrappersSupport.GetObjectReferenceForInterface<IInspectable.Vftbl>(ptr);
+                    var inspectableObjRef = ComWrappersSupport.GetObjectReferenceForInterface<IInspectable.Vftbl>(ptr, IID.IID_IInspectable);
                     ComWrappersHelper.Init(inspectableObjRef);
 
                     IInspectable inspectable = new IInspectable(inspectableObjRef);

src/WinRT.Runtime/Context.cs

@@ -29,17 +29,31 @@ public static unsafe IntPtr GetContextCallback()
         // On any exception, calls onFail callback if any set.
         // If not set, exception is handled due to today we don't
         // have any scenario to propagate it from here.
-        public unsafe static void CallInContext(IntPtr contextCallbackPtr, IntPtr contextToken, Action callback, Action onFailCallback)
+        //
+        // On modern .NET, we can use function pointers to avoid the
+        // small binary size increase from all generated fields and
+        // logic to cache delegates, since we don't need any of that.
+        public unsafe static void CallInContext(
+            IntPtr contextCallbackPtr,
+            IntPtr contextToken,
+#if NET && CsWinRT_LANG_11_FEATURES
+            delegate*<object, void> callback,
+            delegate*<object, void> onFailCallback,
+#else
+            Action<object> callback,
+            Action<object> onFailCallback,
+#endif
+            object state)
         {
             // Check if we are already on the same context, if so we do not need to switch.
             if(contextCallbackPtr == IntPtr.Zero || GetContextToken() == contextToken)
             {
-                callback();
+                callback(state);
                 return;
             }
 
 #if NET && CsWinRT_LANG_11_FEATURES
-            IContextCallbackVftbl.ContextCallback(contextCallbackPtr, callback, onFailCallback);
+            IContextCallbackVftbl.ContextCallback(contextCallbackPtr, callback, onFailCallback, state);
 #else
             ComCallData data = default;
             var contextCallback = new ABI.WinRT.Interop.IContextCallback(ObjectReference<ABI.WinRT.Interop.IContextCallback.Vftbl>.FromAbi(contextCallbackPtr));
@@ -48,13 +62,13 @@ public unsafe static void CallInContext(IntPtr contextCallbackPtr, IntPtr contex
             {
                 contextCallback.ContextCallback(_ =>
                 {
-                    callback();
+                    callback(state);
                     return 0;
                 }, &data, IID.IID_ICallbackWithNoReentrancyToApplicationSTA, 5);
             } 
-            catch(Exception)
+            catch (Exception)
             {
-                onFailCallback?.Invoke();
+                onFailCallback?.Invoke(state);
             }
 #endif
         }

src/WinRT.Runtime/IInspectable.cs

@@ -122,7 +122,7 @@ private static int Do_Abi_GetTrustLevel(IntPtr pThis, TrustLevel* trustLevel)
         }
 
         public static IInspectable FromAbi(IntPtr thisPtr) =>
-            new IInspectable(ObjectReference<Vftbl>.FromAbi(thisPtr));
+            new IInspectable(ObjectReference<Vftbl>.FromAbi(thisPtr, IID.IID_IInspectable));
 
         private readonly ObjectReference<Vftbl> _obj;
         public IntPtr ThisPtr => _obj.ThisPtr;

src/WinRT.Runtime/Interop/ExceptionErrorInfo.net5.cs

@@ -242,7 +242,7 @@ public static unsafe IObjectReference GetLanguageException(ObjectReference<IUnkn
 
                 GC.KeepAlive(obj);
 
-                return ObjectReference<IUnknownVftbl>.Attach(ref __return_value__);
+                return ObjectReference<IUnknownVftbl>.Attach(ref __return_value__, IID.IID_IUnknown);
             }
             finally
             {

src/WinRT.Runtime/Interop/IActivationFactory.cs

@@ -70,7 +70,7 @@ public static unsafe IObjectReference ActivateInstanceUnsafe(IObjectReference ob
 
             try
             {
-                return ComWrappersSupport.GetObjectReferenceForInterface<IUnknownVftbl>(instancePtr);
+                return ComWrappersSupport.GetObjectReferenceForInterface<IUnknownVftbl>(instancePtr, global::WinRT.Interop.IID.IID_IUnknown);
             }
             finally
             {
@@ -142,7 +142,7 @@ private static unsafe int Do_Abi_ActivateInstance_0(IntPtr thisPtr, IntPtr* resu
                 return 0;
             }
         }
-        internal static ObjectReference<Vftbl> FromAbi(IntPtr thisPtr) => ObjectReference<Vftbl>.FromAbi(thisPtr);
+        internal static ObjectReference<Vftbl> FromAbi(IntPtr thisPtr) => ObjectReference<Vftbl>.FromAbi(thisPtr, IID.IID_IActivationFactory);
 
         public static implicit operator IActivationFactory(IObjectReference obj) => (obj != null) ? new IActivationFactory(obj) : null;
         protected readonly ObjectReference<Vftbl> _obj;

src/WinRT.Runtime/Interop/IAgileReference.net5.cs

@@ -72,7 +72,7 @@ public static unsafe ObjectReference<T> Resolve<T>(IObjectReference _obj, Guid r
                 ThisPtr, &riid, &ptr));
             try
             {
-                return ComWrappersSupport.GetObjectReferenceForInterface<T>(ptr);
+                return ComWrappersSupport.GetObjectReferenceForInterface<T>(ptr, riid);
             }
             finally
             {
@@ -134,7 +134,7 @@ static unsafe IAgileObject()
     [Guid("00000146-0000-0000-C000-000000000046")]
     internal sealed unsafe class IGlobalInterfaceTable : global::WinRT.Interop.IGlobalInterfaceTable
     {
-        internal static readonly Guid IID = new(0x00000146, 0, 0, 0xc0, 0, 0, 0, 0, 0, 0, 0x46);
+        internal static readonly Guid IID = global::WinRT.Interop.IID.IID_IGlobalInterfaceTable;
 
         [Guid("00000146-0000-0000-C000-000000000046")]
         [StructLayout(LayoutKind.Sequential)]
@@ -149,7 +149,7 @@ public struct Vftbl
             public delegate* unmanaged[Stdcall]<IntPtr, IntPtr, Guid*, IntPtr*, int> GetInterfaceFromGlobal => (delegate* unmanaged[Stdcall]<IntPtr, IntPtr, Guid*, IntPtr*, int>)_GetInterfaceFromGlobal;
         }
 
-        public static ObjectReference<Vftbl> FromAbi(IntPtr thisPtr) => ObjectReference<Vftbl>.FromAbi(thisPtr);
+        public static ObjectReference<Vftbl> FromAbi(IntPtr thisPtr) => ObjectReference<Vftbl>.FromAbi(thisPtr, global::WinRT.Interop.IID.IID_IGlobalInterfaceTable);
 
         public static implicit operator IGlobalInterfaceTable(IObjectReference obj) => (obj != null) ? new IGlobalInterfaceTable(obj) : null;
         public static implicit operator IGlobalInterfaceTable(ObjectReference<Vftbl> obj) => (obj != null) ? new IGlobalInterfaceTable(obj) : null;

src/WinRT.Runtime/Interop/IContextCallback.cs

@@ -17,6 +17,14 @@ internal struct ComCallData
         public IntPtr pUserDefined;
     }
 
+#if NET && CsWinRT_LANG_11_FEATURES
+    internal unsafe struct CallbackData
+    {
+        public delegate*<object, void> Callback;
+        public object State;
+    }
+#endif
+
 #if NET && CsWinRT_LANG_11_FEATURES
     internal unsafe struct IContextCallbackVftbl
     {
@@ -25,34 +33,31 @@ internal unsafe struct IContextCallbackVftbl
         private delegate* unmanaged[Stdcall]<IntPtr, IntPtr, ComCallData*, Guid*, int, IntPtr, int> ContextCallback_4;
 #pragma warning restore CS0649
 
-        public static void ContextCallback(IntPtr contextCallbackPtr, Action callback, Action onFailCallback)
+        public static void ContextCallback(IntPtr contextCallbackPtr, delegate*<object, void> callback, delegate*<object, void> onFailCallback, object state)
         {
             ComCallData comCallData;
             comCallData.dwDispid = 0;
             comCallData.dwReserved = 0;
 
-            // Copy the callback into a local to make sure it really is a local that
-            // gets marked as address taken, rather than something that could potentially
-            // be inlined into the caller into some state machine or anything else not safe.
-            Action callbackAddressTaken = callback;
+            CallbackData callbackData;
+            callbackData.Callback = callback;
+            callbackData.State = state;
 
             // We can just store a pointer to the callback to invoke in the context,
             // so we don't need to allocate another closure or anything. The callback
             // will be kept alive automatically, because 'comCallData' is address exposed.
             // We only do this if we can use C# 11, and if we're on modern .NET, to be safe.
             // In the callback below, we can then just retrieve the Action again to invoke it.
-            comCallData.pUserDefined = (IntPtr)(void*)&callbackAddressTaken;
+            comCallData.pUserDefined = (IntPtr)(void*)&callbackData;
 
             [UnmanagedCallersOnly]
             static int InvokeCallback(ComCallData* comCallData)
             {
                 try
                 {
-                    // Dereference the pointer to Action and invoke it (see notes above).
-                    // Once again, the pointer is not to the Action object, but just to the
-                    // local *reference* to the object, which is pinned (as it's a local).
-                    // That means that there's no pinning to worry about either.
-                    ((Action*)comCallData->pUserDefined)->Invoke();
+                    CallbackData* callbackData = (CallbackData*)comCallData->pUserDefined;
+
+                    callbackData->Callback(callbackData->State);
 
                     return 0; // S_OK
                 }
@@ -74,7 +79,10 @@ static int InvokeCallback(ComCallData* comCallData)
 
             if (hresult < 0)
             {
-                onFailCallback?.Invoke();
+                if (onFailCallback is not null)
+                {
+                    onFailCallback(state);
+                }
             }
         }
     }