Check for marking virtual method due to base only when state changes

src/linker/Linker.Steps/SealerStep.cs

@@ -96,7 +96,7 @@ void ProcessType (TypeDefinition type)
 				//
 				// cannot de-virtualize nor seal methods if something overrides them
 				//
-				if (IsAnyMarked (overrides))
+				if (IsAnyOverrideMarked (overrides))
 					continue;
 
 				SealMethod (method);
@@ -106,9 +106,9 @@ void ProcessType (TypeDefinition type)
 				if (!type.IsSealed)
 					continue;
 
-				var bases = Annotations.GetBaseMethods (method);
-				// Devirtualize if a method is not override to existing marked methods
-				if (!IsAnyMarked (bases))
+				var bases = Annotations.GetBaseMethods (method); //?.Select (static x => x.Base);
+																 // Devirtualize if a method is not override to existing marked methods
+				if (bases is not null && !IsAnyBaseMarked (bases))
 					method.IsVirtual = method.IsFinal = method.IsNewSlot = false;
 			}
 		}
@@ -123,7 +123,7 @@ protected virtual void SealMethod (MethodDefinition method)
 			method.IsFinal = true;
 		}
 
-		bool IsAnyMarked (IEnumerable<OverrideInformation>? list)
+		bool IsAnyOverrideMarked (IEnumerable<OverrideInformation>? list)
 		{
 			if (list == null)
 				return false;
@@ -135,12 +135,13 @@ bool IsAnyMarked (IEnumerable<OverrideInformation>? list)
 			return false;
 		}
 
-		bool IsAnyMarked (List<MethodDefinition>? list)
+		bool IsAnyBaseMarked (IEnumerable<OverrideInformation>? list)
 		{
 			if (list == null)
 				return false;
+
 			foreach (var m in list) {
-				if (Annotations.IsMarked (m))
+				if (Annotations.IsMarked (m.Base))
 					return true;
 			}
 			return false;

src/linker/Linker.Steps/ValidateVirtualMethodAnnotationsStep.cs

@@ -13,11 +13,11 @@ protected override void Process ()
 		{
 			var annotations = Context.Annotations;
 			foreach (var method in annotations.VirtualMethodsWithAnnotationsToValidate) {
-				var baseMethods = annotations.GetBaseMethods (method);
-				if (baseMethods != null) {
-					foreach (var baseMethod in baseMethods) {
-						annotations.FlowAnnotations.ValidateMethodAnnotationsAreSame (method, baseMethod);
-						ValidateMethodRequiresUnreferencedCodeAreSame (method, baseMethod);
+				var baseOverrideInformations = annotations.GetBaseMethods (method);
+				if (baseOverrideInformations != null) {
+					foreach (var baseOv in baseOverrideInformations) {
+						annotations.FlowAnnotations.ValidateMethodAnnotationsAreSame (method, baseOv.Base);
+						ValidateMethodRequiresUnreferencedCodeAreSame (method, baseOv.Base);
 					}
 				}
 

src/linker/Linker/Annotations.cs

@@ -436,6 +436,9 @@ public bool IsPublic (IMetadataTokenProvider provider)
 			return public_api.Contains (provider);
 		}
 
+		/// <summary>
+		/// Returns a list of all known methods that override <paramref name="method"/>. The list may be incomplete if other overrides exist in assemblies that haven't been processed by TypeMapInfo yet
+		/// </summary>
 		public IEnumerable<OverrideInformation>? GetOverrides (MethodDefinition method)
 		{
 			return TypeMapInfo.GetOverrides (method);
@@ -446,11 +449,26 @@ public bool IsPublic (IMetadataTokenProvider provider)
 			return TypeMapInfo.GetDefaultInterfaceImplementations (method);
 		}
 
-		public List<MethodDefinition>? GetBaseMethods (MethodDefinition method)
+		/// <summary>
+		/// Returns all base methods that <paramref name="method"/> overrides.
+		/// This includes methods on <paramref name="method"/>'s declaring type's base type (but not methods higher up in the type hierarchy),
+		/// methods on an interface that <paramref name="method"/>'s delcaring type implements,
+		/// and methods an interface implemented by a derived type of <paramref name="method"/>'s declaring type if the derived type uses <paramref name="method"/> as the implementing method.
+		/// The list may be incomplete if there are derived types in assemblies that havent been processed yet that use <paramref name="method"/> to implement an interface.
+		/// </summary>
+		public List<OverrideInformation>? GetBaseMethods (MethodDefinition method)
 		{
 			return TypeMapInfo.GetBaseMethods (method);
 		}
 
+		/// <summary>
+		/// Returns a list of all known types that implement <paramref name="interfaceType"/>. The list may be incomplete if other implementing types exist in assemblies that haven't been processed by TypeMapInfo yet
+		/// </summary>
+		public List<(TypeDefinition Implementor, InterfaceImplementation InterfaceImplementation)>? GetInterfaceImplementors (TypeDefinition type)
+		{
+			return TypeMapInfo.GetInterfaceImplementors (type);
+		}
+
 		public List<MethodDefinition>? GetPreservedMethods (TypeDefinition type)
 		{
 			return GetPreservedMethods (type as IMemberDefinition);

src/linker/Linker/TypeMapInfo.cs

@@ -29,6 +29,7 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+using System;
 using System.Collections.Generic;
 using Mono.Cecil;
 
@@ -39,9 +40,10 @@ public class TypeMapInfo
 	{
 		readonly HashSet<AssemblyDefinition> assemblies = new HashSet<AssemblyDefinition> ();
 		readonly LinkContext context;
-		protected readonly Dictionary<MethodDefinition, List<MethodDefinition>> base_methods = new Dictionary<MethodDefinition, List<MethodDefinition>> ();
+		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<TypeDefinition, List<(TypeDefinition, InterfaceImplementation)>> interface_implementors = new ();
 
 		public TypeMapInfo (LinkContext context)
 		{
@@ -57,17 +59,27 @@ void EnsureProcessed (AssemblyDefinition assembly)
 				MapType (type);
 		}
 
+		/// <summary>
+		/// Returns a list of all known methods that override <paramref name="method"/>. The list may be incomplete if other overrides exist in assemblies that haven't been processed by TypeMapInfo yet
+		/// </summary>
 		public IEnumerable<OverrideInformation>? GetOverrides (MethodDefinition method)
 		{
 			EnsureProcessed (method.Module.Assembly);
 			override_methods.TryGetValue (method, out List<OverrideInformation>? overrides);
 			return overrides;
 		}
 
-		public List<MethodDefinition>? GetBaseMethods (MethodDefinition method)
+		/// <summary>
+		/// Returns all base methods that <paramref name="method"/> overrides.
+		/// This includes methods on <paramref name="method"/>'s declaring type's base type (but not methods higher up in the type hierarchy),
+		/// methods on an interface that <paramref name="method"/>'s delcaring type implements,
+		/// and methods an interface implemented by a derived type of <paramref name="method"/>'s declaring type if the derived type uses <paramref name="method"/> as the implementing method.
+		/// The list may be incomplete if there are derived types in assemblies that havent been processed yet that use <paramref name="method"/> to implement an interface.
+		/// </summary>
+		public List<OverrideInformation>? GetBaseMethods (MethodDefinition method)
 		{
 			EnsureProcessed (method.Module.Assembly);
-			base_methods.TryGetValue (method, out List<MethodDefinition>? bases);
+			base_methods.TryGetValue (method, out List<OverrideInformation>? bases);
 			return bases;
 		}
 
@@ -77,14 +89,14 @@ void EnsureProcessed (AssemblyDefinition assembly)
 			return ret;
 		}
 
-		public void AddBaseMethod (MethodDefinition method, MethodDefinition @base)
+		public void AddBaseMethod (MethodDefinition method, MethodDefinition @base, InterfaceImplementation? matchingInterfaceImplementation)
 		{
-			if (!base_methods.TryGetValue (method, out List<MethodDefinition>? methods)) {
-				methods = new List<MethodDefinition> ();
+			if (!base_methods.TryGetValue (method, out List<OverrideInformation>? methods)) {
+				methods = new List<OverrideInformation> ();
 				base_methods[method] = methods;
 			}
 
-			methods.Add (@base);
+			methods.Add (new OverrideInformation (@base, method, context, matchingInterfaceImplementation));
 		}
 
 		public void AddOverride (MethodDefinition @base, MethodDefinition @override, InterfaceImplementation? matchingInterfaceImplementation = null)
@@ -107,10 +119,23 @@ public void AddDefaultInterfaceImplementation (MethodDefinition @base, TypeDefin
 			implementations.Add ((implementingType, matchingInterfaceImplementation));
 		}
 
+		/// <summary>
+		/// Returns a list of all known types that implement <paramref name="interfaceType"/>. The list may be incomplete if other implementing types exist in assemblies that haven't been processed by TypeMapInfo yet
+		/// </summary>
+		public List<(TypeDefinition Implementor, InterfaceImplementation InterfaceImplementation)>? GetInterfaceImplementors (TypeDefinition interfaceType)
+		{
+			if (!interfaceType.IsInterface)
+				throw new InvalidOperationException ("Cannot get interface implementors of a type that is not an interface");
+			if (interface_implementors.TryGetValue (interfaceType, out var interfaces))
+				return interfaces;
+			return null;
+		}
+
 		protected virtual void MapType (TypeDefinition type)
 		{
 			MapVirtualMethods (type);
 			MapInterfaceMethodsInTypeHierarchy (type);
+			MapInterfaces (type);
 
 			if (!type.HasNestedTypes)
 				return;
@@ -163,6 +188,18 @@ void MapInterfaceMethodsInTypeHierarchy (TypeDefinition type)
 			}
 		}
 
+		void MapInterfaces (TypeDefinition type)
+		{
+			foreach (var iface in type.GetAllInterfaceImplementations (context, true)) {
+				if (context.Resolve (iface.InterfaceType) is not TypeDefinition ifaceType)
+					continue;
+				if (!interface_implementors.TryGetValue (ifaceType, out var implementors)) {
+					implementors = new ();
+				}
+				implementors.Add ((type, iface));
+			}
+		}
+
 		void MapVirtualMethods (TypeDefinition type)
 		{
 			if (!type.HasMethods)
@@ -204,7 +241,7 @@ void MapOverrides (MethodDefinition method)
 
 		void AnnotateMethods (MethodDefinition @base, MethodDefinition @override, InterfaceImplementation? matchingInterfaceImplementation = null)
 		{
-			AddBaseMethod (@override, @base);
+			AddBaseMethod (@override, @base, matchingInterfaceImplementation);
 			AddOverride (@base, @override, matchingInterfaceImplementation);
 		}
 

test/Mono.Linker.Tests.Cases/Attributes/TypeWithDynamicInterfaceCastableImplementationAttributeIsKept.cs

@@ -54,6 +54,7 @@ static IReferencedAssembly GetReferencedInterface (object obj)
 #if NETCOREAPP
 	[Kept]
 	[KeptMember (".ctor()")]
+	[KeptInterface (typeof (IDynamicInterfaceCastable))]
 	class Foo : IDynamicInterfaceCastable
 	{
 		[Kept]
@@ -74,6 +75,7 @@ public bool IsInterfaceImplemented (RuntimeTypeHandle interfaceType, bool throwI
 
 	[Kept]
 	[KeptMember (".ctor()")]
+	[KeptInterface (typeof (IDynamicInterfaceCastable))]
 	class DynamicCastableImplementedInOtherAssembly : IDynamicInterfaceCastable
 	{
 		[Kept]

test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/InterfaceVariants.cs

@@ -21,15 +21,20 @@ public static void Main ()
 			t = typeof (UninstantiatedPublicClassWithPrivateInterface);
 			t = typeof (ImplementsUsedStaticInterface.InterfaceMethodUnused);
 
-			ImplementsUnusedStaticInterface.Test (); ;
+			ImplementsUnusedStaticInterface.Test ();
 			GenericMethodThatCallsInternalStaticInterfaceMethod
 				<ImplementsUsedStaticInterface.InterfaceMethodUsedThroughInterface> ();
 			// Use all public interfaces - they're marked as public only to denote them as "used"
 			typeof (IPublicInterface).RequiresPublicMethods ();
 			typeof (IPublicStaticInterface).RequiresPublicMethods ();
-			var ___ = new InstantiatedClassWithInterfaces ();
+			_ = new InstantiatedClassWithInterfaces ();
+			MarkIFormattable (null);
 		}
 
+		[Kept]
+		static void MarkIFormattable (IFormattable x)
+		{ }
+
 		[Kept]
 		internal static void GenericMethodThatCallsInternalStaticInterfaceMethod<T> () where T : IStaticInterfaceUsed
 		{
@@ -113,8 +118,8 @@ public static void Test ()
 			}
 		}
 
+		// Interfaces are kept despite being uninstantiated because it is relevant to variant casting
 		[Kept]
-		[KeptInterface (typeof (IEnumerator))]
 		[KeptInterface (typeof (IPublicInterface))]
 		[KeptInterface (typeof (IPublicStaticInterface))]
 		[KeptInterface (typeof (ICopyLibraryInterface))]
@@ -151,18 +156,12 @@ public static void InternalStaticInterfaceMethod () { }
 			static void IInternalStaticInterface.ExplicitImplementationInternalStaticInterfaceMethod () { }
 
 
-			[Kept]
-			[ExpectBodyModified]
 			bool IEnumerator.MoveNext () { throw new PlatformNotSupportedException (); }
 
-			[Kept]
 			object IEnumerator.Current {
-				[Kept]
-				[ExpectBodyModified]
 				get { throw new PlatformNotSupportedException (); }
 			}
 
-			[Kept]
 			void IEnumerator.Reset () { }
 
 			[Kept]
@@ -198,7 +197,6 @@ public string ToString (string format, IFormatProvider formatProvider)
 		}
 
 		[Kept]
-		[KeptInterface (typeof (IEnumerator))]
 		[KeptInterface (typeof (IPublicInterface))]
 		[KeptInterface (typeof (IPublicStaticInterface))]
 		[KeptInterface (typeof (ICopyLibraryInterface))]
@@ -235,13 +233,10 @@ public static void InternalStaticInterfaceMethod () { }
 
 			static void IInternalStaticInterface.ExplicitImplementationInternalStaticInterfaceMethod () { }
 
-			[Kept]
 			bool IEnumerator.MoveNext () { throw new PlatformNotSupportedException (); }
 
-			[Kept]
-			object IEnumerator.Current { [Kept] get { throw new PlatformNotSupportedException (); } }
+			object IEnumerator.Current { get { throw new PlatformNotSupportedException (); } }
 
-			[Kept]
 			void IEnumerator.Reset () { }
 
 			[Kept]

test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/StaticInterfaceMethods/UnusedInterfacesInPreservedScope.cs

@@ -37,10 +37,15 @@ class MyType : IStaticInterfaceWithDefaultImpls
 			public int InstanceMethod () => 0;
 		}
 
+		// Keep MyType without marking it relevant to variant casting
+		[Kept]
+		static void KeepMyType (MyType x)
+		{ }
+
 		[Kept]
 		static void Test ()
 		{
-			var x = typeof (MyType); // The only use of MyType
+			KeepMyType (null);
 		}
 	}
 }