Linker dependency framework

src/coreclr/tools/aot/ILCompiler.DependencyAnalysisFramework/ILCompiler.DependencyAnalysisFramework.csproj

@@ -8,6 +8,10 @@
     <Platforms>x64;x86</Platforms>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <!-- Workaround for circular dependency (this => trim analyzers in illink.Tasks => Mono.Linker => this)-->
+    <_RequiresLiveILLink>false</_RequiresLiveILLink>
+    <!-- Mono.Linker requires the assembly to be signed -->
+    <SignAssembly>true</SignAssembly>
 
     <!-- We're binplacing these into an existing publish layout so that F5 build in VS updates
          the same bits tests expect to see in artifacts/crossgen2. That way we never need to wonder which

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

@@ -88,11 +88,6 @@ internal LocalScope PushLocalScope (in Scope scope)
 			return new LocalScope (scope, this);
 		}
 
-		internal ParentScope PopToParentScope ()
-		{
-			return new ParentScope (this);
-		}
-
 		public IDisposable PushScope (in MessageOrigin origin)
 		{
 			return new LocalScope (origin, this);

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

@@ -0,0 +1,43 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using ILCompiler.DependencyAnalysisFramework;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+	public partial class MarkStep
+	{
+		internal sealed class MethodDefinitionNode : DependencyNodeCore<NodeFactory>
+		{
+			readonly MethodDefinition method;
+			readonly DependencyInfo reason;
+
+			public MethodDefinitionNode (MethodDefinition method, DependencyInfo reason)
+			{
+				this.method = method;
+				this.reason = reason;
+			}
+
+			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 (NodeFactory context)
+			{
+				context.MarkStep.ProcessMethod (method, reason);
+				return null;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (NodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+			protected override string GetName (NodeFactory context) => method.GetDisplayName();
+		}
+	}
+}

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

@@ -0,0 +1,65 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+	public partial class MarkStep
+	{
+		internal sealed class NodeFactory (MarkStep markStep)
+		{
+			public MarkStep MarkStep { get; } = markStep;
+			readonly NodeCache<TypeDefinition, TypeDefinitionNode> _typeNodes = new (static t => new TypeDefinitionNode(t));
+			readonly NodeCache<MethodDefinition, MethodDefinitionNode> _methodNodes = new (static _ => throw new InvalidOperationException ("Creation of node requires more than the key."));
+			readonly NodeCache<TypeDefinition, TypeIsRelevantToVariantCastingNode> _typeIsRelevantToVariantCastingNodes = new (static (t) => new TypeIsRelevantToVariantCastingNode (t));
+
+			internal TypeDefinitionNode GetTypeNode (TypeDefinition definition)
+			{
+				return _typeNodes.GetOrAdd (definition);
+			}
+
+			internal MethodDefinitionNode GetMethodDefinitionNode (MethodDefinition method, DependencyInfo reason)
+			{
+				return _methodNodes.GetOrAdd (method, (k) => new MethodDefinitionNode (k, reason));
+			}
+
+			internal TypeIsRelevantToVariantCastingNode GetTypeIsRelevantToVariantCastingNode (TypeDefinition type)
+			{
+				return _typeIsRelevantToVariantCastingNodes.GetOrAdd (type);
+			}
+
+			struct NodeCache<TKey, TValue> where TKey : notnull
+			{
+				// Change to concurrent dictionary if/when multithreaded marking is enabled
+				readonly Dictionary<TKey, TValue> _cache;
+				readonly Func<TKey, TValue> _creator;
+
+				public NodeCache (Func<TKey, TValue> creator, IEqualityComparer<TKey> comparer)
+				{
+					_creator = creator;
+					_cache = new (comparer);
+				}
+
+				public NodeCache (Func<TKey, TValue> creator)
+				{
+					_creator = creator;
+					_cache = new ();
+				}
+
+				public TValue GetOrAdd (TKey key)
+				{
+					return _cache.GetOrAdd (key, _creator);
+				}
+
+				public TValue GetOrAdd (TKey key, Func<TKey, TValue> creator)
+				{
+					return _cache.GetOrAdd (key, creator);
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,42 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using ILCompiler.DependencyAnalysisFramework;
+
+namespace Mono.Linker.Steps
+{
+	public partial class MarkStep
+	{
+		sealed class ProcessCallbackNode : DependencyNodeCore<NodeFactory>
+		{
+			Func<bool> _processAction;
+			DependencyList? _dependencies;
+
+			public ProcessCallbackNode (Func<bool> action) => _processAction = action;
+
+			public void Process ()
+			{
+				_dependencies = new DependencyList ();
+				if (_processAction ()) {
+					_dependencies.Add (new ProcessCallbackNode (_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 (NodeFactory context) => _dependencies;
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (NodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+			protected override string GetName (NodeFactory context) => "Process";
+		}
+	}
+}

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

@@ -0,0 +1,40 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using ILCompiler.DependencyAnalysisFramework;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+	public partial class MarkStep
+	{
+		internal sealed class TypeDefinitionNode : DependencyNodeCore<NodeFactory>
+		{
+			readonly TypeDefinition type;
+
+			public TypeDefinitionNode (TypeDefinition type)
+			{
+				this.type = type;
+			}
+
+			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 (NodeFactory context)
+			{
+				context.MarkStep.ProcessType (type);
+				return null;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (NodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+			protected override string GetName (NodeFactory context) => type.GetDisplayName();
+		}
+	}
+}

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

@@ -0,0 +1,39 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using ILCompiler.DependencyAnalysisFramework;
+using Mono.Cecil;
+
+namespace Mono.Linker.Steps
+{
+	public partial class MarkStep
+	{
+		internal sealed class TypeIsRelevantToVariantCastingNode : DependencyNodeCore<NodeFactory>
+		{
+			TypeDefinition type;
+			public TypeIsRelevantToVariantCastingNode (TypeDefinition type) => this.type = type;
+
+			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 (NodeFactory context)
+			{
+				yield break;
+			}
+
+			public override IEnumerable<CombinedDependencyListEntry>? GetConditionalStaticDependencies (NodeFactory context) => null;
+			public override IEnumerable<CombinedDependencyListEntry>? SearchDynamicDependencies (List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+			protected override string GetName (NodeFactory context) => $"{type.GetDisplayName()} is relevant to variant casting";
+			protected override void OnMarked (NodeFactory context)
+			{
+				context.MarkStep.Annotations.MarkRelevantToVariantCasting (type);
+			}
+		}
+	}
+}