jsuarezruiz
/
maui-linux
зеркало из https://github.com/jsuarezruiz/maui-linux.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

[XamlC] Produce correct mdb files (#699) 

* [XamlC] change MockCompile (internal) API

* [XamlC] fix debugging in unit test project

* f

* [XamlC] update cecil to 0.10.0-beta1-v2

* beta2

* avoid method duplication

* [XamlC] force loading MdbReader and Writer

* [XamlC] force use the writer in the other task too

* [XamlC] fix test and test code generator

* try building this

* [XamlC] Ensure InitializeComponent is correctly routed

* fix
This commit is contained in:
Stephane Delcroix 2017-02-02 10:57:50 +01:00 коммит произвёл GitHub
Родитель 72699e34b2
Коммит fa0882114d
47 изменённых файлов: 748 добавлений и 534 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
.nuspec/Xamarin.Forms.Debug.targets
Просмотреть файл

@ -65,6 +65,7 @@
<DebugXamlCTask
Assembly = "$(IntermediateOutputPath)$(TargetFileName)"
ReferencePath = "@(ReferencePath)"
Verbosity = "4"
DebugSymbols = "$(DebugSymbols)" />
</Target>

4
Xamarin.Forms.Build.Tasks/BindablePropertyReferenceExtensions.cs
Просмотреть файл

@ -26,7 +26,7 @@ namespace Xamarin.Forms.Build.Tasks
md.IsStatic &&
md.IsPublic &&
md.Parameters.Count == 1 &&
md.Parameters[0].ParameterType.InheritsFromOrImplements(module.Import(typeof(BindableObject))), module).SingleOrDefault()?.Item1;
md.Parameters[0].ParameterType.InheritsFromOrImplements(module.ImportReference(typeof(BindableObject))), module).SingleOrDefault()?.Item1;
if (getter == null)
throw new XamlParseException($"Missing a public static Get{bpName} or a public instance property getter for the attached property \"{bpRef.DeclaringType}.{bpRef.Name}\"", iXmlLineInfo);
@ -43,7 +43,7 @@ namespace Xamarin.Forms.Build.Tasks
md.IsStatic &&
md.IsPublic &&
md.Parameters.Count == 1 &&
md.Parameters[0].ParameterType.InheritsFromOrImplements(module.Import(typeof(BindableObject))), module).SingleOrDefault()?.Item1;
md.Parameters[0].ParameterType.InheritsFromOrImplements(module.ImportReference(typeof(BindableObject))), module).SingleOrDefault()?.Item1;
var attributes = new List<CustomAttribute>();
if (property != null && property.HasCustomAttributes)

4
Xamarin.Forms.Build.Tasks/CompiledConverters/BindablePropertyConverter.cs
Просмотреть файл

@ -84,8 +84,8 @@ namespace Xamarin.Forms.Core.XamlC
TypeReference declaringTypeReference;
FieldReference bpRef = typeRef.GetField(fd => fd.Name == $"{propertyName}Property" && fd.IsStatic && fd.IsPublic, out declaringTypeReference);
if (bpRef != null) {
bpRef = module.Import(bpRef.ResolveGenericParameters(declaringTypeReference));
bpRef.FieldType = module.Import(bpRef.FieldType);
bpRef = module.ImportReference(bpRef.ResolveGenericParameters(declaringTypeReference));
bpRef.FieldType = module.ImportReference(bpRef.FieldType);
}
return bpRef;
}

4
Xamarin.Forms.Build.Tasks/CompiledConverters/BindingTypeConverter.cs
Просмотреть файл

@ -17,8 +17,8 @@ namespace Xamarin.Forms.Core.XamlC
if (IsNullOrEmpty(value))
throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(Binding)}", node);
var bindingCtor = module.Import(typeof(Binding)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 6);
var bindingCtorRef = module.Import(bindingCtor);
var bindingCtor = module.ImportReference(typeof(Binding)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 6);
var bindingCtorRef = module.ImportReference(bindingCtor);
yield return Instruction.Create(OpCodes.Ldstr, value);
yield return Instruction.Create(OpCodes.Ldc_I4, (int)BindingMode.Default);

4
Xamarin.Forms.Build.Tasks/CompiledConverters/BoundsTypeConverter.cs
Просмотреть файл

@ -65,8 +65,8 @@ namespace Xamarin.Forms.Core.XamlC
yield return Instruction.Create(OpCodes.Ldc_R8, w);
yield return Instruction.Create(OpCodes.Ldc_R8, h);
var rectangleCtor = module.Import(typeof(Rectangle)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 4);
var rectangleCtorRef = module.Import(rectangleCtor);
var rectangleCtor = module.ImportReference(typeof(Rectangle)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 4);
var rectangleCtorRef = module.ImportReference(rectangleCtor);
yield return Instruction.Create(OpCodes.Newobj, rectangleCtorRef);
}
}

12
Xamarin.Forms.Build.Tasks/CompiledConverters/ColorTypeConverter.cs
Просмотреть файл

@ -25,10 +25,10 @@ namespace Xamarin.Forms.Core.XamlC
yield return Instruction.Create(OpCodes.Ldc_R8, color.G);
yield return Instruction.Create(OpCodes.Ldc_R8, color.B);
yield return Instruction.Create(OpCodes.Ldc_R8, color.A);
var colorCtor = module.Import(typeof(Color)).Resolve().Methods.FirstOrDefault(
var colorCtor = module.ImportReference(typeof(Color)).Resolve().Methods.FirstOrDefault(
md => md.IsConstructor && md.Parameters.Count == 4 &&
md.Parameters.All(p => p.ParameterType.FullName == "System.Double"));
var colorCtorRef = module.Import(colorCtor);
var colorCtorRef = module.ImportReference(colorCtor);
yield return Instruction.Create(OpCodes.Newobj, colorCtorRef);
yield break;
}
@ -36,14 +36,14 @@ namespace Xamarin.Forms.Core.XamlC
if (parts.Length == 1 || (parts.Length == 2 && parts [0] == "Color")) {
var color = parts [parts.Length - 1];
var field = module.Import(typeof(Color)).Resolve().Fields.SingleOrDefault(fd => fd.Name == color && fd.IsStatic);
var field = module.ImportReference(typeof(Color)).Resolve().Fields.SingleOrDefault(fd => fd.Name == color && fd.IsStatic);
if (field != null) {
yield return Instruction.Create(OpCodes.Ldsfld, module.Import(field));
yield return Instruction.Create(OpCodes.Ldsfld, module.ImportReference(field));
yield break;
}
var propertyGetter = module.Import(typeof(Color)).Resolve().Properties.SingleOrDefault(pd => pd.Name == color && pd.GetMethod.IsStatic)?.GetMethod;
var propertyGetter = module.ImportReference(typeof(Color)).Resolve().Properties.SingleOrDefault(pd => pd.Name == color && pd.GetMethod.IsStatic)?.GetMethod;
if (propertyGetter != null) {
yield return Instruction.Create(OpCodes.Call, module.Import(propertyGetter));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(propertyGetter));
yield break;
}
}

4
Xamarin.Forms.Build.Tasks/CompiledConverters/ConstraintTypeConverter.cs
Просмотреть файл

@ -20,8 +20,8 @@ namespace Xamarin.Forms.Core.XamlC
yield return Instruction.Create(OpCodes.Ldc_R8, size);
var constantDef = module.Import(typeof(Constraint)).Resolve().Methods.FirstOrDefault(md => md.IsStatic && md.Name == "Constant");
var constantRef = module.Import(constantDef);
var constantDef = module.ImportReference(typeof(Constraint)).Resolve().Methods.FirstOrDefault(md => md.IsStatic && md.Name == "Constant");
var constantRef = module.ImportReference(constantDef);
yield return Instruction.Create(OpCodes.Call, constantRef);
}
}

17
Xamarin.Forms.Build.Tasks/CompiledConverters/ICompiledTypeConverter.cs
Просмотреть файл

@ -1,7 +1,8 @@
using System.Collections.Generic;
using Mono.Cecil.Cil;
using Mono.Cecil;
using System.Xml;
using Xamarin.Forms.Xaml;
using System;
namespace Xamarin.Forms.Xaml
{
@ -10,3 +11,17 @@ namespace Xamarin.Forms.Xaml
IEnumerable<Instruction> ConvertFromString(string value, ModuleDefinition module, BaseNode node);
}
}
namespace Xamarin.Forms.Core.XamlC
{
//only used in unit tests to make sure the compiled InitializeComponent is invoked
class IsCompiledTypeConverter : ICompiledTypeConverter
{
public IEnumerable<Instruction> ConvertFromString(string value, ModuleDefinition module, BaseNode node)
{
if (value != "IsCompiled?")
throw new Exception();
yield return Instruction.Create(OpCodes.Ldc_I4_1);
}
}
}

4
Xamarin.Forms.Build.Tasks/CompiledConverters/LayoutOptionsConverter.cs
Просмотреть файл

@ -23,9 +23,9 @@ namespace Xamarin.Forms.Core.XamlC
if (parts.Length == 1 || (parts.Length == 2 && parts [0] == "LayoutOptions")) {
var options = parts [parts.Length - 1];
var field = module.Import(typeof(LayoutOptions)).Resolve().Fields.SingleOrDefault(fd => fd.Name == options && fd.IsStatic);
var field = module.ImportReference(typeof(LayoutOptions)).Resolve().Fields.SingleOrDefault(fd => fd.Name == options && fd.IsStatic);
if (field != null) {
yield return Instruction.Create(OpCodes.Ldsfld, module.Import(field));
yield return Instruction.Create(OpCodes.Ldsfld, module.ImportReference(field));
yield break;
}
}

12
Xamarin.Forms.Build.Tasks/CompiledConverters/ListStringTypeConverter.cs
Просмотреть файл

@ -20,13 +20,13 @@ namespace Xamarin.Forms.Core.XamlC
}
var parts = value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToList();
var listCtor = module.Import(typeof(List<>)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 1 && md.Parameters[0].ParameterType.FullName == "System.Int32");
var listCtorRef = module.Import(listCtor);
listCtorRef = module.Import(listCtorRef.ResolveGenericParameters(module.Import(typeof(List<string>)), module));
var listCtor = module.ImportReference(typeof(List<>)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 1 && md.Parameters[0].ParameterType.FullName == "System.Int32");
var listCtorRef = module.ImportReference(listCtor);
listCtorRef = module.ImportReference(listCtorRef.ResolveGenericParameters(module.ImportReference(typeof(List<string>)), module));
var adder = module.Import(typeof(ICollection<>)).Resolve().Methods.FirstOrDefault(md => md.Name == "Add" && md.Parameters.Count == 1);
var adderRef = module.Import(adder);
adderRef = module.Import(adderRef.ResolveGenericParameters(module.Import(typeof(ICollection<string>)), module));
var adder = module.ImportReference(typeof(ICollection<>)).Resolve().Methods.FirstOrDefault(md => md.Name == "Add" && md.Parameters.Count == 1);
var adderRef = module.ImportReference(adder);
adderRef = module.ImportReference(adderRef.ResolveGenericParameters(module.ImportReference(typeof(ICollection<string>)), module));
yield return Instruction.Create(OpCodes.Ldc_I4, parts.Count);
yield return Instruction.Create(OpCodes.Newobj, listCtorRef);

4
Xamarin.Forms.Build.Tasks/CompiledConverters/RectangleTypeConverter.cs
Просмотреть файл

@ -40,8 +40,8 @@ namespace Xamarin.Forms.Core.XamlC
yield return Instruction.Create(OpCodes.Ldc_R8, w);
yield return Instruction.Create(OpCodes.Ldc_R8, h);
var rectangleCtor = module.Import(typeof(Rectangle)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 4);
var rectangleCtorRef = module.Import(rectangleCtor);
var rectangleCtor = module.ImportReference(typeof(Rectangle)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 4);
var rectangleCtorRef = module.ImportReference(rectangleCtor);
yield return Instruction.Create(OpCodes.Newobj, rectangleCtorRef);
}
}

4
Xamarin.Forms.Build.Tasks/CompiledConverters/ThicknessTypeConverter.cs
Просмотреть файл

@ -42,8 +42,8 @@ namespace Xamarin.Forms.Core.XamlC
{
foreach (var d in args)
yield return Instruction.Create(OpCodes.Ldc_R8, d);
var thicknessCtor = module.Import(typeof(Thickness)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == args.Length);
var thicknessCtorRef = module.Import(thicknessCtor);
var thicknessCtor = module.ImportReference(typeof(Thickness)).Resolve().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == args.Length);
var thicknessCtorRef = module.ImportReference(thicknessCtor);
yield return Instruction.Create(OpCodes.Newobj, thicknessCtorRef);
}
}

6
Xamarin.Forms.Build.Tasks/CompiledConverters/TypeTypeConverter.cs
Просмотреть файл

@ -31,9 +31,9 @@ namespace Xamarin.Forms.Core.XamlC
if (typeRef == null)
goto error;
var getTypeFromHandle = module.Import(typeof(Type).GetMethod("GetTypeFromHandle", new[] { typeof(RuntimeTypeHandle) }));
yield return Instruction.Create(OpCodes.Ldtoken, module.Import(typeRef));
yield return Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle));
var getTypeFromHandle = module.ImportReference(typeof(Type).GetMethod("GetTypeFromHandle", new[] { typeof(RuntimeTypeHandle) }));
yield return Instruction.Create(OpCodes.Ldtoken, module.ImportReference(typeRef));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(getTypeFromHandle));
yield break;
error:

8
Xamarin.Forms.Build.Tasks/CompiledMarkupExtensions/StaticExtension.cs
Просмотреть файл

@ -26,7 +26,7 @@ namespace Xamarin.Forms.Build.Tasks
var typename = member.Substring(0, dotIdx);
var membername = member.Substring(dotIdx + 1);
var typeRef = module.Import(GetTypeReference(typename, module, node));
var typeRef = module.ImportReference(GetTypeReference(typename, module, node));
var fieldRef = GetFieldReference(typeRef, membername, module);
var propertyDef = GetPropertyDefinition(typeRef, membername, module);
@ -75,7 +75,7 @@ namespace Xamarin.Forms.Build.Tasks
}
memberRef = propertyDef.PropertyType;
var getterDef = module.Import(propertyDef.GetMethod);
var getterDef = module.ImportReference(propertyDef.GetMethod);
return new [] { Instruction.Create(OpCodes.Call, getterDef) };
}
@ -105,8 +105,8 @@ namespace Xamarin.Forms.Build.Tasks
fd.IsStatic &&
fd.IsPublic, out declaringTypeReference);
if (fRef != null) {
fRef = module.Import(fRef.ResolveGenericParameters(declaringTypeReference));
fRef.FieldType = module.Import(fRef.FieldType);
fRef = module.ImportReference(fRef.ResolveGenericParameters(declaringTypeReference));
fRef.FieldType = module.ImportReference(fRef.FieldType);
}
return fRef;
}

2
Xamarin.Forms.Build.Tasks/CompiledValueProviders/SetterValueProvider.cs
Просмотреть файл

@ -29,7 +29,7 @@ namespace Xamarin.Forms.Core.XamlC
var bpRef = (new BindablePropertyConverter()).GetBindablePropertyFieldReference((string)bpNode.Value, module, bpNode);
TypeReference _;
var setValueRef = module.Import(module.Import(typeof(Setter)).GetProperty(p => p.Name == "Value", out _).SetMethod);
var setValueRef = module.ImportReference(module.ImportReference(typeof(Setter)).GetProperty(p => p.Name == "Value", out _).SetMethod);
//push the setter
yield return Instruction.Create(OpCodes.Ldloc, vardefref.VariableDefinition);

2
Xamarin.Forms.Build.Tasks/CompiledValueProviders/TriggerValueProvider.cs
Просмотреть файл

@ -29,7 +29,7 @@ namespace Xamarin.Forms.Core.XamlC
var bpRef = (new BindablePropertyConverter()).GetBindablePropertyFieldReference((string)bpNode.Value, module, bpNode);
TypeReference _;
var setValueRef = module.Import(module.Import(typeof(Trigger)).GetProperty(p => p.Name == "Value", out _).SetMethod);
var setValueRef = module.ImportReference(module.ImportReference(typeof(Trigger)).GetProperty(p => p.Name == "Value", out _).SetMethod);
//push the setter
yield return Instruction.Create(OpCodes.Ldloc, vardefref.VariableDefinition);

52
Xamarin.Forms.Build.Tasks/CreateObjectVisitor.cs
Просмотреть файл

@ -39,7 +39,7 @@ namespace Xamarin.Forms.Build.Tasks
public void Visit(ElementNode node, INode parentNode)
{
var typeref = Module.Import(node.XmlType.GetTypeReference(Module, node));
var typeref = Module.ImportReference(node.XmlType.GetTypeReference(Module, node));
TypeDefinition typedef = typeref.Resolve();
if (IsXaml2009LanguagePrimitive(node)) {
@ -56,7 +56,7 @@ namespace Xamarin.Forms.Build.Tasks
var markupProvider = new StaticExtension();
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
typeref = Module.Import(typeref);
typeref = Module.ImportReference(typeref);
var vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
@ -141,15 +141,15 @@ namespace Xamarin.Forms.Build.Tasks
} else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
implicitOperatorref != null) {
//<FileImageSource>path.png</FileImageSource>
var implicitOperator = Module.Import(implicitOperatorref);
var implicitOperator = Module.ImportReference(implicitOperatorref);
Context.IL.Emit(OpCodes.Ldstr, ((ValueNode)(node.CollectionItems.First())).Value as string);
Context.IL.Emit(OpCodes.Call, implicitOperator);
Context.IL.Emit(OpCodes.Stloc, vardef);
} else if (factorymethodinforef != null) {
Context.IL.Emit(OpCodes.Call, Module.Import(factorymethodinforef));
Context.IL.Emit(OpCodes.Call, Module.ImportReference(factorymethodinforef));
Context.IL.Emit(OpCodes.Stloc, vardef);
} else if (!typedef.IsValueType) {
var ctor = Module.Import(ctorinforef);
var ctor = Module.ImportReference(ctorinforef);
// IL_0001: newobj instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::'.ctor'()
// IL_0006: stloc.0
Context.IL.Emit(OpCodes.Newobj, ctor);
@ -160,7 +160,7 @@ namespace Xamarin.Forms.Build.Tasks
// IL_000a: ldc.i4.1
// IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool)
var ctor = Module.Import(ctorinforef);
var ctor = Module.ImportReference(ctorinforef);
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
Context.IL.Emit(OpCodes.Call, ctor);
@ -168,7 +168,7 @@ namespace Xamarin.Forms.Build.Tasks
// IL_0000: ldloca.s 0
// IL_0002: initobj Test/Foo
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Emit(OpCodes.Initobj, Module.Import(typedef));
Context.IL.Emit(OpCodes.Initobj, Module.ImportReference(typedef));
}
if (typeref.FullName == "Xamarin.Forms.Xaml.TypeExtension") {
@ -433,7 +433,7 @@ namespace Xamarin.Forms.Build.Tasks
var ctorinfo =
Context.Body.Method.Module.TypeSystem.Object.Resolve()
.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters);
var ctor = Context.Body.Method.Module.Import(ctorinfo);
var ctor = Context.Body.Method.Module.ImportReference(ctorinfo);
yield return Instruction.Create(OpCodes.Newobj, ctor);
break;
case "System.Char":
@ -446,7 +446,7 @@ namespace Xamarin.Forms.Build.Tasks
case "System.Decimal":
decimal outdecimal;
if (hasValue && decimal.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out outdecimal)) {
var vardef = new VariableDefinition(Context.Body.Method.Module.Import(typeof(decimal)));
var vardef = new VariableDefinition(Context.Body.Method.Module.ImportReference(typeof(decimal)));
Context.Body.Variables.Add(vardef);
//Use an extra temp var so we can push the value to the stack, just like other cases
// IL_0003: ldstr "adecimal"
@ -458,29 +458,29 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldstr, valueString);
yield return Instruction.Create(OpCodes.Ldc_I4, 0x6f); //NumberStyles.Number
var getInvariantInfo =
Context.Body.Method.Module.Import(typeof(CultureInfo))
Context.Body.Method.Module.ImportReference(typeof(CultureInfo))
.Resolve()
.Properties.FirstOrDefault(pd => pd.Name == "InvariantCulture")
.GetMethod;
var getInvariant = Context.Body.Method.Module.Import(getInvariantInfo);
var getInvariant = Context.Body.Method.Module.ImportReference(getInvariantInfo);
yield return Instruction.Create(OpCodes.Call, getInvariant);
yield return Instruction.Create(OpCodes.Ldloca, vardef);
var tryParseInfo =
Context.Body.Method.Module.Import(typeof(decimal))
Context.Body.Method.Module.ImportReference(typeof(decimal))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "TryParse" && md.Parameters.Count == 4);
var tryParse = Context.Body.Method.Module.Import(tryParseInfo);
var tryParse = Context.Body.Method.Module.ImportReference(tryParseInfo);
yield return Instruction.Create(OpCodes.Call, tryParse);
yield return Instruction.Create(OpCodes.Pop);
yield return Instruction.Create(OpCodes.Ldloc, vardef);
} else {
yield return Instruction.Create(OpCodes.Ldc_I4_0);
var decimalctorinfo =
Context.Body.Method.Module.Import(typeof(decimal))
Context.Body.Method.Module.ImportReference(typeof(decimal))
.Resolve()
.Methods.FirstOrDefault(
md => md.IsConstructor && md.Parameters.Count == 1 && md.Parameters [0].ParameterType.FullName == "System.Int32");
var decimalctor = Context.Body.Method.Module.Import(decimalctorinfo);
var decimalctor = Context.Body.Method.Module.ImportReference(decimalctorinfo);
yield return Instruction.Create(OpCodes.Newobj, decimalctor);
}
break;
@ -501,51 +501,51 @@ namespace Xamarin.Forms.Build.Tasks
case "System.TimeSpan":
TimeSpan outspan;
if (hasValue && TimeSpan.TryParse(valueString, CultureInfo.InvariantCulture, out outspan)) {
var vardef = new VariableDefinition(Context.Body.Method.Module.Import(typeof(TimeSpan)));
var vardef = new VariableDefinition(Context.Body.Method.Module.ImportReference(typeof(TimeSpan)));
Context.Body.Variables.Add(vardef);
//Use an extra temp var so we can push the value to the stack, just like other cases
yield return Instruction.Create(OpCodes.Ldstr, valueString);
var getInvariantInfo =
Context.Body.Method.Module.Import(typeof(CultureInfo))
Context.Body.Method.Module.ImportReference(typeof(CultureInfo))
.Resolve()
.Properties.FirstOrDefault(pd => pd.Name == "InvariantCulture")
.GetMethod;
var getInvariant = Context.Body.Method.Module.Import(getInvariantInfo);
var getInvariant = Context.Body.Method.Module.ImportReference(getInvariantInfo);
yield return Instruction.Create(OpCodes.Call, getInvariant);
yield return Instruction.Create(OpCodes.Ldloca, vardef);
var tryParseInfo =
Context.Body.Method.Module.Import(typeof(TimeSpan))
Context.Body.Method.Module.ImportReference(typeof(TimeSpan))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "TryParse" && md.Parameters.Count == 3);
var tryParse = Context.Body.Method.Module.Import(tryParseInfo);
var tryParse = Context.Body.Method.Module.ImportReference(tryParseInfo);
yield return Instruction.Create(OpCodes.Call, tryParse);
yield return Instruction.Create(OpCodes.Pop);
yield return Instruction.Create(OpCodes.Ldloc, vardef);
} else {
yield return Instruction.Create(OpCodes.Ldc_I8, 0L);
var timespanctorinfo =
Context.Body.Method.Module.Import(typeof(TimeSpan))
Context.Body.Method.Module.ImportReference(typeof(TimeSpan))
.Resolve()
.Methods.FirstOrDefault(
md => md.IsConstructor && md.Parameters.Count == 1 && md.Parameters [0].ParameterType.FullName == "System.Int64");
var timespanctor = Context.Body.Method.Module.Import(timespanctorinfo);
var timespanctor = Context.Body.Method.Module.ImportReference(timespanctorinfo);
yield return Instruction.Create(OpCodes.Newobj, timespanctor);
}
break;
case "System.Uri":
Uri outuri;
if (hasValue && Uri.TryCreate(valueString, UriKind.RelativeOrAbsolute, out outuri)) {
var vardef = new VariableDefinition(Context.Body.Method.Module.Import(typeof(Uri)));
var vardef = new VariableDefinition(Context.Body.Method.Module.ImportReference(typeof(Uri)));
Context.Body.Variables.Add(vardef);
//Use an extra temp var so we can push the value to the stack, just like other cases
yield return Instruction.Create(OpCodes.Ldstr, valueString);
yield return Instruction.Create(OpCodes.Ldc_I4, (int)UriKind.RelativeOrAbsolute);
yield return Instruction.Create(OpCodes.Ldloca, vardef);
var tryCreateInfo =
Context.Body.Method.Module.Import(typeof(Uri))
Context.Body.Method.Module.ImportReference(typeof(Uri))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "TryCreate" && md.Parameters.Count == 3);
var tryCreate = Context.Body.Method.Module.Import(tryCreateInfo);
var tryCreate = Context.Body.Method.Module.ImportReference(tryCreateInfo);
yield return Instruction.Create(OpCodes.Call, tryCreate);
yield return Instruction.Create(OpCodes.Pop);
yield return Instruction.Create(OpCodes.Ldloc, vardef);
@ -555,7 +555,7 @@ namespace Xamarin.Forms.Build.Tasks
default:
var defaultctorinfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters);
if (defaultctorinfo != null) {
var defaultctor = Context.Body.Method.Module.Import(defaultctorinfo);
var defaultctor = Context.Body.Method.Module.ImportReference(defaultctorinfo);
yield return Instruction.Create(OpCodes.Newobj, defaultctor);
} else {
//should never happen. but if it does, this prevents corrupting the IL stack

61
Xamarin.Forms.Build.Tasks/DebugXamlCTask.cs
Просмотреть файл

@ -2,16 +2,22 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Cecil.Mdb;
using Mono.Cecil.Pdb;
using Mono.Cecil.Rocks;
using Xamarin.Forms.Xaml;
namespace Xamarin.Forms.Build.Tasks
{
public class DebugXamlCTask : XamlTask
{
public override bool Execute(IList<Exception> thrownExceptions)
public override bool Execute(out IList<Exception> thrownExceptions)
{
thrownExceptions = null;
Logger = Logger ?? new Logger(null, Verbosity);
Logger.LogLine(1, "Preparing debug code for xamlc");
Logger.LogLine(1, "\nAssembly: {0}", Assembly);
@ -37,40 +43,47 @@ namespace Xamarin.Forms.Build.Tasks
// resolver.AddAssembly (p);
}
}
var assemblyDefinition = AssemblyDefinition.ReadAssembly(Assembly, new ReaderParameters
{
//ReadSymbols = DebugSymbols,
using (var assemblyDefinition = AssemblyDefinition.ReadAssembly(Assembly, new ReaderParameters {
ReadWrite = true,
ReadSymbols = DebugSymbols,
SymbolReaderProvider = System.Type.GetType("Mono.Runtime") != null ? ((ISymbolReaderProvider)(new MdbReaderProvider())) : ((ISymbolReaderProvider)new PdbReaderProvider()),
AssemblyResolver = resolver
});
foreach (var module in assemblyDefinition.Modules)
{
})) {
foreach (var module in assemblyDefinition.Modules) {
Logger.LogLine(2, " Module: {0}", module.Name);
foreach (var resource in module.Resources.OfType<EmbeddedResource>())
{
foreach (var resource in module.Resources.OfType<EmbeddedResource>()) {
Logger.LogString(2, " Resource: {0}... ", resource.Name);
string classname;
if (!resource.IsXaml(out classname))
{
if (!resource.IsXaml(out classname)) {
Logger.LogLine(2, "skipped.");
continue;
}
} else
Logger.LogLine(2, "");
TypeDefinition typeDef = module.GetType(classname);
if (typeDef == null)
{
if (typeDef == null) {
Logger.LogLine(2, "no type found... skipped.");
continue;
}
var initComp = typeDef.Methods.FirstOrDefault(md => md.Name == "InitializeComponent");
if (initComp == null)
{
if (initComp == null) {
Logger.LogLine(2, "no InitializeComponent found... skipped.");
continue;
}
var initCompRuntime = typeDef.Methods.FirstOrDefault(md => md.Name == "__InitComponentRuntime");
if (initCompRuntime == null) {
Logger.LogLine(2, "no __InitComponentRuntime found... duplicating.");
initCompRuntime = DuplicateMethodDef(typeDef, initComp, "__InitComponentRuntime");
Logger.LogString(2, " Creating empty {0}.__InitComponentRuntime ...", typeDef.Name);
initCompRuntime = new MethodDefinition("__InitComponentRuntime", initComp.Attributes, initComp.ReturnType);
Logger.LogLine(2, "done.");
Logger.LogString(2, " Copying body of InitializeComponent to __InitComponentRuntime ...", typeDef.Name);
initCompRuntime.Body = new MethodBody(initCompRuntime);
var iCRIl = initCompRuntime.Body.GetILProcessor();
foreach (var instr in initComp.Body.Instructions)
iCRIl.Append(instr);
initComp.Body.Instructions.Clear();
initComp.Body.GetILProcessor().Emit(OpCodes.Ret);
typeDef.Methods.Add(initCompRuntime);
Logger.LogLine(2, "done.");
}
// IL_0000: ldarg.0
@ -94,8 +107,7 @@ namespace Xamarin.Forms.Build.Tasks
.FirstOrDefault();
if (altCtor != null)
Logger.LogString(2, " Replacing body of {0}.{0} (bool {1}) ... ", typeDef.Name, altCtor.Parameters[0].Name);
else
{
else {
Logger.LogString(2, " Adding {0}.{0} (bool useCompiledXaml) ... ", typeDef.Name);
altCtor = new MethodDefinition(".ctor",
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName |
@ -110,7 +122,7 @@ namespace Xamarin.Forms.Build.Tasks
var ret = Instruction.Create(OpCodes.Ret);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt,
module.Import(typeDef.BaseType.Resolve().GetConstructors().First(c => c.HasParameters == false)));
module.ImportReference(typeDef.BaseType.Resolve().GetConstructors().First(c => c.HasParameters == false)));
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_1);
@ -133,10 +145,11 @@ namespace Xamarin.Forms.Build.Tasks
Logger.LogLine(2, "");
}
Logger.LogString(1, "Writing the assembly... ");
assemblyDefinition.Write(Assembly, new WriterParameters
{
assemblyDefinition.Write(new WriterParameters {
SymbolWriterProvider = System.Type.GetType("Mono.Runtime") != null ? ((ISymbolWriterProvider)(new MdbWriterProvider())) : ((ISymbolWriterProvider)new MdbWriterProvider()),
WriteSymbols = DebugSymbols
});
}
Logger.LogLine(1, "done.");
return true;

8
Xamarin.Forms.Build.Tasks/MethodReferenceExtensions.cs
Просмотреть файл

@ -13,16 +13,16 @@ namespace Xamarin.Forms.Build.Tasks
if (declaringTypeRef == null)
throw new ArgumentNullException(nameof(declaringTypeRef));
var reference = new MethodReference(self.Name, module.Import(self.ReturnType))
var reference = new MethodReference(self.Name, module.ImportReference(self.ReturnType))
{
DeclaringType = module.Import(declaringTypeRef),
DeclaringType = module.ImportReference(declaringTypeRef),
HasThis = self.HasThis,
ExplicitThis = self.ExplicitThis,
CallingConvention = self.CallingConvention
};
foreach (var parameter in self.Parameters) {
var p = parameter.ParameterType.IsGenericParameter ? parameter.ParameterType : module.Import(parameter.ParameterType);
var p = parameter.ParameterType.IsGenericParameter ? parameter.ParameterType : module.ImportReference(parameter.ParameterType);
reference.Parameters.Add(new ParameterDefinition(p));
}
@ -37,7 +37,7 @@ namespace Xamarin.Forms.Build.Tasks
if (self.HasParameters)
{
for (var i = 0; i < self.Parameters.Count; i++)
self.Parameters[i].ParameterType = module.Import(self.Parameters[i].ParameterType);
self.Parameters[i].ParameterType = module.ImportReference(self.Parameters[i].ParameterType);
}
}

108
Xamarin.Forms.Build.Tasks/NodeILExtensions.cs
Просмотреть файл

@ -52,7 +52,7 @@ namespace Xamarin.Forms.Build.Tasks
var str = (string)node.Value;
//If the TypeConverter has a ProvideCompiledAttribute that can be resolved, shortcut this
var compiledConverterName = typeConverter?.GetCustomAttribute (module.Import(typeof(ProvideCompiledAttribute)))?.ConstructorArguments?.First().Value as string;
var compiledConverterName = typeConverter?.GetCustomAttribute (module.ImportReference(typeof(ProvideCompiledAttribute)))?.ConstructorArguments?.First().Value as string;
Type compiledConverterType;
if (compiledConverterName != null && (compiledConverterType = Type.GetType (compiledConverterName)) != null) {
var compiledConverter = Activator.CreateInstance (compiledConverterType);
@ -62,24 +62,24 @@ namespace Xamarin.Forms.Build.Tasks
foreach (var i in instructions)
yield return i;
if (targetTypeRef.IsValueType && boxValueTypes)
yield return Instruction.Create (OpCodes.Box, module.Import (targetTypeRef));
yield return Instruction.Create (OpCodes.Box, module.ImportReference (targetTypeRef));
yield break;
}
//If there's a [TypeConverter], use it
if (typeConverter != null)
{
var isExtendedConverter = typeConverter.ImplementsInterface(module.Import(typeof (IExtendedTypeConverter)));
var isExtendedConverter = typeConverter.ImplementsInterface(module.ImportReference(typeof (IExtendedTypeConverter)));
var typeConverterCtor = typeConverter.Resolve().Methods.Single(md => md.IsConstructor && md.Parameters.Count == 0 && !md.IsStatic);
var typeConverterCtorRef = module.Import(typeConverterCtor);
var typeConverterCtorRef = module.ImportReference(typeConverterCtor);
var convertFromInvariantStringDefinition = isExtendedConverter
? module.Import(typeof (IExtendedTypeConverter))
? module.ImportReference(typeof (IExtendedTypeConverter))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 2)
: typeConverter.Resolve()
.AllMethods()
.FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 1);
var convertFromInvariantStringReference = module.Import(convertFromInvariantStringDefinition);
var convertFromInvariantStringReference = module.ImportReference(convertFromInvariantStringDefinition);
yield return Instruction.Create(OpCodes.Newobj, typeConverterCtorRef);
yield return Instruction.Create(OpCodes.Ldstr, node.Value as string);
@ -93,7 +93,7 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Callvirt, convertFromInvariantStringReference);
if (targetTypeRef.IsValueType && unboxValueTypes)
yield return Instruction.Create(OpCodes.Unbox_Any, module.Import(targetTypeRef));
yield return Instruction.Create(OpCodes.Unbox_Any, module.ImportReference(targetTypeRef));
//ConvertFrom returns an object, no need to Box
yield break;
@ -146,10 +146,10 @@ namespace Xamarin.Forms.Build.Tasks
var ts = TimeSpan.Parse(str, CultureInfo.InvariantCulture);
var ticks = ts.Ticks;
var timeSpanCtor =
module.Import(typeof(TimeSpan))
module.ImportReference(typeof(TimeSpan))
.Resolve()
.Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 1);
var timeSpanCtorRef = module.Import(timeSpanCtor);
var timeSpanCtorRef = module.ImportReference(timeSpanCtor);
yield return Instruction.Create(OpCodes.Ldc_I8, ticks);
yield return Instruction.Create(OpCodes.Newobj, timeSpanCtorRef);
@ -157,10 +157,10 @@ namespace Xamarin.Forms.Build.Tasks
var dt = DateTime.Parse(str, CultureInfo.InvariantCulture);
var ticks = dt.Ticks;
var dateTimeCtor =
module.Import(typeof(DateTime))
module.ImportReference(typeof(DateTime))
.Resolve()
.Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 1);
var dateTimeCtorRef = module.Import(dateTimeCtor);
var dateTimeCtorRef = module.ImportReference(dateTimeCtor);
yield return Instruction.Create(OpCodes.Ldc_I8, ticks);
yield return Instruction.Create(OpCodes.Newobj, dateTimeCtorRef);
@ -173,7 +173,7 @@ namespace Xamarin.Forms.Build.Tasks
else if (targetTypeRef.FullName == "System.Decimal") {
decimal outdecimal;
if (decimal.TryParse(str, NumberStyles.Number, CultureInfo.InvariantCulture, out outdecimal)) {
var vardef = new VariableDefinition(context.Body.Method.Module.Import(typeof(decimal)));
var vardef = new VariableDefinition(context.Body.Method.Module.ImportReference(typeof(decimal)));
context.Body.Variables.Add(vardef);
//Use an extra temp var so we can push the value to the stack, just like other cases
// IL_0003: ldstr "adecimal"
@ -185,41 +185,41 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldstr, str);
yield return Instruction.Create(OpCodes.Ldc_I4, 0x6f); //NumberStyles.Number
var getInvariantInfo =
context.Body.Method.Module.Import(typeof(CultureInfo))
context.Body.Method.Module.ImportReference(typeof(CultureInfo))
.Resolve()
.Properties.FirstOrDefault(pd => pd.Name == "InvariantCulture")
.GetMethod;
var getInvariant = context.Body.Method.Module.Import(getInvariantInfo);
var getInvariant = context.Body.Method.Module.ImportReference(getInvariantInfo);
yield return Instruction.Create(OpCodes.Call, getInvariant);
yield return Instruction.Create(OpCodes.Ldloca, vardef);
var tryParseInfo =
context.Body.Method.Module.Import(typeof(decimal))
context.Body.Method.Module.ImportReference(typeof(decimal))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "TryParse" && md.Parameters.Count == 4);
var tryParse = context.Body.Method.Module.Import(tryParseInfo);
var tryParse = context.Body.Method.Module.ImportReference(tryParseInfo);
yield return Instruction.Create(OpCodes.Call, tryParse);
yield return Instruction.Create(OpCodes.Pop);
yield return Instruction.Create(OpCodes.Ldloc, vardef);
} else {
yield return Instruction.Create(OpCodes.Ldc_I4_0);
var decimalctorinfo =
context.Body.Method.Module.Import(typeof(decimal))
context.Body.Method.Module.ImportReference(typeof(decimal))
.Resolve()
.Methods.FirstOrDefault(
md => md.IsConstructor && md.Parameters.Count == 1 && md.Parameters[0].ParameterType.FullName == "System.Int32");
var decimalctor = context.Body.Method.Module.Import(decimalctorinfo);
var decimalctor = context.Body.Method.Module.ImportReference(decimalctorinfo);
yield return Instruction.Create(OpCodes.Newobj, decimalctor);
}
} else if (implicitOperator != null) {
yield return Instruction.Create(OpCodes.Ldstr, node.Value as string);
yield return Instruction.Create(OpCodes.Call, module.Import(implicitOperator));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(implicitOperator));
} else
yield return Instruction.Create(OpCodes.Ldnull);
if (isNullable)
yield return Instruction.Create(OpCodes.Newobj, module.Import(nullableCtor));
yield return Instruction.Create(OpCodes.Newobj, module.ImportReference(nullableCtor));
if (originalTypeRef.IsValueType && boxValueTypes)
yield return Instruction.Create(OpCodes.Box, module.Import(originalTypeRef));
yield return Instruction.Create(OpCodes.Box, module.ImportReference(originalTypeRef));
}
static Instruction PushParsedEnum(TypeReference enumRef, string value, IXmlLineInfo lineInfo)
@ -320,10 +320,10 @@ namespace Xamarin.Forms.Build.Tasks
{
yield return Instruction.Create(OpCodes.Ldc_I4, xmlLineInfo.LineNumber);
yield return Instruction.Create(OpCodes.Ldc_I4, xmlLineInfo.LinePosition);
ctor = module.Import(typeof (XmlLineInfo).GetConstructor(new[] { typeof (int), typeof (int) }));
ctor = module.ImportReference(typeof (XmlLineInfo).GetConstructor(new[] { typeof (int), typeof (int) }));
}
else
ctor = module.Import(typeof (XmlLineInfo).GetConstructor(new Type[] { }));
ctor = module.ImportReference(typeof (XmlLineInfo).GetConstructor(new Type[] { }));
yield return Instruction.Create(OpCodes.Newobj, ctor);
}
@ -373,7 +373,7 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldc_I4, nodes.Count);
yield return Instruction.Create(OpCodes.Add);
yield return Instruction.Create(OpCodes.Newarr, module.TypeSystem.Object);
var finalArray = new VariableDefinition(module.Import(typeof (object[])));
var finalArray = new VariableDefinition(module.ImportReference(typeof (object[])));
context.Body.Variables.Add(finalArray);
yield return Instruction.Create(OpCodes.Stloc, finalArray);
@ -387,13 +387,13 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldc_I4, nodes.Count); //destinationIndex
yield return Instruction.Create(OpCodes.Ldloc, parentObjectLength); //length
var arrayCopy =
module.Import(typeof (Array))
module.ImportReference(typeof (Array))
.Resolve()
.Methods.First(
md =>
md.Name == "Copy" && md.Parameters.Count == 5 &&
md.Parameters[1].ParameterType.FullName == module.TypeSystem.Int32.FullName);
yield return Instruction.Create(OpCodes.Call, module.Import(arrayCopy));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(arrayCopy));
}
//Add nodes to array
@ -407,7 +407,7 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldc_I4, i);
yield return Instruction.Create(OpCodes.Ldloc, context.Variables[en]);
if (context.Variables[en].VariableType.IsValueType)
yield return Instruction.Create(OpCodes.Box, module.Import(context.Variables[en].VariableType));
yield return Instruction.Create(OpCodes.Box, module.ImportReference(context.Variables[en].VariableType));
yield return Instruction.Create(OpCodes.Stelem_Ref);
}
}
@ -424,12 +424,12 @@ namespace Xamarin.Forms.Build.Tasks
// 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.Import(typeof(Type).GetMethod("GetTypeFromHandle", new [] { typeof(RuntimeTypeHandle) }));
var getPropertyInfo = module.Import(typeof(Type).GetMethod("GetProperty", new [] { typeof(string) }));
yield return Instruction.Create(OpCodes.Ldtoken, module.Import(declaringTypeReference ?? propertyRef.DeclaringType));
yield return Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle));
var getTypeFromHandle = module.ImportReference(typeof(Type).GetMethod("GetTypeFromHandle", new [] { typeof(RuntimeTypeHandle) }));
var getPropertyInfo = module.ImportReference(typeof(Type).GetMethod("GetProperty", new [] { typeof(string) }));
yield return Instruction.Create(OpCodes.Ldtoken, module.ImportReference(declaringTypeReference ?? propertyRef.DeclaringType));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(getTypeFromHandle));
yield return Instruction.Create(OpCodes.Ldstr, propertyRef.Name);
yield return Instruction.Create(OpCodes.Callvirt, module.Import(getPropertyInfo));
yield return Instruction.Create(OpCodes.Callvirt, module.ImportReference(getPropertyInfo));
yield break;
}
yield return Instruction.Create(OpCodes.Ldnull);
@ -446,14 +446,14 @@ namespace Xamarin.Forms.Build.Tasks
#endif
var ctorinfo = typeof (XamlServiceProvider).GetConstructor(new Type[] { });
var ctor = module.Import(ctorinfo);
var ctor = module.ImportReference(ctorinfo);
var addServiceInfo = typeof (XamlServiceProvider).GetMethod("Add", new[] { typeof (Type), typeof (object) });
var addService = module.Import(addServiceInfo);
var addService = module.ImportReference(addServiceInfo);
var getTypeFromHandle =
module.Import(typeof (Type).GetMethod("GetTypeFromHandle", new[] { typeof (RuntimeTypeHandle) }));
var getAssembly = module.Import(typeof (Type).GetProperty("Assembly").GetMethod);
module.ImportReference(typeof (Type).GetMethod("GetTypeFromHandle", new[] { typeof (RuntimeTypeHandle) }));
var getAssembly = module.ImportReference(typeof (Type).GetProperty("Assembly").GetMethod);
yield return Instruction.Create(OpCodes.Newobj, ctor);
@ -462,8 +462,8 @@ namespace Xamarin.Forms.Build.Tasks
if (pushParentIl[pushParentIl.Count - 1].OpCode != OpCodes.Ldnull)
{
yield return Instruction.Create(OpCodes.Dup); //Keep the serviceProvider on the stack
yield return Instruction.Create(OpCodes.Ldtoken, module.Import(typeof (IProvideValueTarget)));
yield return Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle));
yield return Instruction.Create(OpCodes.Ldtoken, module.ImportReference(typeof (IProvideValueTarget)));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(getTypeFromHandle));
foreach (var instruction in pushParentIl)
yield return instruction;
@ -472,7 +472,7 @@ namespace Xamarin.Forms.Build.Tasks
yield return instruction;
var targetProviderCtor =
module.Import(typeof (SimpleValueTargetProvider).GetConstructor(new[] { typeof (object[]), typeof(object) }));
module.ImportReference(typeof (SimpleValueTargetProvider).GetConstructor(new[] { typeof (object[]), typeof(object) }));
yield return Instruction.Create(OpCodes.Newobj, targetProviderCtor);
yield return Instruction.Create(OpCodes.Callvirt, addService);
}
@ -481,12 +481,12 @@ namespace Xamarin.Forms.Build.Tasks
if (context.Scopes.ContainsKey(node))
{
yield return Instruction.Create(OpCodes.Dup); //Dupicate the serviceProvider
yield return Instruction.Create(OpCodes.Ldtoken, module.Import(typeof (INameScopeProvider)));
yield return Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle));
var namescopeProviderCtor = module.Import(typeof (NameScopeProvider).GetConstructor(new Type[] { }));
yield return Instruction.Create(OpCodes.Ldtoken, module.ImportReference(typeof (INameScopeProvider)));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(getTypeFromHandle));
var namescopeProviderCtor = module.ImportReference(typeof (NameScopeProvider).GetConstructor(new Type[] { }));
yield return Instruction.Create(OpCodes.Newobj, namescopeProviderCtor);
yield return Instruction.Create(OpCodes.Dup); //Duplicate the namescopeProvider
var setNamescope = module.Import(typeof (NameScopeProvider).GetProperty("NameScope").GetSetMethod());
var setNamescope = module.ImportReference(typeof (NameScopeProvider).GetProperty("NameScope").GetSetMethod());
yield return Instruction.Create(OpCodes.Ldloc, context.Scopes[node].Item1);
yield return Instruction.Create(OpCodes.Callvirt, setNamescope);
@ -497,10 +497,10 @@ namespace Xamarin.Forms.Build.Tasks
if (node.NamespaceResolver != null)
{
yield return Instruction.Create(OpCodes.Dup); //Dupicate the serviceProvider
yield return Instruction.Create(OpCodes.Ldtoken, module.Import(typeof (IXamlTypeResolver)));
yield return Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle));
var xmlNamespaceResolverCtor = module.Import(typeof (XmlNamespaceResolver).GetConstructor(new Type[] { }));
var addNamespace = module.Import(typeof (XmlNamespaceResolver).GetMethod("Add"));
yield return Instruction.Create(OpCodes.Ldtoken, module.ImportReference(typeof (IXamlTypeResolver)));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(getTypeFromHandle));
var xmlNamespaceResolverCtor = module.ImportReference(typeof (XmlNamespaceResolver).GetConstructor(new Type[] { }));
var addNamespace = module.ImportReference(typeof (XmlNamespaceResolver).GetMethod("Add"));
yield return Instruction.Create(OpCodes.Newobj, xmlNamespaceResolverCtor);
foreach (var kvp in node.NamespaceResolver.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml))
{
@ -510,10 +510,10 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Callvirt, addNamespace);
}
yield return Instruction.Create(OpCodes.Ldtoken, context.Body.Method.DeclaringType);
yield return Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(getTypeFromHandle));
yield return Instruction.Create(OpCodes.Callvirt, getAssembly);
var xtr = module.Import(typeof (XamlTypeResolver)).Resolve();
var xamlTypeResolverCtor = module.Import(xtr.Methods.First(md => md.IsConstructor && md.Parameters.Count == 2));
var xtr = module.ImportReference(typeof (XamlTypeResolver)).Resolve();
var xamlTypeResolverCtor = module.ImportReference(xtr.Methods.First(md => md.IsConstructor && md.Parameters.Count == 2));
yield return Instruction.Create(OpCodes.Newobj, xamlTypeResolverCtor);
yield return Instruction.Create(OpCodes.Callvirt, addService);
}
@ -521,14 +521,14 @@ namespace Xamarin.Forms.Build.Tasks
if (node is IXmlLineInfo)
{
yield return Instruction.Create(OpCodes.Dup); //Dupicate the serviceProvider
yield return Instruction.Create(OpCodes.Ldtoken, module.Import(typeof (IXmlLineInfoProvider)));
yield return Instruction.Create(OpCodes.Call, module.Import(getTypeFromHandle));
yield return Instruction.Create(OpCodes.Ldtoken, module.ImportReference(typeof (IXmlLineInfoProvider)));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(getTypeFromHandle));
foreach (var instruction in node.PushXmlLineInfo(context))
yield return instruction;
var lip = module.Import(typeof (XmlLineInfoProvider)).Resolve();
var lineInfoProviderCtor = module.Import(lip.Methods.First(md => md.IsConstructor && md.Parameters.Count == 1));
var lip = module.ImportReference(typeof (XmlLineInfoProvider)).Resolve();
var lineInfoProviderCtor = module.ImportReference(lip.Methods.First(md => md.IsConstructor && md.Parameters.Count == 1));
yield return Instruction.Create(OpCodes.Newobj, lineInfoProviderCtor);
yield return Instruction.Create(OpCodes.Callvirt, addService);
}

1
Xamarin.Forms.Build.Tasks/Properties/AssemblyInfo.cs
Просмотреть файл

@ -27,4 +27,5 @@ using System.Runtime.CompilerServices;
//[assembly: AssemblyKeyFile("")]
[assembly: InternalsVisibleTo("xamlg")]
[assembly: InternalsVisibleTo("xamlc")]
[assembly: InternalsVisibleTo("Xamarin.Forms.Xaml.UnitTests")]

16
Xamarin.Forms.Build.Tasks/SetNamescopesAndRegisterNamesVisitor.cs
Просмотреть файл

@ -44,7 +44,7 @@ namespace Xamarin.Forms.Build.Tasks
namescopeVarDef = Context.Scopes[parentNode].Item1;
namesInNamescope = Context.Scopes[parentNode].Item2;
}
if (Context.Variables[node].VariableType.InheritsFromOrImplements(Context.Body.Method.Module.Import(typeof (BindableObject))))
if (Context.Variables[node].VariableType.InheritsFromOrImplements(Context.Body.Method.Module.ImportReference(typeof (BindableObject))))
SetNameScope(node, namescopeVarDef);
Context.Scopes[node] = new System.Tuple<VariableDefinition, IList<string>>(namescopeVarDef, namesInNamescope);
}
@ -53,7 +53,7 @@ namespace Xamarin.Forms.Build.Tasks
{
var namescopeVarDef = CreateNamescope();
IList<string> namesInNamescope = new List<string>();
if (Context.Variables[node].VariableType.InheritsFromOrImplements(Context.Body.Method.Module.Import(typeof (BindableObject))))
if (Context.Variables[node].VariableType.InheritsFromOrImplements(Context.Body.Method.Module.ImportReference(typeof (BindableObject))))
SetNameScope(node, namescopeVarDef);
Context.Scopes[node] = new System.Tuple<VariableDefinition, IList<string>>(namescopeVarDef, namesInNamescope);
}
@ -91,12 +91,12 @@ namespace Xamarin.Forms.Build.Tasks
VariableDefinition CreateNamescope()
{
var module = Context.Body.Method.Module;
var nsRef = module.Import(typeof (NameScope));
var nsRef = module.ImportReference(typeof (NameScope));
var vardef = new VariableDefinition(nsRef);
Context.Body.Variables.Add(vardef);
var nsDef = nsRef.Resolve();
var ctorinfo = nsDef.Methods.First(md => md.IsConstructor && !md.HasParameters);
var ctor = module.Import(ctorinfo);
var ctor = module.ImportReference(ctorinfo);
Context.IL.Emit(OpCodes.Newobj, ctor);
Context.IL.Emit(OpCodes.Stloc, vardef);
return vardef;
@ -105,10 +105,10 @@ namespace Xamarin.Forms.Build.Tasks
void SetNameScope(ElementNode node, VariableDefinition ns)
{
var module = Context.Body.Method.Module;
var nsRef = module.Import(typeof (NameScope));
var nsRef = module.ImportReference(typeof (NameScope));
var nsDef = nsRef.Resolve();
var setNSInfo = nsDef.Methods.First(md => md.Name == "SetNameScope" && md.IsStatic);
var setNS = module.Import(setNSInfo);
var setNS = module.ImportReference(setNSInfo);
Context.IL.Emit(OpCodes.Ldloc, Context.Variables[node]);
Context.IL.Emit(OpCodes.Ldloc, ns);
Context.IL.Emit(OpCodes.Call, setNS);
@ -121,10 +121,10 @@ namespace Xamarin.Forms.Build.Tasks
namesInNamescope.Add(str);
var module = Context.Body.Method.Module;
var nsRef = module.Import(typeof (INameScope));
var nsRef = module.ImportReference(typeof (INameScope));
var nsDef = nsRef.Resolve();
var registerInfo = nsDef.Methods.First(md => md.Name == "RegisterName" && md.Parameters.Count == 2);
var register = module.Import(registerInfo);
var register = module.ImportReference(registerInfo);
Context.IL.Emit(OpCodes.Ldloc, namescopeVarDef);
Context.IL.Emit(OpCodes.Ldstr, str);

180
Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
Просмотреть файл

@ -128,14 +128,14 @@ namespace Xamarin.Forms.Build.Tasks
// Collection element, implicit content, or implicit collection element.
string contentProperty;
var parentVar = Context.Variables[(IElementNode)parentNode];
if (parentVar.VariableType.ImplementsInterface(Module.Import(typeof (IEnumerable))))
if (parentVar.VariableType.ImplementsInterface(Module.ImportReference(typeof (IEnumerable))))
{
var elementType = parentVar.VariableType;
if (elementType.FullName != "Xamarin.Forms.ResourceDictionary" && elementType.Resolve().BaseType.FullName != "Xamarin.Forms.ResourceDictionary")
{
var adderTuple = elementType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, Module).First();
var adderRef = Module.Import(adderTuple.Item1);
adderRef = Module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, Module));
var adderRef = Module.ImportReference(adderTuple.Item1);
adderRef = Module.ImportReference(adderRef.ResolveGenericParameters(adderTuple.Item2, Module));
Context.IL.Emit(OpCodes.Ldloc, parentVar);
Context.IL.Emit(OpCodes.Ldloc, vardef);
@ -179,13 +179,13 @@ namespace Xamarin.Forms.Build.Tasks
if (property != null && (propertyGetter = property.GetMethod) != null && propertyGetter.IsPublic)
{
var propertyGetterRef = Module.Import(propertyGetter);
propertyGetterRef = Module.Import(propertyGetterRef.ResolveGenericParameters(propertyDeclaringType, Module));
var propertyGetterRef = Module.ImportReference(propertyGetter);
propertyGetterRef = Module.ImportReference(propertyGetterRef.ResolveGenericParameters(propertyDeclaringType, Module));
var propertyType = propertyGetterRef.ReturnType.ResolveGenericParameters(propertyDeclaringType);
var adderTuple = propertyType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, Module).First();
var adderRef = Module.Import(adderTuple.Item1);
adderRef = Module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, Module));
var adderRef = Module.ImportReference(adderTuple.Item1);
adderRef = Module.ImportReference(adderRef.ResolveGenericParameters(adderTuple.Item2, Module));
Context.IL.Emit(OpCodes.Ldloc, parent);
Context.IL.Emit(OpCodes.Callvirt, propertyGetterRef);
@ -256,23 +256,23 @@ namespace Xamarin.Forms.Build.Tasks
{
var markExt = markupExtension.Resolve();
var provideValueInfo = markExt.Methods.First(md => md.Name == "ProvideValue");
var provideValue = module.Import(provideValueInfo);
var provideValue = module.ImportReference(provideValueInfo);
provideValue =
module.Import(provideValue.ResolveGenericParameters(markupExtension, module));
module.ImportReference(provideValue.ResolveGenericParameters(markupExtension, module));
var typeNode = node.Properties[new XmlName("", "Type")];
TypeReference arrayTypeRef;
if (context.TypeExtensions.TryGetValue(typeNode, out arrayTypeRef))
vardefref.VariableDefinition = new VariableDefinition(module.Import(arrayTypeRef.MakeArrayType()));
vardefref.VariableDefinition = new VariableDefinition(module.ImportReference(arrayTypeRef.MakeArrayType()));
else
vardefref.VariableDefinition = new VariableDefinition(module.Import(genericArguments.First()));
vardefref.VariableDefinition = new VariableDefinition(module.ImportReference(genericArguments.First()));
yield return Instruction.Create(OpCodes.Ldloc, context.Variables[node]);
foreach (var instruction in node.PushServiceProvider(context, bpRef, propertyRef, propertyDeclaringTypeRef))
yield return instruction;
yield return Instruction.Create(OpCodes.Callvirt, provideValue);
if (arrayTypeRef != null)
yield return Instruction.Create(OpCodes.Castclass, module.Import(arrayTypeRef.MakeArrayType()));
yield return Instruction.Create(OpCodes.Castclass, module.ImportReference(arrayTypeRef.MakeArrayType()));
yield return Instruction.Create(OpCodes.Stloc, vardefref.VariableDefinition);
}
else if (vardefref.VariableDefinition.VariableType.ImplementsGenericInterface("Xamarin.Forms.Xaml.IMarkupExtension`1",
@ -284,22 +284,22 @@ namespace Xamarin.Forms.Build.Tasks
var markExt = markupExtension.Resolve();
var provideValueInfo = markExt.Methods.First(md => md.Name == "ProvideValue");
var provideValue = module.Import(provideValueInfo);
var provideValue = module.ImportReference(provideValueInfo);
provideValue =
module.Import(provideValue.ResolveGenericParameters(markupExtension, module));
module.ImportReference(provideValue.ResolveGenericParameters(markupExtension, module));
vardefref.VariableDefinition = new VariableDefinition(module.Import(genericArguments.First()));
vardefref.VariableDefinition = new VariableDefinition(module.ImportReference(genericArguments.First()));
yield return Instruction.Create(OpCodes.Ldloc, context.Variables[node]);
foreach (var instruction in node.PushServiceProvider(context, bpRef, propertyRef, propertyDeclaringTypeRef))
yield return instruction;
yield return Instruction.Create(OpCodes.Callvirt, provideValue);
yield return Instruction.Create(OpCodes.Stloc, vardefref.VariableDefinition);
}
else if (context.Variables[node].VariableType.ImplementsInterface(module.Import(typeof (IMarkupExtension))))
else if (context.Variables[node].VariableType.ImplementsInterface(module.ImportReference(typeof (IMarkupExtension))))
{
var markExt = module.Import(typeof (IMarkupExtension)).Resolve();
var markExt = module.ImportReference(typeof (IMarkupExtension)).Resolve();
var provideValueInfo = markExt.Methods.First(md => md.Name == "ProvideValue");
var provideValue = module.Import(provideValueInfo);
var provideValue = module.ImportReference(provideValueInfo);
vardefref.VariableDefinition = new VariableDefinition(module.TypeSystem.Object);
yield return Instruction.Create(OpCodes.Ldloc, context.Variables[node]);
@ -308,11 +308,11 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Callvirt, provideValue);
yield return Instruction.Create(OpCodes.Stloc, vardefref.VariableDefinition);
}
else if (context.Variables[node].VariableType.ImplementsInterface(module.Import(typeof (IValueProvider))))
else if (context.Variables[node].VariableType.ImplementsInterface(module.ImportReference(typeof (IValueProvider))))
{
var valueProviderType = context.Variables[node].VariableType;
//If the IValueProvider has a ProvideCompiledAttribute that can be resolved, shortcut this
var compiledValueProviderName = valueProviderType?.GetCustomAttribute(module.Import(typeof(ProvideCompiledAttribute)))?.ConstructorArguments?[0].Value as string;
var compiledValueProviderName = valueProviderType?.GetCustomAttribute(module.ImportReference(typeof(ProvideCompiledAttribute)))?.ConstructorArguments?[0].Value as string;
Type compiledValueProviderType;
if (compiledValueProviderName != null && (compiledValueProviderType = Type.GetType(compiledValueProviderName)) != null) {
var compiledValueProvider = Activator.CreateInstance(compiledValueProviderType);
@ -327,9 +327,9 @@ namespace Xamarin.Forms.Build.Tasks
yield break;
}
var valueProviderDef = module.Import(typeof (IValueProvider)).Resolve();
var valueProviderDef = module.ImportReference(typeof (IValueProvider)).Resolve();
var provideValueInfo = valueProviderDef.Methods.First(md => md.Name == "ProvideValue");
var provideValue = module.Import(provideValueInfo);
var provideValue = module.ImportReference(provideValueInfo);
vardefref.VariableDefinition = new VariableDefinition(module.TypeSystem.Object);
yield return Instruction.Create(OpCodes.Ldloc, context.Variables[node]);
@ -372,16 +372,16 @@ namespace Xamarin.Forms.Build.Tasks
var properties = ParsePath(path, tSourceRef, node as IXmlLineInfo, context.Module);
var tPropertyRef = properties != null && properties.Any() ? properties.Last().Item1.PropertyType : tSourceRef;
var funcRef = context.Module.Import(context.Module.Import(typeof(Func<,>)).MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef }));
var actionRef = context.Module.Import(context.Module.Import(typeof(Action<,>)).MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef }));
var funcObjRef = context.Module.Import(context.Module.Import(typeof(Func<,>)).MakeGenericInstanceType(new [] { tSourceRef, context.Module.TypeSystem.Object }));
var tupleRef = context.Module.Import(context.Module.Import(typeof(Tuple<,>)).MakeGenericInstanceType(new [] { funcObjRef, context.Module.TypeSystem.String}));
var typedBindingRef = context.Module.Import(context.Module.Import(typeof(TypedBinding<,>)).MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef}));
var funcRef = context.Module.ImportReference(context.Module.ImportReference(typeof(Func<,>)).MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef }));
var actionRef = context.Module.ImportReference(context.Module.ImportReference(typeof(Action<,>)).MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef }));
var funcObjRef = context.Module.ImportReference(context.Module.ImportReference(typeof(Func<,>)).MakeGenericInstanceType(new [] { tSourceRef, context.Module.TypeSystem.Object }));
var tupleRef = context.Module.ImportReference(context.Module.ImportReference(typeof(Tuple<,>)).MakeGenericInstanceType(new [] { funcObjRef, context.Module.TypeSystem.String}));
var typedBindingRef = context.Module.ImportReference(context.Module.ImportReference(typeof(TypedBinding<,>)).MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef}));
TypeReference _;
var ctorInfo = context.Module.Import(typedBindingRef.Resolve().Methods.FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.Parameters.Count == 3 ));
var ctorInfo = context.Module.ImportReference(typedBindingRef.Resolve().Methods.FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.Parameters.Count == 3 ));
var ctorinforef = ctorInfo.MakeGeneric(typedBindingRef, funcRef, actionRef, tupleRef);
var setTypedBinding = context.Module.Import(typeof(BindingExtension)).GetProperty(pd => pd.Name == "TypedBinding", out _).SetMethod;
var setTypedBinding = context.Module.ImportReference(typeof(BindingExtension)).GetProperty(pd => pd.Name == "TypedBinding", out _).SetMethod;
yield return Instruction.Create(OpCodes.Ldloc, bindingExt);
foreach (var instruction in CompiledBindingGetGetter(tSourceRef, tPropertyRef, properties, node, context))
@ -390,8 +390,8 @@ namespace Xamarin.Forms.Build.Tasks
yield return instruction;
foreach (var instruction in CompiledBindingGetHandlers(tSourceRef, tPropertyRef, properties, node, context))
yield return instruction;
yield return Instruction.Create(OpCodes.Newobj, context.Module.Import(ctorinforef));
yield return Instruction.Create(OpCodes.Callvirt, context.Module.Import(setTypedBinding));
yield return Instruction.Create(OpCodes.Newobj, context.Module.ImportReference(ctorinforef));
yield return Instruction.Create(OpCodes.Callvirt, context.Module.ImportReference(setTypedBinding));
}
static IList<Tuple<PropertyDefinition, string>> ParsePath(string path, TypeReference tSourceRef, IXmlLineInfo lineInfo, ModuleDefinition module)
@ -431,7 +431,7 @@ namespace Xamarin.Forms.Build.Tasks
previousPartTypeRef = property.PropertyType;
}
if (indexArg != null) {
var defaultMemberAttribute = previousPartTypeRef.GetCustomAttribute(module.Import(typeof(System.Reflection.DefaultMemberAttribute)));
var defaultMemberAttribute = previousPartTypeRef.GetCustomAttribute(module.ImportReference(typeof(System.Reflection.DefaultMemberAttribute)));
var indexerName = defaultMemberAttribute?.ConstructorArguments?.FirstOrDefault().Value as string ?? "Item";
var indexer = previousPartTypeRef.GetProperty(pd => pd.Name == indexerName && pd.GetMethod != null && pd.GetMethod.IsPublic, out _);
properties.Add(new Tuple<PropertyDefinition, string>(indexer, indexArg));
@ -456,7 +456,7 @@ namespace Xamarin.Forms.Build.Tasks
// }
var module = context.Module;
var compilerGeneratedCtor = module.Import(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)).GetMethods(md => md.IsConstructor, module).First().Item1;
var compilerGeneratedCtor = module.ImportReference(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)).GetMethods(md => md.IsConstructor, module).First().Item1;
var getter = new MethodDefinition($"<{context.Body.Method.Name}>typedBindingsM__{typedBindingCount++}",
MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.Static,
tPropertyRef) {
@ -464,7 +464,7 @@ namespace Xamarin.Forms.Build.Tasks
new ParameterDefinition(tSourceRef)
},
CustomAttributes = {
new CustomAttribute (context.Module.Import(compilerGeneratedCtor))
new CustomAttribute (context.Module.ImportReference(compilerGeneratedCtor))
}
};
var il = getter.Body.GetILProcessor();
@ -484,7 +484,7 @@ namespace Xamarin.Forms.Build.Tasks
il.Emit(OpCodes.Ldc_I4, index);
}
}
il.Emit(OpCodes.Callvirt, module.Import(property.GetMethod));
il.Emit(OpCodes.Callvirt, module.ImportReference(property.GetMethod));
}
}
@ -492,9 +492,9 @@ namespace Xamarin.Forms.Build.Tasks
context.Body.Method.DeclaringType.Methods.Add(getter);
var funcRef = module.Import(typeof(Func<,>));
funcRef = module.Import(funcRef.MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef }));
var funcCtor = module.Import(funcRef.Resolve().GetConstructors().First());
var funcRef = module.ImportReference(typeof(Func<,>));
funcRef = module.ImportReference(funcRef.MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef }));
var funcCtor = module.ImportReference(funcRef.Resolve().GetConstructors().First());
funcCtor = funcCtor.MakeGeneric(funcRef, new [] { tSourceRef, tPropertyRef });
// IL_0007: ldnull
@ -503,7 +503,7 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldnull);
yield return Instruction.Create(OpCodes.Ldftn, getter);
yield return Instruction.Create(OpCodes.Newobj, module.Import(funcCtor));
yield return Instruction.Create(OpCodes.Newobj, module.ImportReference(funcCtor));
}
static IEnumerable<Instruction> CompiledBindingGetSetter(TypeReference tSourceRef, TypeReference tPropertyRef, IList<Tuple<PropertyDefinition, string>> properties, ElementNode node, ILContext context)
@ -525,7 +525,7 @@ namespace Xamarin.Forms.Build.Tasks
// }
var module = context.Module;
var compilerGeneratedCtor = module.Import(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)).GetMethods(md => md.IsConstructor, module).First().Item1;
var compilerGeneratedCtor = module.ImportReference(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)).GetMethods(md => md.IsConstructor, module).First().Item1;
var setter = new MethodDefinition($"<{context.Body.Method.Name}>typedBindingsM__{typedBindingCount++}",
MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.Static,
module.TypeSystem.Void) {
@ -534,7 +534,7 @@ namespace Xamarin.Forms.Build.Tasks
new ParameterDefinition(tPropertyRef)
},
CustomAttributes = {
new CustomAttribute (module.Import(compilerGeneratedCtor))
new CustomAttribute (module.ImportReference(compilerGeneratedCtor))
}
};
@ -560,7 +560,7 @@ namespace Xamarin.Forms.Build.Tasks
il.Emit(OpCodes.Ldc_I4, index);
}
}
il.Emit(OpCodes.Callvirt, module.Import(property.GetMethod));
il.Emit(OpCodes.Callvirt, module.ImportReference(property.GetMethod));
}
var indexer = properties.Last().Item2;
@ -575,14 +575,14 @@ namespace Xamarin.Forms.Build.Tasks
}
}
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Callvirt, module.Import(setterRef));
il.Emit(OpCodes.Callvirt, module.ImportReference(setterRef));
il.Emit(OpCodes.Ret);
context.Body.Method.DeclaringType.Methods.Add(setter);
var actionRef = module.Import(typeof(Action<,>));
actionRef = module.Import(actionRef.MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef }));
var actionCtor = module.Import(actionRef.Resolve().GetConstructors().First());
var actionRef = module.ImportReference(typeof(Action<,>));
actionRef = module.ImportReference(actionRef.MakeGenericInstanceType(new [] { tSourceRef, tPropertyRef }));
var actionCtor = module.ImportReference(actionRef.Resolve().GetConstructors().First());
actionCtor = actionCtor.MakeGeneric(actionRef, new [] { tSourceRef, tPropertyRef });
// IL_0024: ldnull
@ -590,7 +590,7 @@ namespace Xamarin.Forms.Build.Tasks
// IL_002b: newobj instance void class [mscorlib]System.Action`2<class ViewModel, string>::'.ctor'(object, native int)
yield return Instruction.Create(OpCodes.Ldnull);
yield return Instruction.Create(OpCodes.Ldftn, setter);
yield return Instruction.Create(OpCodes.Newobj, module.Import(actionCtor));
yield return Instruction.Create(OpCodes.Newobj, module.ImportReference(actionCtor));
}
static IEnumerable<Instruction> CompiledBindingGetHandlers(TypeReference tSourceRef, TypeReference tPropertyRef, IList<Tuple<PropertyDefinition, string>> properties, ElementNode node, ILContext context)
@ -609,7 +609,7 @@ namespace Xamarin.Forms.Build.Tasks
// }
var module = context.Module;
var compilerGeneratedCtor = module.Import(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)).GetMethods(md => md.IsConstructor, module).First().Item1;
var compilerGeneratedCtor = module.ImportReference(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)).GetMethods(md => md.IsConstructor, module).First().Item1;
var partGetters = new List<MethodDefinition>();
if (properties == null || properties.Count == 0) {
@ -624,7 +624,7 @@ namespace Xamarin.Forms.Build.Tasks
new ParameterDefinition(tSourceRef)
},
CustomAttributes = {
new CustomAttribute (context.Module.Import(compilerGeneratedCtor))
new CustomAttribute (context.Module.ImportReference(compilerGeneratedCtor))
}
};
var il = partGetter.Body.GetILProcessor();
@ -643,18 +643,18 @@ namespace Xamarin.Forms.Build.Tasks
il.Emit(OpCodes.Ldc_I4, index);
}
}
il.Emit(OpCodes.Callvirt, module.Import(property.GetMethod));
il.Emit(OpCodes.Callvirt, module.ImportReference(property.GetMethod));
}
il.Emit(OpCodes.Ret);
context.Body.Method.DeclaringType.Methods.Add(partGetter);
partGetters.Add(partGetter);
}
var funcObjRef = context.Module.Import(module.Import(typeof(Func<,>)).MakeGenericInstanceType(new [] { tSourceRef, module.TypeSystem.Object }));
var tupleRef = context.Module.Import(module.Import(typeof(Tuple<,>)).MakeGenericInstanceType(new [] { funcObjRef, module.TypeSystem.String }));
var funcCtor = module.Import(funcObjRef.Resolve().GetConstructors().First());
var funcObjRef = context.Module.ImportReference(module.ImportReference(typeof(Func<,>)).MakeGenericInstanceType(new [] { tSourceRef, module.TypeSystem.Object }));
var tupleRef = context.Module.ImportReference(module.ImportReference(typeof(Tuple<,>)).MakeGenericInstanceType(new [] { funcObjRef, module.TypeSystem.String }));
var funcCtor = module.ImportReference(funcObjRef.Resolve().GetConstructors().First());
funcCtor = funcCtor.MakeGeneric(funcObjRef, new [] { tSourceRef, module.TypeSystem.Object });
var tupleCtor = module.Import(tupleRef.Resolve().GetConstructors().First());
var tupleCtor = module.ImportReference(tupleRef.Resolve().GetConstructors().First());
tupleCtor = tupleCtor.MakeGeneric(tupleRef, new [] { funcObjRef, module.TypeSystem.String});
// IL_003a: ldc.i4.2
@ -686,9 +686,9 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldc_I4, i);
yield return Instruction.Create(OpCodes.Ldnull);
yield return Instruction.Create(OpCodes.Ldftn, partGetters [i]);
yield return Instruction.Create(OpCodes.Newobj, module.Import(funcCtor));
yield return Instruction.Create(OpCodes.Newobj, module.ImportReference(funcCtor));
yield return Instruction.Create(OpCodes.Ldstr, properties [i].Item1.Name);
yield return Instruction.Create(OpCodes.Newobj, module.Import(tupleCtor));
yield return Instruction.Create(OpCodes.Newobj, module.ImportReference(tupleCtor));
yield return Instruction.Create(OpCodes.Stelem_Ref);
}
}
@ -740,8 +740,8 @@ namespace Xamarin.Forms.Build.Tasks
fd.IsStatic &&
fd.IsPublic, out declaringTypeReference);
if (bpRef != null) {
bpRef = module.Import(bpRef.ResolveGenericParameters(declaringTypeReference));
bpRef.FieldType = module.Import(bpRef.FieldType);
bpRef = module.ImportReference(bpRef.ResolveGenericParameters(declaringTypeReference));
bpRef.FieldType = module.ImportReference(bpRef.FieldType);
}
return bpRef;
}
@ -791,10 +791,10 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldftn, handler);
//FIXME: eventually get the right ctor instead fo the First() one, just in case another one could exists (not even sure it's possible).
var ctor = module.Import(eventinfo.EventType.Resolve().GetConstructors().First());
var ctor = module.ImportReference(eventinfo.EventType.Resolve().GetConstructors().First());
ctor = ctor.ResolveGenericParameters(eventinfo.EventType, module);
yield return Instruction.Create(OpCodes.Newobj, module.Import(ctor));
yield return Instruction.Create(OpCodes.Callvirt, module.Import(eventinfo.AddMethod));
yield return Instruction.Create(OpCodes.Newobj, module.ImportReference(ctor));
yield return Instruction.Create(OpCodes.Callvirt, module.ImportReference(eventinfo.AddMethod));
}
static bool CanSetDynamicResource(FieldReference bpRef, INode valueNode, ILContext context)
@ -815,14 +815,14 @@ namespace Xamarin.Forms.Build.Tasks
{
var module = context.Body.Method.Module;
var varValue = context.Variables [elementNode];
var setDynamicResource = module.Import(typeof(IDynamicResourceHandler)).Resolve().Methods.First(m => m.Name == "SetDynamicResource");
var setDynamicResource = module.ImportReference(typeof(IDynamicResourceHandler)).Resolve().Methods.First(m => m.Name == "SetDynamicResource");
var getKey = typeof(DynamicResource).GetProperty("Key").GetMethod;
yield return Instruction.Create(OpCodes.Ldloc, parent);
yield return Instruction.Create(OpCodes.Ldsfld, bpRef);
yield return Instruction.Create(OpCodes.Ldloc, varValue);
yield return Instruction.Create(OpCodes.Callvirt, module.Import(getKey));
yield return Instruction.Create(OpCodes.Callvirt, module.Import(setDynamicResource));
yield return Instruction.Create(OpCodes.Callvirt, module.ImportReference(getKey));
yield return Instruction.Create(OpCodes.Callvirt, module.ImportReference(setDynamicResource));
}
static bool CanSetBinding(FieldReference bpRef, INode valueNode, ILContext context)
@ -838,18 +838,18 @@ namespace Xamarin.Forms.Build.Tasks
VariableDefinition varValue;
if (!context.Variables.TryGetValue(valueNode as IElementNode, out varValue))
return false;
var implicitOperator = varValue.VariableType.GetImplicitOperatorTo(module.Import(typeof(BindingBase)), module);
var implicitOperator = varValue.VariableType.GetImplicitOperatorTo(module.ImportReference(typeof(BindingBase)), module);
if (implicitOperator != null)
return true;
return varValue.VariableType.InheritsFromOrImplements(module.Import(typeof(BindingBase)));
return varValue.VariableType.InheritsFromOrImplements(module.ImportReference(typeof(BindingBase)));
}
static IEnumerable<Instruction> SetBinding(VariableDefinition parent, FieldReference bpRef, IElementNode elementNode, IXmlLineInfo iXmlLineInfo, ILContext context)
{
var module = context.Body.Method.Module;
var varValue = context.Variables [elementNode];
var implicitOperator = varValue.VariableType.GetImplicitOperatorTo(module.Import(typeof(BindingBase)), module);
var implicitOperator = varValue.VariableType.GetImplicitOperatorTo(module.ImportReference(typeof(BindingBase)), module);
//TODO: check if parent is a BP
var setBinding = typeof(BindableObject).GetMethod("SetBinding", new [] { typeof(BindableProperty), typeof(BindingBase) });
@ -859,8 +859,8 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldloc, varValue);
if (implicitOperator != null)
// IL_000f: call !0 class [Xamarin.Forms.Core]Xamarin.Forms.OnPlatform`1<BindingBase>::op_Implicit(class [Xamarin.Forms.Core]Xamarin.Forms.OnPlatform`1<!0>)
yield return Instruction.Create(OpCodes.Call, module.Import(implicitOperator));
yield return Instruction.Create(OpCodes.Callvirt, module.Import(setBinding));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(implicitOperator));
yield return Instruction.Create(OpCodes.Callvirt, module.ImportReference(setBinding));
}
static bool CanSetValue(FieldReference bpRef, bool attached, INode node, IXmlLineInfo iXmlLineInfo, ILContext context)
@ -918,14 +918,14 @@ namespace Xamarin.Forms.Build.Tasks
var implicitOperator = varDef.VariableType.GetImplicitOperatorTo(bpTypeRef, module);
yield return Instruction.Create(OpCodes.Ldloc, varDef);
if (implicitOperator != null) {
yield return Instruction.Create(OpCodes.Call, module.Import(implicitOperator));
varType = module.Import(bpTypeRef);
yield return Instruction.Create(OpCodes.Call, module.ImportReference(implicitOperator));
varType = module.ImportReference(bpTypeRef);
}
if (varType.IsValueType)
yield return Instruction.Create(OpCodes.Box, varType);
}
yield return Instruction.Create(OpCodes.Callvirt, module.Import(setValue));
yield return Instruction.Create(OpCodes.Callvirt, module.ImportReference(setValue));
}
static bool CanSet(VariableDefinition parent, string localName, INode node, ILContext context)
@ -975,8 +975,8 @@ namespace Xamarin.Forms.Build.Tasks
// IL_0008: ldstr "foo"
// IL_000d: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.Label::set_Text(string)
module.Import(parent.VariableType.Resolve());
var propertySetterRef = module.Import(module.Import(propertySetter).ResolveGenericParameters(declaringTypeReference, module));
module.ImportReference(parent.VariableType.Resolve());
var propertySetterRef = module.ImportReference(module.ImportReference(propertySetter).ResolveGenericParameters(declaringTypeReference, module));
propertySetterRef.ImportTypes(module);
var propertyType = property.ResolveGenericPropertyType(declaringTypeReference);
var valueNode = node as ValueNode;
@ -1001,9 +1001,9 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Ldloc, vardef);
if (implicitOperator != null) {
// IL_000f: call !0 class [Xamarin.Forms.Core]Xamarin.Forms.OnPlatform`1<bool>::op_Implicit(class [Xamarin.Forms.Core]Xamarin.Forms.OnPlatform`1<!0>)
yield return Instruction.Create(OpCodes.Call, module.Import(implicitOperator));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(implicitOperator));
} else if (!vardef.VariableType.IsValueType && propertyType.IsValueType)
yield return Instruction.Create(OpCodes.Unbox_Any, module.Import(propertyType));
yield return Instruction.Create(OpCodes.Unbox_Any, module.ImportReference(propertyType));
else if (vardef.VariableType.IsValueType && propertyType.FullName == "System.Object")
yield return Instruction.Create(OpCodes.Box, vardef.VariableType);
if (parent.VariableType.IsValueType)
@ -1028,8 +1028,8 @@ namespace Xamarin.Forms.Build.Tasks
return false;
var vardef = context.Variables [elementNode];
var propertyGetterRef = module.Import(propertyGetter);
propertyGetterRef = module.Import(propertyGetterRef.ResolveGenericParameters(declaringTypeReference, module));
var propertyGetterRef = module.ImportReference(propertyGetter);
propertyGetterRef = module.ImportReference(propertyGetterRef.ResolveGenericParameters(declaringTypeReference, module));
var propertyType = propertyGetterRef.ReturnType.ResolveGenericParameters(declaringTypeReference);
//TODO check md.Parameters[0] type
@ -1048,13 +1048,13 @@ namespace Xamarin.Forms.Build.Tasks
var propertyGetter = property.GetMethod;
var elementNode = node as IElementNode;
var vardef = context.Variables [elementNode];
var propertyGetterRef = module.Import(propertyGetter);
propertyGetterRef = module.Import(propertyGetterRef.ResolveGenericParameters(declaringTypeReference, module));
var propertyGetterRef = module.ImportReference(propertyGetter);
propertyGetterRef = module.ImportReference(propertyGetterRef.ResolveGenericParameters(declaringTypeReference, module));
var propertyType = propertyGetterRef.ReturnType.ResolveGenericParameters(declaringTypeReference);
//TODO check md.Parameters[0] type
var adderTuple = propertyType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, module).FirstOrDefault();
var adderRef = module.Import(adderTuple.Item1);
adderRef = module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, module));
var adderRef = module.ImportReference(adderTuple.Item1);
adderRef = module.ImportReference(adderRef.ResolveGenericParameters(adderTuple.Item2, module));
var childType = GetParameterType(adderRef.Parameters [0]);
var implicitOperator = vardef.VariableType.GetImplicitOperatorTo(childType, module);
@ -1062,7 +1062,7 @@ namespace Xamarin.Forms.Build.Tasks
yield return Instruction.Create(OpCodes.Callvirt, propertyGetterRef);
yield return Instruction.Create(OpCodes.Ldloc, vardef);
if (implicitOperator != null)
yield return Instruction.Create(OpCodes.Call, module.Import(implicitOperator));
yield return Instruction.Create(OpCodes.Call, module.ImportReference(implicitOperator));
if (implicitOperator == null && vardef.VariableType.IsValueType && !childType.IsValueType)
yield return Instruction.Create(OpCodes.Box, vardef.VariableType);
yield return Instruction.Create(OpCodes.Callvirt, adderRef);
@ -1105,7 +1105,7 @@ namespace Xamarin.Forms.Build.Tasks
var module = parentContext.Module;
var compilerGeneratedCtor = module.Import(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)).GetMethods(md => md.IsConstructor, module).First().Item1;
var compilerGeneratedCtor = module.ImportReference(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)).GetMethods(md => md.IsConstructor, module).First().Item1;
var anonType = new TypeDefinition(
null,
"<" + parentContext.Body.Method.Name + ">_anonXamlCDataTemplate_" + dtcount++,
@ -1115,7 +1115,7 @@ namespace Xamarin.Forms.Build.Tasks
{
BaseType = module.TypeSystem.Object,
CustomAttributes = {
new CustomAttribute (module.Import(compilerGeneratedCtor))
new CustomAttribute (module.ImportReference(compilerGeneratedCtor))
}
};
@ -1127,7 +1127,7 @@ namespace Xamarin.Forms.Build.Tasks
module.TypeSystem.Object);
anonType.Methods.Add(loadTemplate);
var parentValues = new FieldDefinition("parentValues", FieldAttributes.Assembly, module.Import(typeof (object[])));
var parentValues = new FieldDefinition("parentValues", FieldAttributes.Assembly, module.ImportReference(typeof (object[])));
anonType.Fields.Add(parentValues);
TypeReference rootType = null;
@ -1179,19 +1179,19 @@ namespace Xamarin.Forms.Build.Tasks
//SetDataTemplate
parentIl.Emit(OpCodes.Ldftn, loadTemplate);
var funcObjRef = module.Import(typeof(Func<object>));
var funcObjRef = module.ImportReference(typeof(Func<object>));
var funcCtor =
funcObjRef
.Resolve()
.Methods.First(md => md.IsConstructor && md.Parameters.Count == 2)
.ResolveGenericParameters(funcObjRef, module);
parentIl.Emit(OpCodes.Newobj, module.Import(funcCtor));
parentIl.Emit(OpCodes.Newobj, module.ImportReference(funcCtor));
#pragma warning disable 0612
var propertySetter =
module.Import(typeof (IDataTemplate)).Resolve().Properties.First(p => p.Name == "LoadTemplate").SetMethod;
module.ImportReference(typeof (IDataTemplate)).Resolve().Properties.First(p => p.Name == "LoadTemplate").SetMethod;
#pragma warning restore 0612
parentContext.IL.Emit(OpCodes.Callvirt, module.Import(propertySetter));
parentContext.IL.Emit(OpCodes.Callvirt, module.ImportReference(propertySetter));
loadTemplate.Body.Optimize();
}

12
Xamarin.Forms.Build.Tasks/SetResourcesVisitor.cs
Просмотреть файл

@ -59,7 +59,7 @@ namespace Xamarin.Forms.Build.Tasks
{
// Collection element, implicit content, or implicit collection element.
var parentVar = Context.Variables[(IElementNode)parentNode];
if (parentVar.VariableType.ImplementsInterface(Module.Import(typeof (IEnumerable))))
if (parentVar.VariableType.ImplementsInterface(Module.ImportReference(typeof (IEnumerable))))
{
if ((parentVar.VariableType.FullName == "Xamarin.Forms.ResourceDictionary" ||
parentVar.VariableType.Resolve().BaseType.FullName == "Xamarin.Forms.ResourceDictionary") &&
@ -84,8 +84,8 @@ namespace Xamarin.Forms.Build.Tasks
Context.IL.Emit(OpCodes.Ldloc, parentVar);
Context.IL.Emit(OpCodes.Ldloc, Context.Variables[node]);
Context.IL.Emit(OpCodes.Callvirt,
Module.Import(
Module.Import(typeof (ResourceDictionary))
Module.ImportReference(
Module.ImportReference(typeof (ResourceDictionary))
.Resolve()
.Methods.Single(md => md.Name == "Add" && md.Parameters.Count == 1)));
}
@ -115,10 +115,10 @@ namespace Xamarin.Forms.Build.Tasks
var varDef = Context.Variables[node];
Context.IL.Emit(OpCodes.Ldloc, varDef);
if (varDef.VariableType.IsValueType)
Context.IL.Emit(OpCodes.Box, Module.Import(varDef.VariableType));
Context.IL.Emit(OpCodes.Box, Module.ImportReference(varDef.VariableType));
Context.IL.Emit(OpCodes.Callvirt,
Module.Import(
Module.Import(typeof (ResourceDictionary))
Module.ImportReference(
Module.ImportReference(typeof (ResourceDictionary))
.Resolve()
.Methods.Single(md => md.Name == "Add" && md.Parameters.Count == 2)));
}

4
Xamarin.Forms.Build.Tasks/TypeDefinitionExtensions.cs
Просмотреть файл

@ -20,7 +20,7 @@ namespace Xamarin.Forms.Build.Tasks
public static MethodDefinition AddDefaultConstructor(this TypeDefinition targetType, Type parentType)
{
var module = targetType.Module;
var voidType = module.Import(typeof (void));
var voidType = module.ImportReference(typeof (void));
var methodAttributes = MethodAttributes.Public |
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
@ -35,7 +35,7 @@ namespace Xamarin.Forms.Build.Tasks
if (objectConstructor == null)
objectConstructor = typeof (object).GetConstructor(new Type[0]);
var baseConstructor = module.Import(objectConstructor);
var baseConstructor = module.ImportReference(objectConstructor);
var ctor = new MethodDefinition(".ctor", methodAttributes, voidType)
{

24
Xamarin.Forms.Build.Tasks/TypeReferenceExtensions.cs
Просмотреть файл

@ -85,7 +85,7 @@ namespace Xamarin.Forms.Build.Tasks
public static bool ImplementsInterface(this TypeReference typeRef, TypeReference @interface)
{
var typeDef = typeRef.Resolve();
if (typeDef.Interfaces.Any(tr => tr.FullName == @interface.FullName))
if (typeDef.Interfaces.Any(tr => tr.InterfaceType.FullName == @interface.FullName))
return true;
var baseTypeRef = typeDef.BaseType;
if (baseTypeRef != null && baseTypeRef.FullName != "System.Object")
@ -99,13 +99,13 @@ namespace Xamarin.Forms.Build.Tasks
interfaceReference = null;
genericArguments = null;
var typeDef = typeRef.Resolve();
TypeReference iface;
InterfaceImplementation iface;
if ((iface = typeDef.Interfaces.FirstOrDefault(tr =>
tr.FullName.StartsWith(@interface, StringComparison.Ordinal) &&
tr.IsGenericInstance && (tr as GenericInstanceType).HasGenericArguments)) != null)
tr.InterfaceType.FullName.StartsWith(@interface, StringComparison.Ordinal) &&
tr.InterfaceType.IsGenericInstance && (tr.InterfaceType as GenericInstanceType).HasGenericArguments)) != null)
{
interfaceReference = iface as GenericInstanceType;
genericArguments = (iface as GenericInstanceType).GenericArguments;
interfaceReference = iface.InterfaceType as GenericInstanceType;
genericArguments = (iface.InterfaceType as GenericInstanceType).GenericArguments;
return true;
}
var baseTypeRef = typeDef.BaseType;
@ -157,7 +157,7 @@ namespace Xamarin.Forms.Build.Tasks
var typeDef = typeRef.Resolve();
if (TypeRefComparer.Default.Equals(typeDef, baseClass.Resolve()))
return true;
if (typeDef.Interfaces.Any(ir => TypeRefComparer.Default.Equals(ir, baseClass)))
if (typeDef.Interfaces.Any(ir => TypeRefComparer.Default.Equals(ir.InterfaceType, baseClass)))
return true;
if (typeDef.BaseType == null)
return false;
@ -201,7 +201,7 @@ namespace Xamarin.Forms.Build.Tasks
{
foreach (var face in typeDef.Interfaces)
{
var m = face.GetMethod(predicate);
var m = face.InterfaceType.GetMethod(predicate);
if (m != null)
return m;
}
@ -226,13 +226,13 @@ namespace Xamarin.Forms.Build.Tasks
{
foreach (var face in typeDef.Interfaces)
{
if (face.IsGenericInstance && typeRef is GenericInstanceType)
if (face.InterfaceType.IsGenericInstance && typeRef is GenericInstanceType)
{
int i = 0;
foreach (var arg in ((GenericInstanceType)typeRef).GenericArguments)
((GenericInstanceType)face).GenericArguments[i++] = module.Import(arg);
((GenericInstanceType)face.InterfaceType).GenericArguments[i++] = module.ImportReference(arg);
}
foreach (var tuple in face.GetMethods(predicate, module))
foreach (var tuple in face.InterfaceType.GetMethods(predicate, module))
yield return tuple;
}
yield break;
@ -253,7 +253,7 @@ namespace Xamarin.Forms.Build.Tasks
foreach (var op in implicitOperators) {
var cast = op.Item1;
var opDeclTypeRef = op.Item2;
var castDef = module.Import(cast).ResolveGenericParameters(opDeclTypeRef, module);
var castDef = module.ImportReference(cast).ResolveGenericParameters(opDeclTypeRef, module);
var returnType = castDef.ReturnType;
if (returnType.IsGenericParameter)
returnType = ((GenericInstanceType)opDeclTypeRef).GenericArguments [((GenericParameter)returnType).Position];

14
Xamarin.Forms.Build.Tasks/Xamarin.Forms.Build.Tasks.csproj
Просмотреть файл

@ -52,16 +52,16 @@
<Reference Include="System.Xml" />
<Reference Include="Microsoft.Build.Tasks.v4.0" />
<Reference Include="Mono.Cecil">
<HintPath>..\packages\Mono.Cecil.0.9.6.4\lib\net45\Mono.Cecil.dll</HintPath>
<HintPath>..\packages\Mono.Cecil.0.10.0-beta2\lib\net40\Mono.Cecil.dll</HintPath>
</Reference>
<Reference Include="Mono.Cecil.Mdb">
<HintPath>..\packages\Mono.Cecil.0.9.6.4\lib\net45\Mono.Cecil.Mdb.dll</HintPath>
<HintPath>..\packages\Mono.Cecil.0.10.0-beta2\lib\net40\Mono.Cecil.Mdb.dll</HintPath>
</Reference>
<Reference Include="Mono.Cecil.Pdb">
<HintPath>..\packages\Mono.Cecil.0.9.6.4\lib\net45\Mono.Cecil.Pdb.dll</HintPath>
<HintPath>..\packages\Mono.Cecil.0.10.0-beta2\lib\net40\Mono.Cecil.Pdb.dll</HintPath>
</Reference>
<Reference Include="Mono.Cecil.Rocks">
<HintPath>..\packages\Mono.Cecil.0.9.6.4\lib\net45\Mono.Cecil.Rocks.dll</HintPath>
<HintPath>..\packages\Mono.Cecil.0.10.0-beta2\lib\net40\Mono.Cecil.Rocks.dll</HintPath>
</Reference>
</ItemGroup>
<ItemGroup>
@ -118,9 +118,6 @@
</ItemGroup>
<Copy SourceFiles="@(_CopyItems)" DestinationFolder="..\.nuspec\" ContinueOnError="true" />
</Target>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Xamarin.Forms.Xaml\Xamarin.Forms.Xaml.csproj">
<Project>{9DB2F292-8034-4E06-89AD-98BBDA4306B9}</Project>
@ -145,4 +142,7 @@
<ItemGroup>
<Folder Include="CompiledConverters\" />
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
</Project>

111
Xamarin.Forms.Build.Tasks/XamlCTask.cs
Просмотреть файл

@ -2,9 +2,12 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Cecil.Rocks;
using Mono.Cecil.Mdb;
using Mono.Cecil.Pdb;
using Xamarin.Forms.Xaml;
namespace Xamarin.Forms.Build.Tasks
@ -23,9 +26,12 @@ namespace Xamarin.Forms.Build.Tasks
}
internal string Type { get; set; }
internal MethodDefinition InitCompForType { get; private set; }
internal bool ReadOnly { get; set; }
public override bool Execute(IList<Exception> thrownExceptions)
public override bool Execute(out IList<Exception> thrownExceptions)
{
thrownExceptions = null;
Logger = Logger ?? new Logger(null, Verbosity);
Logger.LogLine(1, "Compiling Xaml");
Logger.LogLine(1, "\nAssembly: {0}", Assembly);
@ -64,18 +70,19 @@ namespace Xamarin.Forms.Build.Tasks
}
}
var assemblyDefinition = AssemblyDefinition.ReadAssembly(Path.GetFullPath(Assembly), new ReaderParameters
{
var readerParameters = new ReaderParameters {
AssemblyResolver = resolver,
ReadSymbols = DebugSymbols
});
ReadWrite = !ReadOnly,
ReadSymbols = DebugSymbols,
SymbolReaderProvider = DebugSymbols ? (System.Type.GetType("Mono.Runtime") != null ? ((ISymbolReaderProvider)(new MdbReaderProvider())) : ((ISymbolReaderProvider)new PdbReaderProvider())) : null,
};
using (var assemblyDefinition = AssemblyDefinition.ReadAssembly(Path.GetFullPath(Assembly),readerParameters)) {
CustomAttribute xamlcAttr;
if (assemblyDefinition.HasCustomAttributes &&
(xamlcAttr =
assemblyDefinition.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null) {
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
skipassembly = true;
@ -83,14 +90,12 @@ namespace Xamarin.Forms.Build.Tasks
skipassembly = false;
}
foreach (var module in assemblyDefinition.Modules)
{
foreach (var module in assemblyDefinition.Modules) {
var skipmodule = skipassembly;
if (module.HasCustomAttributes &&
(xamlcAttr =
module.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null) {
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
skipmodule = true;
@ -100,18 +105,15 @@ namespace Xamarin.Forms.Build.Tasks
Logger.LogLine(2, " Module: {0}", module.Name);
var resourcesToPrune = new List<EmbeddedResource>();
foreach (var resource in module.Resources.OfType<EmbeddedResource>())
{
foreach (var resource in module.Resources.OfType<EmbeddedResource>()) {
Logger.LogString(2, " Resource: {0}... ", resource.Name);
string classname;
if (!resource.IsXaml(out classname))
{
if (!resource.IsXaml(out classname)) {
Logger.LogLine(2, "skipped.");
continue;
}
TypeDefinition typeDef = module.GetType(classname);
if (typeDef == null)
{
if (typeDef == null) {
Logger.LogLine(2, "no type found... skipped.");
continue;
}
@ -119,8 +121,7 @@ namespace Xamarin.Forms.Build.Tasks
if (typeDef.HasCustomAttributes &&
(xamlcAttr =
typeDef.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null) {
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
skiptype = true;
@ -131,15 +132,13 @@ namespace Xamarin.Forms.Build.Tasks
if (Type != null)
skiptype = !(Type == classname);
if (skiptype)
{
if (skiptype) {
Logger.LogLine(2, "Has XamlCompilationAttribute set to Skip and not Compile... skipped");
continue;
}
var initComp = typeDef.Methods.FirstOrDefault(md => md.Name == "InitializeComponent");
if (initComp == null)
{
if (initComp == null) {
Logger.LogLine(2, "no InitializeComponent found... skipped.");
continue;
}
@ -152,17 +151,25 @@ namespace Xamarin.Forms.Build.Tasks
var initCompRuntime = typeDef.Methods.FirstOrDefault(md => md.Name == "__InitComponentRuntime");
if (initCompRuntime != null)
Logger.LogLine(2, " __InitComponentRuntime already exists... not duplicating");
Logger.LogLine(2, " __InitComponentRuntime already exists... not creating");
else {
Logger.LogString(2, " Duplicating {0}.InitializeComponent () into {0}.__InitComponentRuntime ... ", typeDef.Name);
initCompRuntime = DuplicateMethodDef(typeDef, initComp, "__InitComponentRuntime");
Logger.LogString(2, " Creating empty {0}.__InitComponentRuntime ...", typeDef.Name);
initCompRuntime = new MethodDefinition("__InitComponentRuntime", initComp.Attributes, initComp.ReturnType);
Logger.LogLine(2, "done.");
Logger.LogString(2, " Copying body of InitializeComponent to __InitComponentRuntime ...", typeDef.Name);
initCompRuntime.Body = new MethodBody(initCompRuntime);
var iCRIl = initCompRuntime.Body.GetILProcessor();
foreach (var instr in initComp.Body.Instructions)
iCRIl.Append(instr);
initComp.Body.Instructions.Clear();
initComp.Body.GetILProcessor().Emit(OpCodes.Ret);
typeDef.Methods.Add(initCompRuntime);
Logger.LogLine(2, "done.");
}
Logger.LogString(2, " Parsing Xaml... ");
var rootnode = ParseXaml(resource.GetResourceStream(), typeDef);
if (rootnode == null)
{
if (rootnode == null) {
Logger.LogLine(2, "failed.");
continue;
}
@ -175,15 +182,17 @@ namespace Xamarin.Forms.Build.Tasks
if (!TryCoreCompile(initComp, initCompRuntime, rootnode, out e)) {
success = false;
Logger.LogLine(2, "failed.");
thrownExceptions?.Add(e);
(thrownExceptions = thrownExceptions ?? new List<Exception>()).Add(e);
Logger.LogException(null, null, null, xamlFilePath, e);
Logger.LogLine(4, e.StackTrace);
continue;
}
if (Type != null)
InitCompForType = initComp;
Logger.LogLine(2, "done.");
if (OptimizeIL)
{
if (OptimizeIL) {
Logger.LogString(2, " Optimizing IL... ");
initComp.Body.Optimize();
Logger.LogLine(2, "done");
@ -194,12 +203,10 @@ namespace Xamarin.Forms.Build.Tasks
resourcesToPrune.Add(resource);
}
if (!KeepXamlResources)
{
if (!KeepXamlResources) {
if (resourcesToPrune.Any())
Logger.LogLine(2, " Removing compiled xaml resources");
foreach (var resource in resourcesToPrune)
{
foreach (var resource in resourcesToPrune) {
Logger.LogString(2, " Removing {0}... ", resource.Name);
module.Resources.Remove(resource);
Logger.LogLine(2, "done");
@ -209,30 +216,29 @@ namespace Xamarin.Forms.Build.Tasks
Logger.LogLine(2, "");
}
if (!hasCompiledXamlResources)
{
if (!hasCompiledXamlResources) {
Logger.LogLine(1, "No compiled resources. Skipping writing assembly.");
return success;
}
if (ReadOnly)
return success;
Logger.LogString(1, "Writing the assembly... ");
try
{
assemblyDefinition.Write(Assembly, new WriterParameters
{
WriteSymbols = DebugSymbols
try {
assemblyDefinition.Write(new WriterParameters {
WriteSymbols = DebugSymbols,
SymbolWriterProvider = DebugSymbols ? (System.Type.GetType("Mono.Runtime") != null ? ((ISymbolWriterProvider)(new MdbWriterProvider())) : ((ISymbolWriterProvider)new MdbWriterProvider())): null,
});
Logger.LogLine(1, "done.");
}
catch (Exception e)
{
} catch (Exception e) {
Logger.LogLine(1, "failed.");
Logger.LogException(null, null, null, null, e);
thrownExceptions?.Add(e);
(thrownExceptions = thrownExceptions ?? new List<Exception>()).Add(e);
Logger.LogLine(4, e.StackTrace);
success = false;
}
}
return success;
}
@ -258,7 +264,8 @@ namespace Xamarin.Forms.Build.Tasks
// IL_0031: nop
var nop = Instruction.Create(OpCodes.Nop);
var getXamlFileProvider = body.Method.Module.Import(body.Method.Module.Import(typeof(Xamarin.Forms.Xaml.Internals.XamlLoader))
var getXamlFileProvider = body.Method.Module.ImportReference(body.Method.Module.ImportReference(typeof(Xamarin.Forms.Xaml.Internals.XamlLoader))
.Resolve()
.Properties.FirstOrDefault(pd => pd.Name == "XamlFileProvider")
.GetMethod);
@ -266,14 +273,14 @@ namespace Xamarin.Forms.Build.Tasks
il.Emit(OpCodes.Brfalse, nop);
il.Emit(OpCodes.Call, getXamlFileProvider);
il.Emit(OpCodes.Ldarg_0);
var getType = body.Method.Module.Import(body.Method.Module.Import(typeof(object))
var getType = body.Method.Module.ImportReference(body.Method.Module.ImportReference(typeof(object))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "GetType"));
il.Emit(OpCodes.Call, getType);
var func = body.Method.Module.Import(body.Method.Module.Import(typeof(Func<Type, string>))
var func = body.Method.Module.ImportReference(body.Method.Module.ImportReference(typeof(Func<Type, string>))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "Invoke"));
func = func.ResolveGenericParameters(body.Method.Module.Import(typeof(Func<Type, string>)), body.Method.Module);
func = func.ResolveGenericParameters(body.Method.Module.ImportReference(typeof(Func<Type, string>)), body.Method.Module);
il.Emit(OpCodes.Callvirt, func);
il.Emit(OpCodes.Brfalse, nop);
il.Emit(OpCodes.Ldarg_0);

14
Xamarin.Forms.Build.Tasks/XamlTask.cs
Просмотреть файл

@ -10,6 +10,7 @@ using Microsoft.Build.Utilities;
using Mono.Cecil;
using Xamarin.Forms.Xaml;
using Mono.Cecil.Cil;
namespace Xamarin.Forms.Build.Tasks
{
@ -31,18 +32,11 @@ namespace Xamarin.Forms.Build.Tasks
public override bool Execute()
{
Logger = new Logger(Log, Verbosity);
return Execute(null);
IList<Exception> _;
return Execute(out _);
}
public abstract bool Execute(IList<Exception> thrownExceptions);
protected static MethodDefinition DuplicateMethodDef(TypeDefinition typeDef, MethodDefinition methodDef, string newName)
{
var dup = new MethodDefinition(newName, methodDef.Attributes, methodDef.ReturnType);
dup.Body = methodDef.Body;
typeDef.Methods.Add(dup);
return dup;
}
public abstract bool Execute(out IList<Exception> thrownExceptions);
internal static ILRootNode ParseXaml(Stream stream, TypeReference typeReference)
{

6
Xamarin.Forms.Build.Tasks/XmlTypeExtensions.cs
Просмотреть файл

@ -91,7 +91,7 @@ namespace Xamarin.Forms.Build.Tasks
var assemblydefinition = module.Assembly.Name.Name == asm.AssemblyName ?
module.Assembly :
module.AssemblyResolver.Resolve(asm.AssemblyName);
module.AssemblyResolver.Resolve(AssemblyNameReference.Parse(asm.AssemblyName));
type = assemblydefinition.MainModule.GetType(asm.ClrNamespace, name);
if (type == null)
@ -108,14 +108,14 @@ namespace Xamarin.Forms.Build.Tasks
if (type != null && typeArguments != null && type.HasGenericParameters)
{
type =
module.Import(type)
module.ImportReference(type)
.MakeGenericInstanceType(typeArguments.Select(x => GetTypeReference(x, module, xmlInfo)).ToArray());
}
if (type == null)
throw new XamlParseException(string.Format("Type {0} not found in xmlns {1}", elementName, namespaceURI), xmlInfo);
return module.Import(type);
return module.ImportReference(type);
}
}
}

2
Xamarin.Forms.Build.Tasks/packages.config
Просмотреть файл

@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Mono.Cecil" version="0.9.6.4" targetFramework="net451" />
<package id="Mono.Cecil" version="0.10.0-beta2" targetFramework="net451" />
</packages>

6
Xamarin.Forms.Xaml.UnitTests/DefaultCtorRouting.xaml Normal file
Просмотреть файл

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Xamarin.Forms.Xaml.UnitTests.DefaultCtorRouting"
IsCompiled="IsCompiled?">
</ContentPage>

63
Xamarin.Forms.Xaml.UnitTests/DefaultCtorRouting.xaml.cs Normal file
Просмотреть файл

@ -0,0 +1,63 @@
using System;
using System.Collections.Generic;
using Mono.Cecil;
using Mono.Cecil.Cil;
using NUnit.Framework;
using Xamarin.Forms.Core.UnitTests;
using Xamarin.Forms.Xaml;
namespace Xamarin.Forms.Xaml.UnitTests
{
[XamlCompilation(XamlCompilationOptions.Skip)]
public partial class DefaultCtorRouting : ContentPage
{
[TypeConverter(typeof(IsCompiledTypeConverter))]
public bool IsCompiled { get; set; }
public DefaultCtorRouting()
{
InitializeComponent();
}
[TestFixture]
class Tests
{
[SetUp]
public void Setup()
{
Device.PlatformServices = new MockPlatformServices();
}
[TearDown]
public void TearDown()
{
Device.PlatformServices = null;
}
[Test]
public void ShouldntBeCompiled()
{
var p = new DefaultCtorRouting();
Assert.False(p.IsCompiled);
}
}
}
[ProvideCompiled("Xamarin.Forms.Core.XamlC.IsCompiledTypeConverter")]
class IsCompiledTypeConverter : TypeConverter, ICompiledTypeConverter
{
public override object ConvertFromInvariantString(string value)
{
if (value != "IsCompiled?")
throw new Exception();
return false;
}
public IEnumerable<Instruction> ConvertFromString(string value, ModuleDefinition module, BaseNode node)
{
if (value != "IsCompiled?")
throw new Exception();
yield return Instruction.Create(OpCodes.Ldc_I4_1);
}
}
}

6
Xamarin.Forms.Xaml.UnitTests/DefaultCtorRouting2.xaml Normal file
Просмотреть файл

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Xamarin.Forms.Xaml.UnitTests.DefaultCtorRouting2"
IsCompiled="IsCompiled?">
</ContentPage>

57
Xamarin.Forms.Xaml.UnitTests/DefaultCtorRouting2.xaml.cs Normal file
Просмотреть файл

@ -0,0 +1,57 @@
using NUnit.Framework;
using Xamarin.Forms.Core.UnitTests;
namespace Xamarin.Forms.Xaml.UnitTests
{
public partial class DefaultCtorRouting2 : ContentPage
{
[TypeConverter(typeof(IsCompiledTypeConverter))]
public bool IsCompiled { get; set; }
public DefaultCtorRouting2()
{
InitializeComponent();
}
[TestFixture]
class Tests
{
[SetUp]
public void Setup()
{
Device.PlatformServices = new MockPlatformServices();
}
[TearDown]
public void TearDown()
{
Device.PlatformServices = null;
Internals.XamlLoader.XamlFileProvider = null;
}
[Test]
public void ShouldBeCompiled()
{
var p = new DefaultCtorRouting2();
Assert.True(p.IsCompiled);
}
[Test]
public void ShouldntBeCompiled()
{
Internals.XamlLoader.XamlFileProvider = (t) => {
if (t == typeof(DefaultCtorRouting2))
return @"<?xml version=""1.0"" encoding=""UTF-8""?>
<ContentPage xmlns=""http://xamarin.com/schemas/2014/forms""
xmlns:x=""http://schemas.microsoft.com/winfx/2009/xaml""
x:Class=""Xamarin.Forms.Xaml.UnitTests.DefaultCtorRouting2""
IsCompiled=""IsCompiled?"">
</ContentPage>";
return null;
};
var p = new DefaultCtorRouting2();
Assert.False(p.IsCompiled);
}
}
}
}

7
Xamarin.Forms.Xaml.UnitTests/FactoryMethodMissingCtor.xaml.cs
Просмотреть файл

@ -12,6 +12,11 @@ namespace Xamarin.Forms.Xaml.UnitTests
InitializeComponent();
}
public FactoryMethodMissingCtor(bool useCompiledXaml)
{
//this stub will be replaced at compile time
}
[TestFixture]
public class Tests
{
@ -28,7 +33,7 @@ namespace Xamarin.Forms.Xaml.UnitTests
if (useCompiledXaml)
Assert.Throws(new XamlParseExceptionConstraint(7, 4), () => MockCompiler.Compile(typeof(FactoryMethodMissingCtor)));
else
Assert.Throws<MissingMethodException>(() => new FactoryMethodMissingCtor());
Assert.Throws<MissingMethodException>(() => new FactoryMethodMissingCtor(useCompiledXaml));
}
}
}

7
Xamarin.Forms.Xaml.UnitTests/FactoryMethodMissingMethod.xaml.cs
Просмотреть файл

@ -12,6 +12,11 @@ namespace Xamarin.Forms.Xaml.UnitTests
InitializeComponent();
}
public FactoryMethodMissingMethod(bool useCompiledXaml)
{
//this stub will be replaced at compile time
}
[TestFixture]
public class Tests
{
@ -28,7 +33,7 @@ namespace Xamarin.Forms.Xaml.UnitTests
if (useCompiledXaml)
Assert.Throws(new XamlParseExceptionConstraint(8, 4), () => MockCompiler.Compile(typeof(FactoryMethodMissingMethod)));
else
Assert.Throws<MissingMemberException>(() => new FactoryMethodMissingMethod());
Assert.Throws<MissingMemberException>(() => new FactoryMethodMissingMethod(useCompiledXaml));
}
}
}

13
Xamarin.Forms.Xaml.UnitTests/Issues/Bz43450.xaml.cs
Просмотреть файл

@ -1,4 +1,5 @@
using NUnit.Framework;
using Xamarin.Forms.Core.UnitTests;
namespace Xamarin.Forms.Xaml.UnitTests
{
@ -18,6 +19,18 @@ namespace Xamarin.Forms.Xaml.UnitTests
[TestFixture]
class Tests
{
[SetUp]
public void Setup()
{
Device.PlatformServices = new MockPlatformServices();
}
[TearDown]
public void TearDown()
{
Device.PlatformServices = null;
}
[TestCase(true)]
[TestCase(false)]
public void DoesNotAllowGridRowDefinition(bool useCompiledXaml)

1
Xamarin.Forms.Xaml.UnitTests/Issues/Unreported008.xaml.cs
Просмотреть файл

@ -4,7 +4,6 @@ using Xamarin.Forms.Core.UnitTests;
namespace Xamarin.Forms.Xaml.UnitTests
{
[XamlCompilation(XamlCompilationOptions.Skip)]
public partial class Unreported008 : ContentPage
{
public Unreported008()

19
Xamarin.Forms.Xaml.UnitTests/MockCompiler.cs
Просмотреть файл

@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.Linq;
using Xamarin.Forms.Build.Tasks;
using Mono.Cecil;
namespace Xamarin.Forms.Xaml.UnitTests
{
@ -10,6 +11,13 @@ namespace Xamarin.Forms.Xaml.UnitTests
{
public static void Compile(Type type)
{
MethodDefinition _;
Compile(type, out _);
}
public static void Compile(Type type, out MethodDefinition methdoDefinition)
{
methdoDefinition = null;
var assembly = type.Assembly.Location;
var refs = from an in type.Assembly.GetReferencedAssemblies()
let a = System.Reflection.Assembly.Load(an)
@ -20,11 +28,18 @@ namespace Xamarin.Forms.Xaml.UnitTests
ReferencePath = string.Join(";", refs),
KeepXamlResources = true,
OptimizeIL = true,
DebugSymbols = false,
ReadOnly = true,
Type = type.FullName
};
var exceptions = new List<Exception>();
if (!xamlc.Execute(exceptions) && exceptions.Any())
IList<Exception> exceptions;
if (xamlc.Execute(out exceptions) || exceptions == null || !exceptions.Any()) {
methdoDefinition = xamlc.InitCompForType;
return;
}
if (exceptions.Count > 1)
throw new AggregateException(exceptions);
throw exceptions[0];
}
}

20
Xamarin.Forms.Xaml.UnitTests/Xamarin.Forms.Xaml.UnitTests.csproj
Просмотреть файл

@ -57,16 +57,16 @@
<Reference Include="Microsoft.Build.Framework" />
<Reference Include="Microsoft.Build.Tasks.v4.0" />
<Reference Include="Mono.Cecil">
<HintPath>..\packages\Mono.Cecil.0.9.6.4\lib\net45\Mono.Cecil.dll</HintPath>
<HintPath>..\packages\Mono.Cecil.0.10.0-beta2\lib\net40\Mono.Cecil.dll</HintPath>
</Reference>
<Reference Include="Mono.Cecil.Mdb">
<HintPath>..\packages\Mono.Cecil.0.9.6.4\lib\net45\Mono.Cecil.Mdb.dll</HintPath>
<HintPath>..\packages\Mono.Cecil.0.10.0-beta2\lib\net40\Mono.Cecil.Mdb.dll</HintPath>
</Reference>
<Reference Include="Mono.Cecil.Pdb">
<HintPath>..\packages\Mono.Cecil.0.9.6.4\lib\net45\Mono.Cecil.Pdb.dll</HintPath>
<HintPath>..\packages\Mono.Cecil.0.10.0-beta2\lib\net40\Mono.Cecil.Pdb.dll</HintPath>
</Reference>
<Reference Include="Mono.Cecil.Rocks">
<HintPath>..\packages\Mono.Cecil.0.9.6.4\lib\net45\Mono.Cecil.Rocks.dll</HintPath>
<HintPath>..\packages\Mono.Cecil.0.10.0-beta2\lib\net40\Mono.Cecil.Rocks.dll</HintPath>
</Reference>
</ItemGroup>
<ItemGroup>
@ -427,6 +427,12 @@
<Compile Include="Issues\Bz44213.xaml.cs">
<DependentUpon>Bz44213.xaml</DependentUpon>
</Compile>
<Compile Include="DefaultCtorRouting.xaml.cs">
<DependentUpon>DefaultCtorRouting.xaml</DependentUpon>
</Compile>
<Compile Include="DefaultCtorRouting2.xaml.cs">
<DependentUpon>DefaultCtorRouting2.xaml</DependentUpon>
</Compile>
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<Import Project="..\.nuspec\Xamarin.Forms.Debug.targets" />
@ -775,6 +781,12 @@
<EmbeddedResource Include="Issues\Bz44213.xaml">
<Generator>MSBuild:UpdateDesignTimeXaml</Generator>
</EmbeddedResource>
<EmbeddedResource Include="DefaultCtorRouting.xaml">
<Generator>MSBuild:UpdateDesignTimeXaml</Generator>
</EmbeddedResource>
<EmbeddedResource Include="DefaultCtorRouting2.xaml">
<Generator>MSBuild:UpdateDesignTimeXaml</Generator>
</EmbeddedResource>
</ItemGroup>
<ItemGroup>
<Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />

6
Xamarin.Forms.Xaml.UnitTests/XamlC/FieldReferenceExtensionsTests.cs
Просмотреть файл

@ -37,7 +37,7 @@ namespace Xamarin.Forms.Xaml.XamlcUnitTests
[Test]
public void ResolveGenericsOnNonGenericDoesNotThrow ()
{
var type = module.Import (typeof (NonGenericClass));
var type = module.ImportReference (typeof (NonGenericClass));
TypeReference declaringTypeReference;
FieldDefinition field = type.GetField (fd => fd.Name == "Field", out declaringTypeReference);
Assert.DoesNotThrow (() => field.ResolveGenericParameters (declaringTypeReference));
@ -46,7 +46,7 @@ namespace Xamarin.Forms.Xaml.XamlcUnitTests
[Test]
public void NonGenericFieldOnGenericType ()
{
var type = module.Import (typeof (Inheritor));
var type = module.ImportReference (typeof (Inheritor));
TypeReference declaringTypeReference;
FieldDefinition field = type.GetField (fd => fd.Name == "NonGenericField", out declaringTypeReference);
Assert.AreEqual ("NonGenericField", field.Name);
@ -61,7 +61,7 @@ namespace Xamarin.Forms.Xaml.XamlcUnitTests
[Test]
public void GenericFieldOnGenericType ()
{
var type = module.Import (typeof (Inheritor));
var type = module.ImportReference (typeof (Inheritor));
TypeReference declaringTypeReference;
FieldDefinition field1 = type.GetField (fd => fd.Name == "GenericField1", out declaringTypeReference);

20
Xamarin.Forms.Xaml.UnitTests/XamlC/MethodReferenceExtensionsTests.cs
Просмотреть файл

@ -24,13 +24,13 @@ namespace Xamarin.Forms.Xaml.XamlcUnitTests
[Test]
public void ResolveRowDefAdder ()
{
var propertyType = module.Import(typeof (RowDefinitionCollection));
var propertyType = module.ImportReference(typeof (RowDefinitionCollection));
var adderT = propertyType.GetMethods ((md, tr) => md.Name == "Add", module).Single ();
var adder = adderT.Item1;
var ptype = adderT.Item2;
Assert.AreEqual ("System.Void Xamarin.Forms.DefinitionCollection`1::Add(T)", adder.FullName);
Assert.AreEqual ("Xamarin.Forms.DefinitionCollection`1<Xamarin.Forms.RowDefinition>", ptype.FullName);
var adderRef = module.Import (adder);
var adderRef = module.ImportReference (adder);
Assert.AreEqual ("System.Void Xamarin.Forms.DefinitionCollection`1::Add(T)", adderRef.FullName);
adderRef = adderRef.ResolveGenericParameters (ptype, module);
Assert.AreEqual ("System.Void Xamarin.Forms.DefinitionCollection`1<Xamarin.Forms.RowDefinition>::Add(T)", adderRef.FullName);
@ -40,16 +40,16 @@ namespace Xamarin.Forms.Xaml.XamlcUnitTests
public void GenericGetter ()
{
TypeReference declaringTypeReference;
var type = module.Import (typeof (StackLayout));
var type = module.ImportReference (typeof (StackLayout));
var property = type.GetProperty (pd => pd.Name == "Children", out declaringTypeReference);
Assert.AreEqual ("System.Collections.Generic.IList`1<T> Xamarin.Forms.Layout`1::Children()", property.FullName);
Assert.AreEqual ("Xamarin.Forms.Layout`1<Xamarin.Forms.View>", declaringTypeReference.FullName);
var propertyGetter = property.GetMethod;
Assert.AreEqual ("System.Collections.Generic.IList`1<T> Xamarin.Forms.Layout`1::get_Children()", propertyGetter.FullName);
var propertyGetterRef = module.Import (propertyGetter);
var propertyGetterRef = module.ImportReference (propertyGetter);
Assert.AreEqual ("System.Collections.Generic.IList`1<T> Xamarin.Forms.Layout`1::get_Children()", propertyGetterRef.FullName);
propertyGetterRef = module.Import (propertyGetterRef.ResolveGenericParameters (declaringTypeReference, module));
propertyGetterRef = module.ImportReference (propertyGetterRef.ResolveGenericParameters (declaringTypeReference, module));
Assert.AreEqual ("System.Collections.Generic.IList`1<T> Xamarin.Forms.Layout`1<Xamarin.Forms.View>::get_Children()", propertyGetterRef.FullName);
var returnType = propertyGetterRef.ReturnType.ResolveGenericParameters (declaringTypeReference);
Assert.AreEqual ("System.Collections.Generic.IList`1<Xamarin.Forms.View>", returnType.FullName);
@ -59,16 +59,16 @@ namespace Xamarin.Forms.Xaml.XamlcUnitTests
public void GetterWithGenericReturnType ()
{
TypeReference declaringTypeReference;
var type = module.Import (typeof (Style));
var type = module.ImportReference (typeof (Style));
var property = type.GetProperty (pd => pd.Name == "Setters", out declaringTypeReference);
Assert.AreEqual ("System.Collections.Generic.IList`1<Xamarin.Forms.Setter> Xamarin.Forms.Style::Setters()", property.FullName);
Assert.AreEqual ("Xamarin.Forms.Style", declaringTypeReference.FullName);
var propertyGetter = property.GetMethod;
Assert.AreEqual ("System.Collections.Generic.IList`1<Xamarin.Forms.Setter> Xamarin.Forms.Style::get_Setters()", propertyGetter.FullName);
var propertyGetterRef = module.Import (propertyGetter);
var propertyGetterRef = module.ImportReference (propertyGetter);
Assert.AreEqual ("System.Collections.Generic.IList`1<Xamarin.Forms.Setter> Xamarin.Forms.Style::get_Setters()", propertyGetterRef.FullName);
propertyGetterRef = module.Import (propertyGetterRef.ResolveGenericParameters (declaringTypeReference, module));
propertyGetterRef = module.ImportReference (propertyGetterRef.ResolveGenericParameters (declaringTypeReference, module));
Assert.AreEqual ("System.Collections.Generic.IList`1<Xamarin.Forms.Setter> Xamarin.Forms.Style::get_Setters()", propertyGetterRef.FullName);
var returnType = propertyGetterRef.ReturnType.ResolveGenericParameters (declaringTypeReference);
Assert.AreEqual ("System.Collections.Generic.IList`1<Xamarin.Forms.Setter>", returnType.FullName);
@ -77,13 +77,13 @@ namespace Xamarin.Forms.Xaml.XamlcUnitTests
[Test]
public void ResolveChildren ()
{
var propertyType = module.Import (typeof (IList<View>));
var propertyType = module.ImportReference (typeof (IList<View>));
var adderT = propertyType.GetMethods (md => md.Name == "Add" && md.Parameters.Count == 1, module).Single ();
var adder = adderT.Item1;
var ptype = adderT.Item2;
Assert.AreEqual ("System.Void System.Collections.Generic.ICollection`1::Add(T)", adder.FullName);
Assert.AreEqual ("System.Collections.Generic.ICollection`1<Xamarin.Forms.View>", ptype.FullName);
var adderRef = module.Import (adder);
var adderRef = module.ImportReference (adder);
Assert.AreEqual ("System.Void System.Collections.Generic.ICollection`1::Add(T)", adderRef.FullName);
adderRef = adderRef.ResolveGenericParameters (ptype, module);
Assert.AreEqual ("System.Void System.Collections.Generic.ICollection`1<Xamarin.Forms.View>::Add(T)", adderRef.FullName);

2
Xamarin.Forms.Xaml.UnitTests/XamlC/TypeReferenceExtensionsTests.cs
Просмотреть файл

@ -97,7 +97,7 @@ namespace Xamarin.Forms.Xaml.XamlcUnitTests
[TestCase(typeof(Bar<string>), typeof(Foo<string>), ExpectedResult = true)]
public bool TestInheritsFromOrImplements(Type typeRef, Type baseClass)
{
return TypeReferenceExtensions.InheritsFromOrImplements(module.Import(typeRef), module.Import(baseClass));
return TypeReferenceExtensions.InheritsFromOrImplements(module.ImportReference(typeRef), module.ImportReference(baseClass));
}
[Test]

2
Xamarin.Forms.Xaml.UnitTests/packages.config
Просмотреть файл

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Mono.Cecil" version="0.9.6.4" targetFramework="net451" />
<package id="Mono.Cecil" version="0.10.0-beta2" targetFramework="net451" />
<package id="NUnit" version="2.6.4" targetFramework="net451" />
</packages>

6
Xamarin.Forms.Xaml.Xamlc/Xamlc.cs
Просмотреть файл

@ -62,9 +62,11 @@ namespace Xamarin.Forms.Xaml
KeepXamlResources = keep,
OptimizeIL = optimize,
DependencyPaths = paths,
ReferencePath = refs
ReferencePath = refs,
DebugSymbols = true,
};
xamlc.Execute(null);
IList<Exception> _;
xamlc.Execute(out _);
}
static void ShowHelp(OptionSet ops)

2
Xamarin.Forms.Xaml/XamlLoader.cs
Просмотреть файл

@ -52,7 +52,7 @@ namespace Xamarin.Forms.Xaml
{
var xaml = GetXamlForType(callingType);
if (string.IsNullOrEmpty(xaml))
throw new XamlParseException(string.Format("No embeddedresources found for {0}", callingType), new XmlLineInfo());
throw new XamlParseException(string.Format("No embeddedresource found for {0}", callingType), new XmlLineInfo());
Load(view, xaml);
}