Detect static default interface methods in illink

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

@@ -149,26 +149,26 @@ void MapInterfaceMethodsInTypeHierarchy (TypeDefinition type)
 					// we shouldn't need to run the below logic. This results in ILLink potentially
 					// keeping more methods than needed.
 
-					// Static methods on interfaces must be implemented only via explicit method-impl record
-					// not by a signature match. So there's no point in running the logic below for static methods.
-
 					if (!resolvedInterfaceMethod.IsVirtual
-						|| resolvedInterfaceMethod.IsFinal
-						|| resolvedInterfaceMethod.IsStatic)
+						|| resolvedInterfaceMethod.IsFinal)
 						continue;
 
-					// Try to find an implementation with a name/sig match on the current type
-					MethodDefinition? exactMatchOnType = TryMatchMethod (type, interfaceMethod);
-					if (exactMatchOnType != null) {
-						AnnotateMethods (resolvedInterfaceMethod, exactMatchOnType);
-						continue;
-					}
+					// Static methods on interfaces must be implemented only via explicit method-impl record
+					// not by a signature match. So there's no point in running this logic for static methods.
+					if (!resolvedInterfaceMethod.IsStatic) {
+						// Try to find an implementation with a name/sig match on the current type
+						MethodDefinition? exactMatchOnType = TryMatchMethod (type, interfaceMethod);
+						if (exactMatchOnType != null) {
+							AnnotateMethods (resolvedInterfaceMethod, exactMatchOnType);
+							continue;
+						}
 
-					// Next try to find an implementation with a name/sig match in the base hierarchy
-					var @base = GetBaseMethodInTypeHierarchy (type, interfaceMethod);
-					if (@base != null) {
-						AnnotateMethods (resolvedInterfaceMethod, @base, interfaceImpl.OriginalImpl);
-						continue;
+						// Next try to find an implementation with a name/sig match in the base hierarchy
+						var @base = GetBaseMethodInTypeHierarchy (type, interfaceMethod);
+						if (@base != null) {
+							AnnotateMethods (resolvedInterfaceMethod, @base, interfaceImpl.OriginalImpl);
+							continue;
+						}
 					}
 
 					// Look for a default implementation last.

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

@@ -0,0 +1,45 @@
+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 StaticDefaultInterfaceMethodOnStruct
+	{
+		public static void Main ()
+		{
+#if SUPPORTS_DEFAULT_INTERFACE_METHODS
+			Foo<Derived> ();
+#endif
+		}
+
+#if SUPPORTS_DEFAULT_INTERFACE_METHODS
+		[Kept]
+		static void Foo<T> () where T : IBase
+		{
+			T.Foo ();
+		}
+
+		[Kept]
+		interface IBase
+		{
+			[Kept]
+			static abstract void Foo ();
+		}
+
+		[Kept]
+		[KeptInterface (typeof (IBase))]
+		interface IDerived : IBase
+		{
+			[Kept]
+			static void IBase.Foo () { }
+		}
+
+		[Kept]
+		[KeptInterface (typeof (IDerived))]
+		[KeptInterface (typeof (IBase))]
+		struct Derived : IDerived
+		{
+		}
+#endif
+	}
+}