updated browser capabilities file

[mono.git] / mcs / gmcs / convert.cs

diff --git a/mcs/gmcs/convert.cs b/mcs/gmcs/convert.cs
index d47cfe37341f2f63fcab9264e9e09dbf57b3f2aa..6e9407ecc1257ef037d2a6d30f74f67754318f5a 100644 (file)
--- a/mcs/gmcs/convert.cs
+++ b/mcs/gmcs/convert.cs
@@ -39,7 +39,7 @@ namespace Mono.CSharp {
 
                        if (expr_type == TypeManager.void_type)
                                return null;
-                       
+
                        //
                        // notice that it is possible to write "ValueType v = 1", the ValueType here
                        // is an abstract class, and not really a value type, so we apply the same rules.
@@ -59,7 +59,7 @@ namespace Mono.CSharp {
                                if (TypeManager.IsValueType (expr_type))
                                        return new BoxedCast (expr);
                                if (expr is NullLiteral)
-                                       return new BoxedCast (expr);
+                                       return new NullCast (expr, target_type);
                        } else if (expr_type.IsSubclassOf (target_type)) {
                                //
                                // Special case: enumeration to System.Enum.
@@ -91,8 +91,11 @@ namespace Mono.CSharp {
                                        if (TypeManager.ImplementsInterface (expr_type, target_type)){
                                                if (expr_type.IsClass)
                                                        return new EmptyCast (expr, target_type);
-                                               else if (TypeManager.IsValueType (expr_type))
+                                               else if (TypeManager.IsValueType (expr_type) ||
+                                                        TypeManager.IsEnumType (expr_type))
                                                        return new BoxedCast (expr, target_type);
+                                               else
+                                                       return new EmptyCast (expr, target_type);
                                        }
                                }
 
@@ -140,6 +143,10 @@ namespace Mono.CSharp {
                                    expr_type.IsSubclassOf (TypeManager.delegate_type))
                                        if (target_type == TypeManager.icloneable_type)
                                                return new EmptyCast (expr, target_type);
+
+                               // from a generic type definition to a generic instance.
+                               if (TypeManager.IsEqualGenericType (expr_type, target_type))
+                                       return new EmptyCast (expr, target_type);
                                
                                return null;
 
@@ -163,9 +170,9 @@ namespace Mono.CSharp {
                                if (expr_type.IsClass || TypeManager.IsValueType (expr_type) ||
                                    expr_type.IsInterface || expr_type == TypeManager.enum_type)
                                        return true;
-                       } else if (expr_type.IsSubclassOf (target_type)) {
+                       } else if (expr_type.IsSubclassOf (target_type)) 
                                return true;
-                       } else {
+                       else {
                                // Please remember that all code below actually comes
                                // from ImplicitReferenceConversion so make sure code remains in sync
                                
@@ -221,7 +228,10 @@ namespace Mono.CSharp {
                                if (expr is NullLiteral && !target_type.IsValueType &&
                                    !TypeManager.IsEnumType (target_type))
                                        return true;
-                               
+
+                               // from a generic type definition to a generic instance.
+                               if (TypeManager.IsEqualGenericType (expr_type, target_type))
+                                       return true;
                        }
                        return false;
                }
@@ -236,7 +246,7 @@ namespace Mono.CSharp {
                                                                    Type target_type, Location loc)
                {
                        Type expr_type = expr.Type;
-                       
+
                        //
                        // Attempt to do the implicit constant expression conversions
 
@@ -993,7 +1003,6 @@ namespace Mono.CSharp {
                static public Expression ImplicitConversion (EmitContext ec, Expression expr,
                                                             Type target_type, Location loc)
                {
-                       Type expr_type = expr.Type;
                        Expression e;
 
                        if (target_type == null)
@@ -1027,6 +1036,18 @@ namespace Mono.CSharp {
                        Type expr_type = expr.Type;
                        Expression e;
 
+                       if (expr.eclass == ExprClass.MethodGroup){
+                               if (!TypeManager.IsDelegateType (target_type)){
+                                       Report.Error (428, loc,
+                                                     String.Format (
+                                                          "Cannot convert method group to `{0}', since it is not a delegate",
+                                                          TypeManager.CSharpName (target_type)));
+                                       return null;
+                               }
+
+                               return ImplicitDelegateCreation.Create (ec, (MethodGroupExpr) expr, target_type, loc);
+                       }
+
                        if (expr_type.Equals (target_type) && !(expr is NullLiteral))
                                return expr;
 
@@ -1087,7 +1108,7 @@ namespace Mono.CSharp {
                                if (value >= SByte.MinValue && value <= SByte.MaxValue)
                                        return new SByteConstant ((sbyte) value);
                        } else if (target_type == TypeManager.byte_type){
-                               if (Byte.MinValue >= 0 && value <= Byte.MaxValue)
+                               if (value >= Byte.MinValue && value <= Byte.MaxValue)
                                        return new ByteConstant ((byte) value);
                        } else if (target_type == TypeManager.short_type){
                                if (value >= Int16.MinValue && value <= Int16.MaxValue)
@@ -1158,6 +1179,13 @@ namespace Mono.CSharp {
                                              "float type, use F suffix to create a float literal");
                        }
 
+                       if (source is Constant){
+                               Constant c = (Constant) source;
+
+                               Expression.Error_ConstantValueCannotBeConverted (loc, c.AsString (), target_type);
+                               return null;
+                       }
+                       
                        Error_CannotImplicitConversion (loc, source.Type, target_type);
 
                        return null;
@@ -1486,6 +1514,13 @@ namespace Mono.CSharp {
                        if (source_type == TypeManager.object_type && !target_is_value_type)
                                return new ClassCast (source, target_type);
 
+                       //
+                       // Unboxing conversion.
+                       //
+                       if (((source_type == TypeManager.enum_type &&
+                               !(source is EmptyCast)) ||
+                               source_type == TypeManager.value_type) && target_is_value_type)
+                               return new UnboxCast (source, target_type);
 
                        //
                        // From any class S to any class-type T, provided S is a base class of T
@@ -1628,7 +1663,6 @@ namespace Mono.CSharp {
                                return new UnboxCast (expr, target_type);
                        }
 
-                       
                        ne = ExplicitReferenceConversion (expr, target_type);
                        if (ne != null)
                                return ne;