Allow ExternalTypeMap to have duplicates entries with identical mapping but different trimTarget

src/coreclr/tools/Common/Compiler/TypeMapMetadata.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection.Metadata;
 using ILCompiler.DependencyAnalysis;
 using Internal.Text;
@@ -41,7 +42,7 @@ private static TypeMapAttributeKind LookupTypeMapType(TypeDesc attrType)
 
         internal interface IExternalTypeMap
         {
-            IReadOnlyDictionary<string, (TypeDesc type, TypeDesc trimmingType)> TypeMap { get; }
+            IReadOnlyDictionary<string, (TypeDesc type, List<TypeDesc> trimmingTargets)> TypeMap { get; }
             MethodDesc ThrowingMethodStub { get; }
         }
 
@@ -96,7 +97,7 @@ protected override int CompareToImpl(MethodDesc other, TypeSystemComparer compar
             }
 
             private readonly Dictionary<TypeDesc, TypeDesc> _associatedTypeMap = [];
-            private readonly Dictionary<string, (TypeDesc type, TypeDesc trimmingTarget)> _externalTypeMap = [];
+            private readonly Dictionary<string, (TypeDesc type, List<TypeDesc> trimmingTargets)> _externalTypeMap = [];
             private readonly List<ModuleDesc> _targetModules = [];
             private ThrowingMethodStub _externalTypeMapExceptionStub;
             private ThrowingMethodStub _associatedTypeMapExceptionStub;
@@ -125,9 +126,21 @@ public void AddAssociatedTypeMapEntry(TypeDesc type, TypeDesc associatedType)
             }
             public void AddExternalTypeMapEntry(string typeName, TypeDesc type, TypeDesc trimmingTarget)
             {
-                if (!_externalTypeMap.TryAdd(typeName, (type, trimmingTarget)))
+                if (_externalTypeMap.TryGetValue(typeName, out var currentValue))
                 {
-                    ThrowHelper.ThrowBadImageFormatException();
+                    if (currentValue.type != type)
+                    {
+                        // Conflicting type map entry
+                        ThrowHelper.ThrowBadImageFormatException();
+                    }
+                    else
+                    {
+                        currentValue.trimmingTargets.Add(trimmingTarget);
+                    }
+                }
+                else
+                {
+                    _externalTypeMap[typeName] = (type, [trimmingTarget]);
                 }
             }
 
@@ -195,9 +208,12 @@ public void MergePendingMap(ModuleDesc stubModule, Map pendingMap)
                     {
                         try
                         {
-                            foreach (KeyValuePair<string, (TypeDesc type, TypeDesc trimmingTarget)> kvp in pendingMap._externalTypeMap)
+                            foreach (KeyValuePair<string, (TypeDesc type, List<TypeDesc> trimmingTargets)> kvp in pendingMap._externalTypeMap)
                             {
-                                AddExternalTypeMapEntry(kvp.Key, kvp.Value.type, kvp.Value.trimmingTarget);
+                                foreach (TypeDesc trimmingTarget in kvp.Value.trimmingTargets)
+                                {
+                                    AddExternalTypeMapEntry(kvp.Key, kvp.Value.type, trimmingTarget);
+                                }
                             }
                         }
                         catch (TypeSystemException ex)
@@ -227,7 +243,7 @@ public void AddTargetModule(ModuleDesc targetModule)
             /// </summary>
             public IReadOnlyList<ModuleDesc> TargetModules => _targetModules;
 
-            IReadOnlyDictionary<string, (TypeDesc type, TypeDesc trimmingType)> IExternalTypeMap.TypeMap => _externalTypeMap;
+            IReadOnlyDictionary<string, (TypeDesc type, List<TypeDesc> trimmingTargets)> IExternalTypeMap.TypeMap => _externalTypeMap;
 
             MethodDesc IExternalTypeMap.ThrowingMethodStub => _externalTypeMapExceptionStub;
 

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternalTypeMapNode.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
@@ -13,9 +13,9 @@ namespace ILCompiler.DependencyAnalysis
 {
     internal sealed class ExternalTypeMapNode : SortableDependencyNode, IExternalTypeMapNode
     {
-        private readonly IEnumerable<KeyValuePair<string, (TypeDesc targetType, TypeDesc trimmingTargetType)>> _mapEntries;
+        private readonly IEnumerable<KeyValuePair<string, (TypeDesc targetType, List<TypeDesc> trimmingTargetTypes)>> _mapEntries;
 
-        public ExternalTypeMapNode(TypeDesc typeMapGroup, IEnumerable<KeyValuePair<string, (TypeDesc targetType, TypeDesc trimmingTargetType)>> mapEntries)
+        public ExternalTypeMapNode(TypeDesc typeMapGroup, IEnumerable<KeyValuePair<string, (TypeDesc targetType, List<TypeDesc> trimmingTargetTypes)>> mapEntries)
         {
             _mapEntries = mapEntries;
             TypeMapGroup = typeMapGroup;
@@ -37,8 +37,19 @@ public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDep
 
             foreach (var entry in _mapEntries)
             {
-                var (targetType, trimmingTargetType) = entry.Value;
-                if (trimmingTargetType is not null)
+                var (targetType, trimmingTargetTypes) = entry.Value;
+                bool unconditional = false;
+                foreach (var trimTarget in trimmingTargetTypes)
+                {
+                    if (trimTarget is null)
+                    {
+                        unconditional = true;
+                        break;
+                    }
+                }
+                if (unconditional)
+                    continue;
+                foreach (var trimmingTargetType in trimmingTargetTypes)
                 {
                     IEETypeNode effectiveTrimTargetType = GetEffectiveTrimTargetType(context, trimmingTargetType);
 
@@ -58,12 +69,16 @@ public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFacto
         {
             foreach (var entry in _mapEntries)
             {
-                var (targetType, trimmingTargetType) = entry.Value;
-                if (trimmingTargetType is null)
+                var (targetType, trimmingTargetTypes) = entry.Value;
+                foreach (var trimTarget in trimmingTargetTypes)
                 {
-                    yield return new DependencyListEntry(
-                        context.MetadataTypeSymbol(targetType),
-                        "External type map entry target type");
+                    if (trimTarget is null)
+                    {
+                        yield return new DependencyListEntry(
+                            context.MetadataTypeSymbol(targetType),
+                            "External type map entry target type");
+                        break;
+                    }
                 }
             }
         }
@@ -83,14 +98,18 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer
         {
             foreach (var entry in _mapEntries)
             {
-                var (targetType, trimmingTargetType) = entry.Value;
+                var (targetType, trimmingTargetTypes) = entry.Value;
 
-                if (trimmingTargetType is null
-                    || GetEffectiveTrimTargetType(factory, trimmingTargetType).Marked)
+                foreach (var trimmingTargetType in trimmingTargetTypes)
                 {
-                    IEETypeNode targetNode = factory.MetadataTypeSymbol(targetType);
-                    Debug.Assert(targetNode.Marked);
-                    yield return (entry.Key, targetNode);
+                    if (trimmingTargetType is null
+                        || GetEffectiveTrimTargetType(factory, trimmingTargetType).Marked)
+                    {
+                        IEETypeNode targetNode = factory.MetadataTypeSymbol(targetType);
+                        Debug.Assert(targetNode.Marked);
+                        yield return (entry.Key, targetNode);
+                        break;
+                    }
                 }
             }
         }

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

@@ -359,6 +359,13 @@ private unsafe struct TypeNameUtf8
         {
             public required void* Utf8TypeName { get; init; }
             public required int Utf8TypeNameLen { get; init; }
+
+            public bool Equals(TypeNameUtf8 other)
+            {
+                ReadOnlySpan<byte> thisSpan = new ReadOnlySpan<byte>(Utf8TypeName, Utf8TypeNameLen);
+                ReadOnlySpan<byte> otherSpan = new ReadOnlySpan<byte>(other.Utf8TypeName, other.Utf8TypeNameLen);
+                return thisSpan.SequenceEqual(otherSpan);
+            }
         }
 
         [RequiresUnreferencedCode("Lazy TypeMap isn't supported for Trimmer scenarios")]
@@ -376,6 +383,8 @@ public DelayedType(TypeNameUtf8 typeNameUtf8, RuntimeAssembly fallbackAssembly)
                 _type = null;
             }
 
+            public TypeNameUtf8 TypeName => _typeNameUtf8;
+
             public unsafe Type GetOrLoadType()
             {
                 if (_type is null)
@@ -429,9 +438,15 @@ public LazyExternalTypeDictionary(RuntimeType groupType) : base(groupType)
 
             public void Add(string key, TypeNameUtf8 targetType, RuntimeAssembly fallbackAssembly)
             {
-                if (_lazyData.ContainsKey(key))
+                // Allow duplicates that have the same string -> mapping. They may have different trimTargets.
+                // Only throw if the mapping conflicts with an existing mapping.
+                if (_lazyData.TryGetValue(key, out DelayedType? existing))
                 {
-                    ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
+                    if (!existing.TypeName.Equals(targetType))
+                    {
+                        ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
+                    }
+                    return;
                 }
 
                 // Check if any of the pre-cached dictionaries have an entry for this key.

src/libraries/System.Runtime.InteropServices/tests/TrimmingTests/TypeMap.cs

@@ -8,6 +8,8 @@
 
 [assembly: TypeMap<UsedTypeMap>("TrimTargetIsTarget", typeof(TargetAndTrimTarget), typeof(TargetAndTrimTarget))]
 [assembly: TypeMap<UsedTypeMap>("TrimTargetIsUnrelated", typeof(TargetType), typeof(TrimTarget))]
+[assembly: TypeMap<UsedTypeMap>("DuplicateMappingWithDifferentTrimTargets", typeof(TargetType2), typeof(TrimTarget2))]
+[assembly: TypeMap<UsedTypeMap>("DuplicateMappingWithDifferentTrimTargets", typeof(TargetType2), typeof(TrimTarget3))]
 [assembly: TypeMap<UsedTypeMap>("TrimTargetIsUnreferenced", typeof(UnreferencedTargetType), typeof(UnreferencedTrimTarget))]
 [assembly: TypeMapAssociation<UsedTypeMap>(typeof(SourceClass), typeof(ProxyType))]
 
@@ -27,6 +29,14 @@
     {
         Console.WriteLine("Type deriving from TrimTarget instantiated.");
     }
+    else if (t is TrimTarget2)
+    {
+        Console.WriteLine("Type deriving from TrimTarget2 instantiated.");
+    }
+    else if (t is TrimTarget3)
+    {
+        Console.WriteLine("Type deriving from TrimTarget3 instantiated.");
+    }
 
     Console.WriteLine("Hash code of SourceClass instance: " + new SourceClass().GetHashCode());
     return -1;
@@ -95,6 +105,12 @@
     return 10;
 }
 
+if (!usedTypeMap.TryGetValue("DuplicateMappingWithDifferentTrimTargets", out Type duplicatedTarget))
+{
+    Console.WriteLine("Could not find duplicated target type");
+    return 11;
+}
+
 return 100;
 
 [MethodImpl(MethodImplOptions.NoInlining)]
@@ -106,7 +122,10 @@ static Type GetTypeWithoutTrimAnalysis(string typeName)
 class UsedTypeMap;
 class TargetAndTrimTarget;
 class TargetType;
+class TargetType2;
 class TrimTarget;
+class TrimTarget2;
+class TrimTarget3;
 class UnreferencedTargetType;
 class UnreferencedTrimTarget;
 class SourceClass;

src/tests/Interop/TypeMap/GroupTypes.cs

@@ -17,7 +17,9 @@ public class I2<U> {}
 
 public class TypicalUseCase { }
 
-public class DuplicateTypeNameKey { }
+public class ValidDuplicateTypeNameKey { }
+
+public class InvalidDuplicateTypeNameKey { }
 
 public class InvalidTypeNameKey { }
 

src/tests/Interop/TypeMap/TypeMapApp.cs

@@ -63,14 +63,17 @@
 [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: TypeMap<ValidDuplicateTypeNameKey>("1", typeof(object))]
+[assembly: TypeMap<ValidDuplicateTypeNameKey>("1", typeof(object), typeof(object))]
+[assembly: TypeMap<ValidDuplicateTypeNameKey>("1", typeof(object), typeof(string))]
 
-[assembly: TypeMap<DuplicateTypeMapEntriesAcrossAssemblies>("1", typeof(object))]
+[assembly: TypeMap<InvalidDuplicateTypeNameKey>("1", typeof(object))]
+[assembly: TypeMap<InvalidDuplicateTypeNameKey>("1", typeof(string))]
 
+[assembly: TypeMap<DuplicateTypeMapEntriesAcrossAssemblies>("1", typeof(object))]
 
-[assembly: TypeMapAssociation<DuplicateTypeNameKey>(typeof(DupType_MapObject), typeof(object))]
-[assembly: TypeMapAssociation<DuplicateTypeNameKey>(typeof(DupType_MapString), typeof(string))]
+[assembly: TypeMapAssociation<InvalidDuplicateTypeNameKey>(typeof(DupType_MapObject), typeof(object))]
+[assembly: TypeMapAssociation<InvalidDuplicateTypeNameKey>(typeof(DupType_MapString), typeof(string))]
 
 // Redefine the same type as in the TypeMapLib2 assembly
 // This is testing the duplicate type name key for the
@@ -184,21 +187,30 @@ public static void Validate_ProxyTypeMapping()
     }
 
     [Fact]
-    public static void Validate_ExternalTypeMapping_DuplicateTypeKey()
+    public static void Validate_ExternalTypeMapping_InvalidDuplicateTypeKey()
     {
-        Console.WriteLine(nameof(Validate_ExternalTypeMapping_DuplicateTypeKey));
+        Console.WriteLine(nameof(Validate_ExternalTypeMapping_InvalidDuplicateTypeKey));
 
-        AssertExtensions.ThrowsAny<ArgumentException, BadImageFormatException>(() => TypeMapping.GetOrCreateExternalTypeMapping<DuplicateTypeNameKey>());
+        AssertExtensions.ThrowsAny<ArgumentException, BadImageFormatException>(() => TypeMapping.GetOrCreateExternalTypeMapping<InvalidDuplicateTypeNameKey>());
 
         AssertExtensions.ThrowsAny<ArgumentException, BadImageFormatException>(() => TypeMapping.GetOrCreateExternalTypeMapping<DuplicateTypeMapEntriesAcrossAssemblies>());
     }
 
+    [Fact]
+    public static void Validate_ExternalTypeMapping_ValidDuplicateTypeKey()
+    {
+        Console.WriteLine(nameof(Validate_ExternalTypeMapping_ValidDuplicateTypeKey));
+
+        var mapping = TypeMapping.GetOrCreateExternalTypeMapping<ValidDuplicateTypeNameKey>();
+        Assert.Equal(typeof(object), mapping["1"]);
+    }
     [Fact]
     public static void Validate_ProxyTypeMapping_DuplicateTypeKey()
     {
         Console.WriteLine(nameof(Validate_ProxyTypeMapping_DuplicateTypeKey));
 
-        IReadOnlyDictionary<Type, Type> map = TypeMapping.GetOrCreateProxyTypeMapping<DuplicateTypeNameKey>();
+        // Invalid external mapping shouldn't impact proxy mapping
+        IReadOnlyDictionary<Type, Type> map = TypeMapping.GetOrCreateProxyTypeMapping<InvalidDuplicateTypeNameKey>();
 
         Assert.Equal(typeof(object), map[new DupType_MapObject().GetType()]);
         Assert.Equal(typeof(string), map[new DupType_MapString().GetType()]);