public void SetDefaultParameterValue(int index, CType type, CONSTVAL cv)
{
Debug.Assert(_defaultParameterIndex != null);
ConstValFactory factory = new ConstValFactory();
_defaultParameterIndex[index] = true;
_defaultParameters[index] = factory.Copy(type.constValKind(), cv);
_defaultParameterConstValTypes[index] = type;
}
private bool bindImplicitConversionToEnum(AggregateType aggTypeSrc)
{
// The spec states:
// *****************
// 13.1.3 Implicit enumeration conversions
//
// An implicit enumeration conversion permits the decimal-integer-literal 0 to be converted to any
// enum-type.
// *****************
// However, we actually allow any constant zero, not just the integer literal zero, to be converted
// to enum. The reason for this is for backwards compatibility with a premature optimization
// that used to be in the binding layer. We would optimize away expressions such as 0 | blah to be
// just 0, but not erase the "is literal" bit. This meant that expression such as 0 | 0 | E.X
// would succeed rather than correctly producing an error pointing out that 0 | 0 is not a literal
// zero and therefore does not convert to any enum.
//
// We have removed the premature optimization but want old code to continue to compile. Rather than
// try to emulate the somewhat complex behaviour of the previous optimizer, it is easier to simply
// say that any compile time constant zero is convertible to any enum. This means unfortunately
// expressions such as (7-7) * 12 are convertible to enum, but frankly, that's better than having
// some terribly complex rule about what constitutes a legal zero and what doesn't.
// Note: Don't use GetConst here since the conversion only applies to bona-fide compile time constants.
if (
aggTypeSrc.getAggregate().GetPredefType() != PredefinedType.PT_BOOL &&
exprSrc != null &&
exprSrc.isZero() &&
exprSrc.type.isNumericType() &&
/*(exprSrc.flags & EXF_LITERALCONST) &&*/
0 == (flags & CONVERTTYPE.STANDARD))
{
// NOTE: This allows conversions from uint, long, ulong, float, double, and hexadecimal int
// NOTE: This is for backwards compatibility with Everett
// REVIEW: : This is another place where we lose EXPR fidelity. We shouldn't fold this
// into a constant here - we should move this to a later pass.
if (needsExprDest)
{
exprDest = GetExprFactory().CreateConstant(typeDest, ConstValFactory.GetDefaultValue(typeDest.constValKind()));
}
return(true);
}
return(false);
}
/////////////////////////////////////////////////////////////////////////////////
private void SetParameterAttributes(MethodOrPropertySymbol methProp, ParameterInfo[] parameters, int i)
{
if (((parameters[i].Attributes & ParameterAttributes.Optional) != 0) &&
!parameters[i].ParameterType.IsByRef)
{
methProp.SetOptionalParameter(i);
PopulateSymbolTableWithName("Value", new Type[] { typeof(Missing) }, typeof(Missing)); // We might need this later
}
object[] attrs;
// Get MarshalAsAttribute
if ((parameters[i].Attributes & ParameterAttributes.HasFieldMarshal) != 0)
{
if ((attrs = parameters[i].GetCustomAttributes(typeof(MarshalAsAttribute), false).ToArray()) != null
&& attrs.Length > 0)
{
MarshalAsAttribute attr = (MarshalAsAttribute)attrs[0];
methProp.SetMarshalAsParameter(i, attr.Value);
}
}
// Get the various kinds of default values
if ((attrs = parameters[i].GetCustomAttributes(typeof(DateTimeConstantAttribute), false).ToArray()) != null
&& attrs.Length > 0)
{
// Get DateTimeConstant
DateTimeConstantAttribute attr = (DateTimeConstantAttribute)attrs[0];
ConstValFactory factory = new ConstValFactory();
CONSTVAL cv = factory.Create(((System.DateTime)attr.Value).Ticks);
CType cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_DATETIME);
methProp.SetDefaultParameterValue(i, cvType, cv);
}
else if ((attrs = parameters[i].GetCustomAttributes(typeof(DecimalConstantAttribute), false).ToArray()) != null
&& attrs.Length > 0)
{
// Get DecimalConstant
DecimalConstantAttribute attr = (DecimalConstantAttribute)attrs[0];
ConstValFactory factory = new ConstValFactory();
CONSTVAL cv = factory.Create(attr.Value);
CType cvType = _semanticChecker.GetSymbolLoader().GetOptPredefType(PredefinedType.PT_DECIMAL);
methProp.SetDefaultParameterValue(i, cvType, cv);
}
else if (((parameters[i].Attributes & ParameterAttributes.HasDefault) != 0) &&
!parameters[i].ParameterType.IsByRef)
{
// Only set a default value if we have one, and the type that we're
// looking at isn't a by ref type or a type parameter.
ConstValFactory factory = new ConstValFactory();
CONSTVAL cv = cv = ConstValFactory.GetNullRef();
CType cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_OBJECT);
// We need to use RawDefaultValue, because DefaultValue is too clever.
#if UNSUPPORTEDAPI
if (parameters[i].RawDefaultValue != null)
{
object defValue = parameters[i].RawDefaultValue;
#else
if (parameters[i].DefaultValue != null)
{
object defValue = parameters[i].DefaultValue;
#endif
Type defType = defValue.GetType();
if (defType == typeof(System.Byte))
{
cv = factory.Create((System.Byte)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_BYTE);
}
else if (defType == typeof(System.Int16))
{
cv = factory.Create((System.Int16)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_SHORT);
}
else if (defType == typeof(System.Int32))
{
cv = factory.Create((System.Int32)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_INT);
}
else if (defType == typeof(System.Int64))
{
cv = factory.Create((System.Int64)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_LONG);
}
else if (defType == typeof(System.Single))
{
cv = factory.Create((System.Single)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_FLOAT);
}
else if (defType == typeof(System.Double))
{
cv = factory.Create((System.Double)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_DOUBLE);
}
else if (defType == typeof(System.Decimal))
{
cv = factory.Create((System.Decimal)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_DECIMAL);
}
else if (defType == typeof(System.Char))
{
cv = factory.Create((System.Char)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_CHAR);
}
else if (defType == typeof(System.Boolean))
{
cv = factory.Create((System.Boolean)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_BOOL);
}
else if (defType == typeof(System.SByte))
{
cv = factory.Create((System.SByte)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_SBYTE);
}
else if (defType == typeof(System.UInt16))
{
cv = factory.Create((System.UInt16)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_USHORT);
}
else if (defType == typeof(System.UInt32))
{
cv = factory.Create((System.UInt32)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_UINT);
}
else if (defType == typeof(System.UInt64))
{
cv = factory.Create((System.UInt64)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_ULONG);
}
else if (defType == typeof(System.String))
{
cv = factory.Create((System.String)defValue);
cvType = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_STRING);
}
// if we fall off the end of this cascading if, we get Object/null
// because that's how we initialized the constval.
}
methProp.SetDefaultParameterValue(i, cvType, cv);
}
}
/////////////////////////////////////////////////////////////////////////////////
private MethodSymbol FindMatchingMethod(MemberInfo method, AggregateSymbol callingAggregate)
{
MethodSymbol meth = _bsymmgr.LookupAggMember(GetName(method.Name), callingAggregate, symbmask_t.MASK_MethodSymbol).AsMethodSymbol();
while (meth != null)
{
if (meth.AssociatedMemberInfo.IsEquivalentTo(method))
{
return meth;
}
meth = BSYMMGR.LookupNextSym(meth, callingAggregate, symbmask_t.MASK_MethodSymbol).AsMethodSymbol();
}
return null;
}
public void SetDefaultParameterValue(int index, CType type, CONSTVAL cv)
{
Debug.Assert(_defaultParameterIndex != null);
ConstValFactory factory = new ConstValFactory();
_defaultParameterIndex[index] = true;
_defaultParameters[index] = factory.Copy(type.constValKind(), cv);
_defaultParameterConstValTypes[index] = type;
}
public EXPRCONSTANT CreateBoolConstant(bool b)
{
return(CreateConstant(GetTypes().GetReqPredefAgg(PredefinedType.PT_BOOL).getThisType(), ConstValFactory.GetBool(b)));
}
public EXPR CreateNull()
{
return(CreateConstant(GetTypes().GetNullType(), ConstValFactory.GetNullRef()));
}
public EXPRCONSTANT CreateIntegerConstant(int x)
{
return(CreateConstant(GetTypes().GetReqPredefAgg(PredefinedType.PT_INT).getThisType(), ConstValFactory.GetInt(x)));
}
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 ExprFactory(GlobalSymbolContext globalSymbolContext)
{
Debug.Assert(globalSymbolContext != null);
m_globalSymbolContext = globalSymbolContext;
m_constants = new ConstValFactory();
}
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 ExprFactory(GlobalSymbolContext globalSymbolContext)
{
Debug.Assert(globalSymbolContext != null);
_globalSymbolContext = globalSymbolContext;
_constants = new ConstValFactory();
}