Emit IAsyncActionWithProgress<T> and IAsyncOperation* types

src/WinRT.Interop.Generator/Errors/WellKnownInteropExceptions.cs

@@ -386,6 +386,30 @@ public static Exception DynamicImplementationDetailTypeCodeGenerationError(Excep
         return Exception(43, $"Failed to generate marshalling code for some dynamic implementation detail type.", exception);
     }
 
+    /// <summary>
+    /// Failed to generate marshalling code for an <c>Windows.Foundation.IAsyncActionWithProgress&lt;TProgress&gt;</c> type.
+    /// </summary>
+    public static Exception IAsyncActionWithProgressTypeCodeGenerationError(TypeSignature actionType, Exception exception)
+    {
+        return Exception(44, $"Failed to generate marshalling code for 'IAsyncActionWithProgress<TResult>' type '{actionType}'.", exception);
+    }
+
+    /// <summary>
+    /// Failed to generate marshalling code for an <c>Windows.Foundation.IAsyncOperation&lt;TResult&gt;</c> type.
+    /// </summary>
+    public static Exception IAsyncOperationTypeCodeGenerationError(TypeSignature operationType, Exception exception)
+    {
+        return Exception(45, $"Failed to generate marshalling code for 'IAsyncOperation<TResult>' type '{operationType}'.", exception);
+    }
+
+    /// <summary>
+    /// Failed to generate marshalling code for an <c>Windows.Foundation.IAsyncOperationWithProgress&lt;TResult, TProgress&gt;</c> type.
+    /// </summary>
+    public static Exception IAsyncOperationWithProgressTypeCodeGenerationError(TypeSignature operationType, Exception exception)
+    {
+        return Exception(46, $"Failed to generate marshalling code for 'IAsyncOperationWithProgress<TResult, TProgress>' type '{operationType}'.", exception);
+    }
+
     /// <summary>
     /// Creates a new exception with the specified id and message.
     /// </summary>

src/WinRT.Interop.Generator/Extensions/InteropGeneratorDiscoveryStateExtensions.cs

@@ -35,7 +35,7 @@ public static void TrackGenericInterfaceType(
             // type. This ensures that we're never missing any 'IEnumerator<T>' instantiation, which we might depend on
             // from other generated code, or projections. This special handling is needed because unlike with the other
             // interfaces, 'IEnumerator<T>' will not show up as a base interface for other collection interface types.
-            discoveryState.TrackIEnumerator1Type(interopReferences.IEnumerator1.MakeGenericReferenceType(typeSignature.TypeArguments[0]));
+            discoveryState.TrackIEnumerator1Type(interopReferences.IEnumerator1.MakeGenericReferenceType([.. typeSignature.TypeArguments]));
         }
         else if (SignatureComparer.IgnoreVersion.Equals(typeSignature.GenericType, interopReferences.IList1))
         {
@@ -68,12 +68,34 @@ public static void TrackGenericInterfaceType(
         {
             discoveryState.TrackIObservableMap2Type(typeSignature);
 
-            // Same handling as below for 'MapChangedEventHandler<K,V>' types
+            // Same handling as above for 'MapChangedEventHandler<K,V>' types
             discoveryState.TrackGenericDelegateType(interopReferences.MapChangedEventHandler2.MakeGenericReferenceType([.. typeSignature.TypeArguments]));
         }
         else if (SignatureComparer.IgnoreVersion.Equals(typeSignature.GenericType, interopReferences.IMapChangedEventArgs1))
         {
             discoveryState.TrackIMapChangedEventArgs1Type(typeSignature);
         }
+        else if (SignatureComparer.IgnoreVersion.Equals(typeSignature.GenericType, interopReferences.IAsyncActionWithProgress1))
+        {
+            discoveryState.TrackIAsyncActionWithProgress1Type(typeSignature);
+
+            // Ensure that the delegate types for this instantiation of 'IAsyncActionWithProgress<TProgress>' are also tracked.
+            // Same rationale as above for the other special cased types. Same below as well for the other async info types.
+            discoveryState.TrackGenericDelegateType(interopReferences.AsyncActionProgressHandler1.MakeGenericReferenceType([.. typeSignature.TypeArguments]));
+            discoveryState.TrackGenericDelegateType(interopReferences.AsyncActionWithProgressCompletedHandler1.MakeGenericReferenceType([.. typeSignature.TypeArguments]));
+        }
+        else if (SignatureComparer.IgnoreVersion.Equals(typeSignature.GenericType, interopReferences.IAsyncOperation1))
+        {
+            discoveryState.TrackIAsyncOperation1Type(typeSignature);
+
+            discoveryState.TrackGenericDelegateType(interopReferences.AsyncOperationCompletedHandler1.MakeGenericReferenceType([.. typeSignature.TypeArguments]));
+        }
+        else if (SignatureComparer.IgnoreVersion.Equals(typeSignature.GenericType, interopReferences.IAsyncOperationWithProgress2))
+        {
+            discoveryState.TrackIAsyncOperationWithProgress2Type(typeSignature);
+
+            discoveryState.TrackGenericDelegateType(interopReferences.AsyncOperationProgressHandler2.MakeGenericReferenceType([.. typeSignature.TypeArguments]));
+            discoveryState.TrackGenericDelegateType(interopReferences.AsyncOperationWithProgressCompletedHandler2.MakeGenericReferenceType([.. typeSignature.TypeArguments]));
+        }
     }
 }

src/WinRT.Interop.Generator/Factories/InteropMethodDefinitionFactory.IAsyncActionWithProgress1Impl.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using AsmResolver.DotNet;
+using AsmResolver.DotNet.Code.Cil;
+using AsmResolver.DotNet.Signatures;
+using AsmResolver.PE.DotNet.Cil;
+using AsmResolver.PE.DotNet.Metadata.Tables;
+using WindowsRuntime.InteropGenerator.References;
+using static AsmResolver.PE.DotNet.Cil.CilOpCodes;
+
+namespace WindowsRuntime.InteropGenerator.Factories;
+
+/// <inheritdoc cref="InteropMethodDefinitionFactory"/>
+internal partial class InteropMethodDefinitionFactory
+{
+    /// <summary>
+    /// Helpers for impl types for <c>Windows.Foundation.IAsyncActionWithProgress&lt;TProgress&gt;</c> interfaces.
+    /// </summary>
+    public static class IAsyncActionWithProgress1Impl
+    {
+        /// <summary>
+        /// Creates a <see cref="MethodDefinition"/> for the <c>GetResults</c> export method.
+        /// </summary>
+        /// <param name="actionType">The <see cref="TypeSignature"/> for the async action type.</param>
+        /// <param name="interopReferences">The <see cref="InteropReferences"/> instance to use.</param>
+        /// <param name="module">The interop module being built.</param>
+        public static MethodDefinition GetResults(
+            GenericInstanceTypeSignature actionType,
+            InteropReferences interopReferences,
+            ModuleDefinition module)
+        {
+            TypeSignature progressType = actionType.TypeArguments[0];
+
+            // Define the 'GetResults' method as follows:
+            //
+            // [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
+            // private static int GetResults(void* thisPtr)
+            MethodDefinition getResultsMethod = new(
+                name: "GetResults"u8,
+                attributes: MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.Static,
+                signature: MethodSignature.CreateStatic(
+                    returnType: module.CorLibTypeFactory.Int32,
+                    parameterTypes: [module.CorLibTypeFactory.Void.MakePointerType()]))
+            {
+                CustomAttributes = { InteropCustomAttributeFactory.UnmanagedCallersOnly(interopReferences, module) }
+            };
+
+            // Labels for jumps
+            CilInstruction ldarg_0_tryStart = new(Ldarg_0);
+            CilInstruction ldloc_0_returnHResult = new(Ldloc_0);
+            CilInstruction call_catchStartMarshalException = new(Call, interopReferences.RestrictedErrorInfoExceptionMarshallerConvertToUnmanaged.Import(module));
+
+            // Declare the local variables:
+            //   [0]: 'int' (the 'HRESULT' to return)
+            CilLocalVariable loc_0_hresult = new(module.CorLibTypeFactory.Int32);
+
+            // Create a method body for the 'get_Current' method
+            getResultsMethod.CilMethodBody = new CilMethodBody()
+            {
+                LocalVariables = { loc_0_hresult },
+                Instructions =
+                {
+                    // '.try' code
+                    { ldarg_0_tryStart },
+                    { Call, interopReferences.ComInterfaceDispatchGetInstance.MakeGenericInstanceMethod(actionType).Import(module) },
+                    { Callvirt, interopReferences.IAsyncActionWithProgress1GetResults(progressType).Import(module) },
+                    { Ldc_I4_0 },
+                    { Stloc_0 },
+                    { Leave_S, ldloc_0_returnHResult.CreateLabel() },
+
+                    // '.catch' code
+                    { call_catchStartMarshalException },
+                    { Stloc_0 },
+                    { Leave_S, ldloc_0_returnHResult.CreateLabel() },
+
+                    // Return the 'HRESULT' from location [0]
+                    { ldloc_0_returnHResult  },
+                    { Ret }
+                },
+                ExceptionHandlers =
+                {
+                    new CilExceptionHandler
+                    {
+                        HandlerType = CilExceptionHandlerType.Exception,
+                        TryStart = ldarg_0_tryStart.CreateLabel(),
+                        TryEnd = call_catchStartMarshalException.CreateLabel(),
+                        HandlerStart = call_catchStartMarshalException.CreateLabel(),
+                        HandlerEnd = ldloc_0_returnHResult.CreateLabel(),
+                        ExceptionType = interopReferences.Exception.Import(module)
+                    }
+                }
+            };
+
+            return getResultsMethod;
+        }
+    }
+}