[linker] shortcircuit to prevent string.Format calls

I was using the Mono profiler for our build, and I noticed:

    Allocation summary
        Bytes      Count  Average Type name
    180765632    2142803       84 System.String
     53218472 bytes from:
            MonoDroid.Tuner.FixAbstractMethodsStep:FixAbstractMethods (Mono.Cecil.AssemblyDefinition)
            MonoDroid.Tuner.FixAbstractMethodsStep:FixAbstractMethodsUnconditional (Mono.Cecil.AssemblyDefinition)
            MonoDroid.Tuner.FixAbstractMethodsStep:FixAbstractMethods (Mono.Cecil.TypeDefinition)
            MonoDroid.Tuner.FixAbstractMethodsStep:HaveSameSignature (Mono.Cecil.TypeReference,Mono.Cecil.MethodDefinition,Mono.Cecil.MethodDefinition)
            (wrapper managed-to-native) string:FastAllocateString (int)

~53MB of string from this one method is a lot!

I found that one of these `string.Format` calls are running for almost
every method on every interface in every assembly:

    (string.Format ("{0}.{1}", iface.FullName, iMethod.Name) != tMethod.Name) :
    (string.Format ("{0}.{1}.{2}", iMethod.DeclaringType.DeclaringType, iface.Name, iMethod.Name) != tMethod.Name))

Even the simplest non-matching cases would call `string.Format`:

    iMethod.Name == "Foo"
    tMethod.Name == "Bar"

Since this if-statement is quite long, I refactored it into a new
`HaveSameMethodName` method to match the `HaveSameSignature` method.

I added a simple check that would skip the `string.Format` calls:

    if (tMethod.Name.IndexOf (".", StringComparison.Ordinal) == -1)
        return false;

If there is no ".", we don't need to append strings that would contain
one. There is no way the `==` would match in that case.

~~ Results ~~

An initial build of the Xamarin.Forms integration project on
Windows/.NET framework:

    Before:
    796 ms  LinkAssembliesNoShrink                     1 calls
    After:
    767 ms  LinkAssembliesNoShrink                     1 calls

The same project on macOS/Mono (slightly slower machine, too):

    Before:
    1341 ms  LinkAssembliesNoShrink                     1 calls
    After:
    1025 ms  LinkAssembliesNoShrink                     1 calls

String allocations are way better, too:

    Before:
    Allocation summary
        Bytes      Count  Average Type name
    180765632    2142803       84 System.String
    After:
    Allocation summary
        Bytes      Count  Average Type name
    127736832    1652070       77 System.String

Shows 53,028,800 bytes saved.

    Before:
    53218472 bytes from:
        MonoDroid.Tuner.FixAbstractMethodsStep:FixAbstractMethods (Mono.Cecil.AssemblyDefinition)
        MonoDroid.Tuner.FixAbstractMethodsStep:FixAbstractMethodsUnconditional (Mono.Cecil.AssemblyDefinition)
        MonoDroid.Tuner.FixAbstractMethodsStep:FixAbstractMethods (Mono.Cecil.TypeDefinition)
        MonoDroid.Tuner.FixAbstractMethodsStep:HaveSameSignature (Mono.Cecil.TypeReference,Mono.Cecil.MethodDefinition,Mono.Cecil.MethodDefinition)
    After:
     1933624 bytes from:
        MonoDroid.Tuner.FixAbstractMethodsStep:FixAbstractMethodsUnconditional (Mono.Cecil.AssemblyDefinition)
        MonoDroid.Tuner.FixAbstractMethodsStep:FixAbstractMethods (Mono.Cecil.TypeDefinition)
        MonoDroid.Tuner.FixAbstractMethodsStep:HaveSameSignature (Mono.Cecil.TypeReference,Mono.Cecil.MethodDefinition,Mono.Cecil.MethodDefinition)
        MonoDroid.Tuner.FixAbstractMethodsStep:HaveSameMethodName (Mono.Cecil.TypeReference,Mono.Cecil.MethodDefinition,Mono.Cecil.MethodDefinition)

Shows 51,284,848 bytes saved.

I don't know about the discrepancy between these two sets of numbers.
But I think this is roughly ~50MB less string allocations.

Author: jonathanpeppers

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

@@ -158,7 +158,7 @@ bool HaveSameSignature (TypeReference iface, MethodDefinition iMethod, MethodDef
 			if (IsInOverrides (iMethod, tMethod))
 				return true;
 
-			if (iMethod.Name != tMethod.Name && (iMethod.DeclaringType == null || (iMethod.DeclaringType.DeclaringType == null ? (string.Format ("{0}.{1}", iface.FullName, iMethod.Name) != tMethod.Name) : (string.Format ("{0}.{1}.{2}", iMethod.DeclaringType.DeclaringType, iface.Name, iMethod.Name) != tMethod.Name))))
+			if (!HaveSameMethodName (iface, iMethod, tMethod))
 				return false;
 
 			if (!CompareTypes (iMethod.MethodReturnType.ReturnType, tMethod.MethodReturnType.ReturnType))
@@ -189,6 +189,20 @@ bool HaveSameSignature (TypeReference iface, MethodDefinition iMethod, MethodDef
 			return true;
 		}
 
+		bool HaveSameMethodName (TypeReference iface, MethodDefinition iMethod, MethodDefinition tMethod)
+		{
+			if (iMethod.Name == tMethod.Name)
+				return true;
+			if (tMethod.Name.IndexOf (".", StringComparison.Ordinal) == -1)
+				return false;
+			var declaringType = iMethod.DeclaringType?.DeclaringType;
+			if (declaringType == null) {
+				return $"{iface.FullName}.{iMethod.Name}" == tMethod.Name;
+			} else {
+				return $"{iMethod.DeclaringType.DeclaringType}.{iface.Name}.{iMethod.Name}" == tMethod.Name;
+			}
+		}
+
 		bool FixAbstractMethods (TypeDefinition type)
 		{
 			if (!type.HasInterfaces)

src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/LinkerTests.cs

@@ -70,6 +70,75 @@ static void CreateAbstractIfaceImplementation (string assemblyPath, AssemblyDefi
 			}
 		}
 
+		[Test]
+		public void FixAbstractMethodsStep_NestedTypes ()
+		{
+			var path = Path.Combine (Path.GetFullPath (XABuildPaths.TestOutputDirectory), "temp", TestName);
+			var step = new FixAbstractMethodsStep ();
+			var pipeline = new Pipeline ();
+
+			Directory.CreateDirectory (path);
+
+			using (var context = new LinkContext (pipeline)) {
+
+				context.Resolver.AddSearchDirectory (path);
+
+				var myAssemblyPath = Path.Combine (path, "MyAssembly.dll");
+
+				using (var android = CreateFauxMonoAndroidAssembly ()) {
+					android.Write (Path.Combine (path, "Mono.Android.dll"));
+					CreateNestedInterface (myAssemblyPath, android);
+				}
+
+				using (var assm = context.Resolve (myAssemblyPath)) {
+					step.Process (context);
+
+					var impl = assm.MainModule.GetType ("MyNamespace.Nested/MyClass");
+					var method = impl.Methods.FirstOrDefault (m => m.Name == "MyImplementedMethod");
+					Assert.IsNotNull (method, "MyImplementedMethod should exist");
+					Assert.AreEqual (0, method.Body.Instructions.Count, "MyImplementedMethod should be an empty method");
+					method = impl.Methods.FirstOrDefault (m => m.Name == "MyMissingMethod");
+					Assert.IsNotNull (method, "MyMissingMethod should exist");
+					Assert.AreNotEqual (0, method.Body.Instructions.Count, "MyMissingMethod should *not* be an empty method");
+				}
+			}
+
+			Directory.Delete (path, true);
+		}
+
+		static void CreateNestedInterface (string assemblyPath, AssemblyDefinition android)
+		{
+			using (var assm = AssemblyDefinition.CreateAssembly (new AssemblyNameDefinition ("NestedIFaceTest", new Version ()), "NestedIFaceTest", ModuleKind.Dll)) {
+				var void_type = assm.MainModule.ImportReference (typeof (void));
+				var int_type = assm.MainModule.ImportReference (typeof (int));
+
+				// Create nested interface
+				var nested = new TypeDefinition ("MyNamespace", "Nested", TypeAttributes.Class);
+				var iface = new TypeDefinition (null, "IMyInterface", TypeAttributes.Interface);
+				iface.DeclaringType = nested;
+				nested.NestedTypes.Add (iface);
+
+				var impl_method = new MethodDefinition ("MyImplementedMethod", MethodAttributes.Abstract, void_type);
+				iface.Methods.Add (impl_method);
+				var missing_method = new MethodDefinition ("MyMissingMethod", MethodAttributes.Abstract, void_type);
+				iface.Methods.Add (missing_method);
+				assm.MainModule.Types.Add (nested);
+				assm.MainModule.Types.Add (iface);
+
+				// Create nested implementing class
+				var jlo = assm.MainModule.ImportReference (android.MainModule.GetType ("Java.Lang.Object"));
+				var impl = new TypeDefinition (null, "MyClass", TypeAttributes.Public, jlo);
+				impl.Interfaces.Add (new InterfaceImplementation (iface));
+				impl.DeclaringType = nested;
+				nested.NestedTypes.Add (impl);
+
+				impl.Methods.Add (new MethodDefinition (impl_method.Name, MethodAttributes.Public, void_type));
+
+				assm.MainModule.Types.Add (impl);
+				assm.Write (assemblyPath);
+			}
+		}
+
 		static AssemblyDefinition CreateFauxMonoAndroidAssembly ()
 		{
 			var assm = AssemblyDefinition.CreateAssembly (new AssemblyNameDefinition ("Mono.Android", new Version ()), "DimTest", ModuleKind.Dll);