public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstNamePropertyReference prop &&
prop.TargetType is XamlAstClrTypeReference targetRef &&
targetRef.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension))
{
if (prop.Name == "ElementName")
{
return(new AvaloniaSyntheticCompiledBindingProperty(node,
SyntheticCompiledBindingPropertyName.ElementName));
}
else if (prop.Name == "RelativeSource")
{
return(new AvaloniaSyntheticCompiledBindingProperty(node,
SyntheticCompiledBindingPropertyName.RelativeSource));
}
else if (prop.Name == "Source")
{
return(new AvaloniaSyntheticCompiledBindingProperty(node,
SyntheticCompiledBindingPropertyName.Source));
}
}
return(node);
}
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);
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstObjectNode ni && ni.Type is XamlAstXmlTypeReference type)
{
foreach (var d in context.Configuration.KnownDirectives)
{
if (type.XmlNamespace == d.ns && type.Name == d.name)
{
var vnodes = new List <IXamlAstValueNode>();
foreach (var ch in ni.Children)
{
if (ch is IXamlAstValueNode vn)
{
vnodes.Add(vn);
}
if (context.StrictMode)
{
throw new XamlParseException(
"Only value nodes are allowed as directive children elements", ch);
}
}
return(new XamlAstXmlDirective(ni, type.XmlNamespace, type.Name, vnodes));
}
}
}
return(node);
}
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 TEmitResult EmitNodeCore(IXamlAstNode value, TBackendEmitter codeGen, out bool foundEmitter)
{
var result = base.EmitNodeCore(value, codeGen, out foundEmitter);
if (result != null && result.Valid)
{
return(result);
}
foreach (var e in Emitters)
{
if (e is IXamlAstLocalsNodeEmitter <TBackendEmitter, TEmitResult> ve)
{
result = ve.Emit(value, this, codeGen);
if (result != null && result.Valid)
{
foundEmitter = true;
return(result);
}
}
}
if (!foundEmitter)
{
if (value is IXamlAstLocalsEmitableNode <TBackendEmitter, TEmitResult> emittable)
{
foundEmitter = true;
return(emittable.Emit(this, codeGen));
}
}
return(result);
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstObjectNode ni)
{
XamlAstXamlPropertyValueNode propertyNode = null;
for (var c = ni.Children.Count - 1; c >= 0; c--)
{
var child = ni.Children[c];
if (child is IXamlAstValueNode valueNode)
{
if (propertyNode == null)
{
var contentProperty = context.Configuration.FindContentProperty(ni.Type.GetClrType());
if (contentProperty != null)
{
propertyNode = new XamlAstXamlPropertyValueNode(ni,
new XamlAstClrProperty(ni, contentProperty, context.Configuration),
Array.Empty <IXamlAstValueNode>());
}
else
{
var adders = XamlTransformHelpers.FindPossibleAdders(context, ni.Type.GetClrType());
if (adders.Count == 0)
{
// If there's no content property, strip all whitespace-only nodes and continue
WhitespaceNormalization.RemoveWhitespaceNodes(ni.Children);
if (!ni.Children.Contains(child))
{
continue;
}
throw new XamlParseException(
$"No Content property or any Add methods found for type {ni.Type.GetClrType().GetFqn()}",
child);
}
propertyNode = new XamlAstXamlPropertyValueNode(ni, new XamlAstClrProperty(ni,
"Content", ni.Type.GetClrType(), null,
adders.Select(a => new XamlDirectCallPropertySetter(a)
{
BinderParameters = { AllowMultiple = true }
})),
Array.Empty <IXamlAstValueNode>());
}
}
// We are going in reverse order, so insert at the beginning
propertyNode.Values.Insert(0, valueNode);
ni.Children.RemoveAt(c);
}
}
if (propertyNode != null)
{
ni.Children.Add(propertyNode);
}
}
return(node);
}
private TEmitResult EmitCore(IXamlAstNode value, TBackendEmitter codeGen, IXamlType expectedType)
{
TEmitResult res = EmitNode(value, codeGen);
IXamlType returnedType = res.ReturnType;
if (returnedType != null || expectedType != null)
{
if (returnedType != null && expectedType == null)
{
throw new XamlLoadException(
$"Emit of node {value} resulted in {returnedType.GetFqn()} while caller expected void", value);
}
if (expectedType != null && returnedType == null)
{
throw new XamlLoadException(
$"Emit of node {value} resulted in void while caller expected {expectedType.GetFqn()}", value);
}
if (!returnedType.Equals(expectedType))
{
EmitConvert(value, codeGen, expectedType, returnedType);
}
}
return(res);
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContextWithLocals <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (node is RobustNameScopeRegistrationXamlIlNode registration)
{
var scopeField = context.RuntimeContext.ContextType.Fields.First(f =>
f.Name == XamlCompiler.ContextNameScopeFieldName);
var namescopeRegisterFunction = context.Configuration.TypeSystem
.FindType("Robust.Client.UserInterface.XAML.NameScope").Methods
.First(m => m.Name == "Register");
using (var targetLoc = context.GetLocalOfType(context.Configuration.TypeSystem.FindType("Robust.Client.UserInterface.Control")))
{
codeGen
// var target = {pop}
.Stloc(targetLoc.Local)
// _context.NameScope.Register(Name, target)
.Ldloc(context.ContextLocal)
.Ldfld(scopeField);
context.Emit(registration.Name, codeGen, registration.Name.Type.GetClrType());
codeGen
.Ldloc(targetLoc.Local)
.EmitCall(namescopeRegisterFunction, true);
}
return(XamlILNodeEmitResult.Void(1));
}
return(default);
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (!(node is XamlAstObjectNode on))
{
return(node);
}
var nonDirectiveChildren = on.Children.Where(a => !(a is XamlAstXmlDirective)).ToList();
if (on.Arguments.Count != 0 ||
nonDirectiveChildren.Count != 1 ||
!(nonDirectiveChildren[0] is IXamlAstValueNode vn) ||
!vn.Type.GetClrType().Equals(context.Configuration.WellKnownTypes.String))
{
return(node);
}
if (XamlTransformHelpers.TryGetCorrectlyTypedValue(context, vn, on.Type.GetClrType(), out var rv))
{
if (nonDirectiveChildren.Count != on.Children.Count)
{
rv = new XamlValueWithManipulationNode(rv, rv,
new XamlManipulationGroupNode(rv, on.Children.OfType <XamlAstXmlDirective>()));
}
return(rv);
}
if (on.Type.GetClrType().IsValueType)
{
throw new XamlLoadException(
$"Unable to convert value {(vn as XamlAstTextNode)?.Text}) to {on.Type.GetClrType()}", vn);
}
// Parser not found, isn't a value type, probably a regular object creation node with text content
return(node);
}
protected override XamlILNodeEmitResult EmitNode(IXamlAstNode value, IXamlILEmitter codeGen)
{
CheckingILEmitter parent = null;
CheckingILEmitter checkedEmitter = null;
if (EnableIlVerification)
{
parent = codeGen as CheckingILEmitter;
parent?.Pause();
checkedEmitter = new CheckingILEmitter(codeGen);
}
#if XAMLX_DEBUG
var res = base.EmitNode(value, checkedEmitter);
#else
var res = base.EmitNode(value, checkedEmitter ?? codeGen);
#endif
if (EnableIlVerification)
{
var expectedBalance = res.ProducedItems - res.ConsumedItems;
var checkResult =
checkedEmitter.Check(res.ProducedItems - res.ConsumedItems, false);
if (checkResult != null)
{
throw new XamlLoadException($"Error during IL verification: {checkResult}\n{checkedEmitter}\n",
value);
}
parent?.Resume();
parent?.ExplicitStack(expectedBalance);
}
return(res);
}
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 IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstClrProperty prop)
{
if (prop.DeclaringType.Assembly == context.GetWinUITypes().WinUIControlsAssembly)
{
IXamlField propertyIndexMaybe = context.GetWinUITypes().XamlPropertyIndex.Fields.FirstOrDefault(f => f.Name == $"{prop.DeclaringType.Name}_{prop.Name}");
if (propertyIndexMaybe != null)
{
prop.Setters.Insert(0, new XamlDirectSetter(context.GetWinUITypes(), prop.Getter.ReturnType, prop.DeclaringType, propertyIndexMaybe));
foreach (var adder in XamlTransformHelpers.FindPossibleAdders(context, prop.Getter.ReturnType))
{
if (adder.Parameters.Count == 1)
{
prop.Setters.Add(new XamlDirectAdderSetter(context.GetWinUITypes(), adder.Parameters[0], prop.DeclaringType, propertyIndexMaybe));
}
}
return(prop);
}
IXamlField eventIndexMaybe = context.GetWinUITypes().XamlEventIndex.Fields.FirstOrDefault(f => f.Name == $"{prop.DeclaringType.Name}_{prop.Name}");
if (eventIndexMaybe != null)
{
prop.Setters.Insert(0, new XamlDirectEventSetter(context.GetWinUITypes(), prop.Setters[0].Parameters[0], prop.DeclaringType, eventIndexMaybe));
return(prop);
}
}
}
return(node);
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstObjectNode obj)
{
IXamlAstNode classesNode = null;
IXamlAstNode firstSingleClassNode = null;
var types = context.GetAvaloniaTypes();
foreach (var child in obj.Children)
{
if (child is XamlAstXamlPropertyValueNode propValue &&
propValue.Property is XamlAstClrProperty prop)
{
if (prop.DeclaringType.Equals(types.Classes))
{
if (firstSingleClassNode == null)
{
firstSingleClassNode = child;
}
}
else if (prop.Name == "Classes" && prop.DeclaringType.Equals(types.StyledElement))
{
classesNode = child;
}
}
}
if (classesNode != null && firstSingleClassNode != null)
{
obj.Children.Remove(classesNode);
obj.Children.Insert(obj.Children.IndexOf(firstSingleClassNode), classesNode);
}
}
return(node);
}
protected virtual TEmitResult EmitNodeCore(IXamlAstNode value, TBackendEmitter codeGen, out bool foundEmitter)
{
TEmitResult res = default;
foreach (var e in Emitters)
{
if (e is IXamlAstNodeEmitter <TBackendEmitter, TEmitResult> ve)
{
res = ve.Emit(value, this, codeGen);
if (res != null && res.Valid)
{
foundEmitter = true;
return(res);
}
}
}
if (value is IXamlAstEmitableNode <TBackendEmitter, TEmitResult> en)
{
foundEmitter = true;
return(en.Emit(this, codeGen));
}
foundEmitter = false;
return(res);
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
var propertyEncountered = false;
if (node is XamlAstObjectNode ni)
{
for (var c = ni.Children.Count - 1; c >= 0; c--)
{
var child = ni.Children[c];
if (child is XamlAstXamlPropertyValueNode)
{
propertyEncountered = true;
}
else if (propertyEncountered && child is XamlAstTextNode textNode)
{
if (WhitespaceNormalization.IsWhitespace(textNode.Text))
{
ni.Children.RemoveAt(c);
}
}
}
}
return(node);
}
public static List <(string name, string type)> GetNames(IXamlAstNode node)
{
var visitor = new NameVisitor();
node.Visit(visitor);
return(visitor._names);
}
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 XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContextWithLocals <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (node is AvaloniaNameScopeRegistrationXamlIlNode registration)
{
var scopeField = context.RuntimeContext.ContextType.Fields.First(f =>
f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName);
using (var targetLoc = context.GetLocalOfType(context.Configuration.WellKnownTypes.Object))
{
codeGen
// var target = {pop}
.Stloc(targetLoc.Local)
// _context.NameScope.Register(Name, target)
.Ldloc(context.ContextLocal)
.Ldfld(scopeField);
context.Emit(registration.Name, codeGen, registration.Name.Type.GetClrType());
codeGen
.Ldloc(targetLoc.Local)
.EmitCall(context.GetAvaloniaTypes().INameScopeRegister, true);
}
return(XamlILNodeEmitResult.Void(1));
}
return(default);
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstObjectNode objectNode)
{
var nextNodeIsTextNode = false;
for (var i = objectNode.Children.Count - 1; i >= 0; i--)
{
var childNode = objectNode.Children[i];
if (childNode is XamlAstTextNode textNode)
{
// If childNode is the first node in a chain of text nodes, merge it with all subsequent
// text nodes, and remove them.
if (nextNodeIsTextNode && (i == 0 || !(objectNode.Children[i - 1] is XamlAstTextNode)))
{
var newText = new StringBuilder(textNode.Text);
while (i + 1 < objectNode.Children.Count && objectNode.Children[i + 1] is XamlAstTextNode nextTextNode)
{
newText.Append(nextTextNode.Text);
objectNode.Children.RemoveAt(i + 1);
}
textNode.Text = newText.ToString();
}
nextNodeIsTextNode = true;
}
else
{
nextNodeIsTextNode = false;
}
}
}
return(node);
}
public IXamlAstNode Visit(IXamlAstNode node)
{
if (node is XamlAstObjectNode objectNode)
{
var clrtype = objectNode.Type.GetClrType();
var isControl = IsControl(clrtype);
//clrtype.Interfaces.Any(i =>
//i.IsInterface && i.FullName == "Robust.Client.UserInterface.IControl");
if (!isControl)
{
return(node);
}
foreach (var child in objectNode.Children)
{
if (child is XamlAstXamlPropertyValueNode propertyValueNode &&
propertyValueNode.Property is XamlAstNamePropertyReference namedProperty &&
namedProperty.Name == "Name" &&
propertyValueNode.Values.Count > 0 &&
propertyValueNode.Values[0] is XamlAstTextNode text)
{
var reg = (text.Text, $@"{clrtype.Namespace}.{clrtype.Name}");
if (!_names.Contains(reg))
{
_names.Add(reg);
}
}
}
}
return(node);
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (!(node is XamlPropertyAssignmentNode pa) || pa.Values.Count != 2)
{
return(node);
}
if (!ShouldBeDeferred(pa.Values[1]))
{
return(node);
}
var types = context.GetAvaloniaTypes();
if (pa.Property.DeclaringType == types.ResourceDictionary && pa.Property.Name == "Content")
{
pa.Values[1] = new XamlDeferredContentNode(pa.Values[1], types.XamlIlTypes.Object, context.Configuration);
pa.PossibleSetters = new List <IXamlPropertySetter>
{
new XamlDirectCallPropertySetter(types.ResourceDictionaryDeferredAdd),
};
}
else if (pa.Property.Name == "Resources" && pa.Property.Getter.ReturnType.Equals(types.IResourceDictionary))
{
pa.Values[1] = new XamlDeferredContentNode(pa.Values[1], types.XamlIlTypes.Object, context.Configuration);
pa.PossibleSetters = new List <IXamlPropertySetter>
{
new AdderSetter(pa.Property.Getter, types.ResourceDictionaryDeferredAdd),
};
}
return(node);
}
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContextWithLocals <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
{
if (!(node is XamlObjectInitializationNode init))
{
return(null);
}
var supportInitType = context.Configuration.TypeMappings.SupportInitialize;
var supportsInitialize = supportInitType != null &&
context.Configuration.TypeMappings.SupportInitialize
.IsAssignableFrom(init.Type);
if (supportsInitialize)
{
codeGen
// We need a copy for/EndInit
.Emit(OpCodes.Dup);
if (!init.SkipBeginInit)
{
codeGen
.Emit(OpCodes.Dup)
.EmitCall(supportInitType.FindMethod(m => m.Name == "BeginInit"));
}
}
var addToParentStack = context.RuntimeContext.ParentListField != null &&
!init.Type.IsValueType &&
context.GetOrCreateItem <XamlNeedsParentStackCache>().NeedsParentStack(node);
if (addToParentStack)
{
using (var local = context.GetLocalOfType(init.Type))
codeGen
.Stloc(local.Local)
.Ldloc(context.ContextLocal)
.Ldloc(local.Local)
.EmitCall(context.RuntimeContext.PushParentMethod)
.Ldloc(local.Local);
}
using (codeGen.EmitObjectInitializationMarker(init.Type.FullName))
{
context.Emit(init.Manipulation, codeGen, null);
if (addToParentStack)
{
codeGen
.Ldloc(context.ContextLocal)
.EmitCall(context.RuntimeContext.PopParentMethod, true);
}
}
if (supportsInitialize)
{
codeGen
.EmitCall(supportInitType.FindMethod(m => m.Name == "EndInit"));
}
return(XamlILNodeEmitResult.Void(1));
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlManipulationGroupNode group && group.Children.Count == 1)
{
return(group.Children[0]);
}
return(node);
}
public IXamlAstNode Error(IXamlAstNode node, Exception e)
{
if (StrictMode)
{
throw e;
}
return(node);
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstObjectNode binding && binding.Type.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension))
{
var convertedNode = ConvertLongFormPropertiesToBindingExpressionNode(context, binding);
var foundPath = false;
if (binding.Arguments.Count > 0 && binding.Arguments[0] is XamlAstTextNode bindingPathText)
{
var reader = new CharacterReader(bindingPathText.Text.AsSpan());
var(nodes, _) = BindingExpressionGrammar.Parse(ref reader);
if (convertedNode != null)
{
nodes.Insert(nodes.TakeWhile(x => x is BindingExpressionGrammar.ITransformNode).Count(), convertedNode);
}
if (nodes.Count == 1 && nodes[0] is BindingExpressionGrammar.EmptyExpressionNode)
{
binding.Arguments.RemoveAt(0);
}
else
{
binding.Arguments[0] = new ParsedBindingPathNode(bindingPathText, context.GetAvaloniaTypes().CompiledBindingPath, nodes);
foundPath = true;
}
}
if (!foundPath)
{
var bindingPathAssignment = binding.Children.OfType <XamlAstXamlPropertyValueNode>()
.FirstOrDefault(v => v.Property.GetClrProperty().Name == "Path");
if (bindingPathAssignment != null && bindingPathAssignment.Values[0] is XamlAstTextNode pathValue)
{
var reader = new CharacterReader(pathValue.Text.AsSpan());
var(nodes, _) = BindingExpressionGrammar.Parse(ref reader);
if (nodes.Count == 1 && nodes[0] is BindingExpressionGrammar.EmptyExpressionNode)
{
bindingPathAssignment.Values.RemoveAt(0);
}
else
{
if (convertedNode != null)
{
nodes.Insert(nodes.TakeWhile(x => x is BindingExpressionGrammar.ITransformNode).Count(), convertedNode);
}
bindingPathAssignment.Values[0] = new ParsedBindingPathNode(pathValue, context.GetAvaloniaTypes().CompiledBindingPath, nodes);
}
}
}
}
return(node);
}
protected override XamlILNodeEmitResult EmitNodeCore(IXamlAstNode value, IXamlILEmitter codeGen, out bool foundEmitter)
{
if (File != null)
{
codeGen.InsertSequencePoint(File, value.Line, value.Position);
}
return(base.EmitNodeCore(value, codeGen, out foundEmitter));
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is AvaloniaXamlIlTargetTypeMetadataNode targetType)
{
return(targetType.Value);
}
return(node);
}
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlPropertyAssignmentNode pa)
{
if (pa.Property.Name == "Name" &&
pa.Property.DeclaringType.FullName == "Robust.Client.UserInterface.Control")
{
if (context.ParentNodes().FirstOrDefault() is XamlManipulationGroupNode mg &&
mg.Children.OfType <RobustNameScopeRegistrationXamlIlNode>().Any())
{
return(node);
}
IXamlAstValueNode value = null;
for (var c = 0; c < pa.Values.Count; c++)
{
if (pa.Values[c].Type.GetClrType().Equals(context.Configuration.WellKnownTypes.String))
{
value = pa.Values[c];
if (!(value is XamlAstTextNode))
{
var local = new XamlAstCompilerLocalNode(value);
// Wrap original in local initialization
pa.Values[c] = new XamlAstLocalInitializationNodeEmitter(value, value, local);
// Use local
value = local;
}
break;
}
}
if (value != null)
{
var objectType = context.ParentNodes().OfType <XamlAstConstructableObjectNode>().FirstOrDefault()?.Type.GetClrType();
return(new XamlManipulationGroupNode(pa)
{
Children =
{
pa,
new RobustNameScopeRegistrationXamlIlNode(value, objectType)
}
});
}
}
/*else if (pa.Property.CustomAttributes.Select(attr => attr.Type).Intersect(context.Configuration.TypeMappings.DeferredContentPropertyAttributes).Any())
* {
* pa.Values[pa.Values.Count - 1] =
* new NestedScopeMetadataNode(pa.Values[pa.Values.Count - 1]);
* }*/
}
return(node);
}
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 IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstObjectNode objectNode &&
objectNode.Type is XamlAstXmlTypeReference typeReference &&
(typeReference.Name == "DataTemplate" ||
typeReference.Name == "ControlTemplate"))
{
objectNode.Children.Clear();
}
return(node);
}
