?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-11-24 Jb Evain <jbevain@novell.com>
[mcs.git] / mcs / convert.cs
blobbfe3b71bb0e09605944d5b2f2d1d52044f47077c
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 (null, 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 // S -> T?
467 Type t_el = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (target_type)[0]);
468
469 // S? -> T?
470 if (TypeManager.IsNullableType (expr_type))
471 expr_type = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (expr_type)[0]);
472
473 //
474 // Predefined implicit identity or implicit numeric conversion
475 // has to exist between underlying type S and underlying type T
476 //
477
478 // Handles probing
479 if (ec == null) {
480 if (expr_type == t_el)
481 return EmptyExpression.Null;
482
483 return ImplicitNumericConversion (null, expr_type, t_el);
484 }
485
486 Expression unwrap;
487 if (expr_type != expr.Type)
488 unwrap = Nullable.Unwrap.Create (expr);
489 else
490 unwrap = expr;
491
492 Expression conv = expr_type == t_el ? unwrap : ImplicitNumericConversion (unwrap, expr_type, t_el);
493 if (conv == null)
494 return null;
495
496 if (expr_type != expr.Type)
497 return new Nullable.Lifted (conv, unwrap, target_type).Resolve (ec);
498
499 // Do constant optimization for S -> T?
500 if (unwrap is Constant)
501 conv = ((Constant) unwrap).ConvertImplicitly (ec, t_el);
502
503 return Nullable.Wrap.Create (conv, target_type);
504 }
505
506 /// <summary>
507 /// Implicit Numeric Conversions.
508 ///
509 /// expr is the expression to convert, returns a new expression of type
510 /// target_type or null if an implicit conversion is not possible.
511 /// </summary>
512 public static Expression ImplicitNumericConversion (Expression expr, Type target_type)
513 {
514 return ImplicitNumericConversion (expr, expr.Type, target_type);
515 }
516
517 static Expression ImplicitNumericConversion (Expression expr, Type expr_type, Type target_type)
518 {
519 if (expr_type == TypeManager.sbyte_type){
520 //
521 // From sbyte to short, int, long, float, double, decimal
522 //
523 if (target_type == TypeManager.int32_type)
524 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
525 if (target_type == TypeManager.int64_type)
526 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
527 if (target_type == TypeManager.double_type)
528 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
529 if (target_type == TypeManager.float_type)
530 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
531 if (target_type == TypeManager.short_type)
532 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
533 if (target_type == TypeManager.decimal_type)
534 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
535 } else if (expr_type == TypeManager.byte_type){
536 //
537 // From byte to short, ushort, int, uint, long, ulong, float, double, decimal
538 //
539 if (target_type == TypeManager.int32_type || target_type == TypeManager.uint32_type ||
540 target_type == TypeManager.short_type || target_type == TypeManager.ushort_type)
541 return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
542
543 if (target_type == TypeManager.uint64_type)
544 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
545 if (target_type == TypeManager.int64_type)
546 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
547 if (target_type == TypeManager.float_type)
548 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
549 if (target_type == TypeManager.double_type)
550 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
551 if (target_type == TypeManager.decimal_type)
552 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
553
554 } else if (expr_type == TypeManager.short_type){
555 //
556 // From short to int, long, float, double, decimal
557 //
558 if (target_type == TypeManager.int32_type)
559 return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
560 if (target_type == TypeManager.int64_type)
561 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
562 if (target_type == TypeManager.double_type)
563 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
564 if (target_type == TypeManager.float_type)
565 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
566 if (target_type == TypeManager.decimal_type)
567 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
568
569 } else if (expr_type == TypeManager.ushort_type){
570 //
571 // From ushort to int, uint, long, ulong, float, double, decimal
572 //
573 if (target_type == TypeManager.int32_type || target_type == TypeManager.uint32_type)
574 return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
575
576 if (target_type == TypeManager.uint64_type)
577 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
578 if (target_type == TypeManager.int64_type)
579 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
580 if (target_type == TypeManager.double_type)
581 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
582 if (target_type == TypeManager.float_type)
583 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
584 if (target_type == TypeManager.decimal_type)
585 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
586 } else if (expr_type == TypeManager.int32_type){
587 //
588 // From int to long, float, double, decimal
589 //
590 if (target_type == TypeManager.int64_type)
591 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
592 if (target_type == TypeManager.double_type)
593 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
594 if (target_type == TypeManager.float_type)
595 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
596 if (target_type == TypeManager.decimal_type)
597 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
598 } else if (expr_type == TypeManager.uint32_type){
599 //
600 // From uint to long, ulong, float, double, decimal
601 //
602 if (target_type == TypeManager.int64_type)
603 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
604 if (target_type == TypeManager.uint64_type)
605 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
606 if (target_type == TypeManager.double_type)
607 return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R8);
608 if (target_type == TypeManager.float_type)
609 return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R4);
610 if (target_type == TypeManager.decimal_type)
611 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
612 } else if (expr_type == TypeManager.int64_type){
613 //
614 // From long/ulong to float, double
615 //
616 if (target_type == TypeManager.double_type)
617 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
618 if (target_type == TypeManager.float_type)
619 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
620 if (target_type == TypeManager.decimal_type)
621 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
622 } else if (expr_type == TypeManager.uint64_type){
623 //
624 // From ulong to float, double
625 //
626 if (target_type == TypeManager.double_type)
627 return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R8);
628 if (target_type == TypeManager.float_type)
629 return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R4);
630 if (target_type == TypeManager.decimal_type)
631 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
632 } else if (expr_type == TypeManager.char_type){
633 //
634 // From char to ushort, int, uint, long, ulong, float, double, decimal
635 //
636 if ((target_type == TypeManager.ushort_type) ||
637 (target_type == TypeManager.int32_type) ||
638 (target_type == TypeManager.uint32_type))
639 return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
640 if (target_type == TypeManager.uint64_type)
641 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
642 if (target_type == TypeManager.int64_type)
643 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
644 if (target_type == TypeManager.float_type)
645 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
646 if (target_type == TypeManager.double_type)
647 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
648 if (target_type == TypeManager.decimal_type)
649 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
650 } else if (expr_type == TypeManager.float_type){
651 //
652 // float to double
653 //
654 if (target_type == TypeManager.double_type)
655 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
656 }
657
658 return null;
659 }
660
661 /// <summary>
662 /// Same as ImplicitStandardConversionExists except that it also looks at
663 /// implicit user defined conversions - needed for overload resolution
664 /// </summary>
665 public static bool ImplicitConversionExists (ResolveContext ec, Expression expr, Type target_type)
666 {
667 if (ImplicitStandardConversionExists (expr, target_type))
668 return true;
669
670 if (expr.Type == InternalType.AnonymousMethod) {
671 if (!TypeManager.IsDelegateType (target_type) &&
672 TypeManager.DropGenericTypeArguments (target_type) != TypeManager.expression_type)
673 return false;
674
675 AnonymousMethodExpression ame = (AnonymousMethodExpression) expr;
676 return ame.ImplicitStandardConversionExists (ec, target_type);
677 }
678
679 if (expr.eclass == ExprClass.MethodGroup) {
680 if (TypeManager.IsDelegateType (target_type) && RootContext.Version != LanguageVersion.ISO_1) {
681 MethodGroupExpr mg = expr as MethodGroupExpr;
682 if (mg != null)
683 return DelegateCreation.ImplicitStandardConversionExists (ec, mg, target_type);
684 }
685
686 return false;
687 }
688
689 return ImplicitUserConversion (ec, expr, target_type, Location.Null) != null;
690 }
691
692 /// <summary>
693 /// Determines if a standard implicit conversion exists from
694 /// expr_type to target_type
695 ///
696 /// ec should point to a real EmitContext if expr.Type is TypeManager.anonymous_method_type.
697 /// </summary>
698 public static bool ImplicitStandardConversionExists (Expression expr, Type target_type)
699 {
700 Type expr_type = expr.Type;
701
702 if (expr_type == TypeManager.null_type) {
703 NullLiteral nl = expr as NullLiteral;
704 if (nl != null)
705 return nl.ConvertImplicitly (null, target_type) != null;
706 }
707
708 if (expr_type == TypeManager.void_type)
709 return false;
710
711 if (TypeManager.IsEqual (expr_type, target_type))
712 return true;
713
714 if (TypeManager.IsNullableType (target_type)) {
715 return ImplicitNulableConversion (null, expr, target_type) != null;
716 }
717
718 // First numeric conversions
719 if (ImplicitNumericConversion (null, expr_type, target_type) != null)
720 return true;
721
722 if (ImplicitReferenceConversionExists (expr, target_type))
723 return true;
724
725 bool use_class_cast;
726 if (ImplicitBoxingConversionExists (expr, target_type, out use_class_cast))
727 return true;
728
729 //
730 // Implicit Constant Expression Conversions
731 //
732 if (expr is IntConstant){
733 int value = ((IntConstant) expr).Value;
734
735 if (target_type == TypeManager.sbyte_type){
736 if (value >= SByte.MinValue && value <= SByte.MaxValue)
737 return true;
738 } else if (target_type == TypeManager.byte_type){
739 if (value >= 0 && value <= Byte.MaxValue)
740 return true;
741 } else if (target_type == TypeManager.short_type){
742 if (value >= Int16.MinValue && value <= Int16.MaxValue)
743 return true;
744 } else if (target_type == TypeManager.ushort_type){
745 if (value >= UInt16.MinValue && value <= UInt16.MaxValue)
746 return true;
747 } else if (target_type == TypeManager.uint32_type){
748 if (value >= 0)
749 return true;
750 } else if (target_type == TypeManager.uint64_type){
751 //
752 // we can optimize this case: a positive int32
753 // always fits on a uint64. But we need an opcode
754 // to do it.
755 //
756 if (value >= 0)
757 return true;
758 }
759
760 if (value == 0 && TypeManager.IsEnumType (target_type))
761 return true;
762 }
763
764 if (expr is LongConstant && target_type == TypeManager.uint64_type){
765 //
766 // Try the implicit constant expression conversion
767 // from long to ulong, instead of a nice routine,
768 // we just inline it
769 //
770 long v = ((LongConstant) expr).Value;
771 if (v >= 0)
772 return true;
773 }
774
775 //
776 // If `expr_type' implements `target_type' (which is an iface)
777 // see TryImplicitIntConversion
778 //
779 if (target_type.IsInterface && TypeManager.ImplementsInterface (expr_type, target_type))
780 return true;
781
782 if (target_type == TypeManager.void_ptr_type && expr_type.IsPointer)
783 return true;
784
785 // Conversion from __arglist to System.ArgIterator
786 if (expr_type == InternalType.Arglist)
787 return target_type == TypeManager.arg_iterator_type;
788
789 return false;
790 }
791
792 /// <summary>
793 /// Finds "most encompassed type" according to the spec (13.4.2)
794 /// amongst the methods in the MethodGroupExpr
795 /// </summary>
796 static Type FindMostEncompassedType (ArrayList types)
797 {
798 Type best = null;
799
800 if (types.Count == 0)
801 return null;
802
803 if (types.Count == 1)
804 return (Type) types [0];
805
806 EmptyExpression expr = EmptyExpression.Grab ();
807
808 foreach (Type t in types) {
809 if (best == null) {
810 best = t;
811 continue;
812 }
813
814 expr.SetType (t);
815 if (ImplicitStandardConversionExists (expr, best))
816 best = t;
817 }
818
819 expr.SetType (best);
820 foreach (Type t in types) {
821 if (best == t)
822 continue;
823 if (!ImplicitStandardConversionExists (expr, t)) {
824 best = null;
825 break;
826 }
827 }
828
829 EmptyExpression.Release (expr);
830
831 return best;
832 }
833
834 /// <summary>
835 /// Finds "most encompassing type" according to the spec (13.4.2)
836 /// amongst the types in the given set
837 /// </summary>
838 static Type FindMostEncompassingType (ArrayList types)
839 {
840 Type best = null;
841
842 if (types.Count == 0)
843 return null;
844
845 if (types.Count == 1)
846 return (Type) types [0];
847
848 EmptyExpression expr = EmptyExpression.Grab ();
849
850 foreach (Type t in types) {
851 if (best == null) {
852 best = t;
853 continue;
854 }
855
856 expr.SetType (best);
857 if (ImplicitStandardConversionExists (expr, t))
858 best = t;
859 }
860
861 foreach (Type t in types) {
862 if (best == t)
863 continue;
864 expr.SetType (t);
865 if (!ImplicitStandardConversionExists (expr, best)) {
866 best = null;
867 break;
868 }
869 }
870
871 EmptyExpression.Release (expr);
872
873 return best;
874 }
875
876 /// <summary>
877 /// Finds the most specific source Sx according to the rules of the spec (13.4.4)
878 /// by making use of FindMostEncomp* methods. Applies the correct rules separately
879 /// for explicit and implicit conversion operators.
880 /// </summary>
881 static public Type FindMostSpecificSource (IList list,
882 Expression source, bool apply_explicit_conv_rules)
883 {
884 ArrayList src_types_set = new ArrayList ();
885
886 //
887 // If any operator converts from S then Sx = S
888 //
889 Type source_type = source.Type;
890 foreach (MethodBase mb in list){
891 AParametersCollection pd = TypeManager.GetParameterData (mb);
892 Type param_type = pd.Types [0];
893
894 if (param_type == source_type)
895 return param_type;
896
897 src_types_set.Add (param_type);
898 }
899
900 //
901 // Explicit Conv rules
902 //
903 if (apply_explicit_conv_rules) {
904 ArrayList candidate_set = new ArrayList ();
905
906 foreach (Type param_type in src_types_set){
907 if (ImplicitStandardConversionExists (source, param_type))
908 candidate_set.Add (param_type);
909 }
910
911 if (candidate_set.Count != 0)
912 return FindMostEncompassedType (candidate_set);
913 }
914
915 //
916 // Final case
917 //
918 if (apply_explicit_conv_rules)
919 return FindMostEncompassingType (src_types_set);
920 else
921 return FindMostEncompassedType (src_types_set);
922 }
923
924 /// <summary>
925 /// Finds the most specific target Tx according to section 13.4.4
926 /// </summary>
927 static public Type FindMostSpecificTarget (IList list,
928 Type target, bool apply_explicit_conv_rules)
929 {
930 ArrayList tgt_types_set = new ArrayList ();
931
932 //
933 // If any operator converts to T then Tx = T
934 //
935 foreach (MethodInfo mi in list){
936 Type ret_type = TypeManager.TypeToCoreType (mi.ReturnType);
937 if (ret_type == target)
938 return ret_type;
939
940 tgt_types_set.Add (ret_type);
941 }
942
943 //
944 // Explicit conv rules
945 //
946 if (apply_explicit_conv_rules) {
947 ArrayList candidate_set = new ArrayList ();
948
949 EmptyExpression expr = EmptyExpression.Grab ();
950
951 foreach (Type ret_type in tgt_types_set){
952 expr.SetType (ret_type);
953
954 if (ImplicitStandardConversionExists (expr, target))
955 candidate_set.Add (ret_type);
956 }
957
958 EmptyExpression.Release (expr);
959
960 if (candidate_set.Count != 0)
961 return FindMostEncompassingType (candidate_set);
962 }
963
964 //
965 // Okay, final case !
966 //
967 if (apply_explicit_conv_rules)
968 return FindMostEncompassedType (tgt_types_set);
969 else
970 return FindMostEncompassingType (tgt_types_set);
971 }
972
973 /// <summary>
974 /// User-defined Implicit conversions
975 /// </summary>
976 static public Expression ImplicitUserConversion (ResolveContext ec, Expression source,
977 Type target, Location loc)
978 {
979 return UserDefinedConversion (ec, source, target, loc, false, true);
980 }
981
982 /// <summary>
983 /// User-defined Explicit conversions
984 /// </summary>
985 static Expression ExplicitUserConversion (ResolveContext ec, Expression source,
986 Type target, Location loc)
987 {
988 return UserDefinedConversion (ec, source, target, loc, true, true);
989 }
990
991 static void AddConversionOperators (ArrayList list,
992 Expression source, Type target_type,
993 bool look_for_explicit,
994 MethodGroupExpr mg)
995 {
996 if (mg == null)
997 return;
998
999 Type source_type = source.Type;
1000 EmptyExpression expr = EmptyExpression.Grab ();
1001
1002 //
1003 // LAMESPEC: Undocumented IntPtr/UIntPtr conversions
1004 // IntPtr -> uint uses int
1005 // UIntPtr -> long uses ulong
1006 //
1007 if (source_type == TypeManager.intptr_type) {
1008 if (target_type == TypeManager.uint32_type)
1009 target_type = TypeManager.int32_type;
1010 } else if (source_type == TypeManager.uintptr_type) {
1011 if (target_type == TypeManager.int64_type)
1012 target_type = TypeManager.uint64_type;
1013 }
1014
1015 foreach (MethodInfo m in mg.Methods) {
1016 AParametersCollection pd = TypeManager.GetParameterData (m);
1017 Type return_type = TypeManager.TypeToCoreType (m.ReturnType);
1018 Type arg_type = pd.Types [0];
1019
1020 if (source_type != arg_type) {
1021 if (!ImplicitStandardConversionExists (source, arg_type)) {
1022 if (!look_for_explicit)
1023 continue;
1024 expr.SetType (arg_type);
1025 if (!ImplicitStandardConversionExists (expr, source_type))
1026 continue;
1027 }
1028 }
1029
1030 if (target_type != return_type) {
1031 expr.SetType (return_type);
1032 if (!ImplicitStandardConversionExists (expr, target_type)) {
1033 if (!look_for_explicit)
1034 continue;
1035 expr.SetType (target_type);
1036 if (!ImplicitStandardConversionExists (expr, return_type))
1037 continue;
1038 }
1039 }
1040
1041 // See LAMESPEC: Exclude IntPtr -> int conversion
1042 if (source_type == TypeManager.uintptr_type && return_type == TypeManager.uint32_type)
1043 continue;
1044
1045 list.Add (m);
1046 }
1047
1048 EmptyExpression.Release (expr);
1049 }
1050
1051 /// <summary>
1052 /// Compute the user-defined conversion operator from source_type to target_type.
1053 /// `look_for_explicit' controls whether we should also include the list of explicit operators
1054 /// </summary>
1055 static MethodInfo GetConversionOperator (CompilerContext ctx, Type container_type, Expression source, Type target_type, bool look_for_explicit)
1056 {
1057 ArrayList ops = new ArrayList (4);
1058
1059 Type source_type = source.Type;
1060
1061 if (source_type != TypeManager.decimal_type) {
1062 AddConversionOperators (ops, source, target_type, look_for_explicit,
1063 Expression.MethodLookup (ctx, container_type, source_type, "op_Implicit", Location.Null) as MethodGroupExpr);
1064 if (look_for_explicit) {
1065 AddConversionOperators (ops, source, target_type, look_for_explicit,
1066 Expression.MethodLookup (ctx,
1067 container_type, source_type, "op_Explicit", Location.Null) as MethodGroupExpr);
1068 }
1069 }
1070
1071 if (target_type != TypeManager.decimal_type) {
1072 AddConversionOperators (ops, source, target_type, look_for_explicit,
1073 Expression.MethodLookup (ctx, container_type, target_type, "op_Implicit", Location.Null) as MethodGroupExpr);
1074 if (look_for_explicit) {
1075 AddConversionOperators (ops, source, target_type, look_for_explicit,
1076 Expression.MethodLookup (ctx,
1077 container_type, target_type, "op_Explicit", Location.Null) as MethodGroupExpr);
1078 }
1079 }
1080
1081 if (ops.Count == 0)
1082 return null;
1083
1084 Type most_specific_source = FindMostSpecificSource (ops, source, look_for_explicit);
1085 if (most_specific_source == null)
1086 return null;
1087
1088 Type most_specific_target = FindMostSpecificTarget (ops, target_type, look_for_explicit);
1089 if (most_specific_target == null)
1090 return null;
1091
1092 MethodInfo method = null;
1093
1094 foreach (MethodInfo m in ops) {
1095 if (TypeManager.TypeToCoreType (m.ReturnType) != most_specific_target)
1096 continue;
1097 if (TypeManager.GetParameterData (m).Types [0] != most_specific_source)
1098 continue;
1099 // Ambiguous: more than one conversion operator satisfies the signature.
1100 if (method != null)
1101 return null;
1102 method = m;
1103 }
1104
1105 return method;
1106 }
1107
1108 /// <summary>
1109 /// User-defined conversions
1110 /// </summary>
1111 public static Expression UserDefinedConversion (ResolveContext ec, Expression source,
1112 Type target, Location loc,
1113 bool look_for_explicit, bool return_convert)
1114 {
1115 Type source_type = source.Type;
1116 MethodInfo method = null;
1117 Expression expr = 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 if (TypeManager.IsDynamicType (source_type))
1135 return null;
1136
1137 method = GetConversionOperator (ec.Compiler, null, source, target, look_for_explicit);
1138 }
1139
1140 if (method != null) {
1141 Type most_specific_source = TypeManager.GetParameterData (method).Types[0];
1142
1143 //
1144 // This will do the conversion to the best match that we
1145 // found. Now we need to perform an implict standard conversion
1146 // if the best match was not the type that we were requested
1147 // by target.
1148 //
1149 if (look_for_explicit) {
1150 ReportPrinter temp = new SessionReportPrinter ();
1151 ReportPrinter prev = ec.Report.SetPrinter (temp);
1152
1153 expr = ExplicitConversionStandard (ec, source, most_specific_source, loc);
1154
1155 ec.Report.SetPrinter (prev);
1156 if (temp.ErrorsCount != 0)
1157 expr = null;
1158 } else {
1159 if (ImplicitStandardConversionExists (source, most_specific_source))
1160 expr = ImplicitConversionStandard (ec, source, most_specific_source, loc);
1161 else
1162 expr = null;
1163 }
1164 }
1165
1166 if (expr == null) {
1167 bool nullable = false;
1168
1169 if (TypeManager.IsNullableType (source_type)) {
1170 source = Nullable.Unwrap.Create (source);
1171 nullable = true;
1172 }
1173
1174 Type target_underlying;
1175 if (TypeManager.IsNullableType (target)) {
1176 target_underlying = TypeManager.GetTypeArguments (target)[0];
1177 nullable = true;
1178 } else {
1179 // No implicit conversion S? -> T for non-reference type T
1180 if (!look_for_explicit && !TypeManager.IsReferenceType (target))
1181 nullable = false;
1182
1183 target_underlying = target;
1184 }
1185
1186 if (nullable) {
1187 expr = UserDefinedConversion (ec, source, target_underlying, loc, look_for_explicit, return_convert);
1188
1189 // Do result expression lifting only when it's needed
1190 if (expr != null && (!look_for_explicit || TypeManager.IsReferenceType (target)))
1191 expr = new Nullable.Lifted (expr, source, target).Resolve (ec);
1192
1193 return expr;
1194 }
1195 } else {
1196 expr = new UserCast (method, expr, loc).Resolve (ec);
1197
1198 if (return_convert && !TypeManager.IsEqual (expr.Type, target)) {
1199 if (look_for_explicit) {
1200 expr = ExplicitConversionStandard (ec, expr, target, loc);
1201 } else {
1202 expr = ImplicitConversionStandard (ec, expr, target, loc);
1203 }
1204 }
1205 }
1206
1207 if (!(source is Constant))
1208 hash.Insert (source_type, target, method);
1209
1210 return expr;
1211 }
1212
1213 /// <summary>
1214 /// Converts implicitly the resolved expression `expr' into the
1215 /// `target_type'. It returns a new expression that can be used
1216 /// in a context that expects a `target_type'.
1217 /// </summary>
1218 static public Expression ImplicitConversion (ResolveContext ec, Expression expr,
1219 Type target_type, Location loc)
1220 {
1221 Expression e;
1222
1223 if (target_type == null)
1224 throw new Exception ("Target type is null");
1225
1226 e = ImplicitConversionStandard (ec, expr, target_type, loc);
1227 if (e != null)
1228 return e;
1229
1230 e = ImplicitUserConversion (ec, expr, target_type, loc);
1231 if (e != null)
1232 return e;
1233
1234 return null;
1235 }
1236
1237
1238 /// <summary>
1239 /// Attempts to apply the `Standard Implicit
1240 /// Conversion' rules to the expression `expr' into
1241 /// the `target_type'. It returns a new expression
1242 /// that can be used in a context that expects a
1243 /// `target_type'.
1244 ///
1245 /// This is different from `ImplicitConversion' in that the
1246 /// user defined implicit conversions are excluded.
1247 /// </summary>
1248 static public Expression ImplicitConversionStandard (ResolveContext ec, Expression expr,
1249 Type target_type, Location loc)
1250 {
1251 return ImplicitConversionStandard (ec, expr, target_type, loc, false);
1252 }
1253
1254 static Expression ImplicitConversionStandard (ResolveContext ec, Expression expr, Type target_type, Location loc, bool explicit_cast)
1255 {
1256 if (expr.eclass == ExprClass.MethodGroup){
1257 if (!TypeManager.IsDelegateType (target_type)){
1258 return null;
1259 }
1260
1261 //
1262 // Only allow anonymous method conversions on post ISO_1
1263 //
1264 if (RootContext.Version != LanguageVersion.ISO_1){
1265 MethodGroupExpr mg = expr as MethodGroupExpr;
1266 if (mg != null)
1267 return ImplicitDelegateCreation.Create (
1268 ec, mg, target_type, loc);
1269 }
1270 }
1271
1272 Type expr_type = expr.Type;
1273 Expression e;
1274
1275 if (expr_type.Equals (target_type)) {
1276 if (expr_type != TypeManager.null_type && expr_type != InternalType.AnonymousMethod)
1277 return expr;
1278 return null;
1279 }
1280
1281 if (TypeManager.IsVariantOf (expr_type, target_type)) {
1282 return expr;
1283 }
1284
1285 if (TypeManager.IsNullableType (target_type))
1286 return ImplicitNulableConversion (ec, expr, target_type);
1287
1288 //
1289 // Attempt to do the implicit constant expression conversions
1290 //
1291 Constant c = expr as Constant;
1292 if (c != null) {
1293 try {
1294 c = c.ConvertImplicitly (ec, target_type);
1295 } catch {
1296 Console.WriteLine ("Conversion error happened in line {0}", loc);
1297 throw;
1298 }
1299 if (c != null)
1300 return c;
1301 }
1302
1303 e = ImplicitNumericConversion (expr, expr_type, target_type);
1304 if (e != null)
1305 return e;
1306
1307 e = ImplicitReferenceConversion (expr, target_type, explicit_cast);
1308 if (e != null)
1309 return e;
1310
1311 if (expr is IntConstant && TypeManager.IsEnumType (target_type)){
1312 Constant i = (Constant) expr;
1313 //
1314 // LAMESPEC: Conversion from any 0 constant is allowed
1315 //
1316 // An implicit enumeration conversion permits the decimal-integer-literal 0
1317 // to be converted to any enum-type and to any nullable-type whose underlying
1318 // type is an enum-type
1319 //
1320 if (i.IsDefaultValue)
1321 return new EnumConstant (i, target_type).Resolve (ec);
1322 }
1323
1324 if (ec.IsUnsafe) {
1325 if (expr_type.IsPointer){
1326 if (target_type == TypeManager.void_ptr_type)
1327 return EmptyCast.Create (expr, target_type);
1328
1329 //
1330 // yep, comparing pointer types cant be done with
1331 // t1 == t2, we have to compare their element types.
1332 //
1333 if (target_type.IsPointer){
1334 if (TypeManager.GetElementType(target_type) == TypeManager.GetElementType(expr_type))
1335 return expr;
1336
1337 //return null;
1338 }
1339 }
1340
1341 if (expr_type == TypeManager.null_type && target_type.IsPointer)
1342 return EmptyCast.Create (new NullPointer (loc), target_type);
1343 }
1344
1345 if (expr_type == InternalType.AnonymousMethod){
1346 AnonymousMethodExpression ame = (AnonymousMethodExpression) expr;
1347 Expression am = ame.Compatible (ec, target_type);
1348 if (am != null)
1349 return am.Resolve (ec);
1350 }
1351
1352 if (expr_type == InternalType.Arglist && target_type == TypeManager.arg_iterator_type)
1353 return expr;
1354
1355 return null;
1356 }
1357
1358 /// <summary>
1359 /// Attempts to implicitly convert `source' into `target_type', using
1360 /// ImplicitConversion. If there is no implicit conversion, then
1361 /// an error is signaled
1362 /// </summary>
1363 static public Expression ImplicitConversionRequired (ResolveContext ec, Expression source,
1364 Type target_type, Location loc)
1365 {
1366 Expression e = ImplicitConversion (ec, source, target_type, loc);
1367 if (e != null)
1368 return e;
1369
1370 if (TypeManager.IsDynamicType (source.Type)) {
1371 Arguments args = new Arguments (1);
1372 args.Add (new Argument (source));
1373 return new DynamicConversion (target_type, 0, args, loc).Resolve (ec);
1374 }
1375
1376 source.Error_ValueCannotBeConverted (ec, loc, target_type, false);
1377 return null;
1378 }
1379
1380 /// <summary>
1381 /// Performs the explicit numeric conversions
1382 ///
1383 /// There are a few conversions that are not part of the C# standard,
1384 /// they were interim hacks in the C# compiler that were supposed to
1385 /// become explicit operators in the UIntPtr class and IntPtr class,
1386 /// but for historical reasons it did not happen, so the C# compiler
1387 /// ended up with these special hacks.
1388 ///
1389 /// See bug 59800 for details.
1390 ///
1391 /// The conversion are:
1392 /// UIntPtr->SByte
1393 /// UIntPtr->Int16
1394 /// UIntPtr->Int32
1395 /// IntPtr->UInt64
1396 /// UInt64->IntPtr
1397 /// SByte->UIntPtr
1398 /// Int16->UIntPtr
1399 ///
1400 /// </summary>
1401 public static Expression ExplicitNumericConversion (Expression expr, Type target_type)
1402 {
1403 Type expr_type = expr.Type;
1404 Type real_target_type = target_type;
1405
1406 if (expr_type == TypeManager.sbyte_type){
1407 //
1408 // From sbyte to byte, ushort, uint, ulong, char, uintptr
1409 //
1410 if (real_target_type == TypeManager.byte_type)
1411 return new ConvCast (expr, target_type, ConvCast.Mode.I1_U1);
1412 if (real_target_type == TypeManager.ushort_type)
1413 return new ConvCast (expr, target_type, ConvCast.Mode.I1_U2);
1414 if (real_target_type == TypeManager.uint32_type)
1415 return new ConvCast (expr, target_type, ConvCast.Mode.I1_U4);
1416 if (real_target_type == TypeManager.uint64_type)
1417 return new ConvCast (expr, target_type, ConvCast.Mode.I1_U8);
1418 if (real_target_type == TypeManager.char_type)
1419 return new ConvCast (expr, target_type, ConvCast.Mode.I1_CH);
1420
1421 // One of the built-in conversions that belonged in the class library
1422 if (real_target_type == TypeManager.uintptr_type){
1423 Expression u8e = new ConvCast (expr, TypeManager.uint64_type, ConvCast.Mode.I1_U8);
1424
1425 return new OperatorCast (u8e, TypeManager.uintptr_type, true);
1426 }
1427 } else if (expr_type == TypeManager.byte_type){
1428 //
1429 // From byte to sbyte and char
1430 //
1431 if (real_target_type == TypeManager.sbyte_type)
1432 return new ConvCast (expr, target_type, ConvCast.Mode.U1_I1);
1433 if (real_target_type == TypeManager.char_type)
1434 return new ConvCast (expr, target_type, ConvCast.Mode.U1_CH);
1435 } else if (expr_type == TypeManager.short_type){
1436 //
1437 // From short to sbyte, byte, ushort, uint, ulong, char, uintptr
1438 //
1439 if (real_target_type == TypeManager.sbyte_type)
1440 return new ConvCast (expr, target_type, ConvCast.Mode.I2_I1);
1441 if (real_target_type == TypeManager.byte_type)
1442 return new ConvCast (expr, target_type, ConvCast.Mode.I2_U1);
1443 if (real_target_type == TypeManager.ushort_type)
1444 return new ConvCast (expr, target_type, ConvCast.Mode.I2_U2);
1445 if (real_target_type == TypeManager.uint32_type)
1446 return new ConvCast (expr, target_type, ConvCast.Mode.I2_U4);
1447 if (real_target_type == TypeManager.uint64_type)
1448 return new ConvCast (expr, target_type, ConvCast.Mode.I2_U8);
1449 if (real_target_type == TypeManager.char_type)
1450 return new ConvCast (expr, target_type, ConvCast.Mode.I2_CH);
1451
1452 // One of the built-in conversions that belonged in the class library
1453 if (real_target_type == TypeManager.uintptr_type){
1454 Expression u8e = new ConvCast (expr, TypeManager.uint64_type, ConvCast.Mode.I2_U8);
1455
1456 return new OperatorCast (u8e, TypeManager.uintptr_type, true);
1457 }
1458 } else if (expr_type == TypeManager.ushort_type){
1459 //
1460 // From ushort to sbyte, byte, short, char
1461 //
1462 if (real_target_type == TypeManager.sbyte_type)
1463 return new ConvCast (expr, target_type, ConvCast.Mode.U2_I1);
1464 if (real_target_type == TypeManager.byte_type)
1465 return new ConvCast (expr, target_type, ConvCast.Mode.U2_U1);
1466 if (real_target_type == TypeManager.short_type)
1467 return new ConvCast (expr, target_type, ConvCast.Mode.U2_I2);
1468 if (real_target_type == TypeManager.char_type)
1469 return new ConvCast (expr, target_type, ConvCast.Mode.U2_CH);
1470 } else if (expr_type == TypeManager.int32_type){
1471 //
1472 // From int to sbyte, byte, short, ushort, uint, ulong, char, uintptr
1473 //
1474 if (real_target_type == TypeManager.sbyte_type)
1475 return new ConvCast (expr, target_type, ConvCast.Mode.I4_I1);
1476 if (real_target_type == TypeManager.byte_type)
1477 return new ConvCast (expr, target_type, ConvCast.Mode.I4_U1);
1478 if (real_target_type == TypeManager.short_type)
1479 return new ConvCast (expr, target_type, ConvCast.Mode.I4_I2);
1480 if (real_target_type == TypeManager.ushort_type)
1481 return new ConvCast (expr, target_type, ConvCast.Mode.I4_U2);
1482 if (real_target_type == TypeManager.uint32_type)
1483 return new ConvCast (expr, target_type, ConvCast.Mode.I4_U4);
1484 if (real_target_type == TypeManager.uint64_type)
1485 return new ConvCast (expr, target_type, ConvCast.Mode.I4_U8);
1486 if (real_target_type == TypeManager.char_type)
1487 return new ConvCast (expr, target_type, ConvCast.Mode.I4_CH);
1488
1489 // One of the built-in conversions that belonged in the class library
1490 if (real_target_type == TypeManager.uintptr_type){
1491 Expression u8e = new ConvCast (expr, TypeManager.uint64_type, ConvCast.Mode.I2_U8);
1492
1493 return new OperatorCast (u8e, TypeManager.uintptr_type, true);
1494 }
1495 } else if (expr_type == TypeManager.uint32_type){
1496 //
1497 // From uint to sbyte, byte, short, ushort, int, char
1498 //
1499 if (real_target_type == TypeManager.sbyte_type)
1500 return new ConvCast (expr, target_type, ConvCast.Mode.U4_I1);
1501 if (real_target_type == TypeManager.byte_type)
1502 return new ConvCast (expr, target_type, ConvCast.Mode.U4_U1);
1503 if (real_target_type == TypeManager.short_type)
1504 return new ConvCast (expr, target_type, ConvCast.Mode.U4_I2);
1505 if (real_target_type == TypeManager.ushort_type)
1506 return new ConvCast (expr, target_type, ConvCast.Mode.U4_U2);
1507 if (real_target_type == TypeManager.int32_type)
1508 return new ConvCast (expr, target_type, ConvCast.Mode.U4_I4);
1509 if (real_target_type == TypeManager.char_type)
1510 return new ConvCast (expr, target_type, ConvCast.Mode.U4_CH);
1511 } else if (expr_type == TypeManager.int64_type){
1512 //
1513 // From long to sbyte, byte, short, ushort, int, uint, ulong, char
1514 //
1515 if (real_target_type == TypeManager.sbyte_type)
1516 return new ConvCast (expr, target_type, ConvCast.Mode.I8_I1);
1517 if (real_target_type == TypeManager.byte_type)
1518 return new ConvCast (expr, target_type, ConvCast.Mode.I8_U1);
1519 if (real_target_type == TypeManager.short_type)
1520 return new ConvCast (expr, target_type, ConvCast.Mode.I8_I2);
1521 if (real_target_type == TypeManager.ushort_type)
1522 return new ConvCast (expr, target_type, ConvCast.Mode.I8_U2);
1523 if (real_target_type == TypeManager.int32_type)
1524 return new ConvCast (expr, target_type, ConvCast.Mode.I8_I4);
1525 if (real_target_type == TypeManager.uint32_type)
1526 return new ConvCast (expr, target_type, ConvCast.Mode.I8_U4);
1527 if (real_target_type == TypeManager.uint64_type)
1528 return new ConvCast (expr, target_type, ConvCast.Mode.I8_U8);
1529 if (real_target_type == TypeManager.char_type)
1530 return new ConvCast (expr, target_type, ConvCast.Mode.I8_CH);
1531 } else if (expr_type == TypeManager.uint64_type){
1532 //
1533 // From ulong to sbyte, byte, short, ushort, int, uint, long, char
1534 //
1535 if (real_target_type == TypeManager.sbyte_type)
1536 return new ConvCast (expr, target_type, ConvCast.Mode.U8_I1);
1537 if (real_target_type == TypeManager.byte_type)
1538 return new ConvCast (expr, target_type, ConvCast.Mode.U8_U1);
1539 if (real_target_type == TypeManager.short_type)
1540 return new ConvCast (expr, target_type, ConvCast.Mode.U8_I2);
1541 if (real_target_type == TypeManager.ushort_type)
1542 return new ConvCast (expr, target_type, ConvCast.Mode.U8_U2);
1543 if (real_target_type == TypeManager.int32_type)
1544 return new ConvCast (expr, target_type, ConvCast.Mode.U8_I4);
1545 if (real_target_type == TypeManager.uint32_type)
1546 return new ConvCast (expr, target_type, ConvCast.Mode.U8_U4);
1547 if (real_target_type == TypeManager.int64_type)
1548 return new ConvCast (expr, target_type, ConvCast.Mode.U8_I8);
1549 if (real_target_type == TypeManager.char_type)
1550 return new ConvCast (expr, target_type, ConvCast.Mode.U8_CH);
1551
1552 // One of the built-in conversions that belonged in the class library
1553 if (real_target_type == TypeManager.intptr_type){
1554 return new OperatorCast (EmptyCast.Create (expr, TypeManager.int64_type),
1555 TypeManager.intptr_type, true);
1556 }
1557 } else if (expr_type == TypeManager.char_type){
1558 //
1559 // From char to sbyte, byte, short
1560 //
1561 if (real_target_type == TypeManager.sbyte_type)
1562 return new ConvCast (expr, target_type, ConvCast.Mode.CH_I1);
1563 if (real_target_type == TypeManager.byte_type)
1564 return new ConvCast (expr, target_type, ConvCast.Mode.CH_U1);
1565 if (real_target_type == TypeManager.short_type)
1566 return new ConvCast (expr, target_type, ConvCast.Mode.CH_I2);
1567 } else if (expr_type == TypeManager.float_type){
1568 //
1569 // From float to sbyte, byte, short,
1570 // ushort, int, uint, long, ulong, char
1571 // or decimal
1572 //
1573 if (real_target_type == TypeManager.sbyte_type)
1574 return new ConvCast (expr, target_type, ConvCast.Mode.R4_I1);
1575 if (real_target_type == TypeManager.byte_type)
1576 return new ConvCast (expr, target_type, ConvCast.Mode.R4_U1);
1577 if (real_target_type == TypeManager.short_type)
1578 return new ConvCast (expr, target_type, ConvCast.Mode.R4_I2);
1579 if (real_target_type == TypeManager.ushort_type)
1580 return new ConvCast (expr, target_type, ConvCast.Mode.R4_U2);
1581 if (real_target_type == TypeManager.int32_type)
1582 return new ConvCast (expr, target_type, ConvCast.Mode.R4_I4);
1583 if (real_target_type == TypeManager.uint32_type)
1584 return new ConvCast (expr, target_type, ConvCast.Mode.R4_U4);
1585 if (real_target_type == TypeManager.int64_type)
1586 return new ConvCast (expr, target_type, ConvCast.Mode.R4_I8);
1587 if (real_target_type == TypeManager.uint64_type)
1588 return new ConvCast (expr, target_type, ConvCast.Mode.R4_U8);
1589 if (real_target_type == TypeManager.char_type)
1590 return new ConvCast (expr, target_type, ConvCast.Mode.R4_CH);
1591 if (real_target_type == TypeManager.decimal_type)
1592 return new CastToDecimal (expr, true);
1593 } else if (expr_type == TypeManager.double_type){
1594 //
1595 // From double to sbyte, byte, short,
1596 // ushort, int, uint, long, ulong,
1597 // char, float or decimal
1598 //
1599 if (real_target_type == TypeManager.sbyte_type)
1600 return new ConvCast (expr, target_type, ConvCast.Mode.R8_I1);
1601 if (real_target_type == TypeManager.byte_type)
1602 return new ConvCast (expr, target_type, ConvCast.Mode.R8_U1);
1603 if (real_target_type == TypeManager.short_type)
1604 return new ConvCast (expr, target_type, ConvCast.Mode.R8_I2);
1605 if (real_target_type == TypeManager.ushort_type)
1606 return new ConvCast (expr, target_type, ConvCast.Mode.R8_U2);
1607 if (real_target_type == TypeManager.int32_type)
1608 return new ConvCast (expr, target_type, ConvCast.Mode.R8_I4);
1609 if (real_target_type == TypeManager.uint32_type)
1610 return new ConvCast (expr, target_type, ConvCast.Mode.R8_U4);
1611 if (real_target_type == TypeManager.int64_type)
1612 return new ConvCast (expr, target_type, ConvCast.Mode.R8_I8);
1613 if (real_target_type == TypeManager.uint64_type)
1614 return new ConvCast (expr, target_type, ConvCast.Mode.R8_U8);
1615 if (real_target_type == TypeManager.char_type)
1616 return new ConvCast (expr, target_type, ConvCast.Mode.R8_CH);
1617 if (real_target_type == TypeManager.float_type)
1618 return new ConvCast (expr, target_type, ConvCast.Mode.R8_R4);
1619 if (real_target_type == TypeManager.decimal_type)
1620 return new CastToDecimal (expr, true);
1621 } else if (expr_type == TypeManager.uintptr_type){
1622 //
1623 // Various built-in conversions that belonged in the class library
1624 //
1625 // from uintptr to sbyte, short, int32
1626 //
1627 if (real_target_type == TypeManager.sbyte_type){
1628 Expression uint32e = new OperatorCast (expr, TypeManager.uint32_type, true);
1629 return new ConvCast (uint32e, TypeManager.sbyte_type, ConvCast.Mode.U4_I1);
1630 }
1631 if (real_target_type == TypeManager.short_type){
1632 Expression uint32e = new OperatorCast (expr, TypeManager.uint32_type, true);
1633 return new ConvCast (uint32e, TypeManager.sbyte_type, ConvCast.Mode.U4_I2);
1634 }
1635 if (real_target_type == TypeManager.int32_type){
1636 return EmptyCast.Create (new OperatorCast (expr, TypeManager.uint32_type, true),
1637 TypeManager.int32_type);
1638 }
1639 } else if (expr_type == TypeManager.intptr_type){
1640 if (real_target_type == TypeManager.uint64_type){
1641 return EmptyCast.Create (new OperatorCast (expr, TypeManager.int64_type, true),
1642 TypeManager.uint64_type);
1643 }
1644 } else if (expr_type == TypeManager.decimal_type) {
1645 return new CastFromDecimal (expr, target_type).Resolve ();
1646 }
1647 return null;
1648 }
1649
1650 /// <summary>
1651 /// Returns whether an explicit reference conversion can be performed
1652 /// from source_type to target_type
1653 /// </summary>
1654 public static bool ExplicitReferenceConversionExists (Type source_type, Type target_type)
1655 {
1656 Expression e = ExplicitReferenceConversion (null, source_type, target_type);
1657 if (e == null)
1658 return false;
1659
1660 if (e == EmptyExpression.Null)
1661 return true;
1662
1663 throw new InternalErrorException ("Invalid probing conversion result");
1664 }
1665
1666 /// <summary>
1667 /// Implements Explicit Reference conversions
1668 /// </summary>
1669 static Expression ExplicitReferenceConversion (Expression source, Type source_type, Type target_type)
1670 {
1671 bool target_is_value_type = TypeManager.IsStruct (target_type);
1672
1673 //
1674 // From object to a generic parameter
1675 //
1676 if (source_type == TypeManager.object_type && TypeManager.IsGenericParameter (target_type))
1677 return source == null ? EmptyExpression.Null : new UnboxCast (source, target_type);
1678
1679 //
1680 // Explicit type parameter conversion.
1681 //
1682 if (TypeManager.IsGenericParameter (source_type))
1683 return ExplicitTypeParameterConversion (source, source_type, target_type);
1684
1685 //
1686 // From object to any reference type or value type (unboxing)
1687 //
1688 if (source_type == TypeManager.object_type)
1689 return source == null ? EmptyExpression.Null :
1690 target_is_value_type ? (Expression) new UnboxCast (source, target_type) : new ClassCast (source, target_type);
1691
1692 //
1693 // Unboxing conversion from the types object and System.ValueType to any non-nullable-value-type
1694 //
1695 if (source_type == TypeManager.value_type && target_is_value_type)
1696 return source == null ? EmptyExpression.Null : new UnboxCast (source, target_type);
1697
1698 //
1699 // From any class S to any class-type T, provided S is a base class of T
1700 //
1701 if (TypeManager.IsSubclassOf (target_type, source_type))
1702 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1703
1704 //
1705 // From any class type S to any interface T, provides S is not sealed
1706 // and provided S does not implement T.
1707 //
1708 if (target_type.IsInterface && !source_type.IsSealed &&
1709 !TypeManager.ImplementsInterface (source_type, target_type)) {
1710 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1711 }
1712
1713 //
1714 // From any interface-type S to to any class type T, provided T is not
1715 // sealed, or provided T implements S.
1716 //
1717 if (source_type.IsInterface) {
1718 if (!target_type.IsSealed || TypeManager.ImplementsInterface (target_type, source_type)) {
1719 if (target_type.IsClass)
1720 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1721
1722 //
1723 // Unboxing conversion from any interface-type to any non-nullable-value-type that
1724 // implements the interface-type
1725 //
1726 return source == null ? EmptyExpression.Null : new UnboxCast (source, target_type);
1727 }
1728
1729 //
1730 // From System.Collecitons.Generic.IList<T> and its base interfaces to a one-dimensional
1731 // array type S[], provided there is an implicit or explicit reference conversion from S to T.
1732 //
1733 if (IList_To_Array (source_type, target_type))
1734 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1735
1736 return null;
1737 }
1738
1739 if (source_type.IsArray) {
1740 if (target_type.IsArray) {
1741 //
1742 // From System.Array to any array-type
1743 //
1744 if (source_type == TypeManager.array_type)
1745 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1746
1747 //
1748 // From an array type S with an element type Se to an array type T with an
1749 // element type Te provided all the following are true:
1750 // * S and T differe only in element type, in other words, S and T
1751 // have the same number of dimensions.
1752 // * Both Se and Te are reference types
1753 // * An explicit reference conversions exist from Se to Te
1754 //
1755 if (source_type.GetArrayRank () == target_type.GetArrayRank ()) {
1756
1757 source_type = TypeManager.GetElementType (source_type);
1758 if (!TypeManager.IsReferenceType (source_type))
1759 return null;
1760
1761 Type target_type_element = TypeManager.GetElementType (target_type);
1762 if (!TypeManager.IsReferenceType (target_type_element))
1763 return null;
1764
1765 if (ExplicitReferenceConversionExists (source_type, target_type_element))
1766 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1767
1768 return null;
1769 }
1770 }
1771
1772 //
1773 // From a single-dimensional array type S[] to System.Collections.Generic.IList<T> and its base interfaces,
1774 // provided that there is an explicit reference conversion from S to T
1775 //
1776 if (Array_To_IList (source_type, target_type, true))
1777 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1778
1779 return null;
1780 }
1781
1782 //
1783 // From System delegate to any delegate-type
1784 //
1785 if (source_type == TypeManager.delegate_type && TypeManager.IsDelegateType (target_type))
1786 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type);
1787
1788 return null;
1789 }
1790
1791 /// <summary>
1792 /// Performs an explicit conversion of the expression `expr' whose
1793 /// type is expr.Type to `target_type'.
1794 /// </summary>
1795 static public Expression ExplicitConversionCore (ResolveContext ec, Expression expr,
1796 Type target_type, Location loc)
1797 {
1798 Type expr_type = expr.Type;
1799
1800 // Explicit conversion includes implicit conversion and it used for enum underlying types too
1801 Expression ne = ImplicitConversionStandard (ec, expr, target_type, loc, true);
1802 if (ne != null)
1803 return ne;
1804
1805 if (TypeManager.IsEnumType (expr_type)) {
1806 Expression underlying = EmptyCast.Create (expr, TypeManager.GetEnumUnderlyingType (expr_type));
1807 expr = ExplicitConversionCore (ec, underlying, target_type, loc);
1808 if (expr != null)
1809 return expr;
1810
1811 return ExplicitUserConversion (ec, underlying, target_type, loc);
1812 }
1813
1814 if (TypeManager.IsEnumType (target_type)){
1815 //
1816 // Type System.Enum can be unboxed to any enum-type
1817 //
1818 if (expr_type == TypeManager.enum_type)
1819 return new UnboxCast (expr, target_type);
1820
1821 Expression ce = ExplicitConversionCore (ec, expr, TypeManager.GetEnumUnderlyingType (target_type), loc);
1822 if (ce != null)
1823 return EmptyCast.Create (ce, target_type);
1824
1825 //
1826 // LAMESPEC: IntPtr and UIntPtr conversion to any Enum is allowed
1827 //
1828 if (expr_type == TypeManager.intptr_type || expr_type == TypeManager.uintptr_type) {
1829 ne = ExplicitUserConversion (ec, expr, TypeManager.GetEnumUnderlyingType (target_type), loc);
1830 if (ne != null)
1831 return ExplicitConversionCore (ec, ne, target_type, loc);
1832 }
1833
1834 return null;
1835 }
1836
1837 ne = ExplicitNumericConversion (expr, target_type);
1838 if (ne != null)
1839 return ne;
1840
1841 //
1842 // Skip the ExplicitReferenceConversion because we can not convert
1843 // from Null to a ValueType, and ExplicitReference wont check against
1844 // null literal explicitly
1845 //
1846 if (expr_type != TypeManager.null_type){
1847 ne = ExplicitReferenceConversion (expr, expr_type, target_type);
1848 if (ne != null)
1849 return ne;
1850 }
1851
1852 if (ec.IsUnsafe){
1853 ne = ExplicitUnsafe (expr, target_type);
1854 if (ne != null)
1855 return ne;
1856 }
1857
1858 return null;
1859 }
1860
1861 public static Expression ExplicitUnsafe (Expression expr, Type target_type)
1862 {
1863 Type expr_type = expr.Type;
1864
1865 if (target_type.IsPointer){
1866 if (expr_type.IsPointer)
1867 return EmptyCast.Create (expr, target_type);
1868
1869 if (expr_type == TypeManager.sbyte_type ||
1870 expr_type == TypeManager.short_type ||
1871 expr_type == TypeManager.int32_type)
1872 return new OpcodeCast (expr, target_type, OpCodes.Conv_I);
1873
1874 if (expr_type == TypeManager.ushort_type ||
1875 expr_type == TypeManager.uint32_type ||
1876 expr_type == TypeManager.byte_type)
1877 return new OpcodeCast (expr, target_type, OpCodes.Conv_U);
1878
1879 if (expr_type == TypeManager.int64_type)
1880 return new ConvCast (expr, target_type, ConvCast.Mode.I8_I);
1881
1882 if (expr_type == TypeManager.uint64_type)
1883 return new ConvCast (expr, target_type, ConvCast.Mode.U8_I);
1884 }
1885
1886 if (expr_type.IsPointer){
1887 if (target_type == TypeManager.sbyte_type)
1888 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1889 if (target_type == TypeManager.byte_type)
1890 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1891 if (target_type == TypeManager.short_type)
1892 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1893 if (target_type == TypeManager.ushort_type)
1894 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1895 if (target_type == TypeManager.int32_type)
1896 return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
1897 if (target_type == TypeManager.uint32_type)
1898 return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
1899 if (target_type == TypeManager.int64_type)
1900 return new ConvCast (expr, target_type, ConvCast.Mode.I_I8);
1901 if (target_type == TypeManager.uint64_type)
1902 return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
1903 }
1904 return null;
1905 }
1906
1907 /// <summary>
1908 /// Same as ExplicitConversion, only it doesn't include user defined conversions
1909 /// </summary>
1910 static public Expression ExplicitConversionStandard (ResolveContext ec, Expression expr,
1911 Type target_type, Location l)
1912 {
1913 int errors = ec.Report.Errors;
1914 Expression ne = ImplicitConversionStandard (ec, expr, target_type, l);
1915 if (ec.Report.Errors > errors)
1916 return null;
1917
1918 if (ne != null)
1919 return ne;
1920
1921 ne = ExplicitNumericConversion (expr, target_type);
1922 if (ne != null)
1923 return ne;
1924
1925 ne = ExplicitReferenceConversion (expr, expr.Type, target_type);
1926 if (ne != null)
1927 return ne;
1928
1929 if (ec.IsUnsafe && expr.Type == TypeManager.void_ptr_type && target_type.IsPointer)
1930 return EmptyCast.Create (expr, target_type);
1931
1932 expr.Error_ValueCannotBeConverted (ec, l, target_type, true);
1933 return null;
1934 }
1935
1936 /// <summary>
1937 /// Performs an explicit conversion of the expression `expr' whose
1938 /// type is expr.Type to `target_type'.
1939 /// </summary>
1940 static public Expression ExplicitConversion (ResolveContext ec, Expression expr,
1941 Type target_type, Location loc)
1942 {
1943 Expression e = ExplicitConversionCore (ec, expr, target_type, loc);
1944 if (e != null) {
1945 //
1946 // Don't eliminate explicit precission casts
1947 //
1948 if (e == expr) {
1949 if (target_type == TypeManager.float_type)
1950 return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
1951
1952 if (target_type == TypeManager.double_type)
1953 return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
1954 }
1955
1956 return e;
1957 }
1958
1959 Type expr_type = expr.Type;
1960 if (TypeManager.IsNullableType (target_type)) {
1961 if (TypeManager.IsNullableType (expr_type)) {
1962 Type target = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (target_type)[0]);
1963 Expression unwrap = Nullable.Unwrap.Create (expr);
1964 e = ExplicitConversion (ec, unwrap, target, expr.Location);
1965 if (e == null)
1966 return null;
1967
1968 return new Nullable.Lifted (e, unwrap, target_type).Resolve (ec);
1969 } else if (expr_type == TypeManager.object_type) {
1970 return new UnboxCast (expr, target_type);
1971 } else {
1972 Type target = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (target_type) [0]);
1973
1974 e = ExplicitConversionCore (ec, expr, target, loc);
1975 if (e != null)
1976 return Nullable.Wrap.Create (e, target_type);
1977 }
1978 } else if (TypeManager.IsNullableType (expr_type)) {
1979 e = Nullable.Unwrap.Create (expr, false);
1980
1981 bool use_class_cast;
1982 if (ImplicitBoxingConversionExists (e, target_type, out use_class_cast))
1983 return new BoxedCast (expr, target_type);
1984
1985 e = ExplicitConversionCore (ec, e, target_type, loc);
1986 if (e != null)
1987 return EmptyCast.Create (e, target_type);
1988 }
1989
1990 e = ExplicitUserConversion (ec, expr, target_type, loc);
1991 if (e != null)
1992 return e;
1993
1994 expr.Error_ValueCannotBeConverted (ec, loc, target_type, true);
1995 return null;
1996 }
1997 }
1998 }
git-svn mirror of mcs