public override Expression DoResolveLValue(ResolveContext rc, Expression right_side) { if (right_side == EmptyExpression.OutAccess) { right_side.DoResolveLValue(rc, this); return(null); } if (DoResolveCore(rc)) { setter_args = CreateSetterArguments(rc, right_side); setter = CreateCallSiteBinder(rc, setter_args, true); } eclass = ExprClass.Variable; return(this); }
public override Expression DoResolveLValue(ResolveContext rc, Expression right_side) { if (right_side == EmptyExpression.OutAccess.Instance) { right_side.DoResolveLValue (rc, this); return null; } if (DoResolveCore (rc)) { setter_args = new Arguments (Arguments.Count + 1); setter_args.AddRange (Arguments); setter_args.Add (new Argument (right_side)); setter = CreateCallSiteBinder (rc, setter_args, true); } eclass = ExprClass.Variable; return this; }
public override Expression DoResolveLValue (ResolveContext rc, Expression right_side) { if (right_side == EmptyExpression.OutAccess) { right_side.DoResolveLValue (rc, this); return null; } if (DoResolveCore (rc)) { setter_args = CreateSetterArguments (rc, right_side); setter = CreateCallSiteBinder (rc, setter_args, true); } eclass = ExprClass.Variable; return this; }
public override Expression DoResolveLValue(ResolveContext ec, Expression right_side) { eclass = ExprClass.PropertyAccess; if (right_side == EmptyExpression.OutAccess.Instance) { if (ec.CurrentBlock.Toplevel.GetParameterReference (spec.Name, loc) is MemberAccess) { ec.Report.Error (1939, loc, "A range variable `{0}' may not be passes as `ref' or `out' parameter", spec.Name); } else { right_side.DoResolveLValue (ec, this); } return null; } if (right_side == EmptyExpression.LValueMemberAccess || right_side == EmptyExpression.LValueMemberOutAccess) { Error_CannotModifyIntermediateExpressionValue (ec); } if (spec.IsNotRealProperty) { Error_PropertyNotValid (ec); return null; } if (!spec.HasSet){ if (ec.CurrentBlock.Toplevel.GetParameterReference (spec.Name, loc) is MemberAccess) { ec.Report.Error (1947, loc, "A range variable `{0}' cannot be assigned to. Consider using `let' clause to store the value", spec.Name); } else { ec.Report.Error (200, loc, "Property or indexer `{0}' cannot be assigned to (it is read only)", GetSignatureForError ()); } return null; } if (targs != null) { base.SetTypeArguments (ec, targs); return null; } bool must_do_cs1540_check; if (!IsMemberAccessible (ec.CurrentType, spec.Set, out must_do_cs1540_check)) { if (spec.HasDifferentAccessibility) { ec.Report.SymbolRelatedToPreviousError (spec.Set); ec.Report.Error (272, loc, "The property or indexer `{0}' cannot be used in this context because the set accessor is inaccessible", TypeManager.CSharpSignature (spec)); } else { ec.Report.SymbolRelatedToPreviousError (spec.Set); ErrorIsInaccesible (loc, TypeManager.CSharpSignature (spec.Set), ec.Report); } return null; } if (!InstanceResolve (ec, TypeManager.IsStruct (spec.DeclaringType), must_do_cs1540_check)) return null; // // Only base will allow this invocation to happen. // if (IsBase && spec.IsAbstract){ Error_CannotCallAbstractBase (ec, TypeManager.GetFullNameSignature (spec)); } if (spec.MemberType.IsPointer && !ec.IsUnsafe) { UnsafeError (ec, loc); } if (!ec.IsObsolete) { ObsoleteAttribute oa = spec.GetAttributeObsolete (); if (oa != null) AttributeTester.Report_ObsoleteMessage (oa, GetSignatureForError (), loc, ec.Report); } return this; }
public override Expression DoResolveLValue (ResolveContext rc, Expression right_side) { if (right_side == EmptyExpression.OutAccess) { right_side.DoResolveLValue (rc, this); return null; } var res_right_side = right_side.Resolve (rc); if (DoResolveCore (rc) && res_right_side != null) { setter_args = CreateSetterArguments (rc, res_right_side); // create setter callsite var dc = (binder as IDynamicCallSite); if (rc.Module.PredefinedTypes.IsPlayScriptAotMode && (dc != null) && dc.UseCallSite(rc, setter_args)) { this.useDelegateInvoke = false; setter_args.CreateDynamicBinderArguments(rc); setter = CreateCallSite(rc, setter_args, true); } else { this.useDelegateInvoke = true; setter = CreateCallSiteBinder (rc, setter_args, true); } } eclass = ExprClass.Variable; return this; }
public Expression DoResolve (EmitContext ec, Expression right_side, ResolveFlags flags) { if (type != null) throw new Exception (); // // Resolve the expression with flow analysis turned off, we'll do the definite // assignment checks later. This is because we don't know yet what the expression // will resolve to - it may resolve to a FieldExpr and in this case we must do the // definite assignment check on the actual field and not on the whole struct. // Expression original = expr; expr = expr.Resolve (ec, flags | ResolveFlags.DisableFlowAnalysis); if (expr == null) return null; if (expr is SimpleName){ SimpleName child_expr = (SimpleName) expr; Expression new_expr = new SimpleName (child_expr.Name, Identifier, loc); return new_expr.Resolve (ec, flags); } // // TODO: I mailed Ravi about this, and apparently we can get rid // of this and put it in the right place. // // Handle enums here when they are in transit. // Note that we cannot afford to hit MemberLookup in this case because // it will fail to find any members at all // int errors = Report.Errors; Type expr_type = expr.Type; if ((expr is TypeExpr) && (expr_type == TypeManager.enum_type || expr_type.IsSubclassOf (TypeManager.enum_type))){ Enum en = TypeManager.LookupEnum (expr_type); if (en != null) { object value = en.LookupEnumValue (ec, Identifier, loc); if (value != null){ Constant c = Constantify (value, en.UnderlyingType); return new EnumConstant (c, expr_type); } } } if (expr_type.IsPointer){ Error (23, "The `.' operator can not be applied to pointer operands (" + TypeManager.CSharpName (expr_type) + ")"); return null; } member_lookup = MemberLookupFinal (ec, expr_type, expr_type, Identifier, loc); if (member_lookup == null) return null; if (member_lookup is TypeExpr){ member_lookup.Resolve (ec, ResolveFlags.Type); return member_lookup; } else if ((flags & ResolveFlags.MaskExprClass) == ResolveFlags.Type) return null; member_lookup = ResolveMemberAccess (ec, member_lookup, expr, loc, original); if (member_lookup == null) return null; // The following DoResolve/DoResolveLValue will do the definite assignment // check. if (right_side != null) member_lookup = member_lookup.DoResolveLValue (ec, right_side); else member_lookup = member_lookup.DoResolve (ec); return member_lookup; }