?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-06 Jb Evain <jbevain@novell.com>
[mcs.git] / mcs / convert.cs
blob533f828c4ff0711e234d29a9ec36e87322642295
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 using System;
14 using System.Collections.Generic;
15 using System.Diagnostics;
16 using System.Reflection;
17 using System.Reflection.Emit;
18
19 namespace Mono.CSharp {
20
21 //
22 // A container class for all the conversion operations
23 //
24 static class Convert {
25
26 static EmptyExpression MyEmptyExpr;
27 static DoubleHash explicit_conv;
28 static DoubleHash implicit_conv;
29
30 static Convert ()
31 {
32 Reset ();
33 }
34
35 public static void Reset ()
36 {
37 MyEmptyExpr = null;
38 explicit_conv = new DoubleHash (100);
39 implicit_conv = new DoubleHash (100);
40 }
41
42 static Type TypeParam_EffectiveBaseType (GenericConstraints gc)
43 {
44 var list = new List<Type> ();
45 list.Add (gc.EffectiveBaseClass);
46 foreach (Type t in gc.InterfaceConstraints) {
47 if (!TypeManager.IsGenericParameter (t))
48 continue;
49
50 GenericConstraints new_gc = TypeManager.GetTypeParameterConstraints (t);
51 if (new_gc != null)
52 list.Add (TypeParam_EffectiveBaseType (new_gc));
53 }
54 return FindMostEncompassedType (list);
55 }
56
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, bool isExplicit)
63 {
64 if ((array.GetArrayRank () != 1) || !TypeManager.IsGenericType (list))
65 return false;
66
67 Type gt = TypeManager.DropGenericTypeArguments (list);
68 if ((gt != TypeManager.generic_ilist_type) &&
69 (gt != TypeManager.generic_icollection_type) &&
70 (gt != TypeManager.generic_ienumerable_type))
71 return false;
72
73 Type element_type = TypeManager.GetElementType (array);
74 Type arg_type = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (list) [0]);
75
76 if (element_type == arg_type)
77 return true;
78
79 if (isExplicit)
80 return ExplicitReferenceConversionExists (element_type, arg_type);
81
82 Type t = TypeManager.GetElementType (array);
83 if (MyEmptyExpr == null)
84 MyEmptyExpr = new EmptyExpression (t);
85 else
86 MyEmptyExpr.SetType (t);
87
88 return ImplicitReferenceConversionExists (MyEmptyExpr, arg_type);
89 }
90
91 static bool IList_To_Array(Type list, Type array)
92 {
93 if (!TypeManager.IsGenericType (list) || !array.IsArray || array.GetArrayRank() != 1)
94 return false;
95
96 Type gt = TypeManager.DropGenericTypeArguments (list);
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.TypeToCoreType (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(element_type);
110 else
111 MyEmptyExpr.SetType(element_type);
112
113 return ImplicitReferenceConversionExists(MyEmptyExpr, arg_type) || ExplicitReferenceConversionExists(element_type, arg_type);
114 }
115
116 static Expression ImplicitTypeParameterConversion (Expression expr,
117 Type target_type)
118 {
119 Type expr_type = expr.Type;
120
121 GenericConstraints gc = TypeManager.GetTypeParameterConstraints (expr_type);
122
123 if (gc == null) {
124 if (target_type == TypeManager.object_type)
125 return new BoxedCast (expr, target_type);
126
127 return null;
128 }
129
130 // We're converting from a type parameter which is known to be a reference type.
131 Type base_type = TypeParam_EffectiveBaseType (gc);
132
133 if (TypeManager.IsSubclassOf (base_type, target_type))
134 return new ClassCast (expr, target_type);
135
136 if (target_type.IsInterface) {
137 if (TypeManager.ImplementsInterface (base_type, target_type))
138 return new ClassCast (expr, target_type);
139
140 foreach (Type t in gc.InterfaceConstraints) {
141 if (TypeManager.IsSubclassOf (t, target_type))
142 return new ClassCast (expr, target_type);
143 if (TypeManager.ImplementsInterface (t, target_type))
144 return new ClassCast (expr, target_type);
145 }
146 }
147
148 foreach (Type t in gc.InterfaceConstraints) {
149 if (!TypeManager.IsGenericParameter (t))
150 continue;
151 if (TypeManager.IsSubclassOf (t, target_type))
152 return new ClassCast (expr, target_type);
153 if (TypeManager.ImplementsInterface (t, target_type))
154 return new ClassCast (expr, target_type);
155 }
156
157 return null;
158 }
159
160 static bool ImplicitTypeParameterBoxingConversion (Type expr_type, Type target_type,
161 out bool use_class_cast)
162 {
163 GenericConstraints gc = TypeManager.GetTypeParameterConstraints (expr_type);
164
165 if (gc == null) {
166 use_class_cast = false;
167 return target_type == TypeManager.object_type;
168 }
169
170 use_class_cast = true;
171
172 if (!gc.HasReferenceTypeConstraint)
173 return false;
174
175 // We're converting from a type parameter which is known to be a reference type.
176 Type base_type = TypeParam_EffectiveBaseType (gc);
177
178 if (TypeManager.IsSubclassOf (base_type, target_type))
179 return true;
180
181 if (target_type.IsInterface) {
182 if (TypeManager.ImplementsInterface (base_type, target_type))
183 return true;
184
185 foreach (Type t in gc.InterfaceConstraints) {
186 if (TypeManager.IsSubclassOf (t, target_type))
187 return true;
188 if (TypeManager.ImplementsInterface (t, target_type))
189 return true;
190 }
191 }
192
193 foreach (Type t in gc.InterfaceConstraints) {
194 if (!TypeManager.IsGenericParameter (t))
195 continue;
196 if (TypeManager.IsSubclassOf (t, target_type))
197 return true;
198 if (TypeManager.ImplementsInterface (t, target_type))
199 return true;
200 }
201
202 use_class_cast = false;
203 return false;
204 }
205
206 static Expression ExplicitTypeParameterConversion (Expression source, Type source_type, Type target_type)
207 {
208 if (TypeManager.IsGenericParameter (target_type)) {
209 GenericConstraints gc = TypeManager.GetTypeParameterConstraints (target_type);
210 if (gc == null)
211 return null;
212
213 foreach (Type iface in gc.InterfaceConstraints) {
214 if (!TypeManager.IsGenericParameter (iface))
215 continue;
216
217 if (TypeManager.IsSubclassOf (source_type, iface))
218 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type, true);
219 }
220 }
221
222 if (target_type.IsInterface)
223 return source == null ? EmptyExpression.Null : new ClassCast (source, target_type, true);
224
225 return null;
226 }
227
228 static Expression ImplicitReferenceConversion (Expression expr, Type target_type, bool explicit_cast)
229 {
230 Type expr_type = expr.Type;
231
232 if (expr_type == null && expr.eclass == ExprClass.MethodGroup){
233 // if we are a method group, emit a warning
234
235 expr.Emit (null);
236 }
237
238 if (expr_type == TypeManager.void_type)
239 return null;
240
241 if (TypeManager.IsGenericParameter (expr_type))
242 return ImplicitTypeParameterConversion (expr, target_type);
243
244 //
245 // from the null type to any reference-type.
246 //
247 NullLiteral nl = expr as NullLiteral;
248 if (nl != null) {
249 return nl.ConvertImplicitly (null, target_type);
250 }
251
252 if (ImplicitReferenceConversionExists (expr, target_type)) {
253 //
254 // Avoid wrapping implicitly convertible reference type
255 //
256 if (!explicit_cast)
257 return expr;
258
259 return EmptyCast.Create (expr, target_type);
260 }
261
262 bool use_class_cast;
263 if (ImplicitBoxingConversionExists (expr, target_type, out use_class_cast)) {
264 if (use_class_cast)
265 return new ClassCast (expr, target_type);
266 else
267 return new BoxedCast (expr, target_type);
268 }
269
270 return null;
271 }
272
273 //
274 // 6.1.6 Implicit reference conversions
275 //
276 public static bool ImplicitReferenceConversionExists (Expression expr, Type target_type)
277 {
278 if (TypeManager.IsStruct (target_type))
279 return false;
280
281 Type expr_type = expr.Type;
282
283 // from the null type to any reference-type.
284 if (expr_type == TypeManager.null_type)
285 return target_type != InternalType.AnonymousMethod;
286
287 if (TypeManager.IsGenericParameter (expr_type))
288 return ImplicitTypeParameterConversion (expr, target_type) != null;
289
290 //
291 // notice that it is possible to write "ValueType v = 1", the ValueType here
292 // is an abstract class, and not really a value type, so we apply the same rules.
293 //
294 if (target_type == TypeManager.object_type || TypeManager.IsDynamicType (target_type)) {
295 //
296 // A pointer type cannot be converted to object
297 //
298 if (expr_type.IsPointer)
299 return false;
300
301 if (TypeManager.IsValueType (expr_type))
302 return false;
303
304 if (expr_type.IsClass || expr_type.IsInterface || expr_type == TypeManager.enum_type){
305 // No mcs internal types are convertible
306 return expr_type.Module != typeof (Convert).Module;
307 }
308
309 return false;
310 } else if (target_type == TypeManager.value_type) {
311 return expr_type == TypeManager.enum_type;
312 } else if (TypeManager.IsSubclassOf (expr_type, target_type)) {
313 //
314 // Special case: enumeration to System.Enum.
315 // System.Enum is not a value type, it is a class, so we need
316 // a boxing conversion
317 //
318 if (target_type == TypeManager.enum_type || TypeManager.IsGenericParameter (expr_type))
319 return false;
320
321 return true;
322 }
323
324 // This code is kind of mirrored inside ImplicitStandardConversionExists
325 // with the small distinction that we only probe there
326 //
327 // Always ensure that the code here and there is in sync
328
329 // from any class-type S to any interface-type T.
330 if (target_type.IsInterface) {
331 if (TypeManager.ImplementsInterface (expr_type, target_type)){
332 return !TypeManager.IsGenericParameter (expr_type) &&
333 !TypeManager.IsValueType (expr_type);
334 }
335 }
336
337 if (expr_type.IsArray) {
338 // from an array-type S to an array-type of type T
339 if (target_type.IsArray && expr_type.GetArrayRank () == target_type.GetArrayRank ()) {
340
341 //
342 // Both SE and TE are reference-types
343 //
344 Type expr_element_type = TypeManager.GetElementType (expr_type);
345 if (!TypeManager.IsReferenceType (expr_element_type))
346 return false;
347
348 Type target_element_type = TypeManager.GetElementType (target_type);
349 if (!TypeManager.IsReferenceType (target_element_type))
350 return false;
351
352 if (MyEmptyExpr == null)
353 MyEmptyExpr = new EmptyExpression (expr_element_type);
354 else
355 MyEmptyExpr.SetType (expr_element_type);
356
357 return ImplicitStandardConversionExists (MyEmptyExpr, target_element_type);
358 }
359
360 // from an array-type to System.Array
361 if (target_type == TypeManager.array_type)
362 return true;
363
364 // from an array-type of type T to IList<T>
365 if (Array_To_IList (expr_type, target_type, false))
366 return true;
367
368 return false;
369 }
370
371 if (TypeManager.IsVariantOf (expr_type, target_type))
372 return true;
373
374 // from any interface type S to interface-type T.
375 if (expr_type.IsInterface && target_type.IsInterface) {
376 return TypeManager.ImplementsInterface (expr_type, target_type);
377 }
378
379 // from any delegate type to System.Delegate
380 if (target_type == TypeManager.delegate_type &&
381 (expr_type == TypeManager.delegate_type || TypeManager.IsDelegateType (expr_type)))
382 return true;
383
384 if (TypeManager.IsEqual (expr_type, target_type))
385 return true;
386
387 return false;
388 }
389
390 public static bool ImplicitBoxingConversionExists (Expression expr, Type target_type,
391 out bool use_class_cast)
392 {
393 Type expr_type = expr.Type;
394 use_class_cast = false;
395
396 //
397 // From any value-type to the type object.
398 //
399 if (target_type == TypeManager.object_type || TypeManager.IsDynamicType (target_type)) {
400 //
401 // A pointer type cannot be converted to object
402 //
403 if (expr_type.IsPointer)
404 return false;
405
406 return TypeManager.IsValueType (expr_type);
407 }
408
409 //
410 // From any value-type to the type System.ValueType.
411 //
412 if (target_type == TypeManager.value_type)
413 return TypeManager.IsValueType (expr_type);
414
415 if (target_type == TypeManager.enum_type) {
416 //
417 // From any enum-type to the type System.Enum.
418 //
419 if (TypeManager.IsEnumType (expr_type))
420 return true;
421 //
422 // From any nullable-type with an underlying enum-type to the type System.Enum
423 //
424 if (TypeManager.IsNullableType (expr_type))
425 return TypeManager.IsEnumType (TypeManager.GetTypeArguments (expr_type) [0]);
426 }
427
428 if (TypeManager.IsSubclassOf (expr_type, target_type)) {
429 //
430 // Don't box same type arguments
431 //
432 if (TypeManager.IsGenericParameter (expr_type) && expr_type != target_type)
433 return true;
434
435 return false;
436 }
437
438 // This code is kind of mirrored inside ImplicitStandardConversionExists
439 // with the small distinction that we only probe there
440 //
441 // Always ensure that the code here and there is in sync
442
443 // from any class-type S to any interface-type T.
444 if (target_type.IsInterface) {
445 if (TypeManager.ImplementsInterface (expr_type, target_type))
446 return TypeManager.IsGenericParameter (expr_type) ||
447 TypeManager.IsValueType (expr_type);
448 }
449
450 if (TypeManager.IsGenericParameter (expr_type))
451 return ImplicitTypeParameterBoxingConversion (
452 expr_type, target_type, out use_class_cast);
453
454 return false;
455 }
456
457 public static Expression ImplicitNulableConversion (ResolveContext ec, Expression expr, Type target_type)
458 {
459 Type expr_type = expr.Type;
460
461 //
462 // From null to any nullable type
463 //
464 if (expr_type == TypeManager.null_type)
465 return ec == null ? EmptyExpression.Null : Nullable.LiftedNull.Create (target_type, expr.Location);
466
467 // S -> T?
468 Type t_el = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (target_type)[0]);
469
470 // S? -> T?
471 if (TypeManager.IsNullableType (expr_type))
472 expr_type = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (expr_type)[0]);
473
474 //
475 // Predefined implicit identity or implicit numeric conversion
476 // has to exist between underlying type S and underlying type T
477 //
478
479 // Handles probing
480 if (ec == null) {
481 if (expr_type == t_el)
482 return EmptyExpression.Null;
483
484 return ImplicitNumericConversion (null, expr_type, t_el);
485 }
486
487 Expression unwrap;
488 if (expr_type != expr.Type)
489 unwrap = Nullable.Unwrap.Create (expr);
490 else
491 unwrap = expr;
492
493 Expression conv = expr_type == t_el ? unwrap : ImplicitNumericConversion (unwrap, expr_type, t_el);
494 if (conv == null)
495 return null;
496
497 if (expr_type != expr.Type)
498 return new Nullable.Lifted (conv, unwrap, target_type).Resolve (ec);
499
500 // Do constant optimization for S -> T?
501 if (unwrap is Constant)
502 conv = ((Constant) unwrap).ConvertImplicitly (ec, t_el);
503
504 return Nullable.Wrap.Create (conv, target_type);
505 }
506
507 /// <summary>
508 /// Implicit Numeric Conversions.
509 ///
510 /// expr is the expression to convert, returns a new expression of type
511 /// target_type or null if an implicit conversion is not possible.
512 /// </summary>
513 public static Expression ImplicitNumericConversion (Expression expr, Type target_type)
514 {
515 return ImplicitNumericConversion (expr, expr.Type, target_type);
516 }
517
518 static Expression ImplicitNumericConversion (Expression expr, Type expr_type, Type target_type)
519 {
520 if (expr_type == TypeManager.sbyte_type){
521 //
522 // From sbyte to short, int, long, float, double, decimal
523 //
524 if (target_type == TypeManager.int32_type)
525 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
526 if (target_type == TypeManager.int64_type)
527 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
528 if (target_type == TypeManager.double_type)
529 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
530 if (target_type == TypeManager.float_type)
531 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
532 if (target_type == TypeManager.short_type)
533 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
534 if (target_type == TypeManager.decimal_type)
535 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
536 } else if (expr_type == TypeManager.byte_type){
537 //
538 // From byte to short, ushort, int, uint, long, ulong, float, double, decimal
539 //
540 if (target_type == TypeManager.int32_type || target_type == TypeManager.uint32_type ||
541 target_type == TypeManager.short_type || target_type == TypeManager.ushort_type)
542 return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
543
544 if (target_type == TypeManager.uint64_type)
545 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
546 if (target_type == TypeManager.int64_type)
547 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
548 if (target_type == TypeManager.float_type)
549 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
550 if (target_type == TypeManager.double_type)
551 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
552 if (target_type == TypeManager.decimal_type)
553 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
554
555 } else if (expr_type == TypeManager.short_type){
556 //
557 // From short to int, long, float, double, decimal
558 //
559 if (target_type == TypeManager.int32_type)
560 return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
561 if (target_type == TypeManager.int64_type)
562 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
563 if (target_type == TypeManager.double_type)
564 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
565 if (target_type == TypeManager.float_type)
566 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
567 if (target_type == TypeManager.decimal_type)
568 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
569
570 } else if (expr_type == TypeManager.ushort_type){
571 //
572 // From ushort to int, uint, long, ulong, float, double, decimal
573 //
574 if (target_type == TypeManager.int32_type || target_type == TypeManager.uint32_type)
575 return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
576
577 if (target_type == TypeManager.uint64_type)
578 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
579 if (target_type == TypeManager.int64_type)
580 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
581 if (target_type == TypeManager.double_type)
582 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
583 if (target_type == TypeManager.float_type)
584 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
585 if (target_type == TypeManager.decimal_type)
586 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
587 } else if (expr_type == TypeManager.int32_type){
588 //
589 // From int to long, float, double, decimal
590 //
591 if (target_type == TypeManager.int64_type)
592 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
593 if (target_type == TypeManager.double_type)
594 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
595 if (target_type == TypeManager.float_type)
596 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
597 if (target_type == TypeManager.decimal_type)
598 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
599 } else if (expr_type == TypeManager.uint32_type){
600 //
601 // From uint to long, ulong, float, double, decimal
602 //
603 if (target_type == TypeManager.int64_type)
604 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
605 if (target_type == TypeManager.uint64_type)
606 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
607 if (target_type == TypeManager.double_type)
608 return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R8);
609 if (target_type == TypeManager.float_type)
610 return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R4);
611 if (target_type == TypeManager.decimal_type)
612 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
613 } else if (expr_type == TypeManager.int64_type){
614 //
615 // From long/ulong to float, double
616 //
617 if (target_type == TypeManager.double_type)
618 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
619 if (target_type == TypeManager.float_type)
620 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
621 if (target_type == TypeManager.decimal_type)
622 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
623 } else if (expr_type == TypeManager.uint64_type){
624 //
625 // From ulong to float, double
626 //
627 if (target_type == TypeManager.double_type)
628 return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R8);
629 if (target_type == TypeManager.float_type)
630 return expr == null ? EmptyExpression.Null : new OpcodeCast (new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un), target_type, OpCodes.Conv_R4);
631 if (target_type == TypeManager.decimal_type)
632 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
633 } else if (expr_type == TypeManager.char_type){
634 //
635 // From char to ushort, int, uint, long, ulong, float, double, decimal
636 //
637 if ((target_type == TypeManager.ushort_type) ||
638 (target_type == TypeManager.int32_type) ||
639 (target_type == TypeManager.uint32_type))
640 return expr == null ? EmptyExpression.Null : EmptyCast.Create (expr, target_type);
641 if (target_type == TypeManager.uint64_type)
642 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
643 if (target_type == TypeManager.int64_type)
644 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
645 if (target_type == TypeManager.float_type)
646 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
647 if (target_type == TypeManager.double_type)
648 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
649 if (target_type == TypeManager.decimal_type)
650 return expr == null ? EmptyExpression.Null : new CastToDecimal (expr);
651 } else if (expr_type == TypeManager.float_type){
652 //
653 // float to double
654 //
655 if (target_type == TypeManager.double_type)
656 return expr == null ? EmptyExpression.Null : new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
657 }
658
659 return null;
660 }
661
662 /// <summary>
663 /// Same as ImplicitStandardConversionExists except that it also looks at
664 /// implicit user defined conversions - needed for overload resolution
665 /// </summary>
666 public static bool ImplicitConversionExists (ResolveContext ec, Expression expr, Type target_type)
667 {
668 if (ImplicitStandardConversionExists (expr, target_type))
669 return true;
670
671 if (expr.Type == InternalType.AnonymousMethod) {
672 if (!TypeManager.IsDelegateType (target_type) &&
673 TypeManager.DropGenericTypeArguments (target_type) != TypeManager.expression_type)
674 return false;
675
676 AnonymousMethodExpression ame = (AnonymousMethodExpression) expr;
677 return ame.ImplicitStandardConversionExists (ec, target_type);
678 }
679
680 if (expr.eclass == ExprClass.MethodGroup) {
681 if (TypeManager.IsDelegateType (target_type) && RootContext.Version != LanguageVersion.ISO_1) {
682 MethodGroupExpr mg = expr as MethodGroupExpr;
683 if (mg != null)
684 return DelegateCreation.ImplicitStandardConversionExists (ec, mg, target_type);
685 }
686
687 return false;
688 }
689
690 return ImplicitUserConversion (ec, expr, target_type, Location.Null) != null;
691 }
692
693 /// <summary>
694 /// Determines if a standard implicit conversion exists from
695 /// expr_type to target_type
696 ///
697 /// ec should point to a real EmitContext if expr.Type is TypeManager.anonymous_method_type.
698 /// </summary>
699 public static bool ImplicitStandardConversionExists (Expression expr, Type target_type)
700 {
701 Type expr_type = expr.Type;
702
703 if (expr_type == TypeManager.null_type) {
704 NullLiteral nl = expr as NullLiteral;
705 if (nl != null)
706 return nl.ConvertImplicitly (null, target_type) != null;
707 }
708
709 if (expr_type == TypeManager.void_type)
710 return false;
711
712 if (TypeManager.IsEqual (expr_type, target_type))
713 return true;
714
715 if (TypeManager.IsNullableType (target_type)) {
716 return ImplicitNulableConversion (null, expr, target_type) != null;
717 }
718
719 // First numeric conversions
720 if (ImplicitNumericConversion (null, expr_type, target_type) != null)
721 return true;
722
723 if (ImplicitReferenceConversionExists (expr, target_type))
724 return true;
725
726 bool use_class_cast;
727 if (ImplicitBoxingConversionExists (expr, target_type, out use_class_cast))
728 return true;
729
730 //
731 // Implicit Constant Expression Conversions
732 //
733 if (expr is IntConstant){
734 int value = ((IntConstant) expr).Value;
735
736 if (target_type == TypeManager.sbyte_type){
737 if (value >= SByte.MinValue && value <= SByte.MaxValue)
738 return true;
739 } else if (target_type == TypeManager.byte_type){
740 if (value >= 0 && value <= Byte.MaxValue)
741 return true;
742 } else if (target_type == TypeManager.short_type){
743 if (value >= Int16.MinValue && value <= Int16.MaxValue)
744 return true;
745 } else if (target_type == TypeManager.ushort_type){
746 if (value >= UInt16.MinValue && value <= UInt16.MaxValue)
747 return true;
748 } else if (target_type == TypeManager.uint32_type){
749 if (value >= 0)
750 return true;
751 } else if (target_type == TypeManager.uint64_type){
752 //
753 // we can optimize this case: a positive int32
754 // always fits on a uint64. But we need an opcode
755 // to do it.
756 //
757 if (value >= 0)
758 return true;
759 }
760
761 if (value == 0 && TypeManager.IsEnumType (target_type))
762 return true;
763 }
764
765 if (expr is LongConstant && target_type == TypeManager.uint64_type){
766 //
767 // Try the implicit constant expression conversion
768 // from long to ulong, instead of a nice routine,
769 // we just inline it
770 //
771 long v = ((LongConstant) expr).Value;
772 if (v >= 0)
773 return true;
774 }
775
776 //
777 // If `expr_type' implements `target_type' (which is an iface)
778 // see TryImplicitIntConversion
779 //
780 if (target_type.IsInterface && TypeManager.ImplementsInterface (expr_type, target_type))
781 return true;
782
783 if (target_type == TypeManager.void_ptr_type && expr_type.IsPointer)
784 return true;
785
786 // Conversion from __arglist to System.ArgIterator
787 if (expr_type == InternalType.Arglist)
788 return target_type == TypeManager.arg_iterator_type;
789
790 return false;
791 }
792
793 /// <summary>
794 /// Finds "most encompassed type" according to the spec (13.4.2)
795 /// amongst the methods in the MethodGroupExpr
796 /// </summary>
797 static Type FindMostEncompassedType (IList<Type> types)
798 {
799 Type best = null;
800
801 if (types.Count == 0)
802 return null;
803
804 if (types.Count == 1)
805 return (Type) types [0];
806
807 EmptyExpression expr = EmptyExpression.Grab ();
808
809 foreach (Type t in types) {
810 if (best == null) {
811 best = t;
812 continue;
813 }
814
815 expr.SetType (t);
816 if (ImplicitStandardConversionExists (expr, best))
817 best = t;
818 }
819
820 expr.SetType (best);
821 foreach (Type t in types) {
822 if (best == t)
823 continue;
824 if (!ImplicitStandardConversionExists (expr, t)) {
825 best = null;
826 break;
827 }
828 }
829
830 EmptyExpression.Release (expr);
831
832 return best;
833 }
834
835 /// <summary>
836 /// Finds "most encompassing type" according to the spec (13.4.2)
837 /// amongst the types in the given set
838 /// </summary>
839 static Type FindMostEncompassingType (IList<Type> types)
840 {
841 Type best = null;
842
843 if (types.Count == 0)
844 return null;
845
846 if (types.Count == 1)
847 return types [0];
848
849 EmptyExpression expr = EmptyExpression.Grab ();
850
851 foreach (Type t in types) {
852 if (best == null) {
853 best = t;
854 continue;
855 }
856
857 expr.SetType (best);
858 if (ImplicitStandardConversionExists (expr, t))
859 best = t;
860 }
861
862 foreach (Type t in types) {
863 if (best == t)
864 continue;
865 expr.SetType (t);
866 if (!ImplicitStandardConversionExists (expr, best)) {
867 best = null;
868 break;
869 }
870 }
871
872 EmptyExpression.Release (expr);
873
874 return best;
875 }
876
877 /// <summary>
878 /// Finds the most specific source Sx according to the rules of the spec (13.4.4)
879 /// by making use of FindMostEncomp* methods. Applies the correct rules separately
880 /// for explicit and implicit conversion operators.
881 /// </summary>
882 static public Type FindMostSpecificSource (IList<MethodSpec> list,
883 Expression source, bool apply_explicit_conv_rules)
884 {
885 var src_types_set = new List<Type> ();
886
887 //
888 // If any operator converts from S then Sx = S
889 //
890 Type source_type = source.Type;
891 foreach (var mb in list){
892 Type param_type = mb.Parameters.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 var candidate_set = new List<Type> ();
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<MethodSpec> list,
928 Type target, bool apply_explicit_conv_rules)
929 {
930 var tgt_types_set = new List<Type> ();
931
932 //
933 // If any operator converts to T then Tx = T
934 //
935 foreach (var 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 var candidate_set = new List<Type> ();
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 (List<MethodSpec> 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 (var m in mg.Methods) {
1016 AParametersCollection pd = m.Parameters;
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 MethodSpec GetConversionOperator (CompilerContext ctx, Type container_type, Expression source, Type target_type, bool look_for_explicit)
1056 {
1057 var ops = new List<MethodSpec> (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 MethodSpec method = null;
1093
1094 foreach (var m in ops) {
1095 if (TypeManager.TypeToCoreType (m.ReturnType) != most_specific_target)
1096 continue;
1097 if (m.Parameters.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 MethodSpec 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 = (MethodSpec) 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 = method.Parameters.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