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); }