[XamlC] accomodate all kinds of netstandard versions

Author: StephaneDelcroix

Xamarin.Forms.Build.Tasks/CompiledConverters/ListStringTypeConverter.cs

@@ -28,7 +28,7 @@ public IEnumerable<Instruction> ConvertFromString(string value, ILContext contex
 												   classArguments: new[] { ("mscorlib", "System", "String") });
 
 			yield return Instruction.Create(OpCodes.Ldc_I4, parts.Count);
-			yield return Instruction.Create(OpCodes.Newobj, module.ImportCtorReference(("mscorlib", "System.Collections.Generic", "List`1"),
+			yield return Instruction.Create(OpCodes.Newobj, module.ImportCtorReference(("System.Collections", "System.Collections.Generic", "List`1"),
 																					   paramCount: 1,
 																					   predicate: md => md.Parameters[0].ParameterType.FullName == "System.Int32",
 																					   classArguments: new[] { ("mscorlib", "System", "String") }));

Xamarin.Forms.Build.Tasks/ModuleDefinitionExtensions.cs

@@ -139,19 +139,34 @@ public static MethodReference ImportMethodReference(this ModuleDefinition module
 												classArguments?.Select(gp => module.GetTypeDefinition((gp.assemblyName, gp.clrNamespace, gp.typeName))).ToArray());
 		}
 
+		static Dictionary<(ModuleDefinition module, (string assemblyName, string clrNamespace, string typeName)), TypeDefinition> typeDefCache
+			= new Dictionary<(ModuleDefinition module, (string assemblyName, string clrNamespace, string typeName)), TypeDefinition>();
+
 		public static TypeDefinition GetTypeDefinition(this ModuleDefinition module, (string assemblyName, string clrNamespace, string typeName) type)
 		{
+			if (typeDefCache.TryGetValue((module, type), out TypeDefinition cachedTypeDefinition))
+				return cachedTypeDefinition;
+
 			var asm = module.Assembly.Name.Name == type.assemblyName
 							? module.Assembly
 							: module.AssemblyResolver.Resolve(AssemblyNameReference.Parse(type.assemblyName));
 			var typeDef = asm.MainModule.GetType($"{type.clrNamespace}.{type.typeName}");
-			if (typeDef != null)
+			if (typeDef != null) {
+				typeDefCache.Add((module, type), typeDef);
 				return typeDef;
+			}
 			var exportedType = asm.MainModule.ExportedTypes.FirstOrDefault(
-				(ExportedType arg) => arg.IsForwarder && arg.Namespace == type.clrNamespace && arg.Name == type.typeName);
-			if (exportedType != null)
-				return exportedType.Resolve();
-			return null;
+				arg => arg.IsForwarder && arg.Namespace == type.clrNamespace && arg.Name == type.typeName);
+			if (exportedType != null) {
+				typeDef = exportedType.Resolve();
+				typeDefCache.Add((module, type), typeDef);
+				return typeDef;
+			}
+
+			//I hate you, netstandard
+			if (type.assemblyName == "mscorlib" && type.clrNamespace == "System.Reflection")
+				return module.GetTypeDefinition(("System.Reflection", type.clrNamespace, type.typeName));
+				throw new Exception($"Failed to get typedef for {type}");
 		}
 
 		static IEnumerable<PropertyDefinition> Properties(this TypeDefinition typedef, bool flatten)

Xamarin.Forms.Build.Tasks/NodeILExtensions.cs

@@ -443,16 +443,10 @@ static IEnumerable<Instruction> PushTargetProperty(FieldReference bpRef, Propert
 				yield break;
 			}
 			if (propertyRef != null) {
-//				IL_0000:  ldtoken [mscorlib]System.String
-//				IL_0005:  call class [mscorlib]System.Type class [mscorlib] System.Type::GetTypeFromHandle(valuetype [mscorlib] System.RuntimeTypeHandle)
-//				IL_000a:  ldstr "Foo"
-//				IL_000f:  callvirt instance class [mscorlib] System.Reflection.PropertyInfo class [mscorlib] System.Type::GetProperty(string)
-				var getTypeFromHandle = module.ImportMethodReference(("mscorlib", "System", "Type"), methodName: "GetTypeFromHandle", paramCount: 1, predicate: md => md.IsStatic);
-				var getPropertyInfo = module.ImportMethodReference(("mscorlib", "System", "Type"), methodName: "GetProperty", paramCount: 1);
 				yield return Create(Ldtoken, module.ImportReference(declaringTypeReference ?? propertyRef.DeclaringType));
-				yield return Create(Call, module.ImportReference(getTypeFromHandle));
+				yield return Create(Call, module.ImportMethodReference(("mscorlib", "System", "Type"), methodName: "GetTypeFromHandle", paramCount: 1, predicate: md => md.IsStatic));
 				yield return Create(Ldstr, propertyRef.Name);
-				yield return Create(Callvirt, module.ImportReference(getPropertyInfo));
+				yield return Create(Call, module.ImportMethodReference(("System.Reflection.Extensions", "System.Reflection", "RuntimeReflectionExtensions"), methodName: "GetRuntimeProperty", paramCount: 2));
 				yield break;
 			}
 			yield return Create(Ldnull);

Xamarin.Forms.Build.Tasks/XamlCAssemblyResolver.cs

@@ -1,3 +1,4 @@
+using System;
 using Mono.Cecil;
 
 namespace Xamarin.Forms.Build.Tasks
@@ -11,5 +12,36 @@ public void AddAssembly(string p)
 				AssemblyResolver = this
 			}));
 		}
+
+		public override AssemblyDefinition Resolve(AssemblyNameReference name)
+		{
+			if (TryResolve(name, out AssemblyDefinition assembly))
+				return assembly;
+			if (   IsMscorlib(name)
+			    && (  TryResolve(AssemblyNameReference.Parse("mscorlib"), out assembly)
+			       || TryResolve(AssemblyNameReference.Parse("netstandard"), out assembly)
+			       || TryResolve(AssemblyNameReference.Parse("System.Runtime"), out assembly)))
+				return assembly;
+			throw new AssemblyResolutionException(name);
+		}
+
+		bool TryResolve(AssemblyNameReference assemblyNameReference, out AssemblyDefinition assembly)
+		{
+			try {
+				assembly = base.Resolve(assemblyNameReference);
+				return true;
+			}
+			catch (AssemblyResolutionException) {
+				assembly = null;
+				return false;
+			}
+		}
+
+		static bool IsMscorlib(AssemblyNameReference name)
+		{
+			return    name.Name == "mscorlib"
+				   || name.Name == "System.Runtime"
+				   || name.Name == "netstandard";
+		}
 	}
 }