Use specialized marshallers for generic instantiations

src/Authoring/WinRT.SourceGenerator/AotOptimizer.cs

@@ -740,7 +740,8 @@ genericParameter is INamedTypeSymbol genericParameterIface &&
                         genericParameters.Add(new GenericParameter(
                             ToFullyQualifiedString(genericParameter),
                             GeneratorHelper.GetAbiType(genericParameter, mapper),
-                            isNullable ? TypeKind.Interface : genericParameter.TypeKind));
+                            isNullable ? TypeKind.Interface : genericParameter.TypeKind,
+                            ComputeTypeFlags(genericParameter, compilation)));
                     }
 
                     genericInterfacesToAddToVtable.Add(new GenericInterface(
@@ -773,6 +774,25 @@ void CheckForInterfaceToUseForRuntimeClassName(INamedTypeSymbol iface)
             }
         }
 
+        private static TypeFlags ComputeTypeFlags(ITypeSymbol symbol, Compilation compilation)
+        {
+            TypeFlags typeFlags = TypeFlags.None;
+
+            // Check for exception types
+            if (symbol.TypeKind is TypeKind.Class)
+            {
+                var exceptionType = compilation.GetTypeByMetadataName("System.Exception")!;
+
+                if (SymbolEqualityComparer.Default.Equals(symbol, exceptionType) ||
+                    symbol.InheritsFromType(exceptionType))
+                {
+                    typeFlags |= TypeFlags.Exception;
+                }
+            }
+
+            return typeFlags;
+        }
+
         private static bool TryGetCompatibleWindowsRuntimeTypesForVariantType(INamedTypeSymbol type, TypeMapper mapper, Stack<INamedTypeSymbol> typeStack, Func<ISymbol, TypeMapper, bool> isWinRTType, INamedTypeSymbol objectType, out IList<INamedTypeSymbol> compatibleTypes)
         {
             compatibleTypes = null;
@@ -1873,7 +1893,8 @@ namespace {{bindableCustomProperties.Namespace}}
     internal readonly record struct GenericParameter(
         string ProjectedType,
         string AbiType,
-        TypeKind TypeKind);
+        TypeKind TypeKind,
+        TypeFlags TypeFlags);
 
     internal readonly record struct GenericInterface(
         string Interface,
@@ -1923,6 +1944,20 @@ internal readonly record struct CsWinRTAotOptimizerProperties(
         bool IsCsWinRTCcwLookupTableGeneratorEnabled,
         bool IsCsWinRTAotOptimizerInAutoMode);
 
+    /// <summary>
+    /// Additional flags for discovered types.
+    /// </summary>
+    [Flags]
+    internal enum TypeFlags
+    {
+        None = 0x0,
+
+        /// <summary>
+        /// The type derives from <see cref="System.Exception"/>.
+        /// </summary>
+        Exception = 0x1 << 0
+    }
+
     /// <summary>
     /// A model describing a type info in a type hierarchy.
     /// </summary>

src/Authoring/WinRT.SourceGenerator/Extensions/SymbolExtensions.cs

@@ -87,4 +87,27 @@ public static bool IsAccessibleFromCompilationAssembly(this ISymbol symbol, Comp
     {
         return compilation.IsSymbolAccessibleWithin(symbol, compilation.Assembly);
     }
+
+    /// <summary>
+    /// Checks whether or not a given <see cref="ITypeSymbol"/> inherits from a specified type.
+    /// </summary>
+    /// <param name="typeSymbol">The target <see cref="ITypeSymbol"/> instance to check.</param>
+    /// <param name="baseTypeSymbol">The <see cref="ITypeSymbol"/> instane to check for inheritance from.</param>
+    /// <returns>Whether or not <paramref name="typeSymbol"/> inherits from <paramref name="baseTypeSymbol"/>.</returns>
+    public static bool InheritsFromType(this ITypeSymbol typeSymbol, ITypeSymbol baseTypeSymbol)
+    {
+        INamedTypeSymbol? currentBaseTypeSymbol = typeSymbol.BaseType;
+
+        while (currentBaseTypeSymbol is not null)
+        {
+            if (SymbolEqualityComparer.Default.Equals(currentBaseTypeSymbol, baseTypeSymbol))
+            {
+                return true;
+            }
+
+            currentBaseTypeSymbol = currentBaseTypeSymbol.BaseType;
+        }
+
+        return false;
+    }
 }