public EXPRCAST CreateCast(EXPRFLAG nFlags, EXPRTYPEORNAMESPACE pType, EXPR pArg) { Debug.Assert(pArg != null); Debug.Assert(pType != null); Debug.Assert(0 == (nFlags & ~(EXPRFLAG.EXF_CAST_ALL | EXPRFLAG.EXF_MASK_ANY))); EXPRCAST rval = new EXPRCAST(); rval.type = pType.TypeOrNamespace as CType; rval.kind = ExpressionKind.EK_CAST; rval.Argument = pArg; rval.flags = nFlags; rval.DestinationType = pType; Debug.Assert(rval != null); return(rval); }
protected override EXPR VisitCAST(EXPRCAST pExpr) { Debug.Assert(pExpr != null); Debug.Assert(alwaysRewrite || currentAnonMeth != null); EXPR pArgument = pExpr.GetArgument(); // If we have generated an identity cast or reference cast to a base class // we can omit the cast. if (pArgument.type == pExpr.type || GetSymbolLoader().IsBaseClassOfClass(pArgument.type, pExpr.type) || CConversions.FImpRefConv(GetSymbolLoader(), pArgument.type, pExpr.type)) { return Visit(pArgument); } // If we have a cast to PredefinedType.PT_G_EXPRESSION and the thing that we're casting is // a EXPRBOUNDLAMBDA that is an expression tree, then just visit the expression tree. if (pExpr.type != null && pExpr.type.isPredefType(PredefinedType.PT_G_EXPRESSION) && pArgument.isBOUNDLAMBDA()) { return Visit(pArgument); } EXPR result = GenerateConversion(pArgument, pExpr.type, pExpr.isChecked()); if ((pExpr.flags & EXPRFLAG.EXF_UNBOXRUNTIME) != 0) { // Propagate the unbox flag to the call for the ExpressionTreeCallRewriter. result.flags |= EXPRFLAG.EXF_UNBOXRUNTIME; } return result; }
private EXPR CreateZeroInit(EXPRTYPEORNAMESPACE pTypeExpr, EXPR pOptionalOriginalConstructorCall, bool isConstructor) { Debug.Assert(pTypeExpr != null); CType pType = pTypeExpr.TypeOrNamespace.AsType(); bool bIsError = false; if (pType.isEnumType()) { // For enum types, we create a constant that has the default value // as an object pointer. ConstValFactory factory = new ConstValFactory(); EXPRCONSTANT expr = CreateConstant(pType, factory.Create(Activator.CreateInstance(pType.AssociatedSystemType))); return(expr); } switch (pType.fundType()) { default: bIsError = true; break; case FUNDTYPE.FT_PTR: { CType nullType = GetTypes().GetNullType(); // UNDONE: I think this if is always false ... if (nullType.fundType() == pType.fundType()) { // Create a constant here. EXPRCONSTANT expr = CreateConstant(pType, ConstValFactory.GetDefaultValue(ConstValKind.IntPtr)); return(expr); } // Just allocate a new node and fill it in. EXPRCAST cast = CreateCast(0, pTypeExpr, CreateNull()); // UNDONE: should pTree be passed in here? return(cast); } case FUNDTYPE.FT_REF: case FUNDTYPE.FT_I1: case FUNDTYPE.FT_U1: case FUNDTYPE.FT_I2: case FUNDTYPE.FT_U2: case FUNDTYPE.FT_I4: case FUNDTYPE.FT_U4: case FUNDTYPE.FT_I8: case FUNDTYPE.FT_U8: case FUNDTYPE.FT_R4: case FUNDTYPE.FT_R8: { EXPRCONSTANT expr = CreateConstant(pType, ConstValFactory.GetDefaultValue(pType.constValKind())); EXPRCONSTANT exprInOriginal = CreateConstant(pType, ConstValFactory.GetDefaultValue(pType.constValKind())); exprInOriginal.SetOptionalConstructorCall(pOptionalOriginalConstructorCall); return(expr); // UNDONE: Check other bogus casts } case FUNDTYPE.FT_STRUCT: if (pType.isPredefType(PredefinedType.PT_DECIMAL)) { EXPRCONSTANT expr = CreateConstant(pType, ConstValFactory.GetDefaultValue(pType.constValKind())); EXPRCONSTANT exprOriginal = CreateConstant(pType, ConstValFactory.GetDefaultValue(pType.constValKind())); exprOriginal.SetOptionalConstructorCall(pOptionalOriginalConstructorCall); return(expr); } break; case FUNDTYPE.FT_VAR: break; } EXPRZEROINIT rval = new EXPRZEROINIT(); rval.kind = ExpressionKind.EK_ZEROINIT; rval.type = pType; rval.flags = 0; rval.OptionalConstructorCall = pOptionalOriginalConstructorCall; rval.IsConstructor = isConstructor; if (bIsError) { rval.SetError(); } Debug.Assert(rval != null); return(rval); }
///////////////////////////////////////////////////////////////////////////////// protected override EXPR VisitCAST(EXPRCAST pExpr) { return base.VisitCAST(pExpr); }
protected virtual EXPR VisitCAST(EXPRCAST pExpr) { return VisitEXPR(pExpr); }
protected virtual EXPR VisitCAST(EXPRCAST pExpr) { return(VisitEXPR(pExpr)); }
public EXPRCAST CreateCast(EXPRFLAG nFlags, EXPRTYPEORNAMESPACE pType, EXPR pArg) { Debug.Assert(pArg != null); Debug.Assert(pType != null); Debug.Assert(0 == (nFlags & ~(EXPRFLAG.EXF_CAST_ALL | EXPRFLAG.EXF_MASK_ANY))); EXPRCAST rval = new EXPRCAST(); rval.type = pType.TypeOrNamespace as CType; rval.kind = ExpressionKind.EK_CAST; rval.Argument = pArg; rval.flags = nFlags; rval.DestinationType = pType; Debug.Assert(rval != null); return (rval); }