public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen.Ldstr(_color);
codeGen.EmitCall(_method);
return(XamlILNodeEmitResult.Type(0, Type.GetClrType()));
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (!(node is XamlAstNewClrObjectNode n))
{
return(null);
}
var type = n.Type.GetClrType();
var ctor = n.Constructor ?? type.FindConstructor();
if (ctor == null)
{
throw new XamlLoadException("Unable to find default constructor and no non-default one is specified",
n);
}
using (codeGen.EmitNewObjectMarker())
{
for (var c = 0; c < n.Arguments.Count; c++)
{
context.Emit(n.Arguments[c], codeGen, ctor.Parameters[c]);
}
var gen = codeGen
.Emit(OpCodes.Newobj, ctor);
}
return(XamlILNodeEmitResult.Type(0, type));
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (node is XamlObjectFromDirectObjectNode objNode)
{
IXamlType xamlDirectType = context.GetWinUITypes().XamlDirect;
codeGen
.EmitCall(xamlDirectType.GetMethod(new FindMethodMethodSignature("GetDefault", xamlDirectType)
{
IsStatic = true
}));
context.Emit(objNode.Value, codeGen, context.GetWinUITypes().IXamlDirectObject);
codeGen
.EmitCall(xamlDirectType.GetMethod(new FindMethodMethodSignature("GetObject", context.Configuration.WellKnownTypes.Object, context.GetWinUITypes().IXamlDirectObject)))
.Castclass(objNode.Type.GetClrType());
return(XamlILNodeEmitResult.Type(0, objNode.Type.GetClrType()));
}
else if (node is XamlDirectObjectFromObjectNode directObjNode)
{
IXamlType xamlDirectType = context.GetWinUITypes().XamlDirect;
codeGen
.EmitCall(xamlDirectType.GetMethod(new FindMethodMethodSignature("GetDefault", xamlDirectType)
{
IsStatic = true
}));
context.Emit(directObjNode.Value, codeGen, context.Configuration.WellKnownTypes.Object);
codeGen
.EmitCall(xamlDirectType.GetMethod(new FindMethodMethodSignature("GetXamlDirectObject", context.GetWinUITypes().IXamlDirectObject, context.Configuration.WellKnownTypes.Object)));
return(XamlILNodeEmitResult.Type(0, context.GetWinUITypes().IXamlDirectObject));
}
return(null);
}
protected override void DoEmit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
var name = _type.ToString();
EmitCall(context, codeGen,
m => m.Name == name && m.Parameters.Count == 1);
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (Constant is string)
{
codeGen.Emit(OpCodes.Ldstr, (string)Constant);
}
else if (Constant is long || Constant is ulong)
{
codeGen.Emit(OpCodes.Ldc_I8, TypeSystem.TypeSystemHelpers.ConvertLiteralToLong(Constant));
}
else if (Constant is float f)
{
codeGen.Emit(OpCodes.Ldc_R4, f);
}
else if (Constant is double d)
{
codeGen.Emit(OpCodes.Ldc_R8, d);
}
else if (Constant is bool b)
{
codeGen.Emit(b ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
}
else
{
codeGen.Emit(OpCodes.Ldc_I4, TypeSystem.TypeSystemHelpers.ConvertLiteralToInt(Constant));
}
return(XamlILNodeEmitResult.Type(0, Type.GetClrType()));
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (!(node is HandleRootObjectScopeNode))
{
return(null);
}
var types = context.GetAvaloniaTypes();
var next = codeGen.DefineLabel();
var scopeField = context.RuntimeContext.ContextType.Fields.First(f =>
f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName);
using (var local = codeGen.LocalsPool.GetLocal(types.StyledElement))
{
codeGen
.Isinst(types.StyledElement)
.Dup()
.Stloc(local.Local)
.Brfalse(next)
.Ldloc(local.Local)
.Ldloc(context.ContextLocal)
.Ldfld(scopeField)
.EmitCall(types.NameScopeSetNameScope, true)
.MarkLabel(next)
.Ldloc(context.ContextLocal)
.Ldfld(scopeField)
.EmitCall(types.INameScopeComplete, true);
}
return(XamlILNodeEmitResult.Void(1));
}
public void Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen
.Ldtype(_type)
.EmitCall(context.GetAvaloniaTypes()
.PropertyPathBuilder.FindMethod(m => m.Name == (_ensureType ? "EnsureType" : "Cast")));
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
// Discard the stack value we are "supposed" to manipulate
codeGen.Pop();
context.Emit(Imperative, codeGen, null);
return(XamlILNodeEmitResult.Void(1));
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (!(node is XamlMethodCallBaseNode mc))
{
return(null);
}
bool thisArgFromArgs = node is XamlStaticOrTargetedReturnMethodCallNode;
bool expectsVoid = node is XamlNoReturnMethodCallNode;
for (var c = 0; c < mc.Arguments.Count; c++)
{
var off = thisArgFromArgs ? 0 : 1;
var expectedType = mc.Method.ParametersWithThis[c + off];
context.Emit(mc.Arguments[c], codeGen, expectedType);
}
context.Emit(mc.Method, codeGen, expectsVoid);
var isVoid = mc.Method.ReturnType.Equals(context.Configuration.WellKnownTypes.Void);
if (!expectsVoid && isVoid)
{
throw new XamlLoadException(
$"XamlStaticReturnMethodCallNode expects a value while {mc.Method.Name} returns void", node);
}
var consumed = thisArgFromArgs ? 0 : 1;
return(isVoid || expectsVoid
? XamlILNodeEmitResult.Void(consumed)
: XamlILNodeEmitResult.Type(consumed, mc.Method.ReturnType));
}
protected override void DoEmit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen.Ldc_I4(_step);
codeGen.Ldc_I4(_offset);
EmitCall(context, codeGen,
m => m.Name == _type.ToString() && m.Parameters.Count == 3);
}
protected override void DoEmit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (_selectors.Count == 0)
{
throw new XamlLoadException("Invalid selector count", this);
}
if (_selectors.Count == 1)
{
_selectors[0].Emit(context, codeGen);
return;
}
var listType = context.Configuration.TypeSystem.FindType("System.Collections.Generic.List`1")
.MakeGenericType(base.Type.GetClrType());
var add = listType.FindMethod("Add", context.Configuration.WellKnownTypes.Void, false, Type.GetClrType());
codeGen
.Newobj(listType.FindConstructor());
foreach (var s in _selectors)
{
codeGen.Dup();
context.Emit(s, codeGen, Type.GetClrType());
codeGen.EmitCall(add, true);
}
EmitCall(context, codeGen,
m => m.Name == "Or" && m.Parameters.Count == 1 && m.Parameters[0].Name.StartsWith("IReadOnlyList"));
}
protected void EmitCall(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen, Func <IXamlMethod, bool> method)
{
var selectors = context.Configuration.TypeSystem.GetType("Avalonia.Styling.Selectors");
var found = selectors.FindMethod(m => m.IsStatic && m.Parameters.Count > 0 && method(m));
codeGen.EmitCall(found);
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen
.Ldloc(context.ContextLocal)
.Ldfld(context.RuntimeContext.IntermediateRootObjectField);
return(XamlILNodeEmitResult.Type(0, Type.GetClrType()));
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
var type = TargetType.GetClrType();
var member = ResolveMember(type);
if (member is IXamlProperty prop)
{
codeGen.Emit(OpCodes.Call, prop.Getter);
return(XamlILNodeEmitResult.Type(0, prop.Getter.ReturnType));
}
else if (member is IXamlField field)
{
if (field.IsLiteral)
{
ILEmitHelpers.EmitFieldLiteral(field, codeGen);
}
else
{
codeGen.Emit(OpCodes.Ldsfld, field);
}
return(XamlILNodeEmitResult.Type(0, field.FieldType));
}
else
{
throw new XamlLoadException(
$"Unable to resolve {Member} as static field, property, constant or enum value", this);
}
}
public void Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
context.Configuration.GetExtra <XamlIlClrPropertyInfoEmitter>()
.Emit(context, codeGen, _property);
codeGen.EmitCall(context.GetAvaloniaTypes()
.PropertyPathBuilder.FindMethod(m => m.Name == "Property"));
}
protected override void DoEmit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen.Ldstr(String);
var name = _type.ToString();
EmitCall(context, codeGen,
m => m.Name == name && m.Parameters.Count == 2 && m.Parameters[1].FullName == "System.String");
}
protected override void DoEmit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
var name = Concrete ? "OfType" : "Is";
codeGen.Ldtype(TargetType);
EmitCall(context, codeGen,
m => m.Name == name && m.Parameters.Count == 2 && m.Parameters[1].FullName == "System.Type");
}
public virtual XamlILNodeEmitResult Emit(
XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context,
IXamlILEmitter codeGen)
{
codeGen.Newobj(_constructor);
return(XamlILNodeEmitResult.Type(0, Type.GetClrType()));
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
context.Emit(Value, codeGen, Method.DeclaringType);
codeGen
.Ldftn(Method)
.Newobj(DelegateType.Constructors.FirstOrDefault(ct =>
ct.Parameters.Count == 2 && ct.Parameters[0].Equals(context.Configuration.WellKnownTypes.Object)));
return(XamlILNodeEmitResult.Type(0, DelegateType));
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen
.Ldc_R8(_gridLength.Value)
.Ldc_I4((int)_gridLength.GridUnitType)
.Newobj(_types.GridLengthConstructorValueType);
return(XamlILNodeEmitResult.Type(0, Type.GetClrType()));
}
public virtual XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (Previous != null)
{
context.Emit(Previous, codeGen, Type.GetClrType());
}
DoEmit(context, codeGen);
return(XamlILNodeEmitResult.Type(0, Type.GetClrType()));
}
public static AvaloniaXamlIlWellKnownTypes GetAvaloniaTypes(this XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> ctx)
{
if (ctx.TryGetItem <AvaloniaXamlIlWellKnownTypes>(out var rv))
{
return(rv);
}
ctx.SetItem(rv = new AvaloniaXamlIlWellKnownTypes(ctx.Configuration));
return(rv);
}
protected override void DoEmit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen.Ldsfld(PropertyFiled);
context.Emit(Value, codeGen, context.Configuration.WellKnownTypes.Object);
EmitCall(context, codeGen,
m => m.Name == "PropertyEquals" &&
m.Parameters.Count == 3 &&
m.Parameters[1].FullName == "Avalonia.AvaloniaProperty" &&
m.Parameters[2].Equals(context.Configuration.WellKnownTypes.Object));
}
public override XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context,
IXamlILEmitter codeGen)
{
foreach (var value in Values)
{
codeGen.Emit(OpCodes.Ldc_I4, value);
}
return(base.Emit(context, codeGen));
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
foreach (var value in _values)
{
codeGen.Ldc_R8(value);
}
codeGen.Newobj(_constructor);
return(XamlILNodeEmitResult.Type(0, Type.GetClrType()));
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen
.Ldloc(context.ContextLocal)
.Castclass(context.Configuration.TypeMappings.UriContextProvider)
.EmitCall(context.Configuration.TypeMappings.UriContextProvider.FindMethod(
"get_BaseUri", _types.Uri, false))
.Ldstr(_text)
.Newobj(_types.FontFamilyConstructorUriName);
return(XamlILNodeEmitResult.Type(0, _types.FontFamily));
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (!(node is XamlPropertyValueManipulationNode pvm))
{
return(null);
}
codeGen.EmitCall(pvm.Property.Getter);
context.Emit(pvm.Manipulation, codeGen, null);
return(XamlILNodeEmitResult.Void(1));
}
public XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
codeGen
.Newobj(_types.PropertyPathBuilder.FindConstructor());
foreach (var e in _elements)
{
e.Emit(context, codeGen);
}
codeGen.EmitCall(_types.PropertyPathBuilder.FindMethod(m => m.Name == "Build"));
return(XamlILNodeEmitResult.Type(0, _types.PropertyPath));
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter ilgen)
{
if (!(node is XamlMarkupExtensionNode me))
{
return(null);
}
XamlNeedsParentStackCache.Verify(context, node);
var prop = context.ParentNodes().OfType <XamlPropertyAssignmentNode>().FirstOrDefault();
var needProvideValueTarget = me.ProvideValue.Parameters.Count != 0 &&
context.RuntimeContext.PropertyTargetObject != null &&
prop != null;
void EmitPropertyDescriptor()
{
if (context.EmitMappings.ProvideValueTargetPropertyEmitter
?.Invoke(context, ilgen, prop.Property) == true)
{
return;
}
ilgen.Ldstr(prop.Property.Name);
}
context.Emit(me.Value, ilgen, me.Value.Type.GetClrType());
if (me.ProvideValue.Parameters.Count > 0)
{
ilgen
.Emit(OpCodes.Ldloc, context.ContextLocal);
}
if (needProvideValueTarget)
{
ilgen
.Ldloc(context.ContextLocal);
EmitPropertyDescriptor();
ilgen
.Stfld(context.RuntimeContext.PropertyTargetProperty);
}
ilgen.EmitCall(me.ProvideValue);
if (needProvideValueTarget)
{
ilgen
.Ldloc(context.ContextLocal)
.Ldnull()
.Stfld(context.RuntimeContext.PropertyTargetProperty);
}
return(XamlILNodeEmitResult.Type(0, me.ProvideValue.ReturnType));
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (!(node is XamlAstTextNode text))
{
return(null);
}
if (!text.Type.GetClrType().Equals(context.Configuration.WellKnownTypes.String))
{
throw new XamlLoadException("Text node type wasn't resolved to well-known System.String", node);
}
codeGen.Emit(OpCodes.Ldstr, text.Text);
return(XamlILNodeEmitResult.Type(0, text.Type.GetClrType()));
}
