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