2004-04-02 Martin Baulig <martin@ximian.com>

	* convert.cs: Added type parameter conversions.

	* ecore.cs
	(UnboxCast.Emit): Emit an `unbox.any' for type params.
	(ClassCast.Emit): If the source type is a type parameter, box it.
	If the target type is a type parameter, emit an `unbox.any'
	instead of a `classcast'.

svn path=/trunk/mcs/; revision=24952

diff --git a/mcs/gmcs/ChangeLog b/mcs/gmcs/ChangeLog
index 782e8998e4c6ce02d95a801a126a3fa079b91071..076b5f1d7c1bbc85775d014d3d8be82bce5985d4 100755 (executable)
--- a/mcs/gmcs/ChangeLog
+++ b/mcs/gmcs/ChangeLog
@@ -1,3 +1,13 @@
+2004-04-02  Martin Baulig  <martin@ximian.com>
+
+       * convert.cs: Added type parameter conversions.
+
+       * ecore.cs
+       (UnboxCast.Emit): Emit an `unbox.any' for type params.
+       (ClassCast.Emit): If the source type is a type parameter, box it.
+       If the target type is a type parameter, emit an `unbox.any'
+       instead of a `classcast'.       
+
 2004-04-01  Martin Baulig  <martin@ximian.com>
 
        * cs-tokenizer.cs (parse_less_than): Allow Token.DOT.

diff --git a/mcs/gmcs/convert.cs b/mcs/gmcs/convert.cs
index 859af850250e6987d7f4740268d87764b188a38c..637c4150f718621bebbb5137db0efde148a3150d 100644 (file)
--- a/mcs/gmcs/convert.cs
+++ b/mcs/gmcs/convert.cs
@@ -66,7 +66,7 @@ namespace Mono.CSharp {
                                // System.Enum is not a value type, it is a class, so we need
                                // a boxing conversion
                                //
-                               if (expr_type.IsEnum)
+                               if (expr_type.IsEnum || expr_type.IsGenericParameter)
                                        return new BoxedCast (expr);
 
                                return new EmptyCast (expr, target_type);
@@ -89,7 +89,9 @@ namespace Mono.CSharp {
                                // from any class-type S to any interface-type T.
                                if (target_type.IsInterface) {
                                        if (TypeManager.ImplementsInterface (expr_type, target_type)){
-                                               if (expr_type.IsClass)
+                                               if (expr_type.IsGenericParameter)
+                                                       return new BoxedCast (expr, target_type);
+                                               else if (expr_type.IsClass)
                                                        return new EmptyCast (expr, target_type);
                                                else if (TypeManager.IsValueType (expr_type) ||
                                                         TypeManager.IsEnumType (expr_type))
@@ -170,7 +172,7 @@ namespace Mono.CSharp {
                                if (expr_type.IsClass || TypeManager.IsValueType (expr_type) ||
                                    expr_type.IsInterface || expr_type == TypeManager.enum_type)
                                        return true;
-                       } else if (TypeManager.IsSubclassOf (expr_type, target_type)) 
+                       } else if (TypeManager.IsSubclassOf (expr_type, target_type))
                                return true;
                        else {
                                // Please remember that all code below actually comes
@@ -1413,11 +1415,18 @@ namespace Mono.CSharp {
                /// </summary>
                public static bool ExplicitReferenceConversionExists (Type source_type, Type target_type)
                {
+                       bool target_is_type_param = target_type.IsGenericParameter;
                        bool target_is_value_type = target_type.IsValueType;
                        
                        if (source_type == target_type)
                                return true;
-                       
+
+                       //
+                       // From object to a generic parameter
+                       //
+                       if (source_type == TypeManager.object_type && target_is_type_param)
+                               return true;
+
                        //
                        // From object to any reference type
                        //
@@ -1506,8 +1515,15 @@ namespace Mono.CSharp {
                static Expression ExplicitReferenceConversion (Expression source, Type target_type)
                {
                        Type source_type = source.Type;
+                       bool target_is_type_param = target_type.IsGenericParameter;
                        bool target_is_value_type = target_type.IsValueType;
 
+                       //
+                       // From object to a generic parameter
+                       //
+                       if (source_type == TypeManager.object_type && target_is_type_param)
+                               return new UnboxCast (source, target_type);
+
                        //
                        // From object to any reference type
                        //
@@ -1537,7 +1553,7 @@ namespace Mono.CSharp {
                                else
                                        return new ClassCast (source, target_type);
                        }
-                           
+
                        //
                        // From any class type S to any interface T, provides S is not sealed
                        // and provided S does not implement T.

diff --git a/mcs/gmcs/ecore.cs b/mcs/gmcs/ecore.cs
index 169d6d523937acb4a5203cfa00a38899da684d00..857ce268e16e284de07f1dfe9f20198384d9b9d1 100755 (executable)
--- a/mcs/gmcs/ecore.cs
+++ b/mcs/gmcs/ecore.cs
@@ -1602,9 +1602,13 @@ namespace Mono.CSharp {
                        ILGenerator ig = ec.ig;
                        
                        base.Emit (ec);
-                       ig.Emit (OpCodes.Unbox, t);
+                       if (t.IsGenericParameter)
+                               ig.Emit (OpCodes.Unbox_Any, t);
+                       else {
+                               ig.Emit (OpCodes.Unbox, t);
 
-                       LoadFromPtr (ig, t);
+                               LoadFromPtr (ig, t);
+                       }
                }
        }
        
@@ -1887,9 +1891,14 @@ namespace Mono.CSharp {
                {
                        base.Emit (ec);
 
-                       ec.ig.Emit (OpCodes.Castclass, type);
-               }                       
-               
+                       if (child.Type.IsGenericParameter)
+                               ec.ig.Emit (OpCodes.Box, child.Type);
+
+                       if (type.IsGenericParameter)
+                               ec.ig.Emit (OpCodes.Unbox_Any, type);
+                       else
+                               ec.ig.Emit (OpCodes.Castclass, type);
+               }
        }
        
        /// <summary>