Implement unmanaged->managed exception handling spec and get compilat…

…ion unit tests passing.

docs/design/libraries/ComInterfaceGenerator/UnmanagedToManagedEH.md

@@ -37,14 +37,13 @@ namespace System.Runtime.InteropServices.Marshalling;
 public class VirtualMethodTableIndexAttribute
 {
 +     public ExceptionMarshalling ExceptionMarshalling { get; }
-+     public Type ExceptionMarshallingType { get; }
++     public Type? ExceptionMarshallingType { get; } // When set to null or not set, equivalent to option 1
 }
 
 + public enum ExceptionMarshalling
 + {
-+     None, // No exception handling (equivalent to Option 1)
++     Custom,
 +     Com, // Match the COM-focused model described in Option 2
-+     Custom
 + }
 ```
 

src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportCodeGenerator.cs

@@ -28,16 +28,18 @@ public JSExportCodeGenerator(
             Action<TypePositionInfo, MarshallingNotSupportedException> marshallingNotSupportedCallback,
             IMarshallingGeneratorFactory generatorFactory)
         {
+            Action<TypePositionInfo, string> extendedInvariantViolationsCallback = (info, details) =>
+                marshallingNotSupportedCallback(info, new MarshallingNotSupportedException(info, _context) { NotSupportedDetails = details });
             _signatureContext = signatureContext;
-            ManagedToNativeStubCodeContext innerContext = new ManagedToNativeStubCodeContext(targetFramework, targetFrameworkVersion, ReturnIdentifier, ReturnIdentifier);
+            NativeToManagedStubCodeContext innerContext = new NativeToManagedStubCodeContext(targetFramework, targetFrameworkVersion, ReturnIdentifier, ReturnIdentifier);
             _context = new JSExportCodeContext(attributeData, innerContext);
-            _marshallers = new BoundGenerators(argTypes, CreateGenerator);
+            _marshallers = new BoundGenerators(argTypes, CreateGenerator, extendedInvariantViolationsCallback);
             if (_marshallers.ManagedReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.ManagedReturnMarshaller.TypeInfo, null))
             {
                 // If we need a different native return identifier, then recreate the context with the correct identifier before we generate any code.
-                innerContext = new ManagedToNativeStubCodeContext(targetFramework, targetFrameworkVersion, ReturnIdentifier, ReturnNativeIdentifier);
+                innerContext = new NativeToManagedStubCodeContext(targetFramework, targetFrameworkVersion, ReturnIdentifier, ReturnNativeIdentifier);
                 _context = new JSExportCodeContext(attributeData, innerContext);
-                _marshallers = new BoundGenerators(argTypes, CreateGenerator);
+                _marshallers = new BoundGenerators(argTypes, CreateGenerator, extendedInvariantViolationsCallback);
             }
 
             // validate task + span mix
@@ -72,7 +74,7 @@ public BlockSyntax GenerateJSExportBody()
             StatementSyntax invoke = InvokeSyntax();
             GeneratedStatements statements = GeneratedStatements.Create(_marshallers, _context);
             bool shouldInitializeVariables = !statements.GuaranteedUnmarshal.IsEmpty || !statements.Cleanup.IsEmpty;
-            VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForManagedToNative(_marshallers, _context, shouldInitializeVariables);
+            VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForUnmanagedToManaged(_marshallers, _context, shouldInitializeVariables);
 
             var setupStatements = new List<StatementSyntax>();
             SetupSyntax(setupStatements);
@@ -222,7 +224,7 @@ private StatementSyntax InvokeSyntax()
 
         public (ParameterListSyntax ParameterList, TypeSyntax ReturnType, AttributeListSyntax? ReturnTypeAttributes) GenerateTargetMethodSignatureData()
         {
-            return _marshallers.GenerateTargetMethodSignatureData();
+            return _marshallers.GenerateTargetMethodSignatureData(_context);
         }
     }
 }

src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportCodeGenerator.cs

@@ -35,16 +35,18 @@ public JSImportCodeGenerator(
             Action<TypePositionInfo, MarshallingNotSupportedException> marshallingNotSupportedCallback,
             IMarshallingGeneratorFactory generatorFactory)
         {
+            Action<TypePositionInfo, string> extendedInvariantViolationsCallback = (info, details) =>
+                marshallingNotSupportedCallback(info, new MarshallingNotSupportedException(info, _context) { NotSupportedDetails = details });
             _signatureContext = signatureContext;
             ManagedToNativeStubCodeContext innerContext = new ManagedToNativeStubCodeContext(targetFramework, targetFrameworkVersion, ReturnIdentifier, ReturnIdentifier);
             _context = new JSImportCodeContext(attributeData, innerContext);
-            _marshallers = new BoundGenerators(argTypes, CreateGenerator);
+            _marshallers = new BoundGenerators(argTypes, CreateGenerator, extendedInvariantViolationsCallback);
             if (_marshallers.ManagedReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.ManagedReturnMarshaller.TypeInfo, null))
             {
                 // If we need a different native return identifier, then recreate the context with the correct identifier before we generate any code.
                 innerContext = new ManagedToNativeStubCodeContext(targetFramework, targetFrameworkVersion, ReturnIdentifier, ReturnNativeIdentifier);
                 _context = new JSImportCodeContext(attributeData, innerContext);
-                _marshallers = new BoundGenerators(argTypes, CreateGenerator);
+                _marshallers = new BoundGenerators(argTypes, CreateGenerator, extendedInvariantViolationsCallback);
             }
 
             // validate task + span mix
@@ -80,7 +82,7 @@ public BlockSyntax GenerateJSImportBody()
             StatementSyntax invoke = InvokeSyntax();
             GeneratedStatements statements = GeneratedStatements.Create(_marshallers, _context);
             bool shouldInitializeVariables = !statements.GuaranteedUnmarshal.IsEmpty || !statements.Cleanup.IsEmpty;
-            VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForManagedToNative(_marshallers, _context, shouldInitializeVariables);
+            VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForManagedToUnmanaged(_marshallers, _context, shouldInitializeVariables);
 
             var setupStatements = new List<StatementSyntax>();
             BindSyntax(setupStatements);
@@ -209,7 +211,7 @@ private StatementSyntax InvokeSyntax()
 
         public (ParameterListSyntax ParameterList, TypeSyntax ReturnType, AttributeListSyntax? ReturnTypeAttributes) GenerateTargetMethodSignatureData()
         {
-            return _marshallers.GenerateTargetMethodSignatureData();
+            return _marshallers.GenerateTargetMethodSignatureData(_context);
         }
     }
 }

src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/BaseJSGenerator.cs

@@ -22,7 +22,6 @@ protected BaseJSGenerator(MarshalerType marshalerType, IMarshallingGenerator inn
         }
 
         public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _inner.AsNativeType(info);
-        public ParameterSyntax AsParameter(TypePositionInfo info) => _inner.AsParameter(info);
         public bool IsSupported(TargetFramework target, Version version) => _inner.IsSupported(target, version);
         public virtual bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => _inner.UsesNativeIdentifier(info, context);
         public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => _inner.GetNativeSignatureBehavior(info);

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGenerator.csproj

@@ -21,6 +21,7 @@
     <None Include="$(TargetPath)" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
     <None Include="$(AssemblyName).props" Pack="true" PackagePath="build" />
     <Compile Include="..\Common\DefaultMarshallingInfoParser.cs" Link="Common\DefaultMarshallingInfoParser.cs" />
+    <Compile Include="..\..\tests\Common\ExceptionMarshalling.cs" Link="Common\ExceptionMarshalling.cs" />
   </ItemGroup>
 
   <ItemGroup>

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ManagedToNativeVTableMethodGenerator.cs

@@ -75,7 +75,7 @@ public ManagedToNativeVTableMethodGenerator(
             }
 
             _context = new ManagedToNativeStubCodeContext(targetFramework, targetFrameworkVersion, ReturnIdentifier, ReturnIdentifier);
-            _marshallers = new BoundGenerators(argTypes, CreateGenerator);
+            _marshallers = new BoundGenerators(argTypes, CreateGenerator, (info, details) => marshallingNotSupportedCallback(info, new MarshallingNotSupportedException(info, _context) {  NotSupportedDetails = details }));
 
             if (_marshallers.ManagedReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.ManagedReturnMarshaller.TypeInfo, _context))
             {

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnmanagedToManagedStubGenerator.cs

@@ -30,7 +30,7 @@ public UnmanagedToManagedStubGenerator(
             IMarshallingGeneratorFactory generatorFactory)
         {
             _context = new NativeToManagedStubCodeContext(targetFramework, targetFrameworkVersion, ReturnIdentifier, ReturnIdentifier);
-            _marshallers = new BoundGenerators(argTypes, CreateGenerator);
+            _marshallers = new BoundGenerators(argTypes, CreateGenerator, (info, details) => marshallingNotSupportedCallback(info, new MarshallingNotSupportedException(info, _context) { NotSupportedDetails = details }));
 
             if (_marshallers.ManagedReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.ManagedReturnMarshaller.TypeInfo, _context))
             {
@@ -60,14 +60,17 @@ IMarshallingGenerator CreateGenerator(TypePositionInfo p)
         /// <remarks>
         /// The generated code assumes it will be in an unsafe context.
         /// </remarks>
-        public BlockSyntax GenerateStubBody(ExpressionSyntax methodToInvoke, CatchClauseSyntax? catchClause)
+        public BlockSyntax GenerateStubBody(ExpressionSyntax methodToInvoke)
         {
             List<StatementSyntax> setupStatements = new();
             GeneratedStatements statements = GeneratedStatements.Create(
                 _marshallers,
                 _context,
                 methodToInvoke);
-            bool shouldInitializeVariables = !statements.GuaranteedUnmarshal.IsEmpty || !statements.Cleanup.IsEmpty;
+            bool shouldInitializeVariables =
+                !statements.GuaranteedUnmarshal.IsEmpty
+                || !statements.Cleanup.IsEmpty
+                || !statements.ManagedExceptionCatchClauses.IsEmpty;
             VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForUnmanagedToManaged(_marshallers, _context, shouldInitializeVariables);
 
             if (!statements.GuaranteedUnmarshal.IsEmpty)
@@ -102,23 +105,27 @@ public BlockSyntax GenerateStubBody(ExpressionSyntax methodToInvoke, CatchClause
                 finallyStatements.Add(IfStatement(IdentifierName(InvokeSucceededIdentifier), Block(statements.GuaranteedUnmarshal)));
             }
 
-            SyntaxList<CatchClauseSyntax> catchClauses = catchClause is not null ? SingletonList(catchClause) : default;
+            SyntaxList<CatchClauseSyntax> catchClauses = List(statements.ManagedExceptionCatchClauses);
 
             finallyStatements.AddRange(statements.Cleanup);
             if (finallyStatements.Count > 0)
             {
                 allStatements.Add(
                     TryStatement(Block(tryStatements), catchClauses, FinallyClause(Block(finallyStatements))));
             }
-            else
+            else if (catchClauses.Count > 0)
             {
                 allStatements.Add(
                     TryStatement(Block(tryStatements), catchClauses, @finally: null));
             }
+            else
+            {
+                allStatements.AddRange(tryStatements);
+            }
 
             // Return
             if (!_marshallers.IsUnmanagedVoidReturn)
-                allStatements.Add(ReturnStatement(IdentifierName(_context.GetIdentifiers(_marshallers.ManagedReturnMarshaller.TypeInfo).managed)));
+                allStatements.Add(ReturnStatement(IdentifierName(_context.GetIdentifiers(_marshallers.NativeReturnMarshaller.TypeInfo).native)));
 
             return Block(allStatements);
         }

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/VirtualMethodIndexData.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.CodeAnalysis;
+
 namespace Microsoft.Interop
 {
     /// <summary>
@@ -11,5 +13,8 @@ internal sealed record VirtualMethodIndexData(int Index) : InteropAttributeData
         public bool ImplicitThisParameter { get; init; }
 
         public MarshalDirection Direction { get; init; }
+
+        public ExceptionMarshalling ExceptionMarshalling { get; init; }
+        public INamedTypeSymbol? ExceptionMarshallingCustomType { get; init; }
     }
 }

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/VtableIndexStubGenerator.cs

@@ -26,7 +26,7 @@ internal sealed record IncrementalStubGenerationContext(
             MethodSignatureDiagnosticLocations DiagnosticLocation,
             SequenceEqualImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> CallingConvention,
             VirtualMethodIndexData VtableIndexData,
-            MarshallingGeneratorFactoryKey<(TargetFramework TargetFramework, Version TargetFrameworkVersion)> GeneratorFactory,
+            MarshallingInfo ExceptionMarshallingInfo,
             MarshallingGeneratorFactoryKey<(TargetFramework TargetFramework, Version TargetFrameworkVersion)> ManagedToUnmanagedGeneratorFactory,
             MarshallingGeneratorFactoryKey<(TargetFramework TargetFramework, Version TargetFrameworkVersion)> UnmanagedToManagedGeneratorFactory,
             ManagedTypeInfo TypeKeyType,
@@ -182,6 +182,8 @@ private static MethodDeclarationSyntax PrintGeneratedSource(
 
             MarshalDirection direction = MarshalDirection.Bidirectional;
             bool implicitThis = true;
+            ExceptionMarshalling exceptionMarshalling = ExceptionMarshalling.Custom;
+            INamedTypeSymbol? exceptionMarshallingCustomType = null;
             if (namedArguments.TryGetValue(nameof(VirtualMethodIndexData.Direction), out TypedConstant directionValue))
             {
                 // TypedConstant's Value property only contains primitive values.
@@ -200,11 +202,31 @@ private static MethodDeclarationSyntax PrintGeneratedSource(
                 }
                 implicitThis = (bool)implicitThisValue.Value!;
             }
+            if (namedArguments.TryGetValue(nameof(VirtualMethodIndexData.ExceptionMarshalling), out TypedConstant exceptionMarshallingValue))
+            {
+                // TypedConstant's Value property only contains primitive values.
+                if (exceptionMarshallingValue.Value is not int)
+                {
+                    return null;
+                }
+                // A boxed primitive can be unboxed to an enum with the same underlying type.
+                exceptionMarshalling = (ExceptionMarshalling)exceptionMarshallingValue.Value!;
+            }
+            if (namedArguments.TryGetValue(nameof(VirtualMethodIndexData.ExceptionMarshallingCustomType), out TypedConstant exceptionMarshallingCustomTypeValue))
+            {
+                if (exceptionMarshallingCustomTypeValue.Value is not INamedTypeSymbol)
+                {
+                    return null;
+                }
+                exceptionMarshallingCustomType = (INamedTypeSymbol)exceptionMarshallingCustomTypeValue.Value;
+            }
 
             return new VirtualMethodIndexData((int)attrData.ConstructorArguments[0].Value).WithValuesFromNamedArguments(namedArguments) with
             {
                 Direction = direction,
-                ImplicitThisParameter = implicitThis
+                ImplicitThisParameter = implicitThis,
+                ExceptionMarshalling = exceptionMarshalling,
+                ExceptionMarshallingCustomType = exceptionMarshallingCustomType,
             };
         }
 
@@ -307,21 +329,41 @@ private static IncrementalStubGenerationContext CalculateStubInformation(MethodD
                 typeKeyType = ManagedTypeInfo.CreateTypeInfoForTypeSymbol(iUnmanagedInterfaceTypeInstantiation.TypeArguments[1]);
             }
 
+            MarshallingInfo exceptionMarshallingInfo = CreateExceptionMarshallingInfo(virtualMethodIndexAttr, environment.Compilation, generatorDiagnostics, virtualMethodIndexData.ExceptionMarshalling, virtualMethodIndexData.ExceptionMarshallingCustomType);
+
             return new IncrementalStubGenerationContext(
                 signatureContext,
                 containingSyntaxContext,
                 methodSyntaxTemplate,
                 new MethodSignatureDiagnosticLocations(syntax),
                 new SequenceEqualImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax>(callConv, SyntaxEquivalentComparer.Instance),
                 virtualMethodIndexData,
-                ComInterfaceGeneratorHelpers.CreateGeneratorFactory(environment),
+                exceptionMarshallingInfo,
                 ComInterfaceGeneratorHelpers.CreateGeneratorFactory(environment, MarshalDirection.ManagedToUnmanaged),
                 ComInterfaceGeneratorHelpers.CreateGeneratorFactory(environment, MarshalDirection.UnmanagedToManaged),
                 typeKeyType,
                 typeKeyOwner,
                 new SequenceEqualImmutableArray<Diagnostic>(generatorDiagnostics.Diagnostics.ToImmutableArray()));
         }
 
+        private static MarshallingInfo CreateExceptionMarshallingInfo(AttributeData triggerAttribute, Compilation compilation, IGeneratorDiagnostics diagnostics, ExceptionMarshalling marshalling, INamedTypeSymbol? exceptionMarshallingCustomType)
+        {
+            if (marshalling == ExceptionMarshalling.Com)
+            {
+                return new ComExceptionMarshalling();
+            }
+            if (exceptionMarshallingCustomType is null)
+            {
+                return NoMarshallingInfo.Instance;
+            }
+            return CustomMarshallingInfoHelper.CreateNativeMarshallingInfoForNonSignatureElement(
+                    compilation.GetTypeByMetadataName(TypeNames.System_Exception),
+                    exceptionMarshallingCustomType,
+                    triggerAttribute,
+                    compilation,
+                    diagnostics);
+        }
+
         private static (MemberDeclarationSyntax, ImmutableArray<Diagnostic>) GenerateManagedToNativeStub(
             IncrementalStubGenerationContext methodStub)
         {
@@ -395,12 +437,10 @@ private static (MemberDeclarationSyntax, ImmutableArray<Diagnostic>) GenerateNat
                 },
                 methodStub.UnmanagedToManagedGeneratorFactory.GeneratorFactory);
 
-            // TODO: Implement our EH design based on the additional property on the attribute.
             BlockSyntax code = stubGenerator.GenerateStubBody(
                 MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                     IdentifierName(thisParameterIdentifier),
-                    IdentifierName(methodStub.StubMethodSyntaxTemplate.Identifier)),
-                catchClause: null);
+                    IdentifierName(methodStub.StubMethodSyntaxTemplate.Identifier)));
 
             (ParameterListSyntax unmanagedParameterList, TypeSyntax returnType, _) = stubGenerator.GenerateAbiMethodSignatureData();
 
@@ -414,7 +454,7 @@ private static (MemberDeclarationSyntax, ImmutableArray<Diagnostic>) GenerateNat
                         ImplicitArrayCreationExpression(
                             InitializerExpression(SyntaxKind.CollectionInitializerExpression,
                                 SeparatedList<ExpressionSyntax>(
-                                    methodStub.CallingConvention.Array.Select(callConv => TypeOfExpression(ParseName($"CallConv{callConv.Name.ValueText}")))))))
+                                    methodStub.CallingConvention.Array.Select(callConv => TypeOfExpression(ParseName($"System.Runtime.CompilerServices.CallConv{callConv.Name.ValueText}")))))))
                     .WithNameEquals(NameEquals(IdentifierName("CallConvs"))));
             }
 

src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs

@@ -120,7 +120,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo
                     mayRequireAdditionalWork = true;
                     return forwarder;
                 }
-            });
+            }, (info, details) => mayRequireAdditionalWork = true);
 
             if (anyExplicitlyUnsupportedInfo)
             {