//
public static EmitContext ConstantEC = null;
- static public void Error_CannotConvertType (Location loc, Type source, Type target)
- {
- Report.Error (30, loc, "Cannot convert type '" +
- TypeManager.CSharpName (source) + "' to '" +
- TypeManager.CSharpName (target) + "'");
- }
-
static EmptyExpression MyEmptyExpr;
static public Expression ImplicitReferenceConversion (Expression expr, Type target_type)
{
if (expr_type.IsValueType)
return new BoxedCast (expr, target_type);
if (expr_type == TypeManager.null_type)
- return new NullCast (expr, target_type);
+ return new NullCast ((Constant)expr, target_type);
return null;
} else if (expr_type.IsSubclassOf (target_type)) {
if (target_type.IsPointer)
return new EmptyCast (NullPointer.Null, target_type);
- if (!target_type.IsValueType)
- return new NullCast (expr, target_type);
+ if (!target_type.IsValueType) {
+ if (expr is Constant)
+ return new NullCast ((Constant)expr, target_type);
+
+ // I found only one case when it happens -- Foo () ? null : null;
+ Report.Warning (-100, 1, expr.Location, "The result of the expression is always `null'");
+ return new NullCast (new NullLiteral (expr.Location), target_type);
+ }
}
// from any class-type S to any interface-type T.
/// target_type or null if an implicit conversion is not possible.
/// </summary>
static public Expression ImplicitNumericConversion (EmitContext ec, Expression expr,
- Type target_type, Location loc)
+ Type target_type)
{
Type expr_type = expr.Type;
if (real_target_type == TypeManager.short_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.byte_type){
//
// From byte to short, ushort, int, uint, long, ulong, float, double, decimal
if (real_target_type == TypeManager.double_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.short_type){
//
if (real_target_type == TypeManager.float_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.ushort_type){
//
if (real_target_type == TypeManager.float_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.int32_type){
//
// From int to long, float, double, decimal
if (real_target_type == TypeManager.float_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.uint32_type){
//
// From uint to long, ulong, float, double, decimal
return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
OpCodes.Conv_R4);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.int64_type){
//
// From long/ulong to float, double
if (real_target_type == TypeManager.float_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.uint64_type){
//
// From ulong to float, double
return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
OpCodes.Conv_R4);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.char_type){
//
// From char to ushort, int, uint, long, ulong, float, double, decimal
if (real_target_type == TypeManager.double_type)
return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr);
+ return new CastToDecimal (expr);
} else if (expr_type == TypeManager.float_type){
//
// float to double
return null;
}
-
/// <summary>
/// Same as ImplicitStandardConversionExists except that it also looks at
/// implicit user defined conversions - needed for overload resolution
public static bool ImplicitUserConversionExists (EmitContext ec, Type source, Type target)
{
- Expression dummy = ImplicitUserConversion (
- ec, new EmptyExpression (source), target, Location.Null);
- return dummy != null;
+ return ImplicitUserConversion (ec, new EmptyExpression (source), target, Location.Null) != null;
}
/// <summary>
/// for explicit and implicit conversion operators.
/// </summary>
static public Type FindMostSpecificSource (EmitContext ec, IList list,
- Expression source, bool apply_explicit_conv_rules,
- Location loc)
+ Expression source, bool apply_explicit_conv_rules)
{
ArrayList src_types_set = new ArrayList ();
/// Finds the most specific target Tx according to section 13.4.4
/// </summary>
static public Type FindMostSpecificTarget (EmitContext ec, IList list,
- Type target, bool apply_explicit_conv_rules,
- Location loc)
+ Type target, bool apply_explicit_conv_rules)
{
ArrayList tgt_types_set = new ArrayList ();
}
/// <summary>
- /// Computes the list of the user-defined conversion
- /// operators from source_type to target_type. `look_for_explicit'
- /// controls whether we should also include the list of explicit
- /// operators
+ /// Compute the user-defined conversion operator from source_type to target_type.
+ /// `look_for_explicit' controls whether we should also include the list of explicit operators
/// </summary>
- static IList GetConversionOperators (EmitContext ec,
- Expression source, Type target_type,
- Location loc, bool look_for_explicit)
+ static MethodInfo GetConversionOperator (EmitContext ec, Expression source, Type target_type, bool look_for_explicit)
{
- ArrayList ret = new ArrayList (4);
+ ArrayList ops = new ArrayList (4);
Type source_type = source.Type;
if (source_type != TypeManager.decimal_type) {
- AddConversionOperators (ec, ret, source, target_type, look_for_explicit,
- Expression.MethodLookup (
- ec, source_type, "op_Implicit", loc) as MethodGroupExpr);
+ AddConversionOperators (ec, ops, source, target_type, look_for_explicit,
+ Expression.MethodLookup (ec, source_type, "op_Implicit", Location.Null) as MethodGroupExpr);
if (look_for_explicit) {
- AddConversionOperators (ec, ret, source, target_type, look_for_explicit,
+ AddConversionOperators (ec, ops, source, target_type, look_for_explicit,
Expression.MethodLookup (
- ec, source_type, "op_Explicit", loc) as MethodGroupExpr);
+ ec, source_type, "op_Explicit", Location.Null) as MethodGroupExpr);
}
}
if (target_type != TypeManager.decimal_type) {
- AddConversionOperators (ec, ret, source, target_type, look_for_explicit,
- Expression.MethodLookup (
- ec, target_type, "op_Implicit", loc) as MethodGroupExpr);
+ AddConversionOperators (ec, ops, source, target_type, look_for_explicit,
+ Expression.MethodLookup (ec, target_type, "op_Implicit", Location.Null) as MethodGroupExpr);
if (look_for_explicit) {
- AddConversionOperators (ec, ret, source, target_type, look_for_explicit,
+ AddConversionOperators (ec, ops, source, target_type, look_for_explicit,
Expression.MethodLookup (
- ec, target_type, "op_Explicit", loc) as MethodGroupExpr);
+ ec, target_type, "op_Explicit", Location.Null) as MethodGroupExpr);
}
}
- return ret;
+ if (ops.Count == 0)
+ return null;
+
+ Type most_specific_source = FindMostSpecificSource (ec, ops, source, look_for_explicit);
+ if (most_specific_source == null)
+ return null;
+
+ Type most_specific_target = FindMostSpecificTarget (ec, ops, target_type, look_for_explicit);
+ if (most_specific_target == null)
+ return null;
+
+ MethodInfo method = null;
+
+ foreach (MethodInfo m in ops) {
+ if (m.ReturnType != most_specific_target)
+ continue;
+ if (TypeManager.GetParameterData (m).ParameterType (0) != most_specific_source)
+ continue;
+ // Ambiguous: more than one conversion operator satisfies the signature.
+ if (method != null)
+ return null;
+ method = m;
+ }
+
+ return method;
}
static DoubleHash explicit_conv = new DoubleHash (100);
{
Type source_type = source.Type;
MethodInfo method = null;
- Type most_specific_source = null;
- Type most_specific_target = null;
object o;
DoubleHash hash = look_for_explicit ? explicit_conv : implicit_conv;
if (!(source is Constant) && hash.Lookup (source_type, target, out o)) {
method = (MethodInfo) o;
- if (method != null) {
- ParameterData pd = TypeManager.GetParameterData (method);
- most_specific_source = pd.ParameterType (0);
- most_specific_target = method.ReturnType;
- }
} else {
- IList ops = GetConversionOperators (ec, source, target, loc, look_for_explicit);
- if (ops == null || ops.Count == 0) {
- method = null;
- goto skip;
- }
-
- most_specific_source = FindMostSpecificSource (ec, ops, source, look_for_explicit, loc);
- if (most_specific_source == null) {
- method = null;
- goto skip;
- }
-
- most_specific_target = FindMostSpecificTarget (ec, ops, target, look_for_explicit, loc);
- if (most_specific_target == null) {
- method = null;
- goto skip;
- }
-
- int count = 0;
-
- foreach (MethodInfo m in ops) {
- ParameterData pd = TypeManager.GetParameterData (m);
-
- if (pd.ParameterType (0) == most_specific_source &&
- m.ReturnType == most_specific_target) {
- method = m;
- count++;
- }
- }
- if (count > 1)
- method = null;
-
- skip:
+ method = GetConversionOperator (ec, source, target, look_for_explicit);
if (!(source is Constant))
hash.Insert (source_type, target, method);
}
if (method == null)
return null;
+ Type most_specific_source = TypeManager.GetParameterData (method).ParameterType (0);
+
//
// This will do the conversion to the best match that we
// found. Now we need to perform an implict standard conversion
if (expr_type == target_type && expr_type != TypeManager.null_type)
return expr;
- e = ImplicitNumericConversion (ec, expr, target_type, loc);
+ e = ImplicitNumericConversion (ec, expr, target_type);
if (e != null)
return e;
if (target_type.IsPointer){
if (TypeManager.GetElementType(target_type) == TypeManager.GetElementType(expr_type))
return expr;
+
+ //return null;
}
}
- if (target_type.IsPointer) {
- if (expr_type == TypeManager.null_type)
- return new EmptyCast (NullPointer.Null, target_type);
-
- if (expr_type == TypeManager.void_ptr_type)
- return new EmptyCast (expr, target_type);
- }
+ if (expr_type == TypeManager.null_type && target_type.IsPointer)
+ return new EmptyCast (NullPointer.Null, target_type);
}
if (expr_type == TypeManager.anonymous_method_type){
return null;
}
- static public void Error_CannotImplicitConversion (Location loc, Type source, Type target)
- {
- if (source.Name == target.Name){
- Report.ExtraInformation (loc,
- String.Format (
- "The type {0} has two conflicting definitions, one comes from {1} and the other from {2}",
- source.Name, source.Assembly.FullName, target.Assembly.FullName));
-
- }
-
- // TODO: Missing explicit numeric check
- //ExplicitNumericConversion
-
- if (ExplicitReferenceConversionExists (source, target)) {
- Report.Error (266, loc, "Cannot implicitly convert type `{0}' to `{1}'. An explicit conversion exists (are you missing a cast?)",
- TypeManager.CSharpName (source), TypeManager.CSharpName (target));
- return;
- }
-
- Report.Error (29, loc, "Cannot implicitly convert type {0} to `{1}'",
- source == TypeManager.anonymous_method_type ?
- "anonymous method" : "`" + TypeManager.CSharpName (source) + "'",
- TypeManager.CSharpName (target));
- }
-
/// <summary>
/// Attempts to implicitly convert `source' into `target_type', using
/// ImplicitConversion. If there is no implicit conversion, then
}
}
- source.Error_ValueCannotBeConverted (loc, target_type);
+ source.Error_ValueCannotBeConverted (loc, target_type, false);
return null;
}
/// <summary>
/// Performs the explicit numeric conversions
/// </summary>
- static Expression ExplicitNumericConversion (EmitContext ec, Expression expr, Type target_type, Location loc)
+ public static Expression ExplicitNumericConversion (Expression expr, Type target_type)
{
Type expr_type = expr.Type;
-
- //
- // If we have an enumeration, extract the underlying type,
- // use this during the comparison, but wrap around the original
- // target_type
- //
Type real_target_type = target_type;
- if (TypeManager.IsEnumType (real_target_type))
- real_target_type = TypeManager.EnumToUnderlying (real_target_type);
-
- if (ImplicitStandardConversionExists (ec, expr, real_target_type)){
- Expression ce = ImplicitConversionStandard (ec, expr, real_target_type, loc);
-
- if (real_target_type != target_type)
- return new EmptyCast (ce, target_type);
- return ce;
- }
-
if (expr_type == TypeManager.sbyte_type){
//
// From sbyte to byte, ushort, uint, ulong, char
//
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I1_U1);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_U2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I1_U2);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_U4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I1_U4);
if (real_target_type == TypeManager.uint64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_U8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I1_U8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I1_CH);
} else if (expr_type == TypeManager.byte_type){
//
// From byte to sbyte and char
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U1_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U1_I1);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U1_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U1_CH);
} else if (expr_type == TypeManager.short_type){
//
// From short to sbyte, byte, ushort, uint, ulong, char
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I2_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I2_U1);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I2_U2);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I2_U4);
if (real_target_type == TypeManager.uint64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I2_U8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I2_CH);
} else if (expr_type == TypeManager.ushort_type){
//
// From ushort to sbyte, byte, short, char
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U2_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U2_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_I2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U2_I2);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U2_CH);
} else if (expr_type == TypeManager.int32_type){
//
// From int to sbyte, byte, short, ushort, uint, ulong, char
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I4_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I4_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_I2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I4_I2);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I4_U2);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I4_U4);
if (real_target_type == TypeManager.uint64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I4_U8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I4_CH);
} else if (expr_type == TypeManager.uint32_type){
//
// From uint to sbyte, byte, short, ushort, int, char
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U4_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U4_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_I2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U4_I2);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_U2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U4_U2);
if (real_target_type == TypeManager.int32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_I4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U4_I4);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U4_CH);
} else if (expr_type == TypeManager.int64_type){
//
// From long to sbyte, byte, short, ushort, int, uint, ulong, char
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I8_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I8_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I8_I2);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I8_U2);
if (real_target_type == TypeManager.int32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I8_I4);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I8_U4);
if (real_target_type == TypeManager.uint64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I8_U8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.I8_CH);
} else if (expr_type == TypeManager.uint64_type){
//
// From ulong to sbyte, byte, short, ushort, int, uint, long, char
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U8_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U8_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U8_I2);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U8_U2);
if (real_target_type == TypeManager.int32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U8_I4);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U8_U4);
if (real_target_type == TypeManager.int64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U8_I8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.U8_CH);
} else if (expr_type == TypeManager.char_type){
//
// From char to sbyte, byte, short
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.CH_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.CH_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.CH_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.CH_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.CH_I2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.CH_I2);
} else if (expr_type == TypeManager.float_type){
//
// From float to sbyte, byte, short,
// or decimal
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_I2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_I2);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_U2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_U2);
if (real_target_type == TypeManager.int32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_I4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_I4);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_U4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_U4);
if (real_target_type == TypeManager.int64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_I8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_I8);
if (real_target_type == TypeManager.uint64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_U8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_U8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R4_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R4_CH);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr, true);
+ return new CastToDecimal (expr, true);
} else if (expr_type == TypeManager.double_type){
//
// From double to sbyte, byte, short,
// char, float or decimal
//
if (real_target_type == TypeManager.sbyte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_I1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_I1);
if (real_target_type == TypeManager.byte_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_U1);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_U1);
if (real_target_type == TypeManager.short_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_I2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_I2);
if (real_target_type == TypeManager.ushort_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_U2);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_U2);
if (real_target_type == TypeManager.int32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_I4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_I4);
if (real_target_type == TypeManager.uint32_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_U4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_U4);
if (real_target_type == TypeManager.int64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_I8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_I8);
if (real_target_type == TypeManager.uint64_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_U8);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_U8);
if (real_target_type == TypeManager.char_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_CH);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_CH);
if (real_target_type == TypeManager.float_type)
- return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_R4);
+ return new ConvCast (expr, target_type, ConvCast.Mode.R8_R4);
if (real_target_type == TypeManager.decimal_type)
- return new CastToDecimal (ec, expr, true);
+ return new CastToDecimal (expr, true);
} else if (expr_type == TypeManager.decimal_type) {
- //
- // From decimal to sbyte, byte, short, ushort, int, uint,
- // long, ulong, char, double or float
- //
- if (real_target_type == TypeManager.sbyte_type ||
- real_target_type == TypeManager.byte_type ||
- real_target_type == TypeManager.short_type ||
- real_target_type == TypeManager.ushort_type ||
- real_target_type == TypeManager.int32_type ||
- real_target_type == TypeManager.uint32_type ||
- real_target_type == TypeManager.int64_type ||
- real_target_type == TypeManager.uint64_type ||
- real_target_type == TypeManager.char_type ||
- real_target_type == TypeManager.double_type ||
- real_target_type == TypeManager.float_type)
- return new CastFromDecimal (ec, expr, target_type);
+ return new CastFromDecimal (expr, target_type).Resolve ();
}
return null;
}
/// Performs an explicit conversion of the expression `expr' whose
/// type is expr.Type to `target_type'.
/// </summary>
- static public Expression ExplicitConversion (EmitContext ec, Expression expr,
+ static public Expression ExplicitConversionCore (EmitContext ec, Expression expr,
Type target_type, Location loc)
{
Type expr_type = expr.Type;
- Type original_expr_type = expr_type;
+ // Explicit conversion includes implicit conversion and it used for enum underlying types too
Expression ne = ImplicitConversionStandard (ec, expr, target_type, loc);
-
if (ne != null)
return ne;
- if (expr_type.IsSubclassOf (TypeManager.enum_type)){
- if ((expr_type == TypeManager.enum_type) && target_type.IsValueType &&
- target_type.IsSubclassOf (TypeManager.enum_type))
- return new UnboxCast (expr, target_type);
+ //
+ // Unboxing conversions; only object types can be convertible to enum
+ //
+ if (expr_type == TypeManager.object_type && target_type.IsValueType || expr_type == TypeManager.enum_type)
+ return new UnboxCast (expr, target_type);
- //
- // Notice that we have kept the expr_type unmodified, which is only
- // used later on to
+ if (TypeManager.IsEnumType (expr_type)) {
if (expr is EnumConstant)
- expr = ((EnumConstant) expr).Child;
- else
- expr = new EmptyCast (expr, TypeManager.EnumToUnderlying (expr_type));
- expr_type = expr.Type;
+ return ExplicitConversionCore (ec, ((EnumConstant) expr).Child, target_type, loc);
+
+ return ExplicitConversionCore (ec, new EmptyCast (expr, TypeManager.EnumToUnderlying (expr_type)), target_type, loc);
}
- ne = ExplicitNumericConversion (ec, expr, target_type, loc);
+ if (TypeManager.IsEnumType (target_type))
+ return new EmptyCast (ExplicitConversionCore (ec, expr, TypeManager.EnumToUnderlying (target_type), loc), target_type);
+
+ ne = ExplicitNumericConversion (expr, target_type);
if (ne != null)
return ne;
- //
- // Unboxing conversion.
- //
- if (expr_type == TypeManager.object_type && target_type.IsValueType)
- return new UnboxCast (expr, target_type);
-
//
// Skip the ExplicitReferenceConversion because we can not convert
// from Null to a ValueType, and ExplicitReference wont check against
}
if (ec.InUnsafe){
- if (target_type.IsPointer){
- if (expr_type.IsPointer)
- return new EmptyCast (expr, target_type);
-
- if (expr_type == TypeManager.sbyte_type ||
- expr_type == TypeManager.short_type ||
- expr_type == TypeManager.int32_type ||
- expr_type == TypeManager.int64_type)
- return new OpcodeCast (expr, target_type, OpCodes.Conv_I);
-
- if (expr_type == TypeManager.ushort_type ||
- expr_type == TypeManager.uint32_type ||
- expr_type == TypeManager.uint64_type ||
- expr_type == TypeManager.byte_type)
- return new OpcodeCast (expr, target_type, OpCodes.Conv_U);
- }
- if (expr_type.IsPointer){
- Expression e = null;
-
- if (target_type == TypeManager.sbyte_type)
- e = new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
- else if (target_type == TypeManager.byte_type)
- e = new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
- else if (target_type == TypeManager.short_type)
- e = new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
- else if (target_type == TypeManager.ushort_type)
- e = new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
- else if (target_type == TypeManager.int32_type)
- e = new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
- else if (target_type == TypeManager.uint32_type)
- e = new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
- else if (target_type == TypeManager.uint64_type)
- e = new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
- else if (target_type == TypeManager.int64_type){
- e = new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
- }
-
- if (e != null){
- Expression ci, ce;
-
- ci = ImplicitConversionStandard (ec, e, target_type, loc);
-
- if (ci != null)
- return ci;
-
- ce = ExplicitNumericConversion (ec, e, target_type, loc);
- if (ce != null)
- return ce;
- //
- // We should always be able to go from an uint32
- // implicitly or explicitly to the other integral
- // types
- //
- throw new Exception ("Internal compiler error");
- }
- }
+ ne = ExplicitUnsafe (expr, target_type);
+ if (ne != null)
+ return ne;
}
ne = ExplicitUserConversion (ec, expr, target_type, loc);
if (ne != null)
return ne;
- if (expr is Constant)
- expr.Error_ValueCannotBeConverted (loc, target_type);
- else
- Error_CannotConvertType (loc, original_expr_type, target_type);
+ return null;
+ }
+
+ public static Expression ExplicitUnsafe (Expression expr, Type target_type)
+ {
+ Type expr_type = expr.Type;
+
+ if (target_type.IsPointer){
+ if (expr_type.IsPointer)
+ return new EmptyCast (expr, target_type);
+
+ if (expr_type == TypeManager.sbyte_type ||
+ expr_type == TypeManager.short_type ||
+ expr_type == TypeManager.int32_type ||
+ expr_type == TypeManager.int64_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_I);
+
+ if (expr_type == TypeManager.ushort_type ||
+ expr_type == TypeManager.uint32_type ||
+ expr_type == TypeManager.uint64_type ||
+ expr_type == TypeManager.byte_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_U);
+ }
+
+ if (expr_type.IsPointer){
+ if (target_type == TypeManager.sbyte_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
+ else if (target_type == TypeManager.byte_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
+ else if (target_type == TypeManager.short_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
+ else if (target_type == TypeManager.ushort_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
+ else if (target_type == TypeManager.int32_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
+ else if (target_type == TypeManager.uint32_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
+ else if (target_type == TypeManager.uint64_type)
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
+ else if (target_type == TypeManager.int64_type){
+ return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
+ }
+ }
return null;
}
Type target_type, Location l)
{
Expression ne = ImplicitConversionStandard (ec, expr, target_type, l);
-
if (ne != null)
return ne;
- ne = ExplicitNumericConversion (ec, expr, target_type, l);
+ ne = ExplicitNumericConversion (expr, target_type);
if (ne != null)
return ne;
if (ne != null)
return ne;
- Error_CannotConvertType (l, expr.Type, target_type);
+ if (ec.InUnsafe && expr.Type == TypeManager.void_ptr_type && target_type.IsPointer)
+ return new EmptyCast (expr, target_type);
+
+ expr.Error_ValueCannotBeConverted (l, target_type, true);
+ return null;
+ }
+
+ /// <summary>
+ /// Performs an explicit conversion of the expression `expr' whose
+ /// type is expr.Type to `target_type'.
+ /// </summary>
+ static public Expression ExplicitConversion (EmitContext ec, Expression expr,
+ Type target_type, Location loc)
+ {
+ Expression e = ExplicitConversionCore (ec, expr, target_type, loc);
+ if (e != null)
+ return e;
+
+ expr.Error_ValueCannotBeConverted (loc, target_type, true);
return null;
}
}
projects / mono.git / blobdiff