Mark most specific static DIM for types marked RelevantToVariantCasting

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

@@ -722,12 +722,12 @@ void ProcessVirtualMethod (MethodDefinition method)
 		bool ShouldMarkOverrideForBase (OverrideInformation overrideInformation)
 		{
 			Debug.Assert (Annotations.IsMarked (overrideInformation.Base) || IgnoreScope (overrideInformation.Base.DeclaringType.Scope));
-			if (!Annotations.IsMarked (overrideInformation.Override.DeclaringType))
-				return false;
 			if (overrideInformation.IsOverrideOfInterfaceMember) {
 				_interfaceOverrides.Add ((overrideInformation, ScopeStack.CurrentScope));
 				return false;
 			}
+			if (!Annotations.IsMarked (overrideInformation.Override.DeclaringType))
+				return false;
 
 			if (!Context.IsOptimizationEnabled (CodeOptimizations.OverrideRemoval, overrideInformation.Override))
 				return true;
@@ -2275,9 +2275,9 @@ void MarkTypeWithDebuggerDisplayAttribute (TypeDefinition type, CustomAttribute
 				// Record a logical dependency on the attribute so that we can blame it for the kept members below.
 				Tracer.AddDirectDependency (attribute, new DependencyInfo (DependencyKind.CustomAttribute, type), marked: false);
 
-				MarkTypeWithDebuggerDisplayAttributeValue(type, attribute, (string) attribute.ConstructorArguments[0].Value);
+				MarkTypeWithDebuggerDisplayAttributeValue (type, attribute, (string) attribute.ConstructorArguments[0].Value);
 				if (attribute.HasProperties) {
-					foreach (var  property in attribute.Properties) {
+					foreach (var property in attribute.Properties) {
 						if (property.Name is "Name" or "Type") {
 							MarkTypeWithDebuggerDisplayAttributeValue (type, attribute, (string) property.Argument.Value);
 						}
@@ -2549,14 +2549,54 @@ bool IsInterfaceImplementationMethodNeededByTypeDueToInterface (OverrideInformat
 		{
 			var @base = overrideInformation.Base;
 			var method = overrideInformation.Override;
+			Debug.Assert (@base.DeclaringType.IsInterface);
 			if (@base is null || method is null || @base.DeclaringType is null)
 				return false;
 
 			if (Annotations.IsMarked (method))
 				return false;
 
-			if ([email protected])
-				return false;
+			// If the override is a DIM that provides an implementation for a type that requires the interface, we may need to mark the DIM
+			var dims = Annotations.GetDefaultInterfaceImplementations (@base).Where(dim => Annotations.IsRelevantToVariantCasting (dim.InstanceType));
+			if (dims.Any (dim => dim.DefaultInterfaceMethod == method && Annotations.IsRelevantToVariantCasting (dim.InstanceType)))
+			{
+				// We need to find the most derived DIM for each type that has DIMs -- if there is a most derived DIM, we only mark that DIM
+				var dimsByInstanceType = dims.GroupBy (dim => dim.InstanceType).Where(group => group.Any(dim => dim.DefaultInterfaceMethod == method));
+				foreach (var group in dimsByInstanceType) {
+					var allDims = group.ToArray ();
+					int mostDerivedDimIndex = -1;
+					for (int i = 0; i < allDims.Length; i++) {
+						var derivesFromAllOtherDimProviders = true;
+						// Check if DIM i is the most specific DIM for the type by checking if it implements all the other DIM providers for the type
+						for (int j = 0; j < allDims.Length && derivesFromAllOtherDimProviders; j++) {
+							if (j == i)
+								continue;
+							// If the DIM provider i implements DIM provider j, then i is a more specific implementation that j. Otherwise, it is not and we check the next DIM provider
+							if (!allDims[i].DefaultInterfaceMethod.DeclaringType.Interfaces
+								.Any(iface => Context.Resolve(iface.InterfaceType) == allDims[j].DefaultInterfaceMethod.DeclaringType))
+							{
+								derivesFromAllOtherDimProviders = false;
+								break;
+							}
+						}
+						if (derivesFromAllOtherDimProviders) {
+							mostDerivedDimIndex = i;
+							break;
+						}
+					}
+					// If there is a most derived DIM, we only need to mark that DIM -- return true if the override is the most derived DIM
+					if (mostDerivedDimIndex != -1) {
+						if (allDims[mostDerivedDimIndex].DefaultInterfaceMethod == method)
+							return true;
+						else
+							continue;
+					} else {
+						// If there is no most derived DIM, all DIMs should be marked.
+						// We already checked that the override is a DIM that provides an implementation for a type that requires the interface, so we can return true
+						return true;
+					}
+				}
+			}
 
 			// If the interface implementation is not marked, do not mark the implementation method
 			// A type that doesn't implement the interface isn't required to have methods that implement the interface.
@@ -3007,7 +3047,7 @@ void MarkMethodCollection (IList<MethodDefinition> methods, in DependencyInfo re
 		protected virtual MethodDefinition? MarkMethod (MethodReference reference, DependencyInfo reason, in MessageOrigin origin)
 		{
 			DependencyKind originalReasonKind = reason.Kind;
-			(reference, reason) = GetOriginalMethod (reference, reason);
+			(reference, reason) = GetOriginalMethod (reference, reason, in origin);
 
 			if (reference.DeclaringType is ArrayType arrayType) {
 				MarkType (reference.DeclaringType, new DependencyInfo (DependencyKind.DeclaringType, reference));
@@ -3178,14 +3218,15 @@ internal static void ReportRequiresUnreferencedCode (string displayName, Require
 			diagnosticContext.AddDiagnostic (DiagnosticId.RequiresUnreferencedCode, displayName, arg1, arg2);
 		}
 
-		protected (MethodReference, DependencyInfo) GetOriginalMethod (MethodReference method, DependencyInfo reason)
+		protected (MethodReference, DependencyInfo) GetOriginalMethod (MethodReference method, DependencyInfo reason, in MessageOrigin origin)
 		{
 			while (method is MethodSpecification specification) {
 				// Blame the method reference (which isn't marked) on the original reason.
 				Tracer.AddDirectDependency (specification, reason, marked: false);
 				// Blame the outgoing element method on the specification.
-				if (method is GenericInstanceMethod gim)
+				if (method is GenericInstanceMethod gim) {
 					MarkGenericArguments (gim);
+				}
 
 				(method, reason) = (specification.ElementMethod, new DependencyInfo (DependencyKind.ElementMethod, specification));
 				Debug.Assert (!(method is MethodSpecification));
@@ -3231,7 +3272,7 @@ protected virtual void ProcessMethod (MethodDefinition method, in DependencyInfo
 			} else if (method.TryGetProperty (out PropertyDefinition? property))
 				MarkProperty (property, new DependencyInfo (PropagateDependencyKindToAccessors (reason.Kind, DependencyKind.PropertyOfPropertyMethod), method));
 			else if (method.TryGetEvent (out EventDefinition? @event)) {
-				MarkEvent (@event, new DependencyInfo (PropagateDependencyKindToAccessors(reason.Kind, DependencyKind.EventOfEventMethod), method));
+				MarkEvent (@event, new DependencyInfo (PropagateDependencyKindToAccessors (reason.Kind, DependencyKind.EventOfEventMethod), method));
 			}
 
 			if (method.HasMetadataParameters ()) {
@@ -3315,7 +3356,7 @@ protected virtual void DoAdditionalMethodProcessing (MethodDefinition method)
 		{
 		}
 
-		static DependencyKind PropagateDependencyKindToAccessors(DependencyKind parentDependencyKind, DependencyKind kind)
+		static DependencyKind PropagateDependencyKindToAccessors (DependencyKind parentDependencyKind, DependencyKind kind)
 		{
 			switch (parentDependencyKind) {
 			// If the member is marked due to descriptor or similar, propagate the original reason to suppress some warnings correctly
@@ -3335,11 +3376,11 @@ void MarkImplicitlyUsedFields (TypeDefinition type)
 				return;
 
 			// keep fields for types with explicit layout, for enums and for InlineArray types
-			if (!type.IsAutoLayout || type.IsEnum || TypeIsInlineArrayType(type))
+			if (!type.IsAutoLayout || type.IsEnum || TypeIsInlineArrayType (type))
 				MarkFields (type, includeStatic: type.IsEnum, reason: new DependencyInfo (DependencyKind.MemberOfType, type));
 		}
 
-		static bool TypeIsInlineArrayType(TypeDefinition type)
+		static bool TypeIsInlineArrayType (TypeDefinition type)
 		{
 			if (!type.IsValueType)
 				return false;
@@ -3584,7 +3625,7 @@ protected internal virtual void MarkEvent (EventDefinition evt, in DependencyInf
 
 			MarkCustomAttributes (evt, new DependencyInfo (DependencyKind.CustomAttribute, evt));
 
-			DependencyKind dependencyKind = PropagateDependencyKindToAccessors(reason.Kind, DependencyKind.EventMethod);
+			DependencyKind dependencyKind = PropagateDependencyKindToAccessors (reason.Kind, DependencyKind.EventMethod);
 			MarkMethodIfNotNull (evt.AddMethod, new DependencyInfo (dependencyKind, evt), ScopeStack.CurrentScope.Origin);
 			MarkMethodIfNotNull (evt.InvokeMethod, new DependencyInfo (dependencyKind, evt), ScopeStack.CurrentScope.Origin);
 			MarkMethodIfNotNull (evt.RemoveMethod, new DependencyInfo (dependencyKind, evt), ScopeStack.CurrentScope.Origin);
@@ -3762,8 +3803,7 @@ protected virtual void MarkInstruction (Instruction instruction, MethodDefinitio
 					ScopeStack.UpdateCurrentScopeInstructionOffset (instruction.Offset);
 					if (markForReflectionAccess) {
 						MarkMethodVisibleToReflection (methodReference, new DependencyInfo (dependencyKind, method), ScopeStack.CurrentScope.Origin);
-					}
-					else {
+					} else {
 						MarkMethod (methodReference, new DependencyInfo (dependencyKind, method), ScopeStack.CurrentScope.Origin);
 					}
 					break;

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

@@ -454,9 +454,9 @@ public bool IsPublic (IMetadataTokenProvider provider)
 			return TypeMapInfo.GetOverrides (method);
 		}
 
-		public IEnumerable<(TypeDefinition InstanceType, InterfaceImplementation ProvidingInterface)>? GetDefaultInterfaceImplementations (MethodDefinition method)
+		public IEnumerable<(TypeDefinition InstanceType, InterfaceImplementation ProvidingInterface, MethodDefinition DefaultInterfaceMethod)> GetDefaultInterfaceImplementations (MethodDefinition method)
 		{
-			return TypeMapInfo.GetDefaultInterfaceImplementations (method);
+			return TypeMapInfo.GetDefaultInterfaceImplementations (method) ?? [];
 		}
 
 		/// <summary>

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

@@ -42,7 +42,7 @@ public class TypeMapInfo
 		readonly LinkContext context;
 		protected readonly Dictionary<MethodDefinition, List<OverrideInformation>> base_methods = new Dictionary<MethodDefinition, List<OverrideInformation>> ();
 		protected readonly Dictionary<MethodDefinition, List<OverrideInformation>> override_methods = new Dictionary<MethodDefinition, List<OverrideInformation>> ();
-		protected readonly Dictionary<MethodDefinition, List<(TypeDefinition InstanceType, InterfaceImplementation ImplementationProvider)>> default_interface_implementations = new Dictionary<MethodDefinition, List<(TypeDefinition, InterfaceImplementation)>> ();
+		protected readonly Dictionary<MethodDefinition, List<(TypeDefinition InstanceType, InterfaceImplementation ImplementationProvider, MethodDefinition DefaultImplementationMethod)>> default_interface_implementations = new Dictionary<MethodDefinition, List<(TypeDefinition, InterfaceImplementation, MethodDefinition)>> ();
 
 		public TypeMapInfo (LinkContext context)
 		{
@@ -84,9 +84,9 @@ public void EnsureProcessed (AssemblyDefinition assembly)
 			return bases;
 		}
 
-		public IEnumerable<(TypeDefinition InstanceType, InterfaceImplementation ProvidingInterface)>? GetDefaultInterfaceImplementations (MethodDefinition method)
+		public IEnumerable<(TypeDefinition InstanceType, InterfaceImplementation ProvidingInterface, MethodDefinition DefaultImplementationMethod)>? GetDefaultInterfaceImplementations (MethodDefinition baseMethod)
 		{
-			default_interface_implementations.TryGetValue (method, out var ret);
+			default_interface_implementations.TryGetValue (baseMethod, out var ret);
 			return ret;
 		}
 
@@ -110,14 +110,14 @@ public void AddOverride (MethodDefinition @base, MethodDefinition @override, Int
 			methods.Add (new OverrideInformation (@base, @override, context, matchingInterfaceImplementation));
 		}
 
-		public void AddDefaultInterfaceImplementation (MethodDefinition @base, TypeDefinition implementingType, InterfaceImplementation matchingInterfaceImplementation)
+		public void AddDefaultInterfaceImplementation (MethodDefinition @base, TypeDefinition implementingType, (InterfaceImplementation, MethodDefinition) matchingInterfaceImplementation)
 		{
 			if (!default_interface_implementations.TryGetValue (@base, out var implementations)) {
-				implementations = new List<(TypeDefinition, InterfaceImplementation)> ();
+				implementations = new List<(TypeDefinition, InterfaceImplementation, MethodDefinition)> ();
 				default_interface_implementations.Add (@base, implementations);
 			}
 
-			implementations.Add ((implementingType, matchingInterfaceImplementation));
+			implementations.Add ((implementingType, matchingInterfaceImplementation.Item1, matchingInterfaceImplementation.Item2));
 		}
 
 		protected virtual void MapType (TypeDefinition type)
@@ -276,7 +276,7 @@ void AnnotateMethods (MethodDefinition @base, MethodDefinition @override, Interf
 		// Note that this returns a list to potentially cover the diamond case (more than one
 		// most specific implementation of the given interface methods). ILLink needs to preserve
 		// all the implementations so that the proper exception can be thrown at runtime.
-		IEnumerable<InterfaceImplementation> GetDefaultInterfaceImplementations (TypeDefinition type, MethodDefinition interfaceMethod)
+		IEnumerable<(InterfaceImplementation, MethodDefinition)> GetDefaultInterfaceImplementations (TypeDefinition type, MethodDefinition interfaceMethod)
 		{
 			// Go over all interfaces, trying to find a method that is an explicit MethodImpl of the
 			// interface method in question.
@@ -290,7 +290,7 @@ IEnumerable<InterfaceImplementation> GetDefaultInterfaceImplementations (TypeDef
 				foreach (var potentialImplMethod in potentialImplInterface.Methods) {
 					if (potentialImplMethod == interfaceMethod &&
 						!potentialImplMethod.IsAbstract) {
-						yield return interfaceImpl;
+						yield return (interfaceImpl, potentialImplMethod);
 					}
 
 					if (!potentialImplMethod.HasOverrides)
@@ -299,7 +299,7 @@ IEnumerable<InterfaceImplementation> GetDefaultInterfaceImplementations (TypeDef
 					// This method is an override of something. Let's see if it's the method we are looking for.
 					foreach (var @override in potentialImplMethod.Overrides) {
 						if (context.TryResolve (@override) == interfaceMethod) {
-							yield return interfaceImpl;
+							yield return (interfaceImpl, potentialImplMethod);
 							foundImpl = true;
 							break;
 						}

src/tools/illink/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/DefaultInterfaceMethods/MostSpecificDefaultImplementationKept.cs

@@ -0,0 +1,126 @@
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.DefaultInterfaceMethods
+{
+	[TestCaseRequirements (TestRunCharacteristics.SupportsDefaultInterfaceMethods, "Requires support for default interface methods")]
+	class MostSpecificDefaultImplementationKept
+	{
+		[Kept]
+		public static void Main ()
+		{
+#if SUPPORTS_DEFAULT_INTERFACE_METHODS
+			M<UsedAsIBase> ();
+			NotUsedInGeneric.Keep ();
+			GenericType<UsedAsIBase2>.M ();
+			GenericType2<UsedInUnconstrainedGeneric>.Keep ();
+#endif
+		}
+
+#if SUPPORTS_DEFAULT_INTERFACE_METHODS
+
+		[Kept]
+		static int M<T> () where T : IBase
+		{
+			return T.Value;
+		}
+
+		[Kept]
+		interface IBase
+		{
+			[Kept]
+			static virtual int Value {
+				[Kept]
+				get => 0;
+			}
+
+			static virtual int Value2 {
+				get => 0;
+			}
+		}
+
+		[Kept]
+		[KeptInterface (typeof (IBase))]
+		interface IMiddle : IBase
+		{
+			static int IBase.Value {
+				get => 1;
+			}
+		}
+
+		[Kept]
+		[KeptInterface (typeof (IBase))]
+		[KeptInterface (typeof (IMiddle))]
+		interface IDerived : IMiddle
+		{
+			[Kept]
+			static int IBase.Value {
+				[Kept]
+				get => 2;
+			}
+		}
+
+		[Kept]
+		[KeptInterface (typeof (IBase))]
+		[KeptInterface (typeof (IMiddle))]
+		interface IDerived2 : IMiddle
+		{
+			// https://github.com/dotnet/runtime/issues/97798
+			// This shouldn't need to be kept. Implementor UsedInUnconstrainedGeneric is not passed as a constrained generic
+			[Kept]
+			static int IBase.Value {
+				[Kept]
+				get => 2;
+			}
+		}
+
+		interface INotReferenced
+		{ }
+
+		[Kept]
+		[KeptInterface (typeof (IDerived))]
+		[KeptInterface (typeof (IMiddle))]
+		[KeptInterface (typeof (IBase))]
+		class UsedAsIBase : IDerived, INotReferenced
+		{
+		}
+
+		[Kept]
+		class NotUsedInGeneric : IDerived, INotReferenced
+		{
+			[Kept]
+			public static void Keep () { }
+		}
+
+		[Kept]
+		[KeptInterface (typeof (IBase))]
+		[KeptInterface (typeof (IMiddle))]
+		[KeptInterface (typeof (IDerived2))]
+		class UsedInUnconstrainedGeneric : IDerived2, INotReferenced
+		{
+		}
+
+
+		[Kept]
+		class GenericType<T> where T : IBase
+		{
+			[Kept]
+			public static int M () => T.Value;
+		}
+
+		[Kept]
+		class GenericType2<T>
+		{
+			[Kept]
+			public static void Keep() { }
+		}
+
+		[Kept]
+		[KeptInterface (typeof (IDerived))]
+		[KeptInterface (typeof (IMiddle))]
+		[KeptInterface (typeof (IBase))]
+		class UsedAsIBase2 : IDerived
+		{
+		}
+#endif
+	}
+}