Handle exceptions from managed callbacks.

Add tests.

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs

@@ -9,6 +9,7 @@
 using System.Reflection;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Text;
 
 namespace System.Runtime.InteropServices
@@ -40,6 +41,8 @@ public LazyProxyTypeDictionary ProxyTypeMap
                     return _proxyTypeMap;
                 }
             }
+
+            public ExceptionDispatchInfo? CreationException { get; set; }
         }
 
         // See assemblynative.hpp for native version.
@@ -77,18 +80,25 @@ private static unsafe void NewExternalTypeEntry(CallbackContext* context, Proces
             Debug.Assert(arg->Utf8String1 != null);
             Debug.Assert(arg->Utf8String2 != null);
 
-            string externalTypeName = new((sbyte*)arg->Utf8String1, 0, arg->StringLen1, Encoding.UTF8);
-            string targetType = new((sbyte*)arg->Utf8String2, 0, arg->StringLen2, Encoding.UTF8);
+            try
+            {
+                string externalTypeName = new((sbyte*)arg->Utf8String1, 0, arg->StringLen1, Encoding.UTF8);
+                string targetType = new((sbyte*)arg->Utf8String2, 0, arg->StringLen2, Encoding.UTF8);
 
-            TypeName parsedTarget = TypeNameParser.Parse(targetType, throwOnError: true)!;
-            if (parsedTarget.AssemblyName is null)
+                TypeName parsedTarget = TypeNameParser.Parse(targetType, throwOnError: true)!;
+                if (parsedTarget.AssemblyName is null)
+                {
+                    // The assembly name is not included in the type name, so use the fallback assembly name.
+                    Debug.Assert(arg->Utf8String3 != null);
+                    string fallbackAssemblyName = new((sbyte*)arg->Utf8String3, 0, arg->StringLen3, Encoding.UTF8);
+                    parsedTarget = CreateNewTypeName(targetType, fallbackAssemblyName);
+                }
+                context->ExternalTypeMap.Add(externalTypeName, parsedTarget);
+            }
+            catch (Exception ex)
             {
-                // The assembly name is not included in the type name, so use the fallback assembly name.
-                Debug.Assert(arg->Utf8String3 != null);
-                string fallbackAssemblyName = new((sbyte*)arg->Utf8String3, 0, arg->StringLen3, Encoding.UTF8);
-                parsedTarget = CreateNewTypeName(targetType, fallbackAssemblyName);
+                context->CreationException = ExceptionDispatchInfo.Capture(ex);
             }
-            context->ExternalTypeMap.Add(externalTypeName, parsedTarget);
         }
 
         [UnmanagedCallersOnly]
@@ -99,26 +109,33 @@ private static unsafe void NewProxyTypeEntry(CallbackContext* context, ProcessAt
             Debug.Assert(arg->Utf8String1 != null);
             Debug.Assert(arg->Utf8String2 != null);
 
-            string sourceType = new((sbyte*)arg->Utf8String1, 0, arg->StringLen1, Encoding.UTF8);
-            string proxyType = new((sbyte*)arg->Utf8String2, 0, arg->StringLen2, Encoding.UTF8);
-
-            TypeName parsedSource = TypeNameParser.Parse(sourceType, throwOnError: true)!;
-            TypeName parsedProxy = TypeNameParser.Parse(proxyType, throwOnError: true)!;
-            if (parsedSource.AssemblyName is null || parsedProxy.AssemblyName is null)
+            try
             {
-                // The assembly name is not included in the type name, so use the fallback assembly name.
-                Debug.Assert(arg->Utf8String3 != null);
-                string fallbackAssemblyName = new((sbyte*)arg->Utf8String3, 0, arg->StringLen3, Encoding.UTF8);
-                if (parsedSource.AssemblyName is null)
-                {
-                    parsedSource = CreateNewTypeName(sourceType, fallbackAssemblyName);
-                }
-                if (parsedProxy.AssemblyName is null)
+                string sourceType = new((sbyte*)arg->Utf8String1, 0, arg->StringLen1, Encoding.UTF8);
+                string proxyType = new((sbyte*)arg->Utf8String2, 0, arg->StringLen2, Encoding.UTF8);
+
+                TypeName parsedSource = TypeNameParser.Parse(sourceType, throwOnError: true)!;
+                TypeName parsedProxy = TypeNameParser.Parse(proxyType, throwOnError: true)!;
+                if (parsedSource.AssemblyName is null || parsedProxy.AssemblyName is null)
                 {
-                    parsedProxy = CreateNewTypeName(proxyType, fallbackAssemblyName);
+                    // The assembly name is not included in the type name, so use the fallback assembly name.
+                    Debug.Assert(arg->Utf8String3 != null);
+                    string fallbackAssemblyName = new((sbyte*)arg->Utf8String3, 0, arg->StringLen3, Encoding.UTF8);
+                    if (parsedSource.AssemblyName is null)
+                    {
+                        parsedSource = CreateNewTypeName(sourceType, fallbackAssemblyName);
+                    }
+                    if (parsedProxy.AssemblyName is null)
+                    {
+                        parsedProxy = CreateNewTypeName(proxyType, fallbackAssemblyName);
+                    }
                 }
+                context->ProxyTypeMap.Add(parsedSource, parsedProxy);
+            }
+            catch (Exception ex)
+            {
+                context->CreationException = ExceptionDispatchInfo.Capture(ex);
             }
-            context->ProxyTypeMap.Add(parsedSource, parsedProxy);
         }
 
         private static unsafe CallbackContext CreateMaps(
@@ -139,6 +156,9 @@ private static unsafe CallbackContext CreateMaps(
                 newExternalTypeEntry,
                 newProxyTypeEntry,
                 &context);
+
+            context.CreationException?.Throw();
+
             return context;
         }
 

src/tests/Interop/TypeMap/GroupTypes.cs

@@ -19,10 +19,8 @@ public class TypicalUseCase { }
 
 public class DuplicateTypeNameKey { }
 
+public class InvalidTypeNameKey { }
+
 public class MultipleTypeMapAssemblies { }
 
 public class UnknownAssemblyReference { }
-
-public class InvalidExternalTypeName { } // TypeMapAttribute
-
-public class InvalidSourceTypeName { } // TypeMapAssociationAttribute

src/tests/Interop/TypeMap/TypeMapApp.cs

@@ -50,8 +50,11 @@
 [assembly: TypeMapAssociation<C2<string>.I1>(typeof(object), typeof(string))]
 [assembly: TypeMapAssociation<C2<string>.I2<string>>(typeof(object), typeof(string))]
 
-[assembly: TypeMap<InvalidExternalTypeName>(null!, typeof(object))]
-[assembly: TypeMapAssociation<InvalidSourceTypeName>(null!, typeof(object))]
+[assembly: TypeMap<InvalidTypeNameKey>(null!, typeof(object))]
+[assembly: TypeMapAssociation<InvalidTypeNameKey>(null!, typeof(object))]
+
+[assembly: TypeMap<DuplicateTypeNameKey>("1", typeof(object))]
+[assembly: TypeMap<DuplicateTypeNameKey>("1", typeof(object))]
 
 [assembly: TypeMapAssociation<DuplicateTypeNameKey>(typeof(DupType_MapObject), typeof(object))]
 [assembly: TypeMapAssociation<DuplicateTypeNameKey>(typeof(DupType_MapString), typeof(string))]
@@ -148,6 +151,14 @@ public static void Validate_ProxyTypeMapping()
         Assert.False(map.TryGetValue(typeof(object), out Type? _));
     }
 
+    [Fact]
+    public static void Validate_ExternalTypeMapping_DuplicateTypeKey()
+    {
+        Console.WriteLine(nameof(Validate_ExternalTypeMapping_DuplicateTypeKey));
+
+        Assert.Throws<ArgumentException>(() => TypeMapping.GetOrCreateExternalTypeMapping<DuplicateTypeNameKey>());
+    }
+
     [Fact]
     public static void Validate_ProxyTypeMapping_DuplicateTypeKey()
     {
@@ -225,7 +236,7 @@ public static void Validate_EmptyOrInvalidMappings()
     {
         Console.WriteLine(nameof(Validate_EmptyOrInvalidMappings));
 
-        Assert.Throws<COMException>(() => TypeMapping.GetOrCreateExternalTypeMapping<InvalidExternalTypeName>());
-        Assert.Throws<COMException>(() => TypeMapping.GetOrCreateProxyTypeMapping<InvalidSourceTypeName>());
+        Assert.Throws<COMException>(() => TypeMapping.GetOrCreateExternalTypeMapping<InvalidTypeNameKey>());
+        Assert.Throws<COMException>(() => TypeMapping.GetOrCreateProxyTypeMapping<InvalidTypeNameKey>());
     }
 }