Analyze recursive interfaces in illink

src/libraries/System.Reflection.Context/src/System/Reflection/Context/Custom/CustomType.cs

@@ -44,6 +44,7 @@
             return IsAssignableFrom(objectType);
         }
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
         {
             // list of properties on this type according to the underlying ReflectionContext
@@ -139,6 +140,7 @@
             return binder.SelectProperty(bindingAttr, matchingProperties.ToArray(), returnType, types, modifiers);
         }
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
         {
             // list of methods on this type according to the underlying ReflectionContext

src/libraries/System.Reflection.Context/src/System/Reflection/Context/Delegation/DelegatingType.cs

@@ -325,11 +325,17 @@ public override EventInfo[] GetEvents(BindingFlags bindingAttr)
             return _typeInfo.GetEvents(bindingAttr);
         }
 
+#if NET8_0_OR_GREATER
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
+#endif
         public override FieldInfo? GetField(string name, BindingFlags bindingAttr)
         {
             return _typeInfo.GetField(name, bindingAttr);
         }
 
+#if NET8_0_OR_GREATER
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
+#endif
         public override FieldInfo[] GetFields(BindingFlags bindingAttr)
         {
             return _typeInfo.GetFields(bindingAttr);
@@ -345,6 +351,14 @@ public override Type[] GetInterfaces()
             return _typeInfo.GetInterfaces();
         }
 
+#if NET8_0_OR_GREATER
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents |
+            DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
+#endif
         public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
         {
             return _typeInfo.GetMembers(bindingAttr);
@@ -358,6 +372,9 @@ public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
                 _typeInfo.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
         }
 
+#if NET8_0_OR_GREATER
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
+#endif
         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
         {
             return _typeInfo.GetMethods(bindingAttr);
@@ -373,6 +390,9 @@ public override Type[] GetNestedTypes(BindingFlags bindingAttr)
             return _typeInfo.GetNestedTypes(bindingAttr);
         }
 
+#if NET8_0_OR_GREATER
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
+#endif
         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
         {
             return _typeInfo.GetProperties(bindingAttr);

src/libraries/System.Reflection.Context/src/System/Reflection/Context/Projection/ProjectingType.cs

@@ -206,11 +206,13 @@
             return _projector.Project(base.GetEvents(bindingAttr), _projector.ProjectEvent);
         }
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
         public override FieldInfo? GetField(string name, BindingFlags bindingAttr)
         {
             return _projector.ProjectField(base.GetField(name, bindingAttr));
         }
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
         public override FieldInfo[] GetFields(BindingFlags bindingAttr)
         {
             return _projector.Project(base.GetFields(bindingAttr), _projector.ProjectField);
@@ -226,6 +228,12 @@
             return _projector.Project(base.GetInterfaces(), _projector.ProjectType);
         }
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents |
+            DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
         public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
         {
             MethodInfo[] methods = GetMethods(bindingAttr);
@@ -264,6 +272,7 @@
             return _projector.ProjectMethod(base.GetMethodImpl(name, bindingAttr, binder, callConvention, types, modifiers));
         }
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
         {
             return _projector.Project(base.GetMethods(bindingAttr), _projector.ProjectMethod);
@@ -279,6 +288,7 @@
             return _projector.Project(base.GetNestedTypes(bindingAttr), _projector.ProjectType);
         }
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
         {
             return _projector.Project(base.GetProperties(bindingAttr), _projector.ProjectProperty);

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

@@ -36,7 +36,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection.Runtime.TypeParsing;
-using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 using ILLink.Shared;
 using ILLink.Shared.TrimAnalysis;
@@ -779,53 +778,16 @@ void MarkMethodIfNeededByBaseMethod (MethodDefinition method)
 			}
 		}
 
-		/// <summary>
-		/// Returns true if <paramref name="type"/> implements <paramref name="interfaceType"/> and the interface implementation is marked,
-		/// or if any marked interface implementations on <paramref name="type"/> are interfaces that implement <paramref name="interfaceType"/> and that interface implementation is marked
-		/// </summary>
-		bool IsInterfaceImplementationMarkedRecursively (TypeDefinition type, TypeDefinition interfaceType)
-		{
-			if (type.HasInterfaces) {
-				foreach (var intf in type.Interfaces) {
-					TypeDefinition? resolvedInterface = Context.Resolve (intf.InterfaceType);
-					if (resolvedInterface == null)
-						continue;
-
-					if (Annotations.IsMarked (intf) && RequiresInterfaceRecursively (resolvedInterface, interfaceType))
-						return true;
-				}
-			}
-
-			return false;
-		}
-
-		bool RequiresInterfaceRecursively (TypeDefinition typeToExamine, TypeDefinition interfaceType)
-		{
-			if (typeToExamine == interfaceType)
-				return true;
-
-			if (typeToExamine.HasInterfaces) {
-				foreach (var iface in typeToExamine.Interfaces) {
-					var resolved = Context.TryResolve (iface.InterfaceType);
-					if (resolved == null)
-						continue;
-
-					if (RequiresInterfaceRecursively (resolved, interfaceType))
-						return true;
-				}
-			}
-
-			return false;
-		}
-
 		void ProcessDefaultImplementation (OverrideInformation ov)
 		{
 			Debug.Assert (ov.IsOverrideOfInterfaceMember);
 			if ((!ov.Override.IsStatic && !Annotations.IsInstantiated (ov.InterfaceImplementor.Implementor))
 				|| ov.Override.IsStatic && !Annotations.IsRelevantToVariantCasting (ov.InterfaceImplementor.Implementor))
 				return;
 
-			MarkInterfaceImplementation (ov.InterfaceImplementor.InterfaceImplementation);
+			foreach (var ifaceImpl in ov.InterfaceImplementor.MostDirectInterfaceImplementationPath) {
+				MarkInterfaceImplementation (ifaceImpl);
+			}
 		}
 
 		void MarkMarshalSpec (IMarshalInfoProvider spec, in DependencyInfo reason)
@@ -2450,37 +2412,35 @@ void MarkNamedProperty (TypeDefinition type, string property_name, in Dependency
 
 		void MarkInterfaceImplementations (TypeDefinition type)
 		{
-			if (!type.HasInterfaces)
-				return;
-
-			foreach (var iface in type.Interfaces) {
-				// Only mark interface implementations of interface types that have been marked.
-				// This enables stripping of interfaces that are never used
-				if (ShouldMarkInterfaceImplementation (type, iface))
-					MarkInterfaceImplementation (iface, new MessageOrigin (type));
+			foreach (var interfaceImplementor in Annotations.GetRecursiveInterfaces (type)) {
+				if (ShouldMarkInterfaceImplementation (interfaceImplementor)) {
+					foreach (InterfaceImplementation interfaceImpl in interfaceImplementor.MostDirectInterfaceImplementationPath) {
+						MarkInterfaceImplementation (interfaceImpl, new MessageOrigin (type));
+					}
+				}
 			}
 		}
 
-		protected virtual bool ShouldMarkInterfaceImplementation (TypeDefinition type, InterfaceImplementation iface)
+		protected virtual bool ShouldMarkInterfaceImplementation (InterfaceImplementor interfaceImplementor)
 		{
-			if (Annotations.IsMarked (iface))
+			if (interfaceImplementor.IsMostDirectImplementationMarked (Annotations))
 				return false;
 
-			if (!Context.IsOptimizationEnabled (CodeOptimizations.UnusedInterfaces, type))
+			if (!Context.IsOptimizationEnabled (CodeOptimizations.UnusedInterfaces, interfaceImplementor.Implementor))
 				return true;
 
-			if (Context.Resolve (iface.InterfaceType) is not TypeDefinition resolvedInterfaceType)
+			if (interfaceImplementor.InterfaceType is null)
 				return false;
 
-			if (Annotations.IsMarked (resolvedInterfaceType))
+			if (Annotations.IsMarked (interfaceImplementor.InterfaceType))
 				return true;
 
 			// It's hard to know if a com or windows runtime interface will be needed from managed code alone,
 			// so as a precaution we will mark these interfaces once the type is instantiated
-			if (resolvedInterfaceType.IsImport || resolvedInterfaceType.IsWindowsRuntime)
+			if (interfaceImplementor.InterfaceType.IsImport || interfaceImplementor.InterfaceType.IsWindowsRuntime)
 				return true;
 
-			return IsFullyPreserved (type);
+			return IsFullyPreserved (interfaceImplementor.Implementor);
 		}
 
 		void MarkGenericParameterProvider (IGenericParameterProvider provider)
@@ -2560,12 +2520,10 @@ bool IsInterfaceImplementationMethodNeededByTypeDueToInterface (OverrideInformat
 			if (Annotations.IsMarked (method))
 				return false;
 
-			// 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.
-			InterfaceImplementation? iface = overrideInformation.InterfaceImplementor.InterfaceImplementation;
-			if (!((iface is not null && Annotations.IsMarked (iface))
-				|| IsInterfaceImplementationMarkedRecursively (method.DeclaringType, @base.DeclaringType)))
+			// If there is no chain of interface implementations that make the type implement the interface, the method isn't required
+			if (!overrideInformation.InterfaceImplementor.IsMarked(Annotations)) {
 				return false;
+			}
 
 			// If the interface method is not marked and the interface doesn't come from a preserved scope, do not mark the implementation method
 			// Unmarked interface methods from link assemblies will be removed so the implementing method does not need to be kept.

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

@@ -31,6 +31,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -717,5 +718,7 @@ public void EnqueueVirtualMethod (MethodDefinition method)
 			if (FlowAnnotations.RequiresVirtualMethodDataFlowAnalysis (method) || HasLinkerAttribute<RequiresUnreferencedCodeAttribute> (method))
 				VirtualMethodsWithAnnotationsToValidate.Add (method);
 		}
+
+		internal ImmutableArray<InterfaceImplementor> GetRecursiveInterfaces (TypeDefinition type) => TypeMapInfo.GetRecursiveInterfaces (type);
 	}
 }