public override void OnMemberReferenceExpression(MemberReferenceExpression node) { Write("MemberReferenceExpression("); BeginNode(); WriteIndented("Target: "); Visit(node.Target); Write(", "); WriteLine(); WriteIndented("Name: "); WriteString(node.Name); EndNode(); }
B.ReferenceExpression MakeReferenceExpression(string fullName) { string[] parts = fullName.Split('.'); B.ReferenceExpression r = new B.ReferenceExpression(lastLexicalInfo, parts[0]); for (int i = 1; i < parts.Length; i++) r = new B.MemberReferenceExpression(lastLexicalInfo, r, parts[i]); return r; }
private Expression FixCondition(Expression condition) { if (IsTryGetParameterInvocation(condition) == false) return condition; var isNull = new MemberReferenceExpression(condition, "_IsIgnoreNullReferencingNotNullObject_"); return isNull; }
public override void WrapStatementsInBlockIfNeeded(MemberReferenceExpression node, IUpdateCollector<LexicalInfo> updateCollector) { if (!this.IsInsideBlock(node)) { Statement statement = BooExtensions.FindRootStatement(node); updateCollector.Insert(BooExtensions.SourcePosition(BooExtensions.FindExpressionRoot(statement)), "{ ", node.get_LexicalInfo(), null).InclusiveRange = false; updateCollector.Insert(new SourcePosition(statement.get_EndSourceLocation().get_Line(), statement.get_EndSourceLocation().get_Column() + 1), " }", node.get_LexicalInfo(), null); } }
/// <summary> /// Called when we encounters a member reference expression /// </summary> /// <param name="node">The node.</param> public override void OnMemberReferenceExpression(MemberReferenceExpression node) { if (this.ShouldTransformNodeName(node)) { this.TransformNodeName(node); } base.OnMemberReferenceExpression(node); }
public override void OnReferenceExpression(ReferenceExpression node) { if (node.Name[0] == '_') { var result = new MemberReferenceExpression(node.LexicalInfo); result.Name = node.Name.Substring(1); result.Target = instance.CloneNode(); ReplaceCurrentNode(result); } }
B.ReferenceExpression MakeReferenceExpression(string fullName) { string[] parts = fullName.Split('.'); B.ReferenceExpression r = new B.ReferenceExpression(lastLexicalInfo, parts[0]); for (int i = 1; i < parts.Length; i++) { r = new B.MemberReferenceExpression(lastLexicalInfo, r, parts[i]); } return(r); }
override public void OnMemberReferenceExpression(MemberReferenceExpression node) { var tern = ProcessTargets(node); if (tern != null) { ReplaceCurrentNode(tern); return; } base.OnMemberReferenceExpression(node); }
public override void OnMemberReferenceExpression(MemberReferenceExpression node) { if (LookingFor(node)) { Found(node); } else { base.OnMemberReferenceExpression(node); } }
public override void OnMemberReferenceExpression(MemberReferenceExpression node) { var name = node.ToString(); if (name.StartsWith("@")) { ReplaceWithComponentReference(node, name); return; } base.OnMemberReferenceExpression(node); }
public static ReferenceExpression CreateReferenceExpression(string fullname) { string[] parts = fullname.Split('.'); ReferenceExpression expression = new ReferenceExpression(parts[0]); expression.IsSynthetic = true; for (int i=1; i<parts.Length; ++i) { expression = new MemberReferenceExpression(expression, parts[i]); expression.IsSynthetic = true; } return expression; }
protected override Statement ExpandImpl(MacroStatement macro){ if (macro.Arguments.Count == 0) { Context.Errors.Add(new CompilerError(macro.LexicalInfo, "call macro requires at least one reference or string attribute for action name")); } var basis = new ReferenceExpression("Html"); var method = new MemberReferenceExpression(basis, "RenderAction"); var call = new MethodInvocationExpression(method); int i = 0; var result = new Block(); foreach (Expression argument in macro.Arguments){ i++; Expression exp = argument; if (!(exp is HashLiteralExpression)){ //action and contrller parameters if (!(exp is NullLiteralExpression)){ exp = new StringLiteralExpression(argument.ToCodeString()); } call.Arguments.Add(exp); } else{ string name = "__rd"; result.Add( new DeclarationStatement( new Declaration(name, null), new MethodInvocationExpression(AstUtil.CreateReferenceExpression("RouteValueDictionary")) ) ); var dict = argument as HashLiteralExpression; foreach (ExpressionPair item in dict.Items){ result.Add( new MethodInvocationExpression( AstUtil.CreateReferenceExpression(name + ".Add"), item.First, item.Second ) ); } if (i == 2){ call.Arguments.Add(new NullLiteralExpression()); } call.Arguments.Add(AstUtil.CreateReferenceExpression(name)); } } result.Add(call); return result; }
public override void LeaveMemberReferenceExpression(MemberReferenceExpression node) { var property = node.Entity as IProperty; if (property == null || node.IsTargetOfAssignment()) return; var getter = CodeBuilder.CreatePropertyGet(node.Target, property); // preserve duck typing... if (property.IsDuckTyped) ReplaceCurrentNode( CodeBuilder.CreateCast( TypeSystemServices.DuckType, getter)); else ReplaceCurrentNode(getter); }
private Expression FixCondition(Expression condition){ if (IsTryGetParameterInvocation(condition) == false){ return condition; } string name = ((ReferenceExpression) condition).Name.Substring(1); condition = new MethodInvocationExpression( new MemberReferenceExpression(new SuperLiteralExpression(), "TryGetParameter"), new StringLiteralExpression(name) ); var isNull = new MemberReferenceExpression(condition, "_IsIgnoreNullReferencingNotNullObject_"); return isNull; }
public override void OnMemberReferenceExpression(MemberReferenceExpression node) { ReferenceExpression reference = node.Target as ReferenceExpression; if (reference != null && reference.Name.StartsWith("@")) { _component = reference; } else { _component = AstUtil.CreateMethodInvocationExpression( AstUtil.CreateReferenceExpression(typeof(ComponentReference).FullName), node.Target ); } _method = new StringLiteralExpression(node.Name); _found = true; }
protected override void AddResolvedNamedArgumentToEval(MethodInvocationExpression eval, ExpressionPair pair, ReferenceExpression instance) { if (!TypeSystemServices.IsQuackBuiltin(pair.First)) { base.AddResolvedNamedArgumentToEval(eval, pair, instance); return; } MemberReferenceExpression memberRef = new MemberReferenceExpression( pair.First.LexicalInfo, instance.CloneNode(), ((ReferenceExpression)pair.First).Name); BindQuack(memberRef); eval.Arguments.Add( CodeBuilder.CreateAssignment( pair.First.LexicalInfo, memberRef, pair.Second)); }
public override void LeaveMemberReferenceExpression(MemberReferenceExpression node) { if (null == node.Entity) return; if (EntityType.Property != node.Entity.EntityType) return; if (AstUtil.IsLhsOfAssignment(node)) return; var property = (IProperty) node.Entity; MethodInvocationExpression getter = CodeBuilder.CreatePropertyGet(node.Target, property); // preserve duck typing... if (property.IsDuckTyped) { ReplaceCurrentNode( CodeBuilder.CreateCast( TypeSystemServices.DuckType, getter)); } else { ReplaceCurrentNode(getter); } }
public MemberReferenceExpression MemberReferenceForEntity(Expression target, IEntity entity) { MemberReferenceExpression reference = new MemberReferenceExpression(target.LexicalInfo); reference.Target = target; reference.Name = entity.Name; reference.Entity = entity; return reference; }
private IEntity TryToResolveMemberAsExtension(MemberReferenceExpression node) { IEntity extension = NameResolutionService.ResolveExtension(GetReferenceNamespace(node), node.Name); if (null != extension) node.Annotate(ResolvedAsExtensionAnnotation); return extension; }
IEntity ResolveMember(MemberReferenceExpression node) { var entity = node.Entity; if (!ShouldRebindMember(entity)) return entity; var ns = GetReferenceNamespace(node); var member = NameResolutionService.Resolve(ns, node.Name); if (null == member || !IsAccessible(member) || !IsApplicable(member, node)) { var extension = TryToResolveMemberAsExtension(node); if (null != extension) return extension; } if (null != member) return Disambiguate(node, member); MemberNotFound(node, ns); return null; }
void ProcessLenInvocation(MethodInvocationExpression node) { if ((node.Arguments.Count < 1) || (node.Arguments.Count > 2)) { Error(node, CompilerErrorFactory.MethodArgumentCount(node.Target, "len", node.Arguments.Count)); return; } Expression resultingNode = null; Expression target = node.Arguments[0]; IType type = GetExpressionType(target); bool isArray = IsAssignableFrom(TypeSystemServices.ArrayType, type); if ((!isArray) && (node.Arguments.Count != 1)) { Error(node, CompilerErrorFactory.MethodArgumentCount(node.Target, "len", node.Arguments.Count)); } if (TypeSystemServices.IsSystemObject(type)) { resultingNode = CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_Len, target); } else if (TypeSystemServices.StringType == type) { resultingNode = CodeBuilder.CreateMethodInvocation(target, MethodCache.String_get_Length); } else if (isArray) { if (node.Arguments.Count == 1) resultingNode = CodeBuilder.CreateMethodInvocation(target, MethodCache.Array_get_Length); else resultingNode = CodeBuilder.CreateMethodInvocation(target, MethodCache.Array_GetLength, node.Arguments[1]); } else if (IsAssignableFrom(TypeSystemServices.ICollectionType, type)) { resultingNode = CodeBuilder.CreateMethodInvocation(target, MethodCache.ICollection_get_Count); } else if (GenericsServices.HasConstructedType(type, TypeSystemServices.ICollectionGenericType)) { resultingNode = new MemberReferenceExpression(node.LexicalInfo, target, "Count"); Visit(resultingNode); } else { Error(CompilerErrorFactory.InvalidLen(target, type)); } if (null != resultingNode) { node.ParentNode.Replace(node, resultingNode); } }
private void MarkRelatedImportAsUsed(MemberReferenceExpression node) { string ns = null; foreach (var import in _currentModule.Imports) { if (ImportAnnotations.IsUsedImport(import)) continue; if (null == ns) ns = node.ToCodeString(); if (import.Namespace == ns) { ImportAnnotations.MarkAsUsed(import); break; } } }
private bool IsBeingAssignedTo(MemberReferenceExpression node) { Node current = node; Node parent = current.ParentNode; BinaryExpression be = parent as BinaryExpression; while (null == be) { current = parent; parent = parent.ParentNode; if (parent == null || !(parent is Expression)) return false; be = parent as BinaryExpression; } return be.Left == current; }
private bool IsApplicable(IEntity entity, MemberReferenceExpression node) { //ProcessLenInvocation - Visit(resultingNode), call for node without parent if (node == null || node.ParentNode == null) return true; if (AstUtil.IsTargetOfMethodInvocation(node) && !IsCallableEntity(entity)) return false; return true; }
public override void LeaveReturnStatement(ReturnStatement node) { if (null == node.Expression) return; // forces anonymous types to be correctly // instantiated IType expressionType = GetConcreteExpressionType(node.Expression); if (TypeSystemServices.VoidType == expressionType && node.ContainsAnnotation(OptionalReturnStatementAnnotation)) { node.ParentNode.Replace( node, new ExpressionStatement(node.Expression)); return; } IType returnType = _currentMethod.ReturnType; if (TypeSystemServices.IsUnknown(returnType)) _currentMethod.AddReturnExpression(node.Expression); else AssertTypeCompatibility(node.Expression, returnType, expressionType); //bind to nullable Value if needed if (TypeSystemServices.IsNullable(expressionType) && !TypeSystemServices.IsNullable(returnType)) { // TODO: move to later steps or introduce an implicit conversion operator var mre = new MemberReferenceExpression(node.Expression.LexicalInfo, node.Expression, "Value"); Visit(mre); node.Replace(node.Expression, mre); } }
INamespace GetReferenceNamespace(MemberReferenceExpression expression) { Expression target = expression.Target; INamespace ns = target.ExpressionType; if (null != ns) { return GetConcreteExpressionType(target); } return (INamespace)GetEntity(target); }
public override void LeaveMemberReferenceExpression(MemberReferenceExpression node) { _context.TraceVerbose("LeaveMemberReferenceExpression: {0}", node); if (TypeSystemServices.IsError(node.Target)) Error(node); else ProcessMemberReferenceExpression(node); }
bool BindNullableOperation(BinaryExpression node) { if (!IsNullableOperation(node)) return false; if (BinaryOperatorType.ReferenceEquality == node.Operator) { node.Operator = BinaryOperatorType.Equality; return BindNullableComparison(node); } else if (BinaryOperatorType.ReferenceInequality == node.Operator) { node.Operator = BinaryOperatorType.Inequality; return BindNullableComparison(node); } IType lhs = GetExpressionType(node.Left); IType rhs = GetExpressionType(node.Right); bool lhsIsNullable = TypeSystemServices.IsNullable(lhs); bool rhsIsNullable = TypeSystemServices.IsNullable(rhs); if (BinaryOperatorType.Assign == node.Operator) { if (lhsIsNullable) { if (rhsIsNullable) return false; BindNullableInitializer(node, node.Right, lhs); return false; } } if (lhsIsNullable) { MemberReferenceExpression mre = new MemberReferenceExpression(node.Left, "Value"); node.Replace(node.Left, mre); Visit(mre); mre.Annotate("nullableTarget", true); } if (rhsIsNullable) { MemberReferenceExpression mre = new MemberReferenceExpression(node.Right, "Value"); node.Replace(node.Right, mre); Visit(mre); mre.Annotate("nullableTarget", true); } return false; }
bool BindNullableComparison(BinaryExpression node) { if (!IsNullableOperation(node)) return false; if (IsNull(node.Left) || IsNull(node.Right)) { Expression nullable = IsNull(node.Left) ? node.Right : node.Left; Expression val = new MemberReferenceExpression(nullable, "HasValue"); node.Replace(node.Left, val); Visit(val); Expression nil = new BoolLiteralExpression(false); node.Replace(node.Right, nil); Visit(nil); BindExpressionType(node, TypeSystemServices.BoolType); return true; } BinaryExpression valueCheck = new BinaryExpression( (node.Operator == BinaryOperatorType.Inequality) ? BinaryOperatorType.BitwiseOr : BinaryOperatorType.BitwiseAnd, new BinaryExpression( GetCorrespondingHasValueOperator(node.Operator), CreateNullableHasValueOrTrueExpression(node.Left), CreateNullableHasValueOrTrueExpression(node.Right) ), new BinaryExpression( node.Operator, CreateNullableGetValueOrDefaultExpression(node.Left), CreateNullableGetValueOrDefaultExpression(node.Right) ) ); node.ParentNode.Replace(node, valueCheck); Visit(valueCheck); return true; }
public override bool EnterMemberReferenceExpression(MemberReferenceExpression node) { return null == node.ExpressionType; }
protected virtual void ProcessMemberReferenceExpression(MemberReferenceExpression node) { var entity = ResolveMember(node); if (null == entity) return; EnsureRelatedNodeWasVisited(node, entity); if (EntityType.Namespace == entity.EntityType) MarkRelatedImportAsUsed(node); var member = entity as IMember; if (member != null) { if (!AssertTargetContext(node, member)) { Error(node); return; } if (EntityType.Method != member.EntityType) BindExpressionType(node, GetInferredType(member)); else BindExpressionType(node, member.Type); } // TODO: check for generic methods with no generic args here if (EntityType.Property == entity.EntityType) { IProperty property = (IProperty)entity; if (property.IsIndexedProperty()) { if (!AstUtil.IsTargetOfSlicing(node) && (!property.IsExtension || property.GetParameters().Length > 1)) { Error(node, CompilerErrorFactory.PropertyRequiresParameters(MemberAnchorFor(node), entity)); return; } } if (IsWriteOnlyProperty(property) && !IsBeingAssignedTo(node)) { Error(node, CompilerErrorFactory.PropertyIsWriteOnly(MemberAnchorFor(node), entity)); } } else if (EntityType.Event == entity.EntityType) { if (!AstUtil.IsTargetOfMethodInvocation(node) && !AstUtil.IsLhsOfInPlaceAddSubtract(node)) { if (CurrentType == member.DeclaringType) { InternalEvent ev = (InternalEvent)entity; node.Name = ev.BackingField.Name; node.Entity = ev.BackingField; BindExpressionType(node, ev.BackingField.Type); return; } else if (!node.IsTargetOfAssignment() || !IsNull(((BinaryExpression)node.ParentNode).Right)) { Error(node, CompilerErrorFactory.EventIsNotAnExpression(node, entity)); } else //event=null { EnsureInternalEventInvocation((IEvent) entity, node); } } } Bind(node, entity); PostProcessReferenceExpression(node); }