Fixed undefined behavior with delegate reinterpret cast

Author: Sergio0694

CommunityToolkit.WinUI/Extensions/Interop/DispatcherQueueProxyHandler1.cs

@@ -62,6 +62,11 @@ internal unsafe struct DispatcherQueueProxyHandler1 : IDispatcherQueueHandler
         /// </summary>
         private GCHandle stateHandle;
 
+        /// <summary>
+        /// The generic stub to invoke the current callback with the right generic context.
+        /// </summary>
+        private delegate*<DispatcherQueueProxyHandler1*, int> stub;
+
         /// <summary>
         /// The current reference count for the object (from <c>IUnknown</c>).
         /// </summary>
@@ -70,16 +75,19 @@ internal unsafe struct DispatcherQueueProxyHandler1 : IDispatcherQueueHandler
         /// <summary>
         /// Creates a new <see cref="DispatcherQueueProxyHandler1"/> instance for the input callback and state.
         /// </summary>
+        /// <typeparam name="T">The type of state currently being used.</typeparam>
         /// <param name="handler">The input <see cref="DispatcherQueueHandler{TState}"/> callback to enqueue.</param>
         /// <param name="state">The input state to capture and pass to the callback.</param>
         /// <returns>A pointer to the newly initialized <see cref="DispatcherQueueProxyHandler1"/> instance.</returns>
-        public static DispatcherQueueProxyHandler1* Create(object handler, object state)
+        public static DispatcherQueueProxyHandler1* Create<T>(DispatcherQueueHandler<T> handler, T state)
+            where T : class
         {
             DispatcherQueueProxyHandler1* @this = (DispatcherQueueProxyHandler1*)Marshal.AllocHGlobal(sizeof(DispatcherQueueProxyHandler1));
 
             @this->lpVtbl = Vtbl;
             @this->callbackHandle = GCHandle.Alloc(handler);
             @this->stateHandle = GCHandle.Alloc(state);
+            @this->stub = &Impl.Invoke<T>;
             @this->referenceCount = 1;
 
             return @this;
@@ -174,19 +182,22 @@ public static uint Release(DispatcherQueueProxyHandler1* @this)
             /// </summary>
             [UnmanagedCallersOnly]
             public static int Invoke(DispatcherQueueProxyHandler1* @this)
+            {
+                return @this->stub(@this);
+            }
+
+            /// <summary>
+            /// Implements <c>IDispatcherQueueHandler.Invoke()</c> from within a generic context.
+            /// </summary>
+            public static int Invoke<T>(DispatcherQueueProxyHandler1* @this)
+                where T : class
             {
                 object callback = @this->callbackHandle.Target!;
                 object state = @this->stateHandle.Target!;
 
                 try
                 {
-                    // We do an unsafe cast here to treat the captured delegate as if the contravariant
-                    // input type was actually declared as covariant. This is valid because the type
-                    // parameter is constrained to be a reference type, and due to how the proxy handler
-                    // is constructed we know that the captured state will always match the actual type
-                    // of the captured handler at this point. This lets this whole method work without the
-                    // need to make the proxy type itself generic, so without knowing the actual type argument.
-                    Unsafe.As<DispatcherQueueHandler<object>>(callback)(state);
+                    Unsafe.As<DispatcherQueueHandler<T>>(callback)(Unsafe.As<T>(state));
                 }
                 catch (Exception e)
                 {

CommunityToolkit.WinUI/Extensions/Interop/DispatcherQueueProxyHandler2.cs

@@ -67,6 +67,11 @@ internal unsafe struct DispatcherQueueProxyHandler2 : IDispatcherQueueHandler
         /// </summary>
         private GCHandle state2Handle;
 
+        /// <summary>
+        /// The generic stub to invoke the current callback with the right generic context.
+        /// </summary>
+        private delegate*<DispatcherQueueProxyHandler2*, int> stub;
+
         /// <summary>
         /// The current reference count for the object (from <c>IUnknown</c>).
         /// </summary>
@@ -75,18 +80,23 @@ internal unsafe struct DispatcherQueueProxyHandler2 : IDispatcherQueueHandler
         /// <summary>
         /// Creates a new <see cref="DispatcherQueueProxyHandler2"/> instance for the input callback and state.
         /// </summary>
+        /// <typeparam name="T1">The type of the first state to capture.</typeparam>
+        /// <typeparam name="T2">The type of the second state to capture.</typeparam>
         /// <param name="handler">The input <see cref="DispatcherQueueHandler{T1,T2}"/> callback to enqueue.</param>
         /// <param name="state1">The first input state to capture and pass to the callback.</param>
         /// <param name="state2">The second input state to capture and pass to the callback.</param>
         /// <returns>A pointer to the newly initialized <see cref="DispatcherQueueProxyHandler2"/> instance.</returns>
-        public static DispatcherQueueProxyHandler2* Create(object handler, object state1, object state2)
+        public static DispatcherQueueProxyHandler2* Create<T1, T2>(DispatcherQueueHandler<T1, T2> handler, T1 state1, T2 state2)
+            where T1 : class
+            where T2 : class
         {
             DispatcherQueueProxyHandler2* @this = (DispatcherQueueProxyHandler2*)Marshal.AllocHGlobal(sizeof(DispatcherQueueProxyHandler2));
 
             @this->lpVtbl = Vtbl;
             @this->callbackHandle = GCHandle.Alloc(handler);
             @this->state1Handle = GCHandle.Alloc(state1);
             @this->state2Handle = GCHandle.Alloc(state2);
+            @this->stub = &Impl.Invoke<T1, T2>;
             @this->referenceCount = 1;
 
             return @this;
@@ -183,15 +193,26 @@ public static uint Release(DispatcherQueueProxyHandler2* @this)
             /// </summary>
             [UnmanagedCallersOnly]
             public static int Invoke(DispatcherQueueProxyHandler2* @this)
+            {
+                return @this->stub(@this);
+            }
+
+            /// <summary>
+            /// Implements <c>IDispatcherQueueHandler.Invoke()</c> from within a generic context.
+            /// </summary>
+            public static int Invoke<T1, T2>(DispatcherQueueProxyHandler2* @this)
+                where T1 : class
+                where T2 : class
             {
                 object callback = @this->callbackHandle.Target!;
                 object state1 = @this->state1Handle.Target!;
                 object state2 = @this->state2Handle.Target!;
 
                 try
                 {
-                    // Same optimization as in DispatcherQueueProxyHandler1
-                    Unsafe.As<DispatcherQueueHandler<object, object>>(callback)(state1, state2);
+                    Unsafe.As<DispatcherQueueHandler<object, object>>(callback)(
+                        Unsafe.As<T1>(state1),
+                        Unsafe.As<T2>(state2));
                 }
                 catch (Exception e)
                 {