public ImplicitConversion(ExpressionBinder binder, EXPR exprSrc, CType typeSrc, EXPRTYPEORNAMESPACE typeDest, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.TypeOrNamespace.AsType();
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
public ImplicitConversion(ExpressionBinder binder, EXPR exprSrc, CType typeSrc, EXPRTYPEORNAMESPACE typeDest, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.TypeOrNamespace.AsType();
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
public EXPRTYPEOF CreateTypeOf(EXPRTYPEORNAMESPACE pSourceType)
{
EXPRTYPEOF rval = new EXPRTYPEOF();
rval.kind = ExpressionKind.EK_TYPEOF;
rval.type = GetTypes().GetReqPredefAgg(PredefinedType.PT_TYPE).getThisType();
rval.flags = EXPRFLAG.EXF_CANTBENULL;
rval.SetSourceType(pSourceType);
Debug.Assert(rval != null);
return(rval);
}
// ----------------------------------------------------------------------------
// BindExplicitConversion
// ----------------------------------------------------------------------------
public ExplicitConversion(ExpressionBinder binder, EXPR exprSrc, CType typeSrc, EXPRTYPEORNAMESPACE typeDest, CType pDestinationTypeForLambdaErrorReporting, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.TypeOrNamespace.AsType();
_pDestinationTypeForLambdaErrorReporting = pDestinationTypeForLambdaErrorReporting;
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
// ----------------------------------------------------------------------------
// BindExplicitConversion
// ----------------------------------------------------------------------------
public ExplicitConversion(ExpressionBinder binder, EXPR exprSrc, CType typeSrc, EXPRTYPEORNAMESPACE typeDest, CType pDestinationTypeForLambdaErrorReporting, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.TypeOrNamespace.AsType();
_pDestinationTypeForLambdaErrorReporting = pDestinationTypeForLambdaErrorReporting;
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
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);
}
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);
}
public EXPR CreateZeroInit(EXPRTYPEORNAMESPACE pTypeExpr)
{
return(CreateZeroInit(pTypeExpr, null, false));
}
public void bindSimpleCast(EXPR exprSrc, EXPRTYPEORNAMESPACE exprTypeDest, out EXPR pexprDest, EXPRFLAG exprFlags)
{
Debug.Assert(exprTypeDest != null);
Debug.Assert(exprTypeDest.TypeOrNamespace != null);
Debug.Assert(exprTypeDest.TypeOrNamespace.IsType());
CType typeDest = exprTypeDest.TypeOrNamespace.AsType();
pexprDest = null;
// If the source is a constant, and cast is really simple (no change in fundamental
// type, no flags), then create a new constant node with the new type instead of
// creating a cast node. This allows compile-time constants to be easily recognized.
EXPR exprConst = exprSrc.GetConst();
// Make the cast expr anyway, and if we find that we have a constant, then set the cast expr
// as the original tree for the constant. Otherwise, return the cast expr.
EXPRCAST exprCast = GetExprFactory().CreateCast(exprFlags, exprTypeDest, exprSrc);
if (Context.CheckedNormal)
{
exprCast.flags |= EXPRFLAG.EXF_CHECKOVERFLOW;
}
// Check if we have a compile time constant. If we do, create a constant for it and set the
// original tree to the cast.
if (exprConst != null && exprFlags == 0 &&
exprSrc.type.fundType() == typeDest.fundType() &&
(!exprSrc.type.isPredefType(PredefinedType.PT_STRING) || exprConst.asCONSTANT().getVal().IsNullRef()))
{
EXPRCONSTANT expr = GetExprFactory().CreateConstant(typeDest, exprConst.asCONSTANT().getVal());
pexprDest = expr;
return;
}
pexprDest = exprCast;
Debug.Assert(exprCast.GetArgument() != null);
return;
}
////////////////////////////////////////////////////////////////////////////////
// Create a cast node with the given expression flags.
public void bindSimpleCast(EXPR exprSrc, EXPRTYPEORNAMESPACE typeDest, out EXPR pexprDest)
{
bindSimpleCast(exprSrc, typeDest, out pexprDest, 0);
}
protected virtual EXPR VisitTYPEORNAMESPACE(EXPRTYPEORNAMESPACE pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitTYPEORNAMESPACE(EXPRTYPEORNAMESPACE pExpr)
{
return(VisitEXPR(pExpr));
}
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();
// It looks like 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());
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;
}
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);
}
public EXPR CreateZeroInit(EXPRTYPEORNAMESPACE pTypeExpr)
{
return CreateZeroInit(pTypeExpr, null, false);
}
public EXPRTYPEOF CreateTypeOf(EXPRTYPEORNAMESPACE pSourceType)
{
EXPRTYPEOF rval = new EXPRTYPEOF();
rval.kind = ExpressionKind.EK_TYPEOF;
rval.type = GetTypes().GetReqPredefAgg(PredefinedType.PT_TYPE).getThisType();
rval.flags = EXPRFLAG.EXF_CANTBENULL;
rval.SetSourceType(pSourceType);
Debug.Assert(rval != null);
return (rval);
}
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);
}
