public ExprField CreateField(EXPRFLAG nFlags, CType pType, Expr pOptionalObject, FieldWithType FWT) { Debug.Assert(0 == (nFlags & ~(EXPRFLAG.EXF_MEMBERSET | EXPRFLAG.EXF_MASK_ANY))); ExprField rval = new ExprField(pType); rval.Flags = nFlags; rval.OptionalObject = pOptionalObject; rval.FieldWithType = FWT; return(rval); }
private RuntimeBinderException ReportReadOnlyError(ExprField field, CheckLvalueKind kind, bool isNested) { Debug.Assert(field != null); bool isStatic = field.FieldWithType.Field().isStatic; int index = (isNested ? 4 : 0) + (isStatic ? 2 : 0) + (kind == CheckLvalueKind.OutParameter ? 0 : 1); ErrorCode err = s_ReadOnlyErrors[index]; return(ErrorContext.Error(err, isNested ? new ErrArg[] { field.FieldWithType } : Array.Empty <ErrArg>())); }
public ExprField CreateField(EXPRFLAG nFlags, CType pType, Expr pOptionalObject, uint nOffset, FieldWithType FWT, Expr pOptionalLHS) { Debug.Assert(0 == (nFlags & ~(EXPRFLAG.EXF_MEMBERSET | EXPRFLAG.EXF_MASK_ANY))); ExprField rval = new ExprField(); rval.Kind = ExpressionKind.EK_FIELD; rval.Type = pType; rval.Flags = nFlags; rval.OptionalObject = pOptionalObject; if (FWT != null) { rval.FieldWithType = FWT; } Debug.Assert(rval != null); return(rval); }
protected override Expr VisitFIELD(ExprField expr) { Debug.Assert(expr != null); Expr pObject; if (expr.OptionalObject == null) { pObject = GetExprFactory().CreateNull(); } else { pObject = Visit(expr.OptionalObject); } ExprFieldInfo pFieldInfo = GetExprFactory().CreateFieldInfo(expr.FieldWithType.Field(), expr.FieldWithType.GetType()); return(GenerateCall(PREDEFMETH.PM_EXPRESSION_FIELD, pObject, pFieldInfo)); }
private void ReportReadOnlyError(ExprField field, CheckLvalueKind kind, bool isNested) { Debug.Assert(field != null); bool isStatic = field.FieldWithType.Field().isStatic; int index = (isNested ? 4 : 0) + (isStatic ? 2 : 0) + (kind == CheckLvalueKind.OutParameter ? 0 : 1); ErrorCode err = s_ReadOnlyErrors[index]; if (isNested) { ErrorContext.Error(err, field.FieldWithType); } else { ErrorContext.Error(err); } }
private RuntimeBinderException ReportReadOnlyError(ExprField field, bool isNested) { Debug.Assert(field != null); FieldWithType fieldWithType = field.FieldWithType; bool isStatic = fieldWithType.Field().isStatic; ErrArg[] args; ErrorCode err; if (isNested) { args = new ErrArg[] { fieldWithType }; err = isStatic ? ErrorCode.ERR_AssgReadonlyStatic2 : ErrorCode.ERR_AssgReadonly2; } else { args = Array.Empty <ErrArg>(); err = isStatic ? ErrorCode.ERR_AssgReadonlyStatic : ErrorCode.ERR_AssgReadonly; } return(ErrorContext.Error(err, args)); }
protected virtual Expr VisitFIELD(ExprField pExpr) { return(VisitEXPR(pExpr)); }
// Return true if we actually report a failure. private bool TryReportLvalueFailure(Expr expr, CheckLvalueKind kind) { Debug.Assert(expr != null); // We have a lvalue failure. Was the reason because this field // was marked readonly? Give special messages for this case. bool isNested = false; // Did we recurse on a field or property to give a better error? Expr walk = expr; while (true) { Debug.Assert(walk != null); if (walk.isANYLOCAL_OK()) { ReportLocalError(walk.asANYLOCAL().Local, kind, isNested); return(true); } Expr pObject = null; if (walk.isPROP()) { // We've already reported read-only-property errors. Debug.Assert(walk.asPROP().MethWithTypeSet != null); pObject = walk.asPROP().MemberGroup.OptionalObject; } else if (walk.isFIELD()) { ExprField field = walk.asFIELD(); if (field.FieldWithType.Field().isReadOnly) { ReportReadOnlyError(field, kind, isNested); return(true); } if (!field.FieldWithType.Field().isStatic) { pObject = field.OptionalObject; } } if (pObject != null && pObject.Type.isStructOrEnum()) { if (pObject.isCALL() || pObject.isPROP()) { // assigning to RHS of method or property getter returning a value-type on the stack or // passing RHS of method or property getter returning a value-type on the stack, as ref or out ErrorContext.Error(ErrorCode.ERR_ReturnNotLValue, pObject.GetSymWithType()); return(true); } if (pObject.isCAST()) { // An unboxing conversion. // // In the static compiler, we give the following error here: // ErrorContext.Error(pObject.GetTree(), ErrorCode.ERR_UnboxNotLValue); // // But in the runtime, we allow this - mark that we're doing an // unbox here, so that we gen the correct expression tree for it. pObject.Flags |= EXPRFLAG.EXF_UNBOXRUNTIME; return(false); } } // everything else if (pObject != null && !pObject.isLvalue() && (walk.isFIELD() || (!isNested && walk.isPROP()))) { Debug.Assert(pObject.Type.isStructOrEnum()); walk = pObject; } else { ErrorContext.Error(GetStandardLvalueError(kind)); return(true); } isNested = true; } }