mcs/mcs/convert.cs

   1 //
   2 // conversion.cs: various routines for implementing conversions.
   3 //
   4 // Authors:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //   Ravi Pratap (ravi@ximian.com)
   7 //   Marek Safar (marek.safar@gmail.com)
   8 //
   9 // Copyright 2001, 2002, 2003 Ximian, Inc.
  10 // Copyright 2003-2008 Novell, Inc.
  11 //
  12
  13 namespace Mono.CSharp {
  14         using System;
  15         using System.Collections;
  16         using System.Diagnostics;
  17         using System.Reflection;
  18         using System.Reflection.Emit;
  19
  20         //
  21         // A container class for all the conversion operations
  22         //
  23         static class Convert {
  24
  25                 static EmptyExpression MyEmptyExpr;
  26                 static DoubleHash explicit_conv;
  27                 static DoubleHash implicit_conv;
  28
  29                 static Convert ()
  30                 {
  31                         Reset ();
  32                 }
  33
  34                 public static void Reset ()
  35                 {
  36                         MyEmptyExpr = null;
  37                         explicit_conv = new DoubleHash (100);
  38                         implicit_conv = new DoubleHash (100);
  39                 }
  40
  41                 static Type TypeParam_EffectiveBaseType (GenericConstraints gc)
  42                 {
  43                         ArrayList list = new ArrayList ();
  44                         list.Add (gc.EffectiveBaseClass);
  45                         foreach (Type t in gc.InterfaceConstraints) {
  46                                 if (!TypeManager.IsGenericParameter (t))
  47                                         continue;
  48
  49                                 GenericConstraints new_gc = TypeManager.GetTypeParameterConstraints (t);
  50                                 if (new_gc != null)
  51                                         list.Add (TypeParam_EffectiveBaseType (new_gc));
  52                         }
  53                         return FindMostEncompassedType (list);
  54                 }
  55
  56                 //
  57                 // From a one-dimensional array-type S[] to System.Collections.IList<T> and base
  58                 // interfaces of this interface, provided there is an implicit reference conversion
  59                 // from S to T.
  60                 //
  61                 static bool Array_To_IList (Type array, Type list, bool isExplicit)
  62                 {
  63                         if ((array.GetArrayRank () != 1) || !TypeManager.IsGenericType (list))
  64                                 return false;
  65
  66                         Type gt = TypeManager.DropGenericTypeArguments (list);
  67                         if ((gt != TypeManager.generic_ilist_type) &&
  68                             (gt != TypeManager.generic_icollection_type) &&
  69                             (gt != TypeManager.generic_ienumerable_type))
  70                                 return false;
  71
  72                         Type element_type = TypeManager.GetElementType (array);
  73                         Type arg_type = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (list) [0]);
  74
  75                         if (element_type == arg_type)
  76                                 return true;
  77
  78                         if (isExplicit)
  79                                 return ExplicitReferenceConversionExists (element_type, arg_type);
  80
  81                         Type t = TypeManager.GetElementType (array);
  82                         if (MyEmptyExpr == null)
  83                                 MyEmptyExpr = new EmptyExpression (t);
  84                         else
  85                                 MyEmptyExpr.SetType (t);
  86
  87                         return ImplicitReferenceConversionExists (MyEmptyExpr, arg_type);
  88                 }
  89
  90                 static bool IList_To_Array(Type list, Type array)
  91                 {
  92                         if (!TypeManager.IsGenericType (list) || !array.IsArray || array.GetArrayRank() != 1)
  93                                 return false;
  94
  95                         Type gt = TypeManager.DropGenericTypeArguments (list);
  96                         if (gt != TypeManager.generic_ilist_type &&
  97                                 gt != TypeManager.generic_icollection_type &&
  98                                 gt != TypeManager.generic_ienumerable_type)
  99                                 return false;
 100
 101                         Type arg_type = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments(list)[0]);
 102                         Type element_type = TypeManager.GetElementType(array);
 103
 104                         if (element_type == arg_type)
 105                                 return true;
 106
 107                         if (MyEmptyExpr == null)
 108                                 MyEmptyExpr = new EmptyExpression(element_type);
 109                         else
 110                                 MyEmptyExpr.SetType(element_type);
 111
 112                         return ImplicitReferenceConversionExists(MyEmptyExpr, arg_type) || ExplicitReferenceConversionExists(element_type, arg_type);
 113                 }
 114
 115                 static Expression ImplicitTypeParameterConversion (Expression expr,
 116                                                                    Type target_type)
 117                 {
 118                         Type expr_type = expr.Type;
 119
 120                         GenericConstraints gc = TypeManager.GetTypeParameterConstraints (expr_type);
 121
 122                         if (gc == null) {
 123                                 if (target_type == TypeManager.object_type)
 124                                         return new BoxedCast (expr, target_type);
 125
 126                                 return null;
 127                         }
 128
 129                         // We're converting from a type parameter which is known to be a reference type.
 130                         Type base_type = TypeParam_EffectiveBaseType (gc);
 131
 132                         if (TypeManager.IsSubclassOf (base_type, target_type))
 133                                 return new ClassCast (expr, target_type);
 134
 135                         if (target_type.IsInterface) {
 136                                 if (TypeManager.ImplementsInterface (base_type, target_type))
 137                                         return new ClassCast (expr, target_type);
 138
 139                                 foreach (Type t in gc.InterfaceConstraints) {
 140                                         if (TypeManager.IsSubclassOf (t, target_type))
 141                                                 return new ClassCast (expr, target_type);
 142                                         if (TypeManager.ImplementsInterface (t, target_type))
 143                                                 return new ClassCast (expr, target_type);
 144                                 }
 145                         }
 146
 147                         foreach (Type t in gc.InterfaceConstraints) {
 148                                 if (!TypeManager.IsGenericParameter (t))
 149                                         continue;
 150                                 if (TypeManager.IsSubclassOf (t, target_type))
 151                                         return new ClassCast (expr, target_type);
 152                                 if (TypeManager.ImplementsInterface (t, target_type))
 153                                         return new ClassCast (expr, target_type);
 154                         }
 155
 156                         return null;
 157                 }
 158
 159                 static bool ImplicitTypeParameterBoxingConversion (Type expr_type, Type target_type,
 160                                                                    out bool use_class_cast)
 161                 {
 162                         GenericConstraints gc = TypeManager.GetTypeParameterConstraints (expr_type);
 163
 164                         if (gc == null) {
 165                                 use_class_cast = false;
 166                                 return target_type == TypeManager.object_type;
 167                         }
 168
 169                         use_class_cast = true;
 170
 171                         if (!gc.HasReferenceTypeConstraint)
 172                                 return false;
 173
 174                         // We're converting from a type parameter which is known to be a reference type.
 175                         Type base_type = TypeParam_EffectiveBaseType (gc);
 176
 177                         if (TypeManager.IsSubclassOf (base_type, target_type))
 178                                 return true;
 179
 180                         if (target_type.IsInterface) {
 181                                 if (TypeManager.ImplementsInterface (base_type, target_type))
 182                                         return true;
 183
 184                                 foreach (Type t in gc.InterfaceConstraints) {
 185                                         if (TypeManager.IsSubclassOf (t, target_type))
 186                                                 return true;
 187                                         if (TypeManager.ImplementsInterface (t, target_type))
 188                                                 return true;
 189                                 }
 190                         }
 191
 192                         foreach (Type t in gc.InterfaceConstraints) {
 193                                 if (!TypeManager.IsGenericParameter (t))
 194                                         continue;
 195                                 if (TypeManager.IsSubclassOf (t, target_type))
 196                                         return true;
 197                                 if (TypeManager.ImplementsInterface (t, target_type))
 198                                         return true;
 199                         }
 200
 201                         use_class_cast = false;
 202                         return false;
 203                 }
 204
 205                 static Expression ExplicitTypeParameterConversion (Expression source, Type source_type, Type target_type)
 206                 {
 207                         if (TypeManager.IsGenericParameter (target_type)) {
 208                                 GenericConstraints gc = TypeManager.GetTypeParameterConstraints (target_type);
 209                                 if (gc == null)
 210                                         return null;
 211
 212                                 foreach (Type iface in gc.InterfaceConstraints) {
 213                                         if (!TypeManager.IsGenericParameter (iface))
 214                                                 continue;
 215
 216                                         if (TypeManager.IsSubclassOf (source_type, iface))
 217                                                 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type, true);
 218                                 }
 219                         }
 220
 221                         if (target_type.IsInterface)
 222                                 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type, true);
 223
 224                         return null;
 225                 }
 226
 227                 static Expression ImplicitReferenceConversion (Expression expr, Type target_type, bool explicit_cast)
 228                 {
 229                         Type expr_type = expr.Type;
 230
 231                         if (expr_type == null && expr.eclass == ExprClass.MethodGroup){
 232                                 // if we are a method group, emit a warning
 233
 234                                 expr.Emit (null);
 235                         }
 236
 237                         if (expr_type == TypeManager.void_type)
 238                                 return null;
 239
 240                         if (TypeManager.IsGenericParameter (expr_type))
 241                                 return ImplicitTypeParameterConversion (expr, target_type);
 242
 243                         //
 244                         // from the null type to any reference-type.
 245                         //
 246                         NullLiteral nl = expr as NullLiteral;
 247                         if (nl != null) {
 248                                 return nl.ConvertImplicitly(target_type);
 249                         }
 250
 251                         if (ImplicitReferenceConversionExists (expr, target_type)) {
 252                                 //
 253                                 // Avoid wrapping implicitly convertible reference type
 254                                 //
 255                                 if (!explicit_cast)
 256                                         return expr;
 257
 258                                 return EmptyCast.Create (expr, target_type);
 259                         }
 260
 261                         bool use_class_cast;
 262                         if (ImplicitBoxingConversionExists (expr, target_type, out use_class_cast)) {
 263                                 if (use_class_cast)
 264                                         return new ClassCast (expr, target_type);
 265                                 else
 266                                         return new BoxedCast (expr, target_type);
 267                         }
 268
 269                         return null;
 270                 }
 271
 272                 //
 273                 // 6.1.6 Implicit reference conversions
 274                 //
 275                 public static bool ImplicitReferenceConversionExists (Expression expr, Type target_type)
 276                 {
 277                         if (TypeManager.IsStruct (target_type))
 278                                 return false;
 279
 280                         Type expr_type = expr.Type;
 281
 282                         // from the null type to any reference-type.
 283                         if (expr_type == TypeManager.null_type)
 284                                 return target_type != InternalType.AnonymousMethod;
 285
 286                         if (TypeManager.IsGenericParameter (expr_type))
 287                                 return ImplicitTypeParameterConversion (expr, target_type) != null;
 288
 289                         //
 290                         // notice that it is possible to write "ValueType v = 1", the ValueType here
 291                         // is an abstract class, and not really a value type, so we apply the same rules.
 292                         //
 293                         if (target_type == TypeManager.object_type || TypeManager.IsDynamicType (target_type)) {
 294                                 //
 295                                 // A pointer type cannot be converted to object
 296                                 //
 297                                 if (expr_type.IsPointer)
 298                                         return false;
 299
 300                                 if (TypeManager.IsValueType (expr_type))
 301                                         return false;
 302
 303                                 if (expr_type.IsClass || expr_type.IsInterface || expr_type == TypeManager.enum_type){
 304                                         // No mcs internal types are convertible
 305                                         return expr_type.Module != typeof (Convert).Module;
 306                                 }
 307
 308                                 return false;
 309                         } else if (target_type == TypeManager.value_type) {
 310                                 return expr_type == TypeManager.enum_type;
 311                         } else if (TypeManager.IsSubclassOf (expr_type, target_type)) {
 312                                 //
 313                                 // Special case: enumeration to System.Enum.
 314                                 // System.Enum is not a value type, it is a class, so we need
 315                                 // a boxing conversion
 316                                 //
 317                                 if (target_type == TypeManager.enum_type || TypeManager.IsGenericParameter (expr_type))
 318                                         return false;
 319
 320                                 return true;
 321                         }
 322
 323                         // This code is kind of mirrored inside ImplicitStandardConversionExists
 324                         // with the small distinction that we only probe there
 325                         //
 326                         // Always ensure that the code here and there is in sync
 327
 328                         // from any class-type S to any interface-type T.
 329                         if (target_type.IsInterface) {
 330                                 if (TypeManager.ImplementsInterface (expr_type, target_type)){
 331                                         return !TypeManager.IsGenericParameter (expr_type) &&
 332                                                 !TypeManager.IsValueType (expr_type);
 333                                 }
 334                         }
 335
 336                         if (expr_type.IsArray) {
 337                                 // from an array-type S to an array-type of type T
 338                                 if (target_type.IsArray && expr_type.GetArrayRank () == target_type.GetArrayRank ()) {
 339
 340                                         //
 341                                         // Both SE and TE are reference-types
 342                                         //
 343                                         Type expr_element_type = TypeManager.GetElementType (expr_type);
 344                                         if (!TypeManager.IsReferenceType (expr_element_type))
 345                                                 return false;
 346
 347                                         Type target_element_type = TypeManager.GetElementType (target_type);
 348                                         if (!TypeManager.IsReferenceType (target_element_type))
 349                                                 return false;
 350
 351                                         if (MyEmptyExpr == null)
 352                                                 MyEmptyExpr = new EmptyExpression (expr_element_type);
 353                                         else
 354                                                 MyEmptyExpr.SetType (expr_element_type);
 355
 356                                         return ImplicitStandardConversionExists (MyEmptyExpr, target_element_type);
 357                                 }
 358
 359                                 // from an array-type to System.Array
 360                                 if (target_type == TypeManager.array_type)
 361                                         return true;
 362
 363                                 // from an array-type of type T to IList<T>
 364                                 if (Array_To_IList (expr_type, target_type, false))
 365                                         return true;
 366
 367                                 return false;
 368                         }
 369
 370                         if (TypeManager.IsVariantOf (expr_type, target_type))
 371                                 return true;
 372
 373                         // from any interface type S to interface-type T.
 374                         if (expr_type.IsInterface && target_type.IsInterface) {
 375                                 return TypeManager.ImplementsInterface (expr_type, target_type);
 376                         }
 377
 378                         // from any delegate type to System.Delegate
 379                         if (target_type == TypeManager.delegate_type &&
 380                                 (expr_type == TypeManager.delegate_type || TypeManager.IsDelegateType (expr_type)))
 381                                 return true;
 382
 383                         if (TypeManager.IsEqual (expr_type, target_type))
 384                                 return true;
 385
 386                         return false;
 387                 }
 388
 389                 public static bool ImplicitBoxingConversionExists (Expression expr, Type target_type,
 390                                                                    out bool use_class_cast)
 391                 {
 392                         Type expr_type = expr.Type;
 393                         use_class_cast = false;
 394
 395                         //
 396                         // From any value-type to the type object.
 397                         //
 398                         if (target_type == TypeManager.object_type || TypeManager.IsDynamicType (target_type)) {
 399                                 //
 400                                 // A pointer type cannot be converted to object
 401                                 //
 402                                 if (expr_type.IsPointer)
 403                                         return false;
 404
 405                                 return TypeManager.IsValueType (expr_type);
 406                         }
 407
 408                         //
 409                         // From any value-type to the type System.ValueType.
 410                         //
 411                         if (target_type == TypeManager.value_type)
 412                                 return TypeManager.IsValueType (expr_type);
 413
 414                         if (target_type == TypeManager.enum_type) {
 415                                 //
 416                                 // From any enum-type to the type System.Enum.
 417                                 //
 418                                 if (TypeManager.IsEnumType (expr_type))
 419                                         return true;
 420                                 //
 421                                 // From any nullable-type with an underlying enum-type to the type System.Enum
 422                                 //
 423                                 if (TypeManager.IsNullableType (expr_type))
 424                                         return TypeManager.IsEnumType (TypeManager.GetTypeArguments (expr_type) [0]);
 425                         }
 426
 427                         if (TypeManager.IsSubclassOf (expr_type, target_type)) {
 428                                 //
 429                                 // Don't box same type arguments
 430                                 //
 431                                 if (TypeManager.IsGenericParameter (expr_type) && expr_type != target_type)
 432                                         return true;
 433
 434                                 return false;
 435                         }
 436
 437                         // This code is kind of mirrored inside ImplicitStandardConversionExists
 438                         // with the small distinction that we only probe there
 439                         //
 440                         // Always ensure that the code here and there is in sync
 441
 442                         // from any class-type S to any interface-type T.
 443                         if (target_type.IsInterface) {
 444                                 if (TypeManager.ImplementsInterface (expr_type, target_type))
 445                                         return TypeManager.IsGenericParameter (expr_type) ||
 446                                                 TypeManager.IsValueType (expr_type);
 447                         }
 448
 449                         if (TypeManager.IsGenericParameter (expr_type))
 450                                 return ImplicitTypeParameterBoxingConversion (
 451                                         expr_type, target_type, out use_class_cast);
 452
 453                         return false;
 454                 }
 455
 456                 public static Expression ImplicitNulableConversion (EmitContext ec, Expression expr, Type target_type)
 457                 {
 458                         Type expr_type = expr.Type;
 459
 460                         //
 461                         // From null to any nullable type
 462                         //
 463                         if (expr_type == TypeManager.null_type)
 464                                 return ec == null ? EmptyExpression.Null : Nullable.LiftedNull.Create (target_type, expr.Location);
 465
 466                         Type target = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (target_type)[0]);
 467                         Expression e;
 468
 469                         // S? -> T?
 470                         if (TypeManager.IsNullableType (expr_type)) {
 471                                 Type etype = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (expr_type)[0]);
 472
 473                                 if (ec == null)
 474                                         return ImplicitConversionExists (ec, new EmptyExpression (etype), target) ? EmptyExpression.Null : null;
 475
 476                                 Expression unwrap = Nullable.Unwrap.Create (expr);
 477                                 e = ImplicitConversion (ec, unwrap, target, expr.Location);
 478                                 if (e == null)
 479                                         return null;
 480
 481                                 return new Nullable.Lifted (e, unwrap, target_type).Resolve (ec);
 482                         }
 483
 484                         // S -> T?
 485                         if (ec == null)
 486                                 return ImplicitConversionExists (ec, expr, target) ? EmptyExpression.Null : null;
 487
 488                         e = ImplicitConversion (ec, expr, target, expr.Location);
 489                         if (e != null)
 490                                 return Nullable.Wrap.Create (e, target_type);
 491
 492                         return null;
 493                 }
 494
 495                 /// <summary>
 496                 ///   Implicit Numeric Conversions.
 497                 ///
 498                 ///   expr is the expression to convert, returns a new expression of type
 499                 ///   target_type or null if an implicit conversion is not possible.
 500                 /// </summary>
 501                 public static Expression ImplicitNumericConversion (Expression expr, Type target_type)
 502                 {
 503                         return ImplicitNumericConversion (expr, expr.Type, target_type);
 504                 }
 505
 506                 static Expression ImplicitNumericConversion (Expression expr, Type expr_type, Type target_type)
 507                 {
 508                         if (expr_type == TypeManager.sbyte_type){
 509                                 //
 510                                 // From sbyte to short, int, long, float, double, decimal
 511                                 //
 512                                 if (target_type == TypeManager.int32_type)
 513                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
 514                                 if (target_type == TypeManager.int64_type)
 515                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
 516                                 if (target_type == TypeManager.double_type)
 517                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
 518                                 if (target_type == TypeManager.float_type)
 519                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
 520                                 if (target_type == TypeManager.short_type)
 521                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
 522                                 if (target_type == TypeManager.decimal_type)
 523                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 524                         } else if (expr_type == TypeManager.byte_type){
 525                                 //
 526                                 // From byte to short, ushort, int, uint, long, ulong, float, double, decimal
 527                                 //
 528                                 if (target_type == TypeManager.int32_type || target_type == TypeManager.uint32_type ||
 529                                     target_type == TypeManager.short_type || target_type == TypeManager.ushort_type)
 530                                         return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
 531
 532                                 if (target_type == TypeManager.uint64_type)
 533                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
 534                                 if (target_type == TypeManager.int64_type)
 535                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
 536                                 if (target_type == TypeManager.float_type)
 537                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
 538                                 if (target_type == TypeManager.double_type)
 539                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
 540                                 if (target_type == TypeManager.decimal_type)
 541                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 542
 543                         } else if (expr_type == TypeManager.short_type){
 544                                 //
 545                                 // From short to int, long, float, double, decimal
 546                                 //
 547                                 if (target_type == TypeManager.int32_type)
 548                                         return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
 549                                 if (target_type == TypeManager.int64_type)
 550                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
 551                                 if (target_type == TypeManager.double_type)
 552                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
 553                                 if (target_type == TypeManager.float_type)
 554                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
 555                                 if (target_type == TypeManager.decimal_type)
 556                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 557
 558                         } else if (expr_type == TypeManager.ushort_type){
 559                                 //
 560                                 // From ushort to int, uint, long, ulong, float, double, decimal
 561                                 //
 562                                 if (target_type == TypeManager.int32_type || target_type == TypeManager.uint32_type)
 563                                         return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
 564
 565                                 if (target_type == TypeManager.uint64_type)
 566                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
 567                                 if (target_type == TypeManager.int64_type)
 568                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
 569                                 if (target_type == TypeManager.double_type)
 570                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
 571                                 if (target_type == TypeManager.float_type)
 572                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
 573                                 if (target_type == TypeManager.decimal_type)
 574                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 575                         } else if (expr_type == TypeManager.int32_type){
 576                                 //
 577                                 // From int to long, float, double, decimal
 578                                 //
 579                                 if (target_type == TypeManager.int64_type)
 580                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
 581                                 if (target_type == TypeManager.double_type)
 582                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
 583                                 if (target_type == TypeManager.float_type)
 584                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
 585                                 if (target_type == TypeManager.decimal_type)
 586                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 587                         } else if (expr_type == TypeManager.uint32_type){
 588                                 //
 589                                 // From uint to long, ulong, float, double, decimal
 590                                 //
 591                                 if (target_type == TypeManager.int64_type)
 592                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
 593                                 if (target_type == TypeManager.uint64_type)
 594                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
 595                                 if (target_type == TypeManager.double_type)
 596                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R8);
 597                                 if (target_type == TypeManager.float_type)
 598                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R4);
 599                                 if (target_type == TypeManager.decimal_type)
 600                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 601                         } else if (expr_type == TypeManager.int64_type){
 602                                 //
 603                                 // From long/ulong to float, double
 604                                 //
 605                                 if (target_type == TypeManager.double_type)
 606                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
 607                                 if (target_type == TypeManager.float_type)
 608                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
 609                                 if (target_type == TypeManager.decimal_type)
 610                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 611                         } else if (expr_type == TypeManager.uint64_type){
 612                                 //
 613                                 // From ulong to float, double
 614                                 //
 615                                 if (target_type == TypeManager.double_type)
 616                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R8);
 617                                 if (target_type == TypeManager.float_type)
 618                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R4);
 619                                 if (target_type == TypeManager.decimal_type)
 620                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 621                         } else if (expr_type == TypeManager.char_type){
 622                                 //
 623                                 // From char to ushort, int, uint, long, ulong, float, double, decimal
 624                                 //
 625                                 if ((target_type == TypeManager.ushort_type) ||
 626                                     (target_type == TypeManager.int32_type) ||
 627                                     (target_type == TypeManager.uint32_type))
 628                                         return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
 629                                 if (target_type == TypeManager.uint64_type)
 630                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
 631                                 if (target_type == TypeManager.int64_type)
 632                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
 633                                 if (target_type == TypeManager.float_type)
 634                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
 635                                 if (target_type == TypeManager.double_type)
 636                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
 637                                 if (target_type == TypeManager.decimal_type)
 638                                         return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
 639                         } else if (expr_type == TypeManager.float_type){
 640                                 //
 641                                 // float to double
 642                                 //
 643                                 if (target_type == TypeManager.double_type)
 644                                         return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
 645                         }
 646
 647                         return null;
 648                 }
 649
 650                 /// <summary>
 651                 ///  Same as ImplicitStandardConversionExists except that it also looks at
 652                 ///  implicit user defined conversions - needed for overload resolution
 653                 /// </summary>
 654                 public static bool ImplicitConversionExists (EmitContext ec, Expression expr, Type target_type)
 655                 {
 656                         if (ImplicitStandardConversionExists (expr, target_type))
 657                                 return true;
 658
 659                         if (expr.Type == InternalType.AnonymousMethod) {
 660                                 if (!TypeManager.IsDelegateType (target_type) &&
 661                                         TypeManager.DropGenericTypeArguments (target_type) != TypeManager.expression_type)
 662                                         return false;
 663
 664                                 AnonymousMethodExpression ame = (AnonymousMethodExpression) expr;
 665                                 return ame.ImplicitStandardConversionExists (ec, target_type);
 666                         }
 667
 668                         if (expr.eclass == ExprClass.MethodGroup) {
 669                                 if (TypeManager.IsDelegateType (target_type) && RootContext.Version != LanguageVersion.ISO_1) {
 670                                         MethodGroupExpr mg = expr as MethodGroupExpr;
 671                                         if (mg != null)
 672                                                 return DelegateCreation.ImplicitStandardConversionExists (ec, mg, target_type);
 673                                 }
 674
 675                                 return false;
 676                         }
 677
 678                         return ImplicitUserConversion (ec, expr, target_type, Location.Null) != null;
 679                 }
 680
 681                 public static bool ImplicitUserConversionExists (EmitContext ec, Type source, Type target)
 682                 {
 683                         return ImplicitUserConversion (ec, new EmptyExpression (source), target, Location.Null) != null;
 684                 }
 685
 686                 /// <summary>
 687                 ///  Determines if a standard implicit conversion exists from
 688                 ///  expr_type to target_type
 689                 ///
 690                 ///  ec should point to a real EmitContext if expr.Type is TypeManager.anonymous_method_type.
 691                 /// </summary>
 692                 public static bool ImplicitStandardConversionExists (Expression expr, Type target_type)
 693                 {
 694                         Type expr_type = expr.Type;
 695
 696                         if (expr_type == TypeManager.null_type) {
 697                                 NullLiteral nl = expr as NullLiteral;
 698                                 if (nl != null)
 699                                         return nl.ConvertImplicitly (target_type) != null;
 700                         }
 701
 702                         if (expr_type == TypeManager.void_type)
 703                                 return false;
 704
 705                         if (TypeManager.IsEqual (expr_type, target_type))
 706                                 return true;
 707
 708                         if (TypeManager.IsNullableType (target_type))
 709                                 return ImplicitNulableConversion (null, expr, target_type) != null;
 710
 711                         // First numeric conversions
 712                         if (ImplicitNumericConversion (null, expr_type, target_type) != null)
 713                                 return true;
 714
 715                         if (ImplicitReferenceConversionExists (expr, target_type))
 716                                 return true;
 717
 718                         bool use_class_cast;
 719                         if (ImplicitBoxingConversionExists (expr, target_type, out use_class_cast))
 720                                 return true;
 721
 722                         //
 723                         // Implicit Constant Expression Conversions
 724                         //
 725                         if (expr is IntConstant){
 726                                 int value = ((IntConstant) expr).Value;
 727
 728                                 if (target_type == TypeManager.sbyte_type){
 729                                         if (value >= SByte.MinValue && value <= SByte.MaxValue)
 730                                                 return true;
 731                                 } else if (target_type == TypeManager.byte_type){
 732                                         if (value >= 0 && value <= Byte.MaxValue)
 733                                                 return true;
 734                                 } else if (target_type == TypeManager.short_type){
 735                                         if (value >= Int16.MinValue && value <= Int16.MaxValue)
 736                                                 return true;
 737                                 } else if (target_type == TypeManager.ushort_type){
 738                                         if (value >= UInt16.MinValue && value <= UInt16.MaxValue)
 739                                                 return true;
 740                                 } else if (target_type == TypeManager.uint32_type){
 741                                         if (value >= 0)
 742                                                 return true;
 743                                 } else if (target_type == TypeManager.uint64_type){
 744                                          //
 745                                          // we can optimize this case: a positive int32
 746                                          // always fits on a uint64.  But we need an opcode
 747                                          // to do it.
 748                                          //
 749                                         if (value >= 0)
 750                                                 return true;
 751                                 }
 752
 753                                 if (value == 0 && expr is IntLiteral && TypeManager.IsEnumType (target_type))
 754                                         return true;
 755                         }
 756
 757                         if (expr is LongConstant && target_type == TypeManager.uint64_type){
 758                                 //
 759                                 // Try the implicit constant expression conversion
 760                                 // from long to ulong, instead of a nice routine,
 761                                 // we just inline it
 762                                 //
 763                                 long v = ((LongConstant) expr).Value;
 764                                 if (v >= 0)
 765                                         return true;
 766                         }
 767
 768                         //
 769                         // If `expr_type' implements `target_type' (which is an iface)
 770                         // see TryImplicitIntConversion
 771                         //
 772                         if (target_type.IsInterface && TypeManager.ImplementsInterface (expr_type, target_type))
 773                                 return true;
 774
 775                         if (target_type == TypeManager.void_ptr_type && expr_type.IsPointer)
 776                                 return true;
 777
 778                         // Conversion from __arglist to System.ArgIterator
 779                         if (expr_type == InternalType.Arglist)
 780                                 return target_type == TypeManager.arg_iterator_type;
 781
 782                         return false;
 783                 }
 784
 785                 /// <summary>
 786                 ///  Finds "most encompassed type" according to the spec (13.4.2)
 787                 ///  amongst the methods in the MethodGroupExpr
 788                 /// </summary>
 789                 static Type FindMostEncompassedType (ArrayList types)
 790                 {
 791                         Type best = null;
 792
 793                         if (types.Count == 0)
 794                                 return null;
 795
 796                         if (types.Count == 1)
 797                                 return (Type) types [0];
 798
 799                         EmptyExpression expr = EmptyExpression.Grab ();
 800
 801                         foreach (Type t in types) {
 802                                 if (best == null) {
 803                                         best = t;
 804                                         continue;
 805                                 }
 806
 807                                 expr.SetType (t);
 808                                 if (ImplicitStandardConversionExists (expr, best))
 809                                         best = t;
 810                         }
 811
 812                         expr.SetType (best);
 813                         foreach (Type t in types) {
 814                                 if (best == t)
 815                                         continue;
 816                                 if (!ImplicitStandardConversionExists (expr, t)) {
 817                                         best = null;
 818                                         break;
 819                                 }
 820                         }
 821
 822                         EmptyExpression.Release (expr);
 823
 824                         return best;
 825                 }
 826
 827                 /// <summary>
 828                 ///  Finds "most encompassing type" according to the spec (13.4.2)
 829                 ///  amongst the types in the given set
 830                 /// </summary>
 831                 static Type FindMostEncompassingType (ArrayList types)
 832                 {
 833                         Type best = null;
 834
 835                         if (types.Count == 0)
 836                                 return null;
 837
 838                         if (types.Count == 1)
 839                                 return (Type) types [0];
 840
 841                         EmptyExpression expr = EmptyExpression.Grab ();
 842
 843                         foreach (Type t in types) {
 844                                 if (best == null) {
 845                                         best = t;
 846                                         continue;
 847                                 }
 848
 849                                 expr.SetType (best);
 850                                 if (ImplicitStandardConversionExists (expr, t))
 851                                         best = t;
 852                         }
 853
 854                         foreach (Type t in types) {
 855                                 if (best == t)
 856                                         continue;
 857                                 expr.SetType (t);
 858                                 if (!ImplicitStandardConversionExists (expr, best)) {
 859                                         best = null;
 860                                         break;
 861                                 }
 862                         }
 863
 864                         EmptyExpression.Release (expr);
 865
 866                         return best;
 867                 }
 868
 869                 /// <summary>
 870                 ///   Finds the most specific source Sx according to the rules of the spec (13.4.4)
 871                 ///   by making use of FindMostEncomp* methods. Applies the correct rules separately
 872                 ///   for explicit and implicit conversion operators.
 873                 /// </summary>
 874                 static public Type FindMostSpecificSource (IList list,
 875                                                            Expression source, bool apply_explicit_conv_rules)
 876                 {
 877                         ArrayList src_types_set = new ArrayList ();
 878
 879                         //
 880                         // If any operator converts from S then Sx = S
 881                         //
 882                         Type source_type = source.Type;
 883                         foreach (MethodBase mb in list){
 884                                 AParametersCollection pd = TypeManager.GetParameterData (mb);
 885                                 Type param_type = pd.Types [0];
 886
 887                                 if (param_type == source_type)
 888                                         return param_type;
 889
 890                                 src_types_set.Add (param_type);
 891                         }
 892
 893                         //
 894                         // Explicit Conv rules
 895                         //
 896                         if (apply_explicit_conv_rules) {
 897                                 ArrayList candidate_set = new ArrayList ();
 898
 899                                 foreach (Type param_type in src_types_set){
 900                                         if (ImplicitStandardConversionExists (source, param_type))
 901                                                 candidate_set.Add (param_type);
 902                                 }
 903
 904                                 if (candidate_set.Count != 0)
 905                                         return FindMostEncompassedType (candidate_set);
 906                         }
 907
 908                         //
 909                         // Final case
 910                         //
 911                         if (apply_explicit_conv_rules)
 912                                 return FindMostEncompassingType (src_types_set);
 913                         else
 914                                 return FindMostEncompassedType (src_types_set);
 915                 }
 916
 917                 /// <summary>
 918                 ///  Finds the most specific target Tx according to section 13.4.4
 919                 /// </summary>
 920                 static public Type FindMostSpecificTarget (IList list,
 921                                                            Type target, bool apply_explicit_conv_rules)
 922                 {
 923                         ArrayList tgt_types_set = new ArrayList ();
 924
 925                         //
 926                         // If any operator converts to T then Tx = T
 927                         //
 928                         foreach (MethodInfo mi in list){
 929                                 Type ret_type = TypeManager.TypeToCoreType (mi.ReturnType);
 930                                 if (ret_type == target)
 931                                         return ret_type;
 932
 933                                 tgt_types_set.Add (ret_type);
 934                         }
 935
 936                         //
 937                         // Explicit conv rules
 938                         //
 939                         if (apply_explicit_conv_rules) {
 940                                 ArrayList candidate_set = new ArrayList ();
 941
 942                                 EmptyExpression expr = EmptyExpression.Grab ();
 943
 944                                 foreach (Type ret_type in tgt_types_set){
 945                                         expr.SetType (ret_type);
 946
 947                                         if (ImplicitStandardConversionExists (expr, target))
 948                                                 candidate_set.Add (ret_type);
 949                                 }
 950
 951                                 EmptyExpression.Release (expr);
 952
 953                                 if (candidate_set.Count != 0)
 954                                         return FindMostEncompassingType (candidate_set);
 955                         }
 956
 957                         //
 958                         // Okay, final case !
 959                         //
 960                         if (apply_explicit_conv_rules)
 961                                 return FindMostEncompassedType (tgt_types_set);
 962                         else
 963                                 return FindMostEncompassingType (tgt_types_set);
 964                 }
 965
 966                 /// <summary>
 967                 ///  User-defined Implicit conversions
 968                 /// </summary>
 969                 static public Expression ImplicitUserConversion (EmitContext ec, Expression source,
 970                                                                  Type target, Location loc)
 971                 {
 972                         Expression expr = UserDefinedConversion (ec, source, target, loc, false);
 973                         if (expr != null && !TypeManager.IsEqual (expr.Type, target))
 974                                 expr = ImplicitConversionStandard (ec, expr, target, loc);
 975
 976                         return expr;
 977                 }
 978
 979                 /// <summary>
 980                 ///  User-defined Explicit conversions
 981                 /// </summary>
 982                 static public Expression ExplicitUserConversion (EmitContext ec, Expression source,
 983                                                                  Type target, Location loc)
 984                 {
 985                         Expression expr = UserDefinedConversion (ec, source, target, loc, true);
 986                         if (expr != null && !TypeManager.IsEqual (expr.Type, target))
 987                                 expr = ExplicitConversionStandard (ec, expr, target, loc);
 988
 989                         return expr;
 990                 }
 991
 992                 static void AddConversionOperators (ArrayList list,
 993                                                     Expression source, Type target_type,
 994                                                     bool look_for_explicit,
 995                                                     MethodGroupExpr mg)
 996                 {
 997                         if (mg == null)
 998                                 return;
 999
1000                         Type source_type = source.Type;
1001                         EmptyExpression expr = EmptyExpression.Grab ();
1002
1003                         //
1004                         // LAMESPEC: Undocumented IntPtr/UIntPtr conversions
1005                         // IntPtr -> uint uses int
1006                         // UIntPtr -> long uses ulong
1007                         //
1008                         if (source_type == TypeManager.intptr_type) {
1009                                 if (target_type == TypeManager.uint32_type)
1010                                         target_type = TypeManager.int32_type;
1011                         } else if (source_type == TypeManager.uintptr_type) {
1012                                 if (target_type == TypeManager.int64_type)
1013                                         target_type = TypeManager.uint64_type;
1014                         }
1015
1016                         foreach (MethodInfo m in mg.Methods) {
1017                                 AParametersCollection pd = TypeManager.GetParameterData (m);
1018                                 Type return_type = TypeManager.TypeToCoreType (m.ReturnType);
1019                                 Type arg_type = pd.Types [0];
1020
1021                                 if (source_type != arg_type) {
1022                                         if (!ImplicitStandardConversionExists (source, arg_type)) {
1023                                                 if (!look_for_explicit)
1024                                                         continue;
1025                                                 expr.SetType (arg_type);
1026                                                 if (!ImplicitStandardConversionExists (expr, source_type))
1027                                                         continue;
1028                                         }
1029                                 }
1030
1031                                 if (target_type != return_type) {
1032                                         expr.SetType (return_type);
1033                                         if (!ImplicitStandardConversionExists (expr, target_type)) {
1034                                                 if (!look_for_explicit)
1035                                                         continue;
1036                                                 expr.SetType (target_type);
1037                                                 if (!ImplicitStandardConversionExists (expr, return_type))
1038                                                         continue;
1039                                         }
1040                                 }
1041
1042                                 // See LAMESPEC: Exclude IntPtr -> int conversion
1043                                 if (source_type == TypeManager.uintptr_type && return_type == TypeManager.uint32_type)
1044                                         continue;
1045
1046                                 list.Add (m);
1047                         }
1048
1049                         EmptyExpression.Release (expr);
1050                 }
1051
1052                 /// <summary>
1053                 ///   Compute the user-defined conversion operator from source_type to target_type.
1054                 ///   `look_for_explicit' controls whether we should also include the list of explicit operators
1055                 /// </summary>
1056                 static MethodInfo GetConversionOperator (Type container_type, Expression source, Type target_type, bool look_for_explicit)
1057                 {
1058                         ArrayList ops = new ArrayList (4);
1059
1060                         Type source_type = source.Type;
1061
1062                         if (source_type != TypeManager.decimal_type) {
1063                                 AddConversionOperators (ops, source, target_type, look_for_explicit,
1064                                         Expression.MethodLookup (container_type, source_type, "op_Implicit", Location.Null) as MethodGroupExpr);
1065                                 if (look_for_explicit) {
1066                                         AddConversionOperators (ops, source, target_type, look_for_explicit,
1067                                                 Expression.MethodLookup (
1068                                                         container_type, source_type, "op_Explicit", Location.Null) as MethodGroupExpr);
1069                                 }
1070                         }
1071
1072                         if (target_type != TypeManager.decimal_type) {
1073                                 AddConversionOperators (ops, source, target_type, look_for_explicit,
1074                                         Expression.MethodLookup (container_type, target_type, "op_Implicit", Location.Null) as MethodGroupExpr);
1075                                 if (look_for_explicit) {
1076                                         AddConversionOperators (ops, source, target_type, look_for_explicit,
1077                                                 Expression.MethodLookup (
1078                                                         container_type, target_type, "op_Explicit", Location.Null) as MethodGroupExpr);
1079                                 }
1080                         }
1081
1082                         if (ops.Count == 0)
1083                                 return null;
1084
1085                         Type most_specific_source = FindMostSpecificSource (ops, source, look_for_explicit);
1086                         if (most_specific_source == null)
1087                                 return null;
1088
1089                         Type most_specific_target = FindMostSpecificTarget (ops, target_type, look_for_explicit);
1090                         if (most_specific_target == null)
1091                                 return null;
1092
1093                         MethodInfo method = null;
1094
1095                         foreach (MethodInfo m in ops) {
1096                                 if (TypeManager.TypeToCoreType (m.ReturnType) != most_specific_target)
1097                                         continue;
1098                                 if (TypeManager.GetParameterData (m).Types [0] != most_specific_source)
1099                                         continue;
1100                                 // Ambiguous: more than one conversion operator satisfies the signature.
1101                                 if (method != null)
1102                                         return null;
1103                                 method = m;
1104                         }
1105
1106                         return method;
1107                 }
1108
1109                 /// <summary>
1110                 ///   User-defined conversions
1111                 /// </summary>
1112                 static public Expression UserDefinedConversion (EmitContext ec, Expression source,
1113                                                                 Type target, Location loc,
1114                                                                 bool look_for_explicit)
1115                 {
1116                         Type source_type = source.Type;
1117                         MethodInfo method = null;
1118
1119                         object o;
1120                         DoubleHash hash;
1121                         if (look_for_explicit) {
1122                                 hash = explicit_conv;
1123                         } else {
1124                                 // Implicit user operators cannot convert to interfaces
1125                                 if (target.IsInterface)
1126                                         return null;
1127
1128                                 hash = implicit_conv;
1129                         }
1130
1131                         if (!(source is Constant) && hash.Lookup (source_type, target, out o)) {
1132                                 method = (MethodInfo) o;
1133                         } else {
1134                                 method = GetConversionOperator (null, source, target, look_for_explicit);
1135                                 if (!(source is Constant))
1136                                         hash.Insert (source_type, target, method);
1137                         }
1138
1139                         if (method == null)
1140                                 return null;
1141
1142                         Type most_specific_source = TypeManager.GetParameterData (method).Types [0];
1143
1144                         //
1145                         // This will do the conversion to the best match that we
1146                         // found.  Now we need to perform an implict standard conversion
1147                         // if the best match was not the type that we were requested
1148                         // by target.
1149                         //
1150                         if (look_for_explicit)
1151                                 source = ExplicitConversionStandard (ec, source, most_specific_source, loc);
1152                         else
1153                                 source = ImplicitConversionStandard (ec, source, most_specific_source, loc);
1154
1155                         if (source == null)
1156                                 return null;
1157
1158                         return new UserCast (method, source, loc).DoResolve (ec);
1159                 }
1160
1161                 /// <summary>
1162                 ///   Converts implicitly the resolved expression `expr' into the
1163                 ///   `target_type'.  It returns a new expression that can be used
1164                 ///   in a context that expects a `target_type'.
1165                 /// </summary>
1166                 static public Expression ImplicitConversion (EmitContext ec, Expression expr,
1167                                                              Type target_type, Location loc)
1168                 {
1169                         Expression e;
1170
1171                         if (target_type == null)
1172                                 throw new Exception ("Target type is null");
1173
1174                         e = ImplicitConversionStandard (ec, expr, target_type, loc);
1175                         if (e != null)
1176                                 return e;
1177
1178                         e = ImplicitUserConversion (ec, expr, target_type, loc);
1179                         if (e != null)
1180                                 return e;
1181
1182                         return null;
1183                 }
1184
1185
1186                 /// <summary>
1187                 ///   Attempts to apply the `Standard Implicit
1188                 ///   Conversion' rules to the expression `expr' into
1189                 ///   the `target_type'.  It returns a new expression
1190                 ///   that can be used in a context that expects a
1191                 ///   `target_type'.
1192                 ///
1193                 ///   This is different from `ImplicitConversion' in that the
1194                 ///   user defined implicit conversions are excluded.
1195                 /// </summary>
1196                 static public Expression ImplicitConversionStandard (EmitContext ec, Expression expr,
1197                                                                      Type target_type, Location loc)
1198                 {
1199                         return ImplicitConversionStandard (ec, expr, target_type, loc, false);
1200                 }
1201
1202                 static Expression ImplicitConversionStandard (EmitContext ec, Expression expr, Type target_type, Location loc, bool explicit_cast)
1203                 {
1204                         if (expr.eclass == ExprClass.MethodGroup){
1205                                 if (!TypeManager.IsDelegateType (target_type)){
1206                                         return null;
1207                                 }
1208
1209                                 //
1210                                 // Only allow anonymous method conversions on post ISO_1
1211                                 //
1212                                 if (RootContext.Version != LanguageVersion.ISO_1){
1213                                         MethodGroupExpr mg = expr as MethodGroupExpr;
1214                                         if (mg != null)
1215                                                 return ImplicitDelegateCreation.Create (
1216                                                         ec, mg, target_type, loc);
1217                                 }
1218                         }
1219
1220                         Type expr_type = expr.Type;
1221                         Expression e;
1222
1223                         if (expr_type.Equals (target_type)) {
1224                                 if (expr_type != TypeManager.null_type && expr_type != InternalType.AnonymousMethod)
1225                                         return expr;
1226                                 return null;
1227                         }
1228
1229                         if (TypeManager.IsVariantOf (expr_type, target_type)) {
1230                                 return expr;
1231                         }
1232
1233                         if (TypeManager.IsNullableType (target_type))
1234                                 return ImplicitNulableConversion (ec, expr, target_type);
1235
1236                         //
1237                         // Attempt to do the implicit constant expression conversions
1238                         //
1239                         Constant c = expr as Constant;
1240                         if (c != null) {
1241                                 try {
1242                                         c = c.ConvertImplicitly (target_type);
1243                                 } catch {
1244                                         Console.WriteLine ("Conversion error happened in line {0}", loc);
1245                                         throw;
1246                                 }
1247                                 if (c != null)
1248                                         return c;
1249                         }
1250
1251                         e = ImplicitNumericConversion (expr, expr_type, target_type);
1252                         if (e != null)
1253                                 return e;
1254
1255                         e = ImplicitReferenceConversion (expr, target_type, explicit_cast);
1256                         if (e != null)
1257                                 return e;
1258
1259                         if (expr is IntConstant && TypeManager.IsEnumType (target_type)){
1260                                 Constant i = (Constant) expr;
1261                                 //
1262                                 // LAMESPEC: Conversion from any 0 constant is allowed
1263                                 //
1264                                 // An implicit enumeration conversion permits the decimal-integer-literal 0
1265                                 // to be converted to any enum-type and to any nullable-type whose underlying
1266                                 // type is an enum-type
1267                                 //
1268                                 if (i.IsDefaultValue)
1269                                         return new EnumConstant (i, target_type);
1270                         }
1271
1272                         if (ec.InUnsafe) {
1273                                 if (expr_type.IsPointer){
1274                                         if (target_type == TypeManager.void_ptr_type)
1275                                                 return EmptyCast.Create (expr, target_type);
1276
1277                                         //
1278                                         // yep, comparing pointer types cant be done with
1279                                         // t1 == t2, we have to compare their element types.
1280                                         //
1281                                         if (target_type.IsPointer){
1282                                                 if (TypeManager.GetElementType(target_type) == TypeManager.GetElementType(expr_type))
1283                                                         return expr;
1284
1285                                                 //return null;
1286                                         }
1287                                 }
1288
1289                                 if (expr_type == TypeManager.null_type && target_type.IsPointer)
1290                                         return EmptyCast.Create (new NullPointer (loc), target_type);
1291                         }
1292
1293                         if (expr_type == InternalType.AnonymousMethod){
1294                                 AnonymousMethodExpression ame = (AnonymousMethodExpression) expr;
1295                                 Expression am = ame.Compatible (ec, target_type);
1296                                 if (am != null)
1297                                         return am.DoResolve (ec);
1298                         }
1299
1300                         if (expr_type == InternalType.Arglist && target_type == TypeManager.arg_iterator_type)
1301                                 return expr;
1302
1303                         return null;
1304                 }
1305
1306                 /// <summary>
1307                 ///   Attempts to implicitly convert `source' into `target_type', using
1308                 ///   ImplicitConversion.  If there is no implicit conversion, then
1309                 ///   an error is signaled
1310                 /// </summary>
1311                 static public Expression ImplicitConversionRequired (EmitContext ec, Expression source,
1312                                                                      Type target_type, Location loc)
1313                 {
1314                         Expression e = ImplicitConversion (ec, source, target_type, loc);
1315                         if (e != null)
1316                                 return e;
1317
1318                         source.Error_ValueCannotBeConverted (ec, loc, target_type, false);
1319                         return null;
1320                 }
1321
1322                 /// <summary>
1323                 ///   Performs the explicit numeric conversions
1324                 ///
1325                 /// There are a few conversions that are not part of the C# standard,
1326                 /// they were interim hacks in the C# compiler that were supposed to
1327                 /// become explicit operators in the UIntPtr class and IntPtr class,
1328                 /// but for historical reasons it did not happen, so the C# compiler
1329                 /// ended up with these special hacks.
1330                 ///
1331                 /// See bug 59800 for details.
1332                 ///
1333                 /// The conversion are:
1334                 ///   UIntPtr->SByte
1335                 ///   UIntPtr->Int16
1336                 ///   UIntPtr->Int32
1337                 ///   IntPtr->UInt64
1338                 ///   UInt64->IntPtr
1339                 ///   SByte->UIntPtr
1340                 ///   Int16->UIntPtr
1341                 ///
1342                 /// </summary>
1343                 public static Expression ExplicitNumericConversion (Expression expr, Type target_type)
1344                 {
1345                         Type expr_type = expr.Type;
1346                         Type real_target_type = target_type;
1347
1348                         if (expr_type == TypeManager.sbyte_type){
1349                                 //
1350                                 // From sbyte to byte, ushort, uint, ulong, char, uintptr
1351                                 //
1352                                 if (real_target_type == TypeManager.byte_type)
1353                                         return new ConvCast (expr, target_type, ConvCast.Mode.I1_U1);
1354                                 if (real_target_type == TypeManager.ushort_type)
1355                                         return new ConvCast (expr, target_type, ConvCast.Mode.I1_U2);
1356                                 if (real_target_type == TypeManager.uint32_type)
1357                                         return new ConvCast (expr, target_type, ConvCast.Mode.I1_U4);
1358                                 if (real_target_type == TypeManager.uint64_type)
1359                                         return new ConvCast (expr, target_type, ConvCast.Mode.I1_U8);
1360                                 if (real_target_type == TypeManager.char_type)
1361                                         return new ConvCast (expr, target_type, ConvCast.Mode.I1_CH);
1362
1363                                 // One of the built-in conversions that belonged in the class library
1364                                 if (real_target_type == TypeManager.uintptr_type){
1365                                         Expression u8e = new ConvCast (expr, TypeManager.uint64_type, ConvCast.Mode.I1_U8);
1366
1367                                         return new OperatorCast (u8e, TypeManager.uintptr_type, true);
1368                                 }
1369                         } else if (expr_type == TypeManager.byte_type){
1370                                 //
1371                                 // From byte to sbyte and char
1372                                 //
1373                                 if (real_target_type == TypeManager.sbyte_type)
1374                                         return new ConvCast (expr, target_type, ConvCast.Mode.U1_I1);
1375                                 if (real_target_type == TypeManager.char_type)
1376                                         return new ConvCast (expr, target_type, ConvCast.Mode.U1_CH);
1377                         } else if (expr_type == TypeManager.short_type){
1378                                 //
1379                                 // From short to sbyte, byte, ushort, uint, ulong, char, uintptr
1380                                 //
1381                                 if (real_target_type == TypeManager.sbyte_type)
1382                                         return new ConvCast (expr, target_type, ConvCast.Mode.I2_I1);
1383                                 if (real_target_type == TypeManager.byte_type)
1384                                         return new ConvCast (expr, target_type, ConvCast.Mode.I2_U1);
1385                                 if (real_target_type == TypeManager.ushort_type)
1386                                         return new ConvCast (expr, target_type, ConvCast.Mode.I2_U2);
1387                                 if (real_target_type == TypeManager.uint32_type)
1388                                         return new ConvCast (expr, target_type, ConvCast.Mode.I2_U4);
1389                                 if (real_target_type == TypeManager.uint64_type)
1390                                         return new ConvCast (expr, target_type, ConvCast.Mode.I2_U8);
1391                                 if (real_target_type == TypeManager.char_type)
1392                                         return new ConvCast (expr, target_type, ConvCast.Mode.I2_CH);
1393
1394                                 // One of the built-in conversions that belonged in the class library
1395                                 if (real_target_type == TypeManager.uintptr_type){
1396                                         Expression u8e = new ConvCast (expr, TypeManager.uint64_type, ConvCast.Mode.I2_U8);
1397
1398                                         return new OperatorCast (u8e, TypeManager.uintptr_type, true);
1399                                 }
1400                         } else if (expr_type == TypeManager.ushort_type){
1401                                 //
1402                                 // From ushort to sbyte, byte, short, char
1403                                 //
1404                                 if (real_target_type == TypeManager.sbyte_type)
1405                                         return new ConvCast (expr, target_type, ConvCast.Mode.U2_I1);
1406                                 if (real_target_type == TypeManager.byte_type)
1407                                         return new ConvCast (expr, target_type, ConvCast.Mode.U2_U1);
1408                                 if (real_target_type == TypeManager.short_type)
1409                                         return new ConvCast (expr, target_type, ConvCast.Mode.U2_I2);
1410                                 if (real_target_type == TypeManager.char_type)
1411                                         return new ConvCast (expr, target_type, ConvCast.Mode.U2_CH);
1412                         } else if (expr_type == TypeManager.int32_type){
1413                                 //
1414                                 // From int to sbyte, byte, short, ushort, uint, ulong, char, uintptr
1415                                 //
1416                                 if (real_target_type == TypeManager.sbyte_type)
1417                                         return new ConvCast (expr, target_type, ConvCast.Mode.I4_I1);
1418                                 if (real_target_type == TypeManager.byte_type)
1419                                         return new ConvCast (expr, target_type, ConvCast.Mode.I4_U1);
1420                                 if (real_target_type == TypeManager.short_type)
1421                                         return new ConvCast (expr, target_type, ConvCast.Mode.I4_I2);
1422                                 if (real_target_type == TypeManager.ushort_type)
1423                                         return new ConvCast (expr, target_type, ConvCast.Mode.I4_U2);
1424                                 if (real_target_type == TypeManager.uint32_type)
1425                                         return new ConvCast (expr, target_type, ConvCast.Mode.I4_U4);
1426                                 if (real_target_type == TypeManager.uint64_type)
1427                                         return new ConvCast (expr, target_type, ConvCast.Mode.I4_U8);
1428                                 if (real_target_type == TypeManager.char_type)
1429                                         return new ConvCast (expr, target_type, ConvCast.Mode.I4_CH);
1430
1431                                 // One of the built-in conversions that belonged in the class library
1432                                 if (real_target_type == TypeManager.uintptr_type){
1433                                         Expression u8e = new ConvCast (expr, TypeManager.uint64_type, ConvCast.Mode.I2_U8);
1434
1435                                         return new OperatorCast (u8e, TypeManager.uintptr_type, true);
1436                                 }
1437                         } else if (expr_type == TypeManager.uint32_type){
1438                                 //
1439                                 // From uint to sbyte, byte, short, ushort, int, char
1440                                 //
1441                                 if (real_target_type == TypeManager.sbyte_type)
1442                                         return new ConvCast (expr, target_type, ConvCast.Mode.U4_I1);
1443                                 if (real_target_type == TypeManager.byte_type)
1444                                         return new ConvCast (expr, target_type, ConvCast.Mode.U4_U1);
1445                                 if (real_target_type == TypeManager.short_type)
1446                                         return new ConvCast (expr, target_type, ConvCast.Mode.U4_I2);
1447                                 if (real_target_type == TypeManager.ushort_type)
1448                                         return new ConvCast (expr, target_type, ConvCast.Mode.U4_U2);
1449                                 if (real_target_type == TypeManager.int32_type)
1450                                         return new ConvCast (expr, target_type, ConvCast.Mode.U4_I4);
1451                                 if (real_target_type == TypeManager.char_type)
1452                                         return new ConvCast (expr, target_type, ConvCast.Mode.U4_CH);
1453                         } else if (expr_type == TypeManager.int64_type){
1454                                 //
1455                                 // From long to sbyte, byte, short, ushort, int, uint, ulong, char
1456                                 //
1457                                 if (real_target_type == TypeManager.sbyte_type)
1458                                         return new ConvCast (expr, target_type, ConvCast.Mode.I8_I1);
1459                                 if (real_target_type == TypeManager.byte_type)
1460                                         return new ConvCast (expr, target_type, ConvCast.Mode.I8_U1);
1461                                 if (real_target_type == TypeManager.short_type)
1462                                         return new ConvCast (expr, target_type, ConvCast.Mode.I8_I2);
1463                                 if (real_target_type == TypeManager.ushort_type)
1464                                         return new ConvCast (expr, target_type, ConvCast.Mode.I8_U2);
1465                                 if (real_target_type == TypeManager.int32_type)
1466                                         return new ConvCast (expr, target_type, ConvCast.Mode.I8_I4);
1467                                 if (real_target_type == TypeManager.uint32_type)
1468                                         return new ConvCast (expr, target_type, ConvCast.Mode.I8_U4);
1469                                 if (real_target_type == TypeManager.uint64_type)
1470                                         return new ConvCast (expr, target_type, ConvCast.Mode.I8_U8);
1471                                 if (real_target_type == TypeManager.char_type)
1472                                         return new ConvCast (expr, target_type, ConvCast.Mode.I8_CH);
1473                         } else if (expr_type == TypeManager.uint64_type){
1474                                 //
1475                                 // From ulong to sbyte, byte, short, ushort, int, uint, long, char
1476                                 //
1477                                 if (real_target_type == TypeManager.sbyte_type)
1478                                         return new ConvCast (expr, target_type, ConvCast.Mode.U8_I1);
1479                                 if (real_target_type == TypeManager.byte_type)
1480                                         return new ConvCast (expr, target_type, ConvCast.Mode.U8_U1);
1481                                 if (real_target_type == TypeManager.short_type)
1482                                         return new ConvCast (expr, target_type, ConvCast.Mode.U8_I2);
1483                                 if (real_target_type == TypeManager.ushort_type)
1484                                         return new ConvCast (expr, target_type, ConvCast.Mode.U8_U2);
1485                                 if (real_target_type == TypeManager.int32_type)
1486                                         return new ConvCast (expr, target_type, ConvCast.Mode.U8_I4);
1487                                 if (real_target_type == TypeManager.uint32_type)
1488                                         return new ConvCast (expr, target_type, ConvCast.Mode.U8_U4);
1489                                 if (real_target_type == TypeManager.int64_type)
1490                                         return new ConvCast (expr, target_type, ConvCast.Mode.U8_I8);
1491                                 if (real_target_type == TypeManager.char_type)
1492                                         return new ConvCast (expr, target_type, ConvCast.Mode.U8_CH);
1493
1494                                 // One of the built-in conversions that belonged in the class library
1495                                 if (real_target_type == TypeManager.intptr_type){
1496                                         return new OperatorCast (EmptyCast.Create (expr, TypeManager.int64_type),
1497                                                                  TypeManager.intptr_type, true);
1498                                 }
1499                         } else if (expr_type == TypeManager.char_type){
1500                                 //
1501                                 // From char to sbyte, byte, short
1502                                 //
1503                                 if (real_target_type == TypeManager.sbyte_type)
1504                                         return new ConvCast (expr, target_type, ConvCast.Mode.CH_I1);
1505                                 if (real_target_type == TypeManager.byte_type)
1506                                         return new ConvCast (expr, target_type, ConvCast.Mode.CH_U1);
1507                                 if (real_target_type == TypeManager.short_type)
1508                                         return new ConvCast (expr, target_type, ConvCast.Mode.CH_I2);
1509                         } else if (expr_type == TypeManager.float_type){
1510                                 //
1511                                 // From float to sbyte, byte, short,
1512                                 // ushort, int, uint, long, ulong, char
1513                                 // or decimal
1514                                 //
1515                                 if (real_target_type == TypeManager.sbyte_type)
1516                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_I1);
1517                                 if (real_target_type == TypeManager.byte_type)
1518                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_U1);
1519                                 if (real_target_type == TypeManager.short_type)
1520                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_I2);
1521                                 if (real_target_type == TypeManager.ushort_type)
1522                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_U2);
1523                                 if (real_target_type == TypeManager.int32_type)
1524                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_I4);
1525                                 if (real_target_type == TypeManager.uint32_type)
1526                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_U4);
1527                                 if (real_target_type == TypeManager.int64_type)
1528                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_I8);
1529                                 if (real_target_type == TypeManager.uint64_type)
1530                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_U8);
1531                                 if (real_target_type == TypeManager.char_type)
1532                                         return new ConvCast (expr, target_type, ConvCast.Mode.R4_CH);
1533                                 if (real_target_type == TypeManager.decimal_type)
1534                                         return new CastToDecimal (expr, true);
1535                         } else if (expr_type == TypeManager.double_type){
1536                                 //
1537                                 // From double to sbyte, byte, short,
1538                                 // ushort, int, uint, long, ulong,
1539                                 // char, float or decimal
1540                                 //
1541                                 if (real_target_type == TypeManager.sbyte_type)
1542                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_I1);
1543                                 if (real_target_type == TypeManager.byte_type)
1544                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_U1);
1545                                 if (real_target_type == TypeManager.short_type)
1546                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_I2);
1547                                 if (real_target_type == TypeManager.ushort_type)
1548                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_U2);
1549                                 if (real_target_type == TypeManager.int32_type)
1550                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_I4);
1551                                 if (real_target_type == TypeManager.uint32_type)
1552                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_U4);
1553                                 if (real_target_type == TypeManager.int64_type)
1554                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_I8);
1555                                 if (real_target_type == TypeManager.uint64_type)
1556                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_U8);
1557                                 if (real_target_type == TypeManager.char_type)
1558                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_CH);
1559                                 if (real_target_type == TypeManager.float_type)
1560                                         return new ConvCast (expr, target_type, ConvCast.Mode.R8_R4);
1561                                 if (real_target_type == TypeManager.decimal_type)
1562                                         return new CastToDecimal (expr, true);
1563                         } else if (expr_type == TypeManager.uintptr_type){
1564                                 //
1565                                 // Various built-in conversions that belonged in the class library
1566                                 //
1567                                 // from uintptr to sbyte, short, int32
1568                                 //
1569                                 if (real_target_type == TypeManager.sbyte_type){
1570                                         Expression uint32e = new OperatorCast (expr, TypeManager.uint32_type, true);
1571                                         return new ConvCast (uint32e, TypeManager.sbyte_type, ConvCast.Mode.U4_I1);
1572                                 }
1573                                 if (real_target_type == TypeManager.short_type){
1574                                         Expression uint32e = new OperatorCast (expr, TypeManager.uint32_type, true);
1575                                         return new ConvCast (uint32e, TypeManager.sbyte_type, ConvCast.Mode.U4_I2);
1576                                 }
1577                                 if (real_target_type == TypeManager.int32_type){
1578                                         return EmptyCast.Create (new OperatorCast (expr, TypeManager.uint32_type, true),
1579                                                               TypeManager.int32_type);
1580                                 }
1581                         } else if (expr_type == TypeManager.intptr_type){
1582                                 if (real_target_type == TypeManager.uint64_type){
1583                                         return EmptyCast.Create (new OperatorCast (expr, TypeManager.int64_type, true),
1584                                                               TypeManager.uint64_type);
1585                                 }
1586                         } else if (expr_type == TypeManager.decimal_type) {
1587                                 return new CastFromDecimal (expr, target_type).Resolve ();
1588                         }
1589                         return null;
1590                 }
1591
1592                 /// <summary>
1593                 ///  Returns whether an explicit reference conversion can be performed
1594                 ///  from source_type to target_type
1595                 /// </summary>
1596                 public static bool ExplicitReferenceConversionExists (Type source_type, Type target_type)
1597                 {
1598                         Expression e = ExplicitReferenceConversion (null, source_type, target_type);
1599                         if (e == null)
1600                                 return false;
1601
1602                         if (e == EmptyExpression.Null)
1603                                 return true;
1604
1605                         throw new InternalErrorException ("Invalid probing conversion result");
1606                 }
1607
1608                 /// <summary>
1609                 ///   Implements Explicit Reference conversions
1610                 /// </summary>
1611                 static Expression ExplicitReferenceConversion (Expression source, Type source_type, Type target_type)
1612                 {
1613                         bool target_is_value_type = TypeManager.IsStruct (target_type);
1614
1615                         //
1616                         // From object to a generic parameter
1617                         //
1618                         if (source_type == TypeManager.object_type && TypeManager.IsGenericParameter (target_type))
1619                                 return source == null ? EmptyExpression.Null : new UnboxCast (source, target_type);
1620
1621                         //
1622                         // Explicit type parameter conversion.
1623                         //
1624                         if (TypeManager.IsGenericParameter (source_type))
1625                                 return ExplicitTypeParameterConversion (source, source_type, target_type);
1626
1627                         //
1628                         // From object to any reference type or value type (unboxing)
1629                         //
1630                         if (source_type == TypeManager.object_type)
1631                                 return source == null ? EmptyExpression.Null :
1632                                         target_is_value_type ? (Expression) new UnboxCast (source, target_type) : new ClassCast (source, target_type);
1633
1634                         //
1635                         // Unboxing conversion from the types object and System.ValueType to any non-nullable-value-type
1636                         //
1637                         if (source_type == TypeManager.value_type && target_is_value_type)
1638                                 return source == null ? EmptyExpression.Null : new UnboxCast (source, target_type);
1639
1640                         //
1641                         // From any class S to any class-type T, provided S is a base class of T
1642                         //
1643                         if (TypeManager.IsSubclassOf (target_type, source_type))
1644                                 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1645
1646                         //
1647                         // From any class type S to any interface T, provides S is not sealed
1648                         // and provided S does not implement T.
1649                         //
1650                         if (target_type.IsInterface && !source_type.IsSealed &&
1651                                 !TypeManager.ImplementsInterface (source_type, target_type)) {
1652                                 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1653                         }
1654
1655                         //
1656                         // From any interface-type S to to any class type T, provided T is not
1657                         // sealed, or provided T implements S.
1658                         //
1659                         if (source_type.IsInterface) {
1660                                 if (!target_type.IsSealed || TypeManager.ImplementsInterface (target_type, source_type)) {
1661                                         if (target_type.IsClass)
1662                                                 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1663
1664                                         //
1665                                         // Unboxing conversion from any interface-type to any non-nullable-value-type that
1666                                         // implements the interface-type
1667                                         //
1668                                         return source == null ? EmptyExpression.Null : new UnboxCast (source, target_type);
1669                                 }
1670
1671                                 //
1672                                 // From System.Collecitons.Generic.IList<T> and its base interfaces to a one-dimensional
1673                                 // array type S[], provided there is an implicit or explicit reference conversion from S to T.
1674                                 //
1675                                 if (IList_To_Array (source_type, target_type))
1676                                         return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1677
1678                                 return null;
1679                         }
1680
1681                         if (source_type.IsArray) {
1682                                 if (target_type.IsArray) {
1683                                         //
1684                                         // From System.Array to any array-type
1685                                         //
1686                                         if (source_type == TypeManager.array_type)
1687                                                 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1688
1689                                         //
1690                                         // From an array type S with an element type Se to an array type T with an
1691                                         // element type Te provided all the following are true:
1692                                         //     * S and T differe only in element type, in other words, S and T
1693                                         //       have the same number of dimensions.
1694                                         //     * Both Se and Te are reference types
1695                                         //     * An explicit reference conversions exist from Se to Te
1696                                         //
1697                                         if (source_type.GetArrayRank () == target_type.GetArrayRank ()) {
1698
1699                                                 source_type = TypeManager.GetElementType (source_type);
1700                                                 if (!TypeManager.IsReferenceType (source_type))
1701                                                         return null;
1702
1703                                                 Type target_type_element = TypeManager.GetElementType (target_type);
1704                                                 if (!TypeManager.IsReferenceType (target_type_element))
1705                                                         return null;
1706
1707                                                 if (ExplicitReferenceConversionExists (source_type, target_type_element))
1708                                                         return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1709
1710                                                 return null;
1711                                         }
1712                                 }
1713
1714                                 //
1715                                 // From a single-dimensional array type S[] to System.Collections.Generic.IList<T> and its base interfaces,
1716                                 // provided that there is an explicit reference conversion from S to T
1717                                 //
1718                                 if (Array_To_IList (source_type, target_type, true))
1719                                         return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1720
1721                                 return null;
1722                         }
1723
1724                         //
1725                         // From System delegate to any delegate-type
1726                         //
1727                         if (source_type == TypeManager.delegate_type && TypeManager.IsDelegateType (target_type))
1728                                 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1729
1730                         return null;
1731                 }
1732
1733                 /// <summary>
1734                 ///   Performs an explicit conversion of the expression `expr' whose
1735                 ///   type is expr.Type to `target_type'.
1736                 /// </summary>
1737                 static public Expression ExplicitConversionCore (EmitContext ec, Expression expr,
1738                                                                  Type target_type, Location loc)
1739                 {
1740                         Type expr_type = expr.Type;
1741
1742                         // Explicit conversion includes implicit conversion and it used for enum underlying types too
1743                         Expression ne = ImplicitConversionStandard (ec, expr, target_type, loc, true);
1744                         if (ne != null)
1745                                 return ne;
1746
1747                         if (TypeManager.IsEnumType (expr_type)) {
1748                                 Expression underlying = EmptyCast.Create (expr, TypeManager.GetEnumUnderlyingType (expr_type));
1749                                 expr = ExplicitConversionCore (ec, underlying, target_type, loc);
1750                                 if (expr != null)
1751                                         return expr;
1752
1753                                 return ExplicitUserConversion (ec, underlying, target_type, loc);
1754                         }
1755
1756                         if (TypeManager.IsEnumType (target_type)){
1757                                 //
1758                                 // Type System.Enum can be unboxed to any enum-type
1759                                 //
1760                                 if (expr_type == TypeManager.enum_type)
1761                                         return new UnboxCast (expr, target_type);
1762
1763                                 Expression ce = ExplicitConversionCore (ec, expr, TypeManager.GetEnumUnderlyingType (target_type), loc);
1764                                 if (ce != null)
1765                                         return EmptyCast.Create (ce, target_type);
1766
1767                                 //
1768                                 // LAMESPEC: IntPtr and UIntPtr conversion to any Enum is allowed
1769                                 //
1770                                 if (expr_type == TypeManager.intptr_type || expr_type == TypeManager.uintptr_type) {
1771                                         ne = ExplicitUserConversion (ec, expr, TypeManager.GetEnumUnderlyingType (target_type), loc);
1772                                         if (ne != null)
1773                                                 return ExplicitConversionCore (ec, ne, target_type, loc);
1774                                 }
1775
1776                                 return null;
1777                         }
1778
1779                         ne = ExplicitNumericConversion (expr, target_type);
1780                         if (ne != null)
1781                                 return ne;
1782
1783                         //
1784                         // Skip the ExplicitReferenceConversion because we can not convert
1785                         // from Null to a ValueType, and ExplicitReference wont check against
1786                         // null literal explicitly
1787                         //
1788                         if (expr_type != TypeManager.null_type){
1789                                 ne = ExplicitReferenceConversion (expr, expr_type, target_type);
1790                                 if (ne != null)
1791                                         return ne;
1792                         }
1793
1794                         if (ec.InUnsafe){
1795                                 ne = ExplicitUnsafe (expr, target_type);
1796                                 if (ne != null)
1797                                         return ne;
1798                         }
1799
1800                         return null;
1801                 }
1802
1803                 public static Expression ExplicitUnsafe (Expression expr, Type target_type)
1804                 {
1805                         Type expr_type = expr.Type;
1806
1807                         if (target_type.IsPointer){
1808                                 if (expr_type.IsPointer)
1809                                         return EmptyCast.Create (expr, target_type);
1810
1811                                 if (expr_type == TypeManager.sbyte_type ||
1812                                         expr_type == TypeManager.short_type ||
1813                                         expr_type == TypeManager.int32_type)
1814                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_I);
1815
1816                                 if (expr_type == TypeManager.ushort_type ||
1817                                         expr_type == TypeManager.uint32_type ||
1818                                         expr_type == TypeManager.uint64_type || expr_type == TypeManager.int64_type ||
1819                                         expr_type == TypeManager.byte_type)
1820                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_U);
1821                         }
1822
1823                         if (expr_type.IsPointer){
1824                                 if (target_type == TypeManager.sbyte_type)
1825                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1826                                 else if (target_type == TypeManager.byte_type)
1827                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1828                                 else if (target_type == TypeManager.short_type)
1829                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1830                                 else if (target_type == TypeManager.ushort_type)
1831                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1832                                 else if (target_type == TypeManager.int32_type)
1833                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
1834                                 else if (target_type == TypeManager.uint32_type)
1835                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
1836                                 else if (target_type == TypeManager.uint64_type || target_type == TypeManager.int64_type)
1837                                         return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
1838                         }
1839                         return null;
1840                 }
1841
1842                 /// <summary>
1843                 ///   Same as ExplicitConversion, only it doesn't include user defined conversions
1844                 /// </summary>
1845                 static public Expression ExplicitConversionStandard (EmitContext ec, Expression expr,
1846                                                                      Type target_type, Location l)
1847                 {
1848                         int errors = Report.Errors;
1849                         Expression ne = ImplicitConversionStandard (ec, expr, target_type, l);
1850                         if (Report.Errors > errors)
1851                                 return null;
1852
1853                         if (ne != null)
1854                                 return ne;
1855
1856                         ne = ExplicitNumericConversion (expr, target_type);
1857                         if (ne != null)
1858                                 return ne;
1859
1860                         ne = ExplicitReferenceConversion (expr, expr.Type, target_type);
1861                         if (ne != null)
1862                                 return ne;
1863
1864                         if (ec.InUnsafe && expr.Type == TypeManager.void_ptr_type && target_type.IsPointer)
1865                                 return EmptyCast.Create (expr, target_type);
1866
1867                         expr.Error_ValueCannotBeConverted (ec, l, target_type, true);
1868                         return null;
1869                 }
1870
1871                 /// <summary>
1872                 ///   Performs an explicit conversion of the expression `expr' whose
1873                 ///   type is expr.Type to `target_type'.
1874                 /// </summary>
1875                 static public Expression ExplicitConversion (EmitContext ec, Expression expr,
1876                         Type target_type, Location loc)
1877                 {
1878                         Expression e = ExplicitConversionCore (ec, expr, target_type, loc);
1879                         if (e != null)
1880                                 return e;
1881
1882                         Type expr_type = expr.Type;
1883                         if (TypeManager.IsNullableType (target_type)) {
1884                                 if (TypeManager.IsNullableType (expr_type)) {
1885                                         Type target = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (target_type)[0]);
1886                                         Expression unwrap = Nullable.Unwrap.Create (expr);
1887                                         e = ExplicitConversion (ec, unwrap, target, expr.Location);
1888                                         if (e == null)
1889                                                 return null;
1890
1891                                         return new Nullable.Lifted (e, unwrap, target_type).Resolve (ec);
1892                                 } else if (expr_type == TypeManager.object_type) {
1893                                         return new UnboxCast (expr, target_type);
1894                                 } else {
1895                                         Type target = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (target_type) [0]);
1896
1897                                         e = ExplicitConversionCore (ec, expr, target, loc);
1898                                         if (e != null)
1899                                                 return Nullable.Wrap.Create (e, target_type);
1900                                 }
1901                         } else if (TypeManager.IsNullableType (expr_type)) {
1902                                 e = Nullable.Unwrap.Create (expr, false);
1903
1904                                 bool use_class_cast;
1905                                 if (ImplicitBoxingConversionExists (e, target_type, out use_class_cast))
1906                                         return new BoxedCast (expr, target_type);
1907
1908                                 e = ExplicitConversion (ec, e, target_type, loc);
1909                                 if (e != null)
1910                                         e = EmptyCast.Create (e, target_type);
1911                                 return e;
1912                         }
1913
1914                         e = ExplicitUserConversion (ec, expr, target_type, loc);
1915                         if (e != null)
1916                                 return e;
1917
1918                         expr.Error_ValueCannotBeConverted (ec, loc, target_type, true);
1919                         return null;
1920                 }
1921         }
1922 }