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