Update to new linker custom steps API

src/Microsoft.Android.Sdk.ILLink/BaseMarkHandler.cs

@@ -0,0 +1,19 @@
+using Microsoft.Android.Sdk.ILLink;
+using Mono.Cecil;
+using Mono.Linker.Steps;
+
+namespace Mono.Linker
+{
+	public class BaseMarkHandler : IMarkHandler
+	{
+		protected LinkContext Context;
+		protected AnnotationStore Annotations => Context?.Annotations;
+		protected IMetadataResolver cache;
+
+		public virtual void Initialize (LinkContext context, MarkContext markContext)
+		{
+			Context = context;
+			cache = new LinkContextMetadataResolver (context);
+		}
+	}
+}

src/Microsoft.Android.Sdk.ILLink/LinkContextMetadataResolver.cs

@@ -0,0 +1,30 @@
+using Java.Interop.Tools.Cecil;
+using Mono.Cecil;
+using Mono.Linker;
+
+namespace Microsoft.Android.Sdk.ILLink
+{
+	public class LinkContextMetadataResolver : IMetadataResolver {
+		LinkContext context;
+
+		public LinkContextMetadataResolver (LinkContext context)
+		{
+			this.context = context;
+		}
+
+		public virtual TypeDefinition Resolve (TypeReference type)
+		{
+			return context.ResolveTypeDefinition (type);
+		}
+
+		public virtual FieldDefinition Resolve (FieldReference field)
+		{
+			return context.ResolveFieldDefinition (field);
+		}
+
+		public virtual MethodDefinition Resolve (MethodReference method)
+		{
+			return context.ResolveMethodDefinition (method);
+		}
+	}
+}

src/Microsoft.Android.Sdk.ILLink/PreserveJavaInterfaces.cs

@@ -1,20 +1,28 @@
 using Mono.Cecil;
+using Mono.Linker;
 using Mono.Linker.Steps;
 using MonoDroid.Tuner;
 
 namespace Microsoft.Android.Sdk.ILLink
 {
-	class PreserveJavaInterfaces : BaseSubStep
+	class PreserveJavaInterfaces : BaseMarkHandler
 	{
-		public override bool IsActiveFor (AssemblyDefinition assembly)
+		public override void Initialize (LinkContext context, MarkContext markContext)
 		{
-			return assembly.Name.Name == "Mono.Android" || assembly.MainModule.HasTypeReference ("Android.Runtime.IJavaObject");
+			base.Initialize (context, markContext);
+			markContext.RegisterMarkTypeAction (type => ProcessType (type));
 		}
 
-		public override SubStepTargets Targets { get { return SubStepTargets.Type;  } }
+		bool IsActiveFor (AssemblyDefinition assembly)
+		{
+			return assembly.Name.Name == "Mono.Android" || assembly.MainModule.HasTypeReference ("Android.Runtime.IJavaObject");
+		}
 
-		public override void ProcessType (TypeDefinition type)
+		void ProcessType (TypeDefinition type)
 		{
+			if (!IsActiveFor (type.Module.Assembly))
+				return;
+
 			// If we are preserving a Mono.Android interface,
 			// preserve all members on the interface.
 			if (!type.IsInterface)

src/Microsoft.Android.Sdk.ILLink/PreserveRegistrations.cs

@@ -10,31 +10,19 @@
 
 namespace Microsoft.Android.Sdk.ILLink
 {
-	class PreserveRegistrations : BaseSubStep
+	class PreserveRegistrations : BaseMarkHandler
 	{
-		delegate void AddPreservedMethodDelegate (AnnotationStore store, MethodDefinition key, MethodDefinition method);
-
-		static readonly AddPreservedMethodDelegate addPreservedMethod;
-
-		readonly TypeDefinitionCache cache;
-
-		public PreserveRegistrations (TypeDefinitionCache cache) => this.cache = cache;
-
-		static PreserveRegistrations ()
+		public override void Initialize (LinkContext context, MarkContext markContext)
 		{
-			// temporarily use reflection to get void AnnotationStore::AddPreservedMethod (MethodDefinition key, MethodDefinition method)
-			// this can be removed once we have newer Microsoft.NET.ILLink containing https://github.com/mono/linker/commit/e6dadc995a834603e1178f9a1918f0ae38056b29
-			var method = typeof (AnnotationStore).GetMethod ("AddPreservedMethod", new Type [] { typeof (MethodDefinition), typeof (MethodDefinition) });
-			addPreservedMethod = (AddPreservedMethodDelegate)(method != null ? Delegate.CreateDelegate (typeof (AddPreservedMethodDelegate), null, method, false) : null);
+			base.Initialize (context, markContext);
+			markContext.RegisterMarkMethodAction (method => ProcessMethod (method));
 		}
 
-		public override bool IsActiveFor (AssemblyDefinition assembly)
+		bool IsActiveFor (AssemblyDefinition assembly)
 		{
-			return addPreservedMethod != null && (assembly.Name.Name == "Mono.Android" || assembly.MainModule.HasTypeReference ("Android.Runtime.RegisterAttribute"));
+			return assembly.Name.Name == "Mono.Android" || assembly.MainModule.HasTypeReference ("Android.Runtime.RegisterAttribute");
 		}
 
-		public override SubStepTargets Targets { get { return SubStepTargets.Method;  } }
-
 		bool PreserveJniMarshalMethods ()
 		{
 			if (Context.TryGetCustomData ("XAPreserveJniMarshalMethods", out var boolValue))
@@ -78,13 +66,16 @@ void PreserveRegisteredMethod (TypeDefinition type, string member, MethodDefinit
 				type = type.BaseType.Resolve ();
 		}
 
-		public override void ProcessMethod (MethodDefinition method)
+		void ProcessMethod (MethodDefinition method)
 		{
+			if (!IsActiveFor (method.Module.Assembly))
+				return;
+
 			bool preserveJniMarshalMethodOnly = false;
 			if (!method.TryGetRegisterMember (out var member, out var nativeMethod, out var signature)) {
 				if (PreserveJniMarshalMethods () &&
-				    method.DeclaringType.GetMarshalMethodsType () != null &&
-				    method.TryGetBaseOrInterfaceRegisterMember (cache, out member, out nativeMethod, out signature)) {
+					method.DeclaringType.GetMarshalMethodsType () != null &&
+					method.TryGetBaseOrInterfaceRegisterMember (cache, out member, out nativeMethod, out signature)) {
 					preserveJniMarshalMethodOnly = true;
 				} else {
 					return;
@@ -105,7 +96,7 @@ public override void ProcessMethod (MethodDefinition method)
 
 		void AddPreservedMethod (MethodDefinition key, MethodDefinition method)
 		{
-			addPreservedMethod.Invoke (Context.Annotations, key, method);
+			Annotations.AddPreservedMethod (key, method);
 		}
 	}
 }

src/Microsoft.Android.Sdk.ILLink/PreserveSubStepDispatcher.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Mono.Linker.Steps;
+using Mono.Tuner;
+
+namespace Microsoft.Android.Sdk.ILLink
+{
+	public class PreserveSubStepDispatcher : MarkSubStepsDispatcher
+	{
+		public PreserveSubStepDispatcher ()
+			: base (new ISubStep[] {
+				new ApplyPreserveAttribute (),
+				new PreserveExportedTypes ()
+			})
+		{
+		}
+	}
+}

src/Microsoft.Android.Sdk.ILLink/SetupStep.cs

@@ -26,51 +26,18 @@ List<IStep> Steps {
 			}
 		}
 
-		static MethodInfo getReferencedAssembliesMethod = typeof (LinkContext).GetMethod ("GetReferencedAssemblies", BindingFlags.Public | BindingFlags.Instance);
-
 		protected override void Process ()
 		{
-			string tfmPaths;
-			if (Context.TryGetCustomData ("XATargetFrameworkDirectories", out tfmPaths))
+			if (Context.TryGetCustomData ("XATargetFrameworkDirectories", out string tfmPaths))
 				Xamarin.Android.Tasks.MonoAndroidHelper.TargetFrameworkDirectories = tfmPaths.Split (new char [] { ';' });
 
-			var subSteps1 = new SubStepDispatcher ();
-			subSteps1.Add (new ApplyPreserveAttribute ());
-
-			var cache = new TypeDefinitionCache ();
-			var subSteps2 = new SubStepDispatcher ();
-			subSteps2.Add (new PreserveExportedTypes ());
-			subSteps2.Add (new MarkJavaObjects ());
-			subSteps2.Add (new PreserveJavaExceptions ());
-			subSteps2.Add (new PreserveApplications ());
-			subSteps2.Add (new PreserveRegistrations (cache));
-			subSteps2.Add (new PreserveJavaInterfaces ());
-
-			InsertAfter (new FixAbstractMethodsStep (cache), "SetupStep");
-			InsertAfter (subSteps2, "SetupStep");
-			InsertAfter (subSteps1, "SetupStep");
-
-			// temporary workaround: this call forces illink to process all the assemblies
-			if (getReferencedAssembliesMethod == null)
-				throw new InvalidOperationException ($"Temporary linker workaround failed, {nameof (getReferencedAssembliesMethod)} is null.");
-
-			foreach (var assembly in (IEnumerable<AssemblyDefinition>)getReferencedAssembliesMethod.Invoke (Context, null))
-				Context.LogMessage ($"Reference assembly to process: {assembly}");
-
-			string proguardPath;
-			if (Context.TryGetCustomData ("ProguardConfiguration", out proguardPath))
-				InsertAfter (new GenerateProguardConfiguration (proguardPath),  "CleanStep");
-
-			string addKeepAlivesStep;
-			if (Context.TryGetCustomData ("AddKeepAlivesStep", out addKeepAlivesStep) && bool.TryParse (addKeepAlivesStep, out var bv) && bv)
-				InsertAfter (new AddKeepAlivesStep (cache), "CleanStep");
-
+			// The following steps share state and must be injected via reflection until we get
+			// a linker with the fix from https://github.com/mono/linker/pull/2019.
 			string androidLinkResources;
 			if (Context.TryGetCustomData ("AndroidLinkResources", out androidLinkResources) && bool.TryParse (androidLinkResources, out var linkResources) && linkResources) {
 				InsertAfter (new RemoveResourceDesignerStep (),  "CleanStep");
 				InsertAfter (new GetAssembliesStep (), "CleanStep");
 			}
-			InsertAfter (new StripEmbeddedLibraries (),  "CleanStep");
 		}
 
 		void InsertAfter (IStep step, string stepName)

src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/AddKeepAlivesStep.cs

@@ -10,18 +10,30 @@
 using Mono.Linker.Steps;
 
 using Mono.Cecil.Cil;
+#if NET5_LINKER
+using Microsoft.Android.Sdk.ILLink;
+#endif  // NET5_LINKER
 
 namespace MonoDroid.Tuner
 {
 	public class AddKeepAlivesStep : BaseStep
 	{
-		readonly TypeDefinitionCache cache;
 
-		public AddKeepAlivesStep (TypeDefinitionCache cache)
+#if NET5_LINKER
+		protected override void Process ()
+		{
+			cache = new LinkContextMetadataResolver (Context);
+		}
+#else   // !NET5_LINKER
+		public AddKeepAlivesStep (IMetadataResolver cache)
 		{
 			this.cache = cache;
 		}
 
+		readonly
+#endif  // !NET5_LINKER
+		IMetadataResolver cache;
+
 		protected override void ProcessAssembly (AssemblyDefinition assembly)
 		{
 			var action = Annotations.HasAction (assembly) ? Annotations.GetAction (assembly) : AssemblyAction.Skip;

src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/ApplyPreserveAttribute.cs

@@ -8,10 +8,6 @@
 
 using Mono.Cecil;
 
-#if NET5_LINKER
-using Microsoft.Android.Sdk.ILLink;
-#endif
-
 namespace MonoDroid.Tuner {
 
 	public class ApplyPreserveAttribute : ApplyPreserveAttributeBase {

src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/Extensions.cs

@@ -255,7 +255,7 @@ public static TypeDefinition GetMarshalMethodsType (this TypeDefinition type)
 			return null;
 		}
 
-		public static bool TryGetBaseOrInterfaceRegisterMember (this MethodDefinition method, TypeDefinitionCache cache, out string member, out string nativeMethod, out string signature)
+		public static bool TryGetBaseOrInterfaceRegisterMember (this MethodDefinition method, IMetadataResolver resolver, out string member, out string nativeMethod, out string signature)
 		{
 			var type = method.DeclaringType;
 
@@ -264,45 +264,45 @@ public static bool TryGetBaseOrInterfaceRegisterMember (this MethodDefinition me
 			if (method.IsConstructor || type == null || !type.HasNestedTypes)
 				return false;
 
-			var m = method.GetBaseDefinition (cache);
+			var m = method.GetBaseDefinition (resolver);
 
 			while (m != null) {
 				if (m == method)
-                                        break;
+					break;
 
 				method = m;
 
 				if (m.TryGetRegisterMember (out member, out nativeMethod, out signature))
 					return true;
 
-				m = m.GetBaseDefinition (cache);
+				m = m.GetBaseDefinition (resolver);
 			}
 
 			if (!method.DeclaringType.HasInterfaces || !method.IsNewSlot)
 				return false;
 
 			foreach (var iface in method.DeclaringType.Interfaces) {
 				if (iface.InterfaceType.IsGenericInstance)
-                                        continue;
+					continue;
 
 				var itype = iface.InterfaceType.Resolve ();
 				if (itype == null || !itype.HasMethods)
 					continue;
 
 				foreach (var im in itype.Methods)
-					if (im.IsEqual (method, cache))
+					if (im.IsEqual (method, resolver))
 						return im.TryGetRegisterMember (out member, out nativeMethod, out signature);
-                        }
+				}
 
-                        return false;
+			return false;
 		}
 
-		public static bool IsEqual (this MethodDefinition m1, MethodDefinition m2, TypeDefinitionCache cache)
+		public static bool IsEqual (this MethodDefinition m1, MethodDefinition m2, IMetadataResolver resolver)
 		{
 			if (m1.Name != m2.Name || m1.ReturnType.Name != m2.ReturnType.Name)
 				return false;
 
-			return m1.Parameters.AreParametersCompatibleWith (m2.Parameters, cache);
+			return m1.Parameters.AreParametersCompatibleWith (m2.Parameters, resolver);
 		}
 
 		public static bool TryGetMarshalMethod (this MethodDefinition method, string nativeMethod, string signature, out MethodDefinition marshalMethod)