Use Override pair to store logic for IsStaticInterfaceMethodPair

src/linker/Linker.Steps/MarkStep.cs

@@ -3050,15 +3050,15 @@ protected virtual void ProcessMethod (MethodDefinition method, in DependencyInfo
 			// Mark overridden methods and interface implementations except for static interface methods
 			// This will not mark implicit interface methods because they do not have a MethodImpl and aren't in the .Overrides
 			if (method.HasOverrides) {
-				foreach (MethodReference ov in method.Overrides) {
+				foreach (MethodReference @base in method.Overrides) {
 					// Method implementing a static interface method will have an override to it - note nonstatic methods usually don't unless they're explicit.
 					// Calling the implementation method directly has no impact on the interface, and as such it should not mark the interface or its method.
 					// Only if the interface method is referenced, then all the methods which implemented must be kept, but not the other way round.
-					if (Context.Resolve (ov)?.IsStatic == true
-						&& Context.Resolve (ov.DeclaringType)?.IsInterface == true)
+					if (Context.Resolve (@base) is MethodDefinition baseDefinition
+						&& new OverrideInformation.OverridePair (baseDefinition, method).IsStaticInterfaceMethodPair ())
 						continue;
-					MarkMethod (ov, new DependencyInfo (DependencyKind.MethodImplOverride, method), ScopeStack.CurrentScope.Origin);
-					MarkExplicitInterfaceImplementation (method, ov);
+					MarkMethod (@base, new DependencyInfo (DependencyKind.MethodImplOverride, method), ScopeStack.CurrentScope.Origin);
+					MarkExplicitInterfaceImplementation (method, @base);
 				}
 			}
 

src/linker/Linker/OverrideInformation.cs

@@ -10,17 +10,22 @@ namespace Mono.Linker
 	public class OverrideInformation
 	{
 		readonly ITryResolveMetadata resolver;
+		readonly OverridePair _pair;
 
 		public OverrideInformation (MethodDefinition @base, MethodDefinition @override, ITryResolveMetadata resolver, InterfaceImplementation? matchingInterfaceImplementation = null)
 		{
-			Base = @base;
-			Override = @override;
+			_pair = new OverridePair (@base, @override);
 			MatchingInterfaceImplementation = matchingInterfaceImplementation;
 			this.resolver = resolver;
 		}
 
-		public MethodDefinition Base { get; }
-		public MethodDefinition Override { get; }
+		public record struct OverridePair(MethodDefinition Base, MethodDefinition Override)
+		{
+			public bool IsStaticInterfaceMethodPair () => Base.DeclaringType.IsInterface && Base.IsStatic && Override.IsStatic;
+		}
+
+		public MethodDefinition Base { get => _pair.Base; }
+		public MethodDefinition Override { get => _pair.Override; }
 		public InterfaceImplementation? MatchingInterfaceImplementation { get; }
 
 		public bool IsOverrideOfInterfaceMember {
@@ -44,10 +49,6 @@ public TypeDefinition? InterfaceType {
 			}
 		}
 
-		public bool IsStaticInterfaceMethodPair {
-			get => IsOverrideOfInterfaceMember
-				&& Base.IsAbstract && Base.IsStatic
-				&& Override.IsStatic;
-		}
+		public bool IsStaticInterfaceMethodPair => _pair.IsStaticInterfaceMethodPair ();
 	}
 }