Linker dependency framework

src/coreclr/tools/Common/Sorting/ArrayAccessor.cs

@@ -3,6 +3,8 @@
 
 using System;
 
+#nullable disable
+
 namespace ILCompiler.Sorting.Implementation
 {
     internal struct ArrayAccessor<T> : ISortableDataStructureAccessor<T, T[]>

src/coreclr/tools/Common/Sorting/ICompareAsEqualAction.cs

@@ -3,6 +3,8 @@
 
 using System.Diagnostics;
 
+#nullable disable
+
 namespace ILCompiler
 {
     internal interface ICompareAsEqualAction

src/coreclr/tools/Common/Sorting/ISortableDataStructureAccessor.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#nullable disable
+
 namespace ILCompiler
 {
     internal interface ISortableDataStructureAccessor<T, TDataStructure>

src/coreclr/tools/Common/Sorting/ListAccessor.cs

@@ -3,6 +3,8 @@
 
 using System.Collections.Generic;
 
+#nullable disable
+
 namespace ILCompiler.Sorting.Implementation
 {
     internal struct ListAccessor<T> : ISortableDataStructureAccessor<T, List<T>>

src/coreclr/tools/Common/Sorting/MergeSort.cs

@@ -5,6 +5,8 @@
 using System.Collections.Generic;
 using ILCompiler.Sorting.Implementation;
 
+#nullable disable
+
 namespace ILCompiler
 {
     public static class MergeSortApi

src/coreclr/tools/Common/Sorting/MergeSortCore.cs

@@ -4,6 +4,8 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
+#nullable disable
+
 namespace ILCompiler.Sorting.Implementation
 {
     internal static class MergeSortCore<T, TDataStructure, TDataStructureAccessor, TComparer, TCompareAsEqualAction>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/ComputedStaticDependencyNode.cs

@@ -5,6 +5,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public abstract class ComputedStaticDependencyNode<DependencyContextType> : DependencyNodeCore<DependencyContextType>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/DependencyAnalyzer.cs

@@ -6,6 +6,8 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     /// <summary>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/DependencyAnalyzerBase.cs

@@ -5,6 +5,8 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     /// <summary>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/DependencyNode.cs

@@ -3,6 +3,8 @@
 
 using System.Diagnostics;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public abstract class DependencyNode : IDependencyNode

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/DependencyNodeCore.cs

@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public abstract class DependencyNodeCore<DependencyContextType> : DependencyNode, IDependencyNode<DependencyContextType>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/DgmlWriter.cs

@@ -7,6 +7,8 @@
 using System.IO;
 using System.Diagnostics;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public class DgmlWriter

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/EventSourceLogStrategy.cs

@@ -7,6 +7,8 @@
 using System.Diagnostics.Tracing;
 using System.Runtime.InteropServices;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     [EventSource(Name = "Microsoft-ILCompiler-DependencyGraph")]

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/FirstMarkLogStrategy.cs

@@ -5,6 +5,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public struct FirstMarkLogStrategy<DependencyContextType> : IDependencyAnalysisMarkStrategy<DependencyContextType>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/FullGraphLogStrategy.cs

@@ -5,6 +5,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public struct FullGraphLogStrategy<DependencyContextType> : IDependencyAnalysisMarkStrategy<DependencyContextType>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/IDependencyAnalysisMarkStrategy.cs

@@ -3,6 +3,8 @@
 
 using System.Collections.Generic;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public interface IDependencyAnalysisMarkStrategy<DependencyContextType>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/IDependencyAnalyzerLogEdgeVisitor.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public interface IDependencyAnalyzerLogEdgeVisitor<DependencyContextType>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/IDependencyAnalyzerLogNodeVisitor.cs

@@ -3,6 +3,8 @@
 
 using System;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public interface IDependencyAnalyzerLogNodeVisitor<DependencyContextType>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/IDependencyNode.cs

@@ -3,6 +3,8 @@
 
 using System.Collections.Generic;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     public interface IDependencyNode

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/NoLogStrategy.cs

@@ -3,6 +3,8 @@
 
 using System.Collections.Generic;
 
+#nullable disable
+
 namespace ILCompiler.DependencyAnalysisFramework
 {
     /// <summary>

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/PerfEventSource.cs

@@ -4,6 +4,8 @@
 using System;
 using System.Diagnostics.Tracing;
 
+#nullable disable
+
 /// <summary>
 /// Performance events specific to the dependency graph.
 /// </summary>

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

@@ -38,6 +38,7 @@
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.Runtime.TypeParsing;
 using System.Text.RegularExpressions;
+using ILCompiler.DependencyAnalysisFramework;
 using ILLink.Shared;
 using ILLink.Shared.TrimAnalysis;
 using ILLink.Shared.TypeSystemProxy;
@@ -229,6 +230,7 @@ public MarkStep ()
 			_pending_isinst_instr = new List<(TypeDefinition, MethodBody, Instruction)> ();
 			_entireTypesMarked = new HashSet<TypeDefinition> ();
 			_compilerGeneratedMethodRequiresScanner = new Dictionary<MethodBody, bool> ();
+			_analyzer = new DependencyAnalyzer<NoLogStrategy<MarkStepNodeFactory>, MarkStepNodeFactory> (new MarkStepNodeFactory (this), null);
 		}
 
 		public AnnotationStore Annotations => Context.Annotations;
@@ -372,15 +374,103 @@ internal void MarkEntireType (TypeDefinition type, in DependencyInfo reason)
 			}
 		}
 
+		DependencyAnalyzer<NoLogStrategy<MarkStepNodeFactory>, MarkStepNodeFactory> _analyzer;
 		void Process ()
 		{
-			while (ProcessPrimaryQueue () ||
+			_analyzer.ComputeDependencyRoutine += (List<DependencyNodeCore<MarkStepNodeFactory>> nodes) => {
+				foreach (DependencyNodeCore<MarkStepNodeFactory> node in nodes) {
+					if (node is ProcessCallbackDependencyNode processNode)
+						processNode.Process ();
+				}
+			};
+			_analyzer.AddRoot (new ProcessCallbackDependencyNode (ProcessAllPendingItems), "start");
+			_analyzer.ComputeMarkedNodes ();
+
+			ProcessPendingTypeChecks ();
+
+			bool ProcessAllPendingItems ()
+				=> ProcessPrimaryQueue () ||
 				ProcessMarkedPending () ||
 				ProcessLazyAttributes () ||
 				ProcessLateMarkedAttributes () ||
-				MarkFullyPreservedAssemblies ()) ;
+				MarkFullyPreservedAssemblies ();
+		}
 
-			ProcessPendingTypeChecks ();
+		public class MarkStepNodeFactory (MarkStep markStep)
+		{
+			public MarkStep MarkStep { get; } = markStep;
+		}
+
+		sealed class ProcessCallbackDependencyNode : DependencyNodeCore<MarkStepNodeFactory>
+		{
+			Func<bool> _processAction;
+			DependencyList? _dependencies;
+
+			public ProcessCallbackDependencyNode (Func<bool> action) => _processAction = action;
+
+			public void Process ()
+			{
+				_dependencies = new DependencyList ();
+				if (_processAction ()) {
+					_dependencies.Add (new ProcessCallbackDependencyNode (_processAction), "Some processing was done, continuation required");
+				}
+			}
+
+			public override bool InterestingForDynamicDependencyAnalysis => false;
+
+			public override bool HasDynamicDependencies => false;
+
+			public override bool HasConditionalStaticDependencies => false;
+
+			public override bool StaticDependenciesAreComputed => _dependencies != null;
+
+			public override IEnumerable<DependencyListEntry>? GetStaticDependencies (MarkStepNodeFactory context) => _dependencies;
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (MarkStepNodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<MarkStepNodeFactory>> markedNodes, int firstNode, MarkStepNodeFactory context) => null;
+			protected override string GetName (MarkStepNodeFactory context) => "Process";
+		}
+
+		public class TypeDependencyNode : DependencyNodeCore<MarkStepNodeFactory>
+		{
+			readonly TypeReference reference;
+			readonly DependencyInfo reason;
+			readonly MessageOrigin? origin;
+			readonly MarkStep markStep;
+
+			public TypeDependencyNode (TypeReference reference, DependencyInfo reason, MessageOrigin? origin, MarkStep markStep)
+			{
+				this.reference = reference;
+				this.reason = reason;
+				this.origin = origin;
+				this.markStep = markStep;
+			}
+			public override bool InterestingForDynamicDependencyAnalysis => false;
+
+			public override bool HasDynamicDependencies => false;
+
+			public override bool HasConditionalStaticDependencies => false;
+
+			public override bool StaticDependenciesAreComputed => true;
+
+			public override IEnumerable<DependencyListEntry>? GetStaticDependencies (MarkStepNodeFactory context)
+			{
+				// Add other types that are marked in MarkType
+				yield break;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (MarkStepNodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<MarkStepNodeFactory>> markedNodes, int firstNode, MarkStepNodeFactory context) => null;
+			protected override string GetName (MarkStepNodeFactory context) => "TypeNode";
+			protected override void OnMarked (MarkStepNodeFactory context)
+			{
+				markStep.MarkTypeImpl (reference, reason, origin);
+			}
+		}
+
+		protected internal virtual void MarkType (TypeReference reference, DependencyInfo reason, MessageOrigin? origin = null)
+		{
+			_analyzer.AddRoot (new TypeDependencyNode (reference, reason, origin, this), "MarkedType");
 		}
 
 		static bool IsFullyPreservedAction (AssemblyAction action) => action == AssemblyAction.Copy || action == AssemblyAction.Save;
@@ -666,7 +756,7 @@ void ProcessVirtualMethod (MethodDefinition method)
 							MarkMethod (dimInfo.Override, new DependencyInfo (DependencyKind.Override, dimInfo.Base), ScopeStack.CurrentScope.Origin);
 					}
 				}
-				List<OverrideInformation>? overridingMethods = (List<OverrideInformation>?)Annotations.GetOverrides (method);
+				List<OverrideInformation>? overridingMethods = (List<OverrideInformation>?) Annotations.GetOverrides (method);
 				if (overridingMethods is not null) {
 					for (int i = 0; i < overridingMethods.Count; i++) {
 						OverrideInformation ov = overridingMethods[i];
@@ -1896,7 +1986,7 @@ protected virtual void MarkSerializable (TypeDefinition type)
 			MarkMethodsIf (type.Methods, HasOnSerializeOrDeserializeAttribute, new DependencyInfo (DependencyKind.SerializationMethodForType, type), ScopeStack.CurrentScope.Origin);
 		}
 
-		protected internal virtual TypeDefinition? MarkTypeVisibleToReflection (TypeReference type, TypeDefinition definition, in DependencyInfo reason, in MessageOrigin origin)
+		protected internal virtual void MarkTypeVisibleToReflection (TypeReference type, TypeDefinition definition, in DependencyInfo reason, in MessageOrigin origin)
 		{
 			// If a type is visible to reflection, we need to stop doing optimization that could cause observable difference
 			// in reflection APIs. This includes APIs like MakeGenericType (where variant castability of the produced type
@@ -1907,7 +1997,7 @@ protected virtual void MarkSerializable (TypeDefinition type)
 
 			MarkImplicitlyUsedFields (definition);
 
-			return MarkType (type, reason, origin);
+			MarkType (type, reason, origin);
 		}
 
 		internal void MarkMethodVisibleToReflection (MethodReference method, in DependencyInfo reason, in MessageOrigin origin)
@@ -1958,7 +2048,7 @@ internal void MarkStaticConstructorVisibleToReflection (TypeDefinition type, in
 		/// <param name="reference">The type reference to mark.</param>
 		/// <param name="reason">The reason why the marking is occuring</param>
 		/// <returns>The resolved type definition if the reference can be resolved</returns>
-		protected internal virtual TypeDefinition? MarkType (TypeReference reference, DependencyInfo reason, MessageOrigin? origin = null)
+		protected internal virtual TypeDefinition? MarkTypeImpl (TypeReference reference, DependencyInfo reason, MessageOrigin? origin = null)
 		{
 #if DEBUG
 			if (!_typeReasons.Contains (reason.Kind))
@@ -2759,7 +2849,7 @@ void MarkGenericArguments (IGenericInstance instance)
 				var argument = arguments[i];
 				var parameter = parameters[i];
 
-				TypeDefinition? argumentTypeDef = MarkType (argument, new DependencyInfo (DependencyKind.GenericArgumentType, instance));
+				var argumentTypeDef = MarkTypeImpl (argument, new DependencyInfo (DependencyKind.GenericArgumentType, instance));
 
 				if (Annotations.FlowAnnotations.RequiresGenericArgumentDataFlowAnalysis (parameter)) {
 					// The only two implementations of IGenericInstance both derive from MemberReference