?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-09-04 Zoltan Varga <vargaz@gmail.com>
[mcs.git] / mcs / convert.cs
blobd9c903690fdbb60222d469c0cb56f1d603834df4
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 (ResolveContext 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 (ResolveContext 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 (ResolveContext 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 (ResolveContext 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 (ResolveContext 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 (ResolveContext 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 (ResolveContext 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 (ResolveContext 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 (ResolveContext 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.IsUnsafe) {
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 (ResolveContext 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 (ResolveContext 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.IsUnsafe){
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 (ResolveContext 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.IsUnsafe && 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 (ResolveContext 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 }
git-svn mirror of mcs