public void Visit(ElementNode node, INode parentNode)
{
XmlName propertyName;
//Set ResourcesDictionaries to their parents
if (IsResourceDictionary(node) && SetPropertiesVisitor.TryGetPropertyName(node, parentNode, out propertyName))
{
if ((propertyName.LocalName == "Resources" || propertyName.LocalName.EndsWith(".Resources", StringComparison.Ordinal)))
{
Context.IL.Append(SetPropertiesVisitor.SetPropertyValue(Context.Variables[(IElementNode)parentNode], propertyName, node, Context, node));
return;
}
}
//Only proceed further if the node is a keyless RD
if (parentNode is IElementNode &&
IsResourceDictionary((IElementNode)parentNode) &&
!((IElementNode)parentNode).Properties.ContainsKey(XmlName.xKey))
{
node.Accept(new SetPropertiesVisitor(Context, stopOnResourceDictionary: false), parentNode);
}
else if (parentNode is ListNode &&
IsResourceDictionary((IElementNode)parentNode.Parent) &&
!((IElementNode)parentNode.Parent).Properties.ContainsKey(XmlName.xKey))
{
node.Accept(new SetPropertiesVisitor(Context, stopOnResourceDictionary: false), parentNode);
}
}
public void Visit(ListNode node, INode parentNode)
{
XmlName name;
if (SetPropertiesVisitor.TryGetPropertyName(node, parentNode, out name))
{
node.XmlName = name;
}
}
public void Visit(ValueNode node, INode parentNode)
{
Context.Values[node] = node.Value;
XmlName propertyName;
if (SetPropertiesVisitor.TryGetPropertyName(node, parentNode, out propertyName))
{
if (propertyName.NamespaceURI == "http://schemas.openxmlformats.org/markup-compatibility/2006" &&
propertyName.LocalName == "Ignorable")
{
(parentNode.IgnorablePrefixes ?? (parentNode.IgnorablePrefixes = new List <string>())).AddRange(
(node.Value as string).Split(','));
}
}
}
public void Visit(ValueNode node, INode parentNode)
{
XmlName propertyName;
if (!SetPropertiesVisitor.TryGetPropertyName(node, parentNode, out propertyName))
{
if (!IsCollectionItem(node, parentNode))
{
return;
}
string contentProperty;
if (!Context.Variables.ContainsKey((IElementNode)parentNode))
{
return;
}
var parentVar = Context.Variables[(IElementNode)parentNode];
if ((contentProperty = SetPropertiesVisitor.GetContentProperty(parentVar.VariableType)) != null)
{
propertyName = new XmlName(((IElementNode)parentNode).NamespaceURI, contentProperty);
}
else
{
return;
}
}
if (node.SkipPrefix((node.NamespaceResolver ?? parentNode.NamespaceResolver)?.LookupPrefix(propertyName.NamespaceURI)))
{
return;
}
if (propertyName.NamespaceURI == "http://schemas.openxmlformats.org/markup-compatibility/2006" &&
propertyName.LocalName == "Ignorable")
{
(parentNode.IgnorablePrefixes ?? (parentNode.IgnorablePrefixes = new List <string>())).AddRange(
(node.Value as string).Split(','));
return;
}
if (propertyName.LocalName != "MergedWith")
{
return;
}
SetPropertiesVisitor.SetPropertyValue(Context.Variables[(IElementNode)parentNode], propertyName, node, Context, node);
}
public void Visit(ValueNode node, INode parentNode)
{
XmlName propertyName;
if (!SetPropertiesVisitor.TryGetPropertyName(node, parentNode, out propertyName))
{
if (!IsCollectionItem(node, parentNode))
{
return;
}
string contentProperty;
if (!Context.Variables.ContainsKey((IElementNode)parentNode))
{
return;
}
var parentVar = Context.Variables[(IElementNode)parentNode];
if ((contentProperty = SetPropertiesVisitor.GetContentProperty(parentVar.VariableType)) != null)
{
propertyName = new XmlName(((IElementNode)parentNode).NamespaceURI, contentProperty);
}
else
{
return;
}
}
if (propertyName.NamespaceURI == "http://schemas.openxmlformats.org/markup-compatibility/2006" &&
propertyName.LocalName == "Ignorable")
{
return;
}
if (propertyName.LocalName != "MergedWith")
{
return;
}
Context.IL.Append(SetPropertiesVisitor.SetPropertyValue(Context.Variables[(IElementNode)parentNode], propertyName, node, Context, node));
}
public void Visit(ElementNode node, INode parentNode)
{
var typeref = Module.Import(node.XmlType.GetTypeReference(Module, node));
TypeDefinition typedef = typeref.Resolve();
if (IsXaml2009LanguagePrimitive(node))
{
var vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(PushValueFromLanguagePrimitive(typedef, node));
Context.IL.Emit(OpCodes.Stloc, vardef);
return;
}
if (typeref.FullName == "Xamarin.Forms.Xaml.StaticExtension")
{
var markupProvider = new StaticExtension();
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
typeref = Module.Import(typeref);
var vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
node.Properties.Clear();
node.CollectionItems.Clear();
return;
}
MethodDefinition factoryCtorInfo = null;
MethodDefinition factoryMethodInfo = null;
MethodDefinition parameterizedCtorInfo = null;
MethodDefinition ctorInfo = null;
if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.MatchXArguments(node, Module, Context));
if (factoryCtorInfo == null)
{
throw new XamlParseException(
string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node);
}
ctorInfo = factoryCtorInfo;
if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params
{
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
}
}
else if (node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
var factoryMethod = (string)(node.Properties [XmlName.xFactoryMethod] as ValueNode).Value;
factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, Module, Context));
if (factoryMethodInfo == null)
{
throw new XamlParseException(
String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node);
}
Context.IL.Append(PushCtorXArguments(factoryMethodInfo, node));
}
if (ctorInfo == null && factoryMethodInfo == null)
{
parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.Parameters.All(
pd =>
pd.CustomAttributes.Any(
ca =>
ca.AttributeType.FullName ==
"Xamarin.Forms.ParameterAttribute")));
}
if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node))
{
ctorInfo = parameterizedCtorInfo;
// IL_0000: ldstr "foo"
Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node));
}
ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic);
var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module);
var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module);
var implicitOperatorref = typedef.Methods.FirstOrDefault(md =>
md.IsPublic &&
md.IsStatic &&
md.IsSpecialName &&
md.Name == "op_Implicit" && md.Parameters [0].ParameterType.FullName == "System.String");
if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType)
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
ValueNode vnode = null;
if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
vardef.VariableType.IsValueType)
{
//<Color>Purple</Color>
Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider [] { typedef },
node.PushServiceProvider(Context), false, true));
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
implicitOperatorref != null)
{
//<FileImageSource>path.png</FileImageSource>
var implicitOperator = Module.Import(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.Stloc, vardef);
}
else if (!typedef.IsValueType)
{
var ctor = Module.Import(ctorinforef);
// IL_0001: newobj instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::'.ctor'()
// IL_0006: stloc.0
Context.IL.Emit(OpCodes.Newobj, ctor);
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) &&
!node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, Module, Context))
{
// IL_0008: ldloca.s 1
// IL_000a: ldc.i4.1
// IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool)
var ctor = Module.Import(ctorinforef);
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
Context.IL.Emit(OpCodes.Call, ctor);
}
else
{
// IL_0000: ldloca.s 0
// IL_0002: initobj Test/Foo
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Emit(OpCodes.Initobj, Module.Import(typedef));
}
if (typeref.FullName == "Xamarin.Forms.Xaml.TypeExtension")
{
var visitor = new SetPropertiesVisitor(Context);
foreach (var cnode in node.Properties.Values.ToList())
{
cnode.Accept(visitor, node);
}
foreach (var cnode in node.CollectionItems)
{
cnode.Accept(visitor, node);
}
//As we're stripping the TypeExtension bare, keep the type if we need it later (hint: we do need it)
INode ntype;
if (!node.Properties.TryGetValue(new XmlName("", "TypeName"), out ntype))
{
ntype = node.CollectionItems [0];
}
var type = ((ValueNode)ntype).Value as string;
var prefix = "";
if (type.Contains(":"))
{
prefix = type.Split(':') [0].Trim();
type = type.Split(':') [1].Trim();
}
var namespaceuri = node.NamespaceResolver.LookupNamespace(prefix);
Context.TypeExtensions [node] = new XmlType(namespaceuri, type, null).GetTypeReference(Module, node);
if (!node.SkipProperties.Contains(new XmlName("", "TypeName")))
{
node.SkipProperties.Add(new XmlName("", "TypeName"));
}
var vardefref = new VariableDefinitionReference(vardef);
Context.IL.Append(SetPropertiesVisitor.ProvideValue(vardefref, Context, Module, node));
if (vardef != vardefref.VariableDefinition)
{
Context.Variables [node] = vardefref.VariableDefinition;
Context.Body.Variables.Add(vardefref.VariableDefinition);
}
}
if (typeref.FullName == "Xamarin.Forms.Xaml.ArrayExtension")
{
var visitor = new SetPropertiesVisitor(Context);
foreach (var cnode in node.Properties.Values.ToList())
{
cnode.Accept(visitor, node);
}
foreach (var cnode in node.CollectionItems)
{
cnode.Accept(visitor, node);
}
var markupProvider = new ArrayExtension();
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
node.Properties.Remove(new XmlName("", "Type"));
node.CollectionItems.Clear();
}
}
}
public void Visit(ElementNode node, INode parentNode)
{
var typeref = Module.ImportReference(node.XmlType.GetTypeReference(Module, node));
TypeDefinition typedef = typeref.ResolveCached();
if (IsXaml2009LanguagePrimitive(node))
{
var vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(PushValueFromLanguagePrimitive(typedef, node));
Context.IL.Emit(OpCodes.Stloc, vardef);
return;
}
//if this is a MarkupExtension that can be compiled directly, compile and returns the value
var compiledMarkupExtensionName = typeref
.GetCustomAttribute(Module, ("Xamarin.Forms.Core", "Xamarin.Forms.Xaml", "ProvideCompiledAttribute"))
?.ConstructorArguments?[0].Value as string;
Type compiledMarkupExtensionType;
ICompiledMarkupExtension markupProvider;
if (compiledMarkupExtensionName != null &&
(compiledMarkupExtensionType = Type.GetType(compiledMarkupExtensionName)) != null &&
(markupProvider = Activator.CreateInstance(compiledMarkupExtensionType) as ICompiledMarkupExtension) != null)
{
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
typeref = Module.ImportReference(typeref);
var vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
foreach (var prop in node.Properties)
{
if (!node.SkipProperties.Contains(prop.Key))
{
node.SkipProperties.Add(prop.Key);
}
}
node.CollectionItems.Clear();
return;
}
MethodDefinition factoryCtorInfo = null;
MethodDefinition factoryMethodInfo = null;
MethodDefinition parameterizedCtorInfo = null;
MethodDefinition ctorInfo = null;
if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryCtorInfo == null)
{
throw new XamlParseException(
string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node);
}
ctorInfo = factoryCtorInfo;
if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params
{
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
}
}
else if (node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
var factoryMethod = (string)(node.Properties [XmlName.xFactoryMethod] as ValueNode).Value;
factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryMethodInfo == null)
{
throw new XamlParseException(
String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node);
}
Context.IL.Append(PushCtorXArguments(factoryMethodInfo, node));
}
if (ctorInfo == null && factoryMethodInfo == null)
{
parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.Parameters.All(
pd =>
pd.CustomAttributes.Any(
ca =>
ca.AttributeType.FullName ==
"Xamarin.Forms.ParameterAttribute")));
}
string missingCtorParameter = null;
if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node, out missingCtorParameter))
{
ctorInfo = parameterizedCtorInfo;
// IL_0000: ldstr "foo"
Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node));
}
ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic);
if (parameterizedCtorInfo != null && ctorInfo == null)
{
//there was a parameterized ctor, we didn't use it
throw new XamlParseException($"The Property '{missingCtorParameter}' is required to create a '{typedef.FullName}' object.", node);
}
var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module);
var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module);
var implicitOperatorref = typedef.Methods.FirstOrDefault(md =>
md.IsPublic &&
md.IsStatic &&
md.IsSpecialName &&
md.Name == "op_Implicit" && md.Parameters [0].ParameterType.FullName == "System.String");
if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType)
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
ValueNode vnode = null;
if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
vardef.VariableType.IsValueType)
{
//<Color>Purple</Color>
Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider [] { typedef },
node.PushServiceProvider(Context), false, true));
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
implicitOperatorref != null)
{
//<FileImageSource>path.png</FileImageSource>
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.ImportReference(factorymethodinforef));
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (!typedef.IsValueType)
{
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);
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) &&
!node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, typeref, Module, Context))
{
// IL_0008: ldloca.s 1
// IL_000a: ldc.i4.1
// IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool)
var ctor = Module.ImportReference(ctorinforef);
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
Context.IL.Emit(OpCodes.Call, ctor);
}
else
{
// IL_0000: ldloca.s 0
// IL_0002: initobj Test/Foo
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Emit(OpCodes.Initobj, Module.ImportReference(typedef));
}
if (typeref.FullName == "Xamarin.Forms.Xaml.ArrayExtension")
{
var visitor = new SetPropertiesVisitor(Context);
foreach (var cnode in node.Properties.Values.ToList())
{
cnode.Accept(visitor, node);
}
foreach (var cnode in node.CollectionItems)
{
cnode.Accept(visitor, node);
}
markupProvider = new ArrayExtension();
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
foreach (var prop in node.Properties)
{
if (!node.SkipProperties.Contains(prop.Key))
{
node.SkipProperties.Add(prop.Key);
}
}
node.CollectionItems.Clear();
return;
}
}
}
public void Visit(ElementNode node, INode parentNode)
{
//Set Resources in ResourcesDictionaries
if (IsCollectionItem(node, parentNode) && parentNode is IElementNode)
{
// Collection element, implicit content, or implicit collection element.
CustomAttribute cpAttr;
var parentVar = Context.Variables[(IElementNode)parentNode];
if (parentVar.VariableType.ImplementsInterface(Module.Import(typeof(IEnumerable))))
{
if ((parentVar.VariableType.FullName == "Xamarin.Forms.ResourceDictionary" ||
parentVar.VariableType.Resolve().BaseType.FullName == "Xamarin.Forms.ResourceDictionary") &&
!node.Properties.ContainsKey(XmlName.xKey))
{
node.Accept(new SetPropertiesVisitor(Context), parentNode);
if (node.XmlType.Name != "Style")
{
throw new XamlParseException("resources in ResourceDictionary require a x:Key attribute", node);
}
//if this node is an IMarkupExtension, invoke ProvideValue() and replace the variable
var vardef = Context.Variables[node];
var vardefref = new VariableDefinitionReference(vardef);
Context.IL.Append(SetPropertiesVisitor.ProvideValue(vardefref, Context, Module, node));
if (vardef != vardefref.VariableDefinition)
{
vardef = vardefref.VariableDefinition;
Context.Body.Variables.Add(vardef);
Context.Variables[node] = vardef;
}
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))
.Resolve()
.Methods.Single(md => md.Name == "Add" && md.Parameters.Count == 1)));
}
else if ((parentVar.VariableType.FullName == "Xamarin.Forms.ResourceDictionary" ||
parentVar.VariableType.Resolve().BaseType.FullName == "Xamarin.Forms.ResourceDictionary") &&
node.Properties.ContainsKey(XmlName.xKey))
{
node.Accept(new SetPropertiesVisitor(Context), parentNode);
//if this node is an IMarkupExtension, invoke ProvideValue() and replace the variable
var vardef = Context.Variables[node];
var vardefref = new VariableDefinitionReference(vardef);
Context.IL.Append(SetPropertiesVisitor.ProvideValue(vardefref, Context, Module, node));
if (vardef != vardefref.VariableDefinition)
{
vardef = vardefref.VariableDefinition;
Context.Body.Variables.Add(vardef);
Context.Variables[node] = vardef;
}
// IL_0013: ldloc.0
// IL_0014: ldstr "key"
// IL_0019: ldstr "foo"
// IL_001e: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.ResourceDictionary::Add(string, object)
Context.IL.Emit(OpCodes.Ldloc, parentVar);
Context.IL.Emit(OpCodes.Ldstr, (node.Properties[XmlName.xKey] as ValueNode).Value as string);
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.Callvirt,
Module.Import(
Module.Import(typeof(ResourceDictionary))
.Resolve()
.Methods.Single(md => md.Name == "Add" && md.Parameters.Count == 2)));
}
}
}
//Set ResourcesDictionaries to their parents
XmlName propertyName;
if (SetPropertiesVisitor.TryGetPropertyName(node, parentNode, out propertyName) &&
(propertyName.LocalName == "Resources" || propertyName.LocalName.EndsWith(".Resources", StringComparison.Ordinal)) &&
(Context.Variables[node].VariableType.FullName == "Xamarin.Forms.ResourceDictionary" ||
Context.Variables[node].VariableType.Resolve().BaseType.FullName == "Xamarin.Forms.ResourceDictionary"))
{
SetPropertiesVisitor.SetPropertyValue(Context.Variables[(IElementNode)parentNode], propertyName, node, Context, node);
}
}