Implement trimming support for the Interop Type Map

src/coreclr/tools/Common/Compiler/Dataflow/MethodProxy.cs

@@ -49,6 +49,7 @@ internal partial ParameterProxy GetParameter(ParameterIndex index)
         internal partial bool HasGenericParameters() => Method.HasInstantiation;
 
         internal partial bool HasGenericParametersCount(int genericParameterCount) => Method.Instantiation.Length == genericParameterCount;
+        internal partial bool HasGenericArgumentsCount(int genericArgumentCount) => Method.Instantiation.Length == genericArgumentCount;
 
         internal partial ImmutableArray<GenericParameterProxy> GetGenericParameters()
         {

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

@@ -118,9 +118,6 @@ private static void AddDependenciesDueToCustomAttributes(ref DependencyList depe
                 {
                     MethodDesc constructor = module.GetMethod(attribute.Constructor);
 
-                    if (TypeMapManager.LookupTypeMapType(constructor.OwningType) != TypeMapManager.TypeMapAttributeKind.None)
-                        continue;
-
                     if (!mdManager.GeneratesAttributeMetadata(constructor.OwningType))
                         continue;
 

src/libraries/System.Private.CoreLib/src/ILLink/ILLink.LinkAttributes.Shared.xml

@@ -1,4 +1,16 @@
 <linker>
+  <!-- Type Map attributes will be preserved by NativeAOT or the trimmer when necessary. -->
+  <assembly fullname="*">
+    <type fullname="System.Runtime.InteropServices.TypeMapAttribute`1">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="System.Runtime.InteropServices.TypeMapAssociationAttribute`1">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="System.Runtime.InteropServices.TypeMapAssemblyTargetAttribute`1">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+  </assembly>
   <!-- The following attributes are only necessary when debugging is supported -->
   <assembly fullname="System.Private.CoreLib" feature="System.Diagnostics.Debugger.IsSupported" featurevalue="false">
     <type fullname="System.Diagnostics.DebuggableAttribute">

src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/MethodProxy.cs

@@ -33,6 +33,8 @@ internal readonly partial struct MethodProxy
 
 		internal partial bool HasGenericParametersCount (int genericParameterCount) => Method.TypeParameters.Length == genericParameterCount;
 
+		internal partial bool HasGenericArgumentsCount (int genericArgumentCount) => Method.TypeArguments.Length == genericArgumentCount;
+
 		internal partial ImmutableArray<GenericParameterProxy> GetGenericParameters ()
 		{
 			if (Method.TypeParameters.IsEmpty)

src/tools/illink/src/ILLink.Shared/TrimAnalysis/Intrinsics.cs

@@ -421,13 +421,13 @@ public static IntrinsicId GetIntrinsicIdForMethod (MethodProxy calledMethod)
 				// static System.Runtime.InteropServices.TypeMapping.GetOrCreateExternalTypeMapping<T> ()
 				"GetOrCreateExternalTypeMapping" when calledMethod.IsDeclaredOnType ("System.Runtime.InteropServices.TypeMapping")
 					&& calledMethod.IsStatic ()
-					&& calledMethod.HasGenericParametersCount (1)
+					&& calledMethod.HasGenericArgumentsCount (1)
 					=> IntrinsicId.TypeMapping_GetOrCreateExternalTypeMapping,
 
 				// static System.Runtime.InteropServices.TypeMapping.GetOrCreateProxyTypeMapping<T> ()
 				"GetOrCreateProxyTypeMapping" when calledMethod.IsDeclaredOnType ("System.Runtime.InteropServices.TypeMapping")
 					&& calledMethod.IsStatic ()
-					&& calledMethod.HasGenericParametersCount (1)
+					&& calledMethod.HasGenericArgumentsCount (1)
 					=> IntrinsicId.TypeMapping_GetOrCreateProxyTypeMapping,
 
 				_ => IntrinsicId.None,

src/tools/illink/src/ILLink.Shared/TypeSystemProxy/MethodProxy.cs

@@ -56,6 +56,7 @@ internal bool HasParameterOfType (ParameterIndex parameterIndex, string fullType
 		internal partial bool HasGenericParameters ();
 		internal partial bool HasGenericParametersCount (int genericParameterCount);
 		internal partial ImmutableArray<GenericParameterProxy> GetGenericParameters ();
+		internal partial bool HasGenericArgumentsCount (int genericArgumentCount);
 		internal partial bool IsConstructor ();
 		internal partial bool IsStatic ();
 		internal partial bool HasImplicitThis ();

src/tools/illink/src/linker/Linker.Dataflow/HandleCallAction.cs

@@ -175,6 +175,22 @@ private partial bool TryHandleIntrinsic (
 				}
 				break;
 
+			case IntrinsicId.TypeMapping_GetOrCreateExternalTypeMapping:
+			case IntrinsicId.TypeMapping_GetOrCreateProxyTypeMapping: {
+				GenericInstanceMethod method = ((GenericInstanceMethod) calledMethod.Method);
+				if (method.GenericArguments[0].ContainsGenericParameter) {
+					_diagnosticContext.AddDiagnostic (DiagnosticId.TypeMapGroupTypeCannotBeStaticallyDetermined, method.GenericArguments[0].FullName);
+					return true;
+				}
+
+				if (intrinsicId == IntrinsicId.TypeMapping_GetOrCreateExternalTypeMapping) {
+					_markStep.TypeMapHandler.ProcessExternalTypeMapGroupSeen (_callingMethodDefinition, method.GenericArguments[0]);
+				} else {
+					_markStep.TypeMapHandler.ProcessProxyTypeMapGroupSeen (_callingMethodDefinition, method.GenericArguments[0]);
+				}
+			}
+			break;
+
 			// Note about Activator.CreateInstance<T>
 			// There are 2 interesting cases:
 			//  - The generic argument for T is either specific type or annotated - in that case generic instantiation will handle this

src/tools/illink/src/linker/Linker.Dataflow/MethodProxy.cs

@@ -67,6 +67,8 @@ internal partial ParameterProxyEnumerable GetParameters ()
 
 		internal partial bool HasGenericParametersCount (int genericParameterCount) => Method.GenericParameters.Count == genericParameterCount;
 
+		internal partial bool HasGenericArgumentsCount (int genericArgumentCount) => Method is GenericInstanceMethod generic && generic.GenericArguments.Count == genericArgumentCount;
+
 		internal partial ImmutableArray<GenericParameterProxy> GetGenericParameters ()
 		{
 			if (!Method.HasGenericParameters)

src/tools/illink/src/linker/Linker.Steps/MarkStep.cs

@@ -73,6 +73,8 @@ protected LinkContext Context {
 		// method body scanner.
 		readonly Dictionary<MethodBody, bool> _compilerGeneratedMethodRequiresScanner;
 
+		TypeMapHandler _typeMapHandler;
+
 		MarkStepContext? _markContext;
 		MarkStepContext MarkContext {
 			get {
@@ -90,6 +92,8 @@ internal DynamicallyAccessedMembersTypeHierarchy DynamicallyAccessedMembersTypeH
 			}
 		}
 
+		internal TypeMapHandler TypeMapHandler => _typeMapHandler;
+
 #if DEBUG
 		static readonly DependencyKind[] _entireTypeReasons = new DependencyKind[] {
 			DependencyKind.AccessedViaReflection,
@@ -221,6 +225,7 @@ public MarkStep ()
 			_pending_isinst_instr = new List<(TypeDefinition, MethodBody, Instruction)> ();
 			_entireTypesMarked = new HashSet<TypeDefinition> ();
 			_compilerGeneratedMethodRequiresScanner = new Dictionary<MethodBody, bool> ();
+			_typeMapHandler = new TypeMapHandler ();
 		}
 
 		public AnnotationStore Annotations => Context.Annotations;
@@ -244,6 +249,12 @@ protected virtual void Initialize ()
 			InitializeCorelibAttributeXml ();
 			Context.Pipeline.InitializeMarkHandlers (Context, MarkContext);
 
+			if (Annotations.GetEntryPointAssembly() is AssemblyDefinition entryPoint) {
+				_typeMapHandler = new TypeMapHandler (entryPoint);
+			}
+
+			_typeMapHandler.Initialize (Context, this);
+
 			ProcessMarkedPending ();
 		}
 
@@ -1059,7 +1070,7 @@ void LazyMarkCustomAttributes (ICustomAttributeProvider provider)
 			}
 		}
 
-		protected virtual void MarkCustomAttribute (CustomAttribute ca, in DependencyInfo reason, MessageOrigin origin)
+		protected internal virtual void MarkCustomAttribute (CustomAttribute ca, in DependencyInfo reason, MessageOrigin origin)
 		{
 			Annotations.Mark (ca, reason);
 			MarkMethod (ca.Constructor, new DependencyInfo (DependencyKind.AttributeConstructor, ca), origin);
@@ -1918,6 +1929,8 @@ internal void MarkStaticConstructorVisibleToReflection (TypeDefinition type, in
 				break;
 			}
 
+			_typeMapHandler.ProcessType (type);
+
 			// Treat cctors triggered by a called method specially and mark this case up-front.
 			if (type.HasMethods && ShouldMarkTypeStaticConstructor (type) && reason.Kind == DependencyKind.DeclaringTypeOfCalledMethod)
 				MarkStaticConstructor (type, new DependencyInfo (DependencyKind.TriggersCctorForCalledMethod, reason.Source), origin);
@@ -1929,8 +1942,11 @@ internal void MarkStaticConstructorVisibleToReflection (TypeDefinition type, in
 				// or because of a copy assembly with a reference and so on) then we should not spam the warnings due to the type itself.
 				// Also don't warn when the type is marked due to an assembly being rooted.
 				if (!(reason.Source is IMemberDefinition sourceMemberDefinition && sourceMemberDefinition.DeclaringType == type) &&
-					reason.Kind is not DependencyKind.TypeInAssembly)
-					Context.LogWarning (origin, DiagnosticId.AttributeIsReferencedButTrimmerRemoveAllInstances, type.GetDisplayName ());
+					reason.Kind is not DependencyKind.TypeInAssembly) {
+					// Don't warn for type map attribute types. They're marked as "remove attributes" but we explicitly keep the ones needed.
+					if (type is not { Namespace: "System.Runtime.InteropServices", Name: "TypeMapAttribute`1" or "TypeMapAssociationAttribute`1" or "TypeMapAssemblyTargetAttribute`1"})
+						Context.LogWarning (origin, DiagnosticId.AttributeIsReferencedButTrimmerRemoveAllInstances, type.GetDisplayName ());
+				}
 			}
 
 			if (CheckProcessed (type))
@@ -3233,6 +3249,8 @@ protected virtual void MarkRequirementsForInstantiatedTypes (TypeDefinition type
 
 			MarkImplicitlyUsedFields (type, typeOrigin);
 
+			_typeMapHandler.ProcessInstantiated (type);
+
 			DoAdditionalInstantiatedTypeProcessing (type);
 		}
 
@@ -3668,6 +3686,8 @@ protected virtual void MarkInstruction (Instruction instruction, MethodDefinitio
 					if (type.IsInterface)
 						break;
 
+					_typeMapHandler.ProcessType (type);
+
 					if (!Annotations.IsInstantiated (type)) {
 						_pending_isinst_instr.Add ((type, method.Body, instruction));
 						return;

src/tools/illink/src/linker/Linker.Steps/RootAssemblyInputStep.cs

@@ -51,6 +51,7 @@ protected override void Process ()
 
 				Annotations.Mark (ep.DeclaringType, di, origin);
 				Annotations.AddPreservedMethod (ep.DeclaringType, ep);
+				Annotations.SetEntryPointAssembly (assembly);
 				break;
 			case AssemblyRootMode.VisibleMembers:
 				var preserve_visible = TypePreserveMembers.Visible;

src/tools/illink/src/linker/Linker/Annotations.cs

@@ -71,6 +71,7 @@ public partial class AnnotationStore
 		protected readonly HashSet<MethodDefinition> indirectly_called = new HashSet<MethodDefinition> ();
 		protected readonly HashSet<TypeDefinition> types_relevant_to_variant_casting = new HashSet<TypeDefinition> ();
 		readonly HashSet<IMemberDefinition> reflection_used = new ();
+		AssemblyDefinition? entry_assembly;
 
 		public AnnotationStore (LinkContext context)
 		{
@@ -587,6 +588,17 @@ public bool TryGetLinkerAttribute<T> (IMemberDefinition member, [NotNullWhen (re
 			return attribute != null;
 		}
 
+		public AssemblyDefinition? GetEntryPointAssembly()
+		{
+			return entry_assembly;
+		}
+
+		public void SetEntryPointAssembly(AssemblyDefinition asmDef)
+		{
+			Debug.Assert (entry_assembly is null);
+			entry_assembly = asmDef;
+		}
+
 		/// <summary>
 		/// Determines if method is within a declared RUC scope - this typically means that trim analysis
 		/// warnings should be suppressed in such a method.

src/tools/illink/src/linker/Linker/DependencyInfo.cs

@@ -145,6 +145,8 @@ public enum DependencyKind
 		DynamicallyAccessedMemberOnType = 88, // type with DynamicallyAccessedMembers annotations (including those inherited from base types and interfaces)
 
 		UnsafeAccessorTarget = 89, // the member is referenced via UnsafeAccessor attribute
+
+		TypeMapEntry = 90, // external or proxy type map entry
 	}
 
 	public readonly struct DependencyInfo : IEquatable<DependencyInfo>

src/tools/illink/src/linker/Linker/LinkContext.cs

@@ -742,6 +742,11 @@ public bool IsWarningSuppressed (int warningCode, string subcategory, MessageOri
 			if (Suppressions == null)
 				return false;
 
+			// Don't warn for RUC on assembly attributes.
+			// There's no way to suppress it.
+			if (warningCode == 2026 && origin.Provider is AssemblyDefinition)
+				return true;
+
 			return Suppressions.IsSuppressed (warningCode, origin, out _);
 		}