?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
In ilasm/tests:
[mcs.git] / bmcs / generic.cs
blob1f641368957eca9ca5486117e060adc9fa6dcfa2
1 //
2 // generic.cs: Generics support
3 //
4 // Authors: Martin Baulig (martin@ximian.com)
5 // Miguel de Icaza (miguel@ximian.com)
6 //
7 // Licensed under the terms of the GNU GPL
8 //
9 // (C) 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
10 // (C) 2004 Novell, Inc
11 //
12 using System;
13 using System.Reflection;
14 using System.Reflection.Emit;
15 using System.Globalization;
16 using System.Collections;
17 using System.Text;
18 using System.Text.RegularExpressions;
19
20 namespace Mono.CSharp {
21
22 public abstract class GenericConstraints {
23 public abstract GenericParameterAttributes Attributes {
24 get;
25 }
26
27 public bool HasConstructorConstraint {
28 get { return (Attributes & GenericParameterAttributes.DefaultConstructorConstraint) != 0; }
29 }
30
31 public bool HasReferenceTypeConstraint {
32 get { return (Attributes & GenericParameterAttributes.ReferenceTypeConstraint) != 0; }
33 }
34
35 public bool HasValueTypeConstraint {
36 get { return (Attributes & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0; }
37 }
38
39 public virtual bool HasClassConstraint {
40 get { return ClassConstraint != null; }
41 }
42
43 public abstract Type ClassConstraint {
44 get;
45 }
46
47 public abstract Type[] InterfaceConstraints {
48 get;
49 }
50
51 public abstract Type EffectiveBaseClass {
52 get;
53 }
54
55 // <summary>
56 // Returns whether the type parameter is "known to be a reference type".
57 // </summary>
58 public virtual bool IsReferenceType {
59 get {
60 if (HasReferenceTypeConstraint)
61 return true;
62 if (HasValueTypeConstraint)
63 return false;
64
65 if (ClassConstraint != null) {
66 if (ClassConstraint.IsValueType)
67 return false;
68
69 if (ClassConstraint != TypeManager.object_type)
70 return true;
71 }
72
73 foreach (Type t in InterfaceConstraints) {
74 if (!t.IsGenericParameter)
75 continue;
76
77 GenericConstraints gc = TypeManager.GetTypeParameterConstraints (t);
78 if ((gc != null) && gc.IsReferenceType)
79 return true;
80 }
81
82 return false;
83 }
84 }
85
86 // <summary>
87 // Returns whether the type parameter is "known to be a value type".
88 // </summary>
89 public virtual bool IsValueType {
90 get {
91 if (HasValueTypeConstraint)
92 return true;
93 if (HasReferenceTypeConstraint)
94 return false;
95
96 if (ClassConstraint != null) {
97 if (!ClassConstraint.IsValueType)
98 return false;
99
100 if (ClassConstraint != TypeManager.value_type)
101 return true;
102 }
103
104 foreach (Type t in InterfaceConstraints) {
105 if (!t.IsGenericParameter)
106 continue;
107
108 GenericConstraints gc = TypeManager.GetTypeParameterConstraints (t);
109 if ((gc != null) && gc.IsValueType)
110 return true;
111 }
112
113 return false;
114 }
115 }
116 }
117
118 public enum SpecialConstraint
119 {
120 Constructor,
121 ReferenceType,
122 ValueType
123 }
124
125 //
126 // Tracks the constraints for a type parameter
127 //
128 public class Constraints : GenericConstraints {
129 string name;
130 ArrayList constraints;
131 Location loc;
132
133 //
134 // name is the identifier, constraints is an arraylist of
135 // Expressions (with types) or `true' for the constructor constraint.
136 //
137 public Constraints (string name, ArrayList constraints,
138 Location loc)
139 {
140 this.name = name;
141 this.constraints = constraints;
142 this.loc = loc;
143 }
144
145 public string TypeParameter {
146 get {
147 return name;
148 }
149 }
150
151 GenericParameterAttributes attrs;
152 TypeExpr class_constraint;
153 ArrayList iface_constraints;
154 ArrayList type_param_constraints;
155 int num_constraints, first_constraint;
156 Type class_constraint_type;
157 Type[] iface_constraint_types;
158 Type effective_base_type;
159
160 public bool Resolve (EmitContext ec)
161 {
162 iface_constraints = new ArrayList ();
163 type_param_constraints = new ArrayList ();
164
165 foreach (object obj in constraints) {
166 if (HasConstructorConstraint) {
167 Report.Error (401, loc,
168 "The new() constraint must be last.");
169 return false;
170 }
171
172 if (obj is SpecialConstraint) {
173 SpecialConstraint sc = (SpecialConstraint) obj;
174
175 if (sc == SpecialConstraint.Constructor) {
176 if (!HasValueTypeConstraint) {
177 attrs |= GenericParameterAttributes.DefaultConstructorConstraint;
178 continue;
179 }
180
181 Report.Error (
182 451, loc, "The new () constraint " +
183 "cannot be used with the `struct' " +
184 "constraint.");
185 return false;
186 }
187
188 if ((num_constraints > 0) || HasReferenceTypeConstraint || HasValueTypeConstraint) {
189 Report.Error (449, loc,
190 "The `class' or `struct' " +
191 "constraint must be first");
192 return false;
193 }
194
195 if (sc == SpecialConstraint.ReferenceType)
196 attrs |= GenericParameterAttributes.ReferenceTypeConstraint;
197 else
198 attrs |= GenericParameterAttributes.NotNullableValueTypeConstraint;
199 continue;
200 }
201
202 TypeExpr expr;
203 if (obj is ConstructedType) {
204 ConstructedType cexpr = (ConstructedType) obj;
205 if (!cexpr.ResolveConstructedType (ec))
206 return false;
207 expr = cexpr;
208 } else
209 expr = ((Expression) obj).ResolveAsTypeTerminal (ec);
210
211 if (expr == null)
212 return false;
213
214 TypeParameterExpr texpr = expr as TypeParameterExpr;
215 if (texpr != null)
216 type_param_constraints.Add (expr);
217 else if (expr.IsInterface)
218 iface_constraints.Add (expr);
219 else if (class_constraint != null) {
220 Report.Error (406, loc,
221 "`{0}': the class constraint for `{1}' " +
222 "must come before any other constraints.",
223 expr.Name, name);
224 return false;
225 } else if (HasReferenceTypeConstraint || HasValueTypeConstraint) {
226 Report.Error (450, loc, "`{0}': cannot specify both " +
227 "a constraint class and the `class' " +
228 "or `struct' constraint.", expr.Name);
229 return false;
230 } else
231 class_constraint = expr;
232
233 num_constraints++;
234 }
235
236 return true;
237 }
238
239 bool CheckTypeParameterConstraints (TypeParameter tparam, Hashtable seen)
240 {
241 seen.Add (tparam, true);
242
243 Constraints constraints = tparam.Constraints;
244 if (constraints == null)
245 return true;
246
247 if (constraints.HasValueTypeConstraint) {
248 Report.Error (456, loc, "Type parameter `{0}' has " +
249 "the `struct' constraint, so it cannot " +
250 "be used as a constraint for `{1}'",
251 tparam.Name, name);
252 return false;
253 }
254
255 if (constraints.type_param_constraints == null)
256 return true;
257
258 foreach (TypeParameterExpr expr in constraints.type_param_constraints) {
259 if (seen.Contains (expr.TypeParameter)) {
260 Report.Error (454, loc, "Circular constraint " +
261 "dependency involving `{0}' and `{1}'",
262 tparam.Name, expr.Name);
263 return false;
264 }
265
266 if (!CheckTypeParameterConstraints (expr.TypeParameter, seen))
267 return false;
268 }
269
270 return true;
271 }
272
273 public bool ResolveTypes (EmitContext ec)
274 {
275 if (effective_base_type != null)
276 return true;
277
278 foreach (object obj in constraints) {
279 ConstructedType cexpr = obj as ConstructedType;
280 if (cexpr == null)
281 continue;
282
283 if (!cexpr.CheckConstraints (ec))
284 return false;
285 }
286
287 foreach (TypeParameterExpr expr in type_param_constraints) {
288 Hashtable seen = new Hashtable ();
289 if (!CheckTypeParameterConstraints (expr.TypeParameter, seen))
290 return false;
291 }
292
293 ArrayList list = new ArrayList ();
294
295 foreach (TypeExpr iface_constraint in iface_constraints) {
296 foreach (Type type in list) {
297 if (!type.Equals (iface_constraint.Type))
298 continue;
299
300 Report.Error (405, loc,
301 "Duplicate constraint `{0}' for type " +
302 "parameter `{1}'.", iface_constraint.Type,
303 name);
304 return false;
305 }
306
307 list.Add (iface_constraint.Type);
308 }
309
310 foreach (TypeParameterExpr expr in type_param_constraints) {
311 foreach (Type type in list) {
312 if (!type.Equals (expr.Type))
313 continue;
314
315 Report.Error (405, loc,
316 "Duplicate constraint `{0}' for type " +
317 "parameter `{1}'.", expr.Type, name);
318 return false;
319 }
320
321 list.Add (expr.Type);
322 }
323
324 iface_constraint_types = new Type [list.Count];
325 list.CopyTo (iface_constraint_types, 0);
326
327 if (class_constraint != null) {
328 class_constraint_type = class_constraint.Type;
329 if (class_constraint_type == null)
330 return false;
331
332 if (class_constraint_type.IsSealed) {
333 Report.Error (701, loc,
334 "`{0}' is not a valid bound. Bounds " +
335 "must be interfaces or non sealed " +
336 "classes", class_constraint_type);
337 return false;
338 }
339
340 if ((class_constraint_type == TypeManager.array_type) ||
341 (class_constraint_type == TypeManager.delegate_type) ||
342 (class_constraint_type == TypeManager.enum_type) ||
343 (class_constraint_type == TypeManager.value_type) ||
344 (class_constraint_type == TypeManager.object_type)) {
345 Report.Error (702, loc,
346 "Bound cannot be special class `{0}'",
347 class_constraint_type);
348 return false;
349 }
350 }
351
352 if (class_constraint_type != null)
353 effective_base_type = class_constraint_type;
354 else if (HasValueTypeConstraint)
355 effective_base_type = TypeManager.value_type;
356 else
357 effective_base_type = TypeManager.object_type;
358
359 return true;
360 }
361
362 public bool CheckDependencies (EmitContext ec)
363 {
364 foreach (TypeParameterExpr expr in type_param_constraints) {
365 if (!CheckDependencies (expr.TypeParameter, ec))
366 return false;
367 }
368
369 return true;
370 }
371
372 bool CheckDependencies (TypeParameter tparam, EmitContext ec)
373 {
374 Constraints constraints = tparam.Constraints;
375 if (constraints == null)
376 return true;
377
378 if (HasValueTypeConstraint && constraints.HasClassConstraint) {
379 Report.Error (455, loc, "Type parameter `{0}' inherits " +
380 "conflicting constraints `{1}' and `{2}'",
381 name, constraints.ClassConstraint,
382 "System.ValueType");
383 return false;
384 }
385
386 if (HasClassConstraint && constraints.HasClassConstraint) {
387 Type t1 = ClassConstraint;
388 TypeExpr e1 = class_constraint;
389 Type t2 = constraints.ClassConstraint;
390 TypeExpr e2 = constraints.class_constraint;
391
392 if (!Convert.WideningReferenceConversionExists (ec, e1, t2) &&
393 !Convert.WideningReferenceConversionExists (ec, e2, t1)) {
394 Report.Error (455, loc,
395 "Type parameter `{0}' inherits " +
396 "conflicting constraints `{1}' and `{2}'",
397 name, t1, t2);
398 return false;
399 }
400 }
401
402 if (constraints.type_param_constraints == null)
403 return true;
404
405 foreach (TypeParameterExpr expr in constraints.type_param_constraints) {
406 if (!CheckDependencies (expr.TypeParameter, ec))
407 return false;
408 }
409
410 return true;
411 }
412
413 public void Define (GenericTypeParameterBuilder type)
414 {
415 type.SetGenericParameterAttributes (attrs);
416 }
417
418 public override GenericParameterAttributes Attributes {
419 get { return attrs; }
420 }
421
422 public override bool HasClassConstraint {
423 get { return class_constraint != null; }
424 }
425
426 public override Type ClassConstraint {
427 get { return class_constraint_type; }
428 }
429
430 public override Type[] InterfaceConstraints {
431 get { return iface_constraint_types; }
432 }
433
434 public override Type EffectiveBaseClass {
435 get { return effective_base_type; }
436 }
437
438 internal bool IsSubclassOf (Type t)
439 {
440 if ((class_constraint_type != null) &&
441 class_constraint_type.IsSubclassOf (t))
442 return true;
443
444 if (iface_constraint_types == null)
445 return false;
446
447 foreach (Type iface in iface_constraint_types) {
448 if (TypeManager.IsSubclassOf (iface, t))
449 return true;
450 }
451
452 return false;
453 }
454
455 public bool CheckInterfaceMethod (EmitContext ec, GenericConstraints gc)
456 {
457 if (gc.Attributes != attrs)
458 return false;
459
460 if (HasClassConstraint != gc.HasClassConstraint)
461 return false;
462 if (HasClassConstraint && !TypeManager.IsEqual (gc.ClassConstraint, ClassConstraint))
463 return false;
464
465 int gc_icount = gc.InterfaceConstraints != null ?
466 gc.InterfaceConstraints.Length : 0;
467 int icount = InterfaceConstraints != null ?
468 InterfaceConstraints.Length : 0;
469
470 if (gc_icount != icount)
471 return false;
472
473 foreach (Type iface in gc.InterfaceConstraints) {
474 bool ok = false;
475 foreach (Type check in InterfaceConstraints) {
476 if (TypeManager.IsEqual (iface, check)) {
477 ok = true;
478 break;
479 }
480 }
481
482 if (!ok)
483 return false;
484 }
485
486 return true;
487 }
488 }
489
490 //
491 // This type represents a generic type parameter
492 //
493 public class TypeParameter : MemberCore, IMemberContainer {
494 string name;
495 GenericConstraints gc;
496 Constraints constraints;
497 Location loc;
498 GenericTypeParameterBuilder type;
499
500 public TypeParameter (TypeContainer parent, string name,
501 Constraints constraints, Location loc)
502 : base (parent, new MemberName (name), null, loc)
503 {
504 this.name = name;
505 this.constraints = constraints;
506 this.loc = loc;
507 }
508
509 public GenericConstraints GenericConstraints {
510 get {
511 return gc != null ? gc : constraints;
512 }
513 }
514
515 public Constraints Constraints {
516 get {
517 return constraints;
518 }
519 }
520
521 public bool HasConstructorConstraint {
522 get {
523 if (constraints != null)
524 return constraints.HasConstructorConstraint;
525
526 return false;
527 }
528 }
529
530 public Type Type {
531 get {
532 return type;
533 }
534 }
535
536 public bool Resolve (DeclSpace ds)
537 {
538 if (constraints != null) {
539 if (!constraints.Resolve (ds.EmitContext)) {
540 constraints = null;
541 return false;
542 }
543 }
544
545 return true;
546 }
547
548 public void Define (GenericTypeParameterBuilder type)
549 {
550 if (this.type != null)
551 throw new InvalidOperationException ();
552
553 this.type = type;
554 TypeManager.AddTypeParameter (type, this);
555 }
556
557 public void DefineConstraints ()
558 {
559 if (constraints != null)
560 constraints.Define (type);
561 }
562
563 public bool ResolveType (EmitContext ec)
564 {
565 if (constraints != null) {
566 if (!constraints.ResolveTypes (ec)) {
567 constraints = null;
568 return false;
569 }
570 }
571
572 return true;
573 }
574
575 public bool DefineType (EmitContext ec)
576 {
577 return DefineType (ec, null, null, false);
578 }
579
580 public bool DefineType (EmitContext ec, MethodBuilder builder,
581 MethodInfo implementing, bool is_override)
582 {
583 if (!ResolveType (ec))
584 return false;
585
586 if (implementing != null) {
587 if (is_override && (constraints != null)) {
588 Report.Error (
589 460, loc, "Constraints for override and " +
590 "explicit interface implementation methods " +
591 "are inherited from the base method so they " +
592 "cannot be specified directly");
593 return false;
594 }
595
596 MethodBase mb = implementing;
597 if (mb.Mono_IsInflatedMethod)
598 mb = mb.GetGenericMethodDefinition ();
599
600 int pos = type.GenericParameterPosition;
601 ParameterData pd = Invocation.GetParameterData (mb);
602 GenericConstraints temp_gc = pd.GenericConstraints (pos);
603 Type mparam = mb.GetGenericArguments () [pos];
604
605 if (temp_gc != null)
606 gc = new InflatedConstraints (temp_gc, implementing.DeclaringType);
607 else if (constraints != null)
608 gc = new InflatedConstraints (constraints, implementing.DeclaringType);
609
610 bool ok = true;
611 if (constraints != null) {
612 if (temp_gc == null)
613 ok = false;
614 else if (!constraints.CheckInterfaceMethod (ec, gc))
615 ok = false;
616 } else {
617 if (!is_override && (temp_gc != null))
618 ok = false;
619 }
620
621 if (!ok) {
622 Report.SymbolRelatedToPreviousError (implementing);
623
624 Report.Error (
625 425, loc, "The constraints for type " +
626 "parameter `{0}' of method `{1}' must match " +
627 "the constraints for type parameter `{2}' " +
628 "of interface method `{3}'. Consider using " +
629 "an explicit interface implementation instead",
630 Name, TypeManager.CSharpSignature (builder),
631 mparam, TypeManager.CSharpSignature (mb));
632 return false;
633 }
634 } else {
635 gc = (GenericConstraints) constraints;
636 }
637
638 if (gc == null)
639 return true;
640
641 if (gc.HasClassConstraint)
642 type.SetBaseTypeConstraint (gc.ClassConstraint);
643
644 type.SetInterfaceConstraints (gc.InterfaceConstraints);
645 TypeManager.RegisterBuilder (type, gc.InterfaceConstraints);
646
647 return true;
648 }
649
650 public bool CheckDependencies (EmitContext ec)
651 {
652 if (constraints != null)
653 return constraints.CheckDependencies (ec);
654
655 return true;
656 }
657
658 public bool UpdateConstraints (EmitContext ec, Constraints new_constraints, bool check)
659 {
660 //
661 // We're used in partial generic type definitions.
662 // If `check' is false, we just encountered the first ClassPart which has
663 // constraints - they become our "real" constraints.
664 // Otherwise we're called after the type parameters have already been defined
665 // and check whether the constraints are the same in all parts.
666 //
667 if (!check) {
668 if (type != null)
669 throw new InvalidOperationException ();
670 constraints = new_constraints;
671 return true;
672 }
673
674 if (type == null)
675 throw new InvalidOperationException ();
676
677 if (constraints == null)
678 return new_constraints == null;
679 else if (new_constraints == null)
680 return false;
681
682 if (!new_constraints.Resolve (ec))
683 return false;
684 if (!new_constraints.ResolveTypes (ec))
685 return false;
686
687 return constraints.CheckInterfaceMethod (ec, new_constraints);
688 }
689
690 public override string DocCommentHeader {
691 get {
692 throw new InvalidOperationException (
693 "Unexpected attempt to get doc comment from " + this.GetType () + ".");
694 }
695 }
696
697 //
698 // MemberContainer
699 //
700
701 public override bool Define ()
702 {
703 return true;
704 }
705
706 protected override void VerifyObsoleteAttribute ()
707 { }
708
709 public override void ApplyAttributeBuilder (Attribute a,
710 CustomAttributeBuilder cb)
711 { }
712
713 public override AttributeTargets AttributeTargets {
714 get {
715 return (AttributeTargets) 0;
716 }
717 }
718
719 public override string[] ValidAttributeTargets {
720 get {
721 return new string [0];
722 }
723 }
724
725 //
726 // IMemberContainer
727 //
728
729 string IMemberContainer.Name {
730 get { return Name; }
731 }
732
733 MemberCache IMemberContainer.BaseCache {
734 get { return null; }
735 }
736
737 bool IMemberContainer.IsInterface {
738 get { return true; }
739 }
740
741 MemberList IMemberContainer.GetMembers (MemberTypes mt, BindingFlags bf)
742 {
743 return FindMembers (mt, bf, null, null);
744 }
745
746 MemberCache IMemberContainer.MemberCache {
747 get { return null; }
748 }
749
750 public MemberList FindMembers (MemberTypes mt, BindingFlags bf,
751 MemberFilter filter, object criteria)
752 {
753 if (constraints == null)
754 return MemberList.Empty;
755
756 ArrayList members = new ArrayList ();
757
758 GenericConstraints gc = (GenericConstraints) constraints;
759
760 if (gc.HasClassConstraint) {
761 MemberList list = TypeManager.FindMembers (
762 gc.ClassConstraint, mt, bf, filter, criteria);
763
764 members.AddRange (list);
765 }
766
767 foreach (Type t in gc.InterfaceConstraints) {
768 MemberList list = TypeManager.FindMembers (
769 t, mt, bf, filter, criteria);
770
771 members.AddRange (list);
772 }
773
774 return new MemberList (members);
775 }
776
777 public bool IsSubclassOf (Type t)
778 {
779 if (type.Equals (t))
780 return true;
781
782 if (constraints != null)
783 return constraints.IsSubclassOf (t);
784
785 return false;
786 }
787
788 public override string ToString ()
789 {
790 return "TypeParameter[" + name + "]";
791 }
792
793 protected class InflatedConstraints : GenericConstraints
794 {
795 GenericConstraints gc;
796 Type base_type;
797 Type class_constraint;
798 Type[] iface_constraints;
799 Type[] dargs;
800 Type declaring;
801
802 public InflatedConstraints (GenericConstraints gc, Type declaring)
803 {
804 this.gc = gc;
805 this.declaring = declaring;
806
807 dargs = TypeManager.GetTypeArguments (declaring);
808
809 ArrayList list = new ArrayList ();
810 if (gc.HasClassConstraint)
811 list.Add (inflate (gc.ClassConstraint));
812 foreach (Type iface in gc.InterfaceConstraints)
813 list.Add (inflate (iface));
814
815 bool has_class_constr = false;
816 if (list.Count > 0) {
817 Type first = (Type) list [0];
818 has_class_constr = !first.IsInterface && !first.IsGenericParameter;
819 }
820
821 if ((list.Count > 0) && has_class_constr) {
822 class_constraint = (Type) list [0];
823 iface_constraints = new Type [list.Count - 1];
824 list.CopyTo (1, iface_constraints, 0, list.Count - 1);
825 } else {
826 iface_constraints = new Type [list.Count];
827 list.CopyTo (iface_constraints, 0);
828 }
829
830 if (HasValueTypeConstraint)
831 base_type = TypeManager.value_type;
832 else if (class_constraint != null)
833 base_type = class_constraint;
834 else
835 base_type = TypeManager.object_type;
836 }
837
838 Type inflate (Type t)
839 {
840 if (t == null)
841 return null;
842 if (t.IsGenericParameter)
843 return dargs [t.GenericParameterPosition];
844 if (t.IsGenericInstance) {
845 t = t.GetGenericTypeDefinition ();
846 t = t.MakeGenericType (dargs);
847 }
848
849 return t;
850 }
851
852 public override GenericParameterAttributes Attributes {
853 get { return gc.Attributes; }
854 }
855
856 public override Type ClassConstraint {
857 get { return class_constraint; }
858 }
859
860 public override Type EffectiveBaseClass {
861 get { return base_type; }
862 }
863
864 public override Type[] InterfaceConstraints {
865 get { return iface_constraints; }
866 }
867 }
868 }
869
870 //
871 // This type represents a generic type parameter reference.
872 //
873 // These expressions are born in a fully resolved state.
874 //
875 public class TypeParameterExpr : TypeExpr {
876 TypeParameter type_parameter;
877
878 public override string Name {
879 get {
880 return type_parameter.Name;
881 }
882 }
883
884 public override string FullName {
885 get {
886 return type_parameter.Name;
887 }
888 }
889
890 public TypeParameter TypeParameter {
891 get {
892 return type_parameter;
893 }
894 }
895
896 public TypeParameterExpr (TypeParameter type_parameter, Location loc)
897 {
898 this.type_parameter = type_parameter;
899 this.loc = loc;
900 }
901
902 protected override TypeExpr DoResolveAsTypeStep (EmitContext ec)
903 {
904 type = type_parameter.Type;
905
906 return this;
907 }
908
909 public override bool IsInterface {
910 get { return false; }
911 }
912
913 public override bool CheckAccessLevel (DeclSpace ds)
914 {
915 return true;
916 }
917
918 public void Error_CannotUseAsUnmanagedType (Location loc)
919 {
920 Report.Error (-203, loc, "Can not use type parameter as unamanged type");
921 }
922 }
923
924 public class TypeArguments {
925 public readonly Location Location;
926 ArrayList args;
927 Type[] atypes;
928 int dimension;
929 bool has_type_args;
930 bool created;
931
932 public TypeArguments (Location loc)
933 {
934 args = new ArrayList ();
935 this.Location = loc;
936 }
937
938 public TypeArguments (int dimension, Location loc)
939 {
940 this.dimension = dimension;
941 this.Location = loc;
942 }
943
944 public void Add (Expression type)
945 {
946 if (created)
947 throw new InvalidOperationException ();
948
949 args.Add (type);
950 }
951
952 public void Add (TypeArguments new_args)
953 {
954 if (created)
955 throw new InvalidOperationException ();
956
957 args.AddRange (new_args.args);
958 }
959
960 public string[] GetDeclarations ()
961 {
962 string[] ret = new string [args.Count];
963 for (int i = 0; i < args.Count; i++) {
964 SimpleName sn = args [i] as SimpleName;
965 if (sn != null) {
966 ret [i] = sn.Name;
967 continue;
968 }
969
970 Report.Error (81, Location, "Type parameter declaration " +
971 "must be an identifier not a type");
972 return null;
973 }
974 return ret;
975 }
976
977 public Type[] Arguments {
978 get {
979 return atypes;
980 }
981 }
982
983 public bool HasTypeArguments {
984 get {
985 return has_type_args;
986 }
987 }
988
989 public int Count {
990 get {
991 if (dimension > 0)
992 return dimension;
993 else
994 return args.Count;
995 }
996 }
997
998 public bool IsUnbound {
999 get {
1000 return dimension > 0;
1001 }
1002 }
1003
1004 public override string ToString ()
1005 {
1006 StringBuilder s = new StringBuilder ();
1007
1008 int count = Count;
1009 for (int i = 0; i < count; i++){
1010 //
1011 // FIXME: Use TypeManager.CSharpname once we have the type
1012 //
1013 if (args != null)
1014 s.Append (args [i].ToString ());
1015 if (i+1 < count)
1016 s.Append (",");
1017 }
1018 return s.ToString ();
1019 }
1020
1021 public bool Resolve (EmitContext ec)
1022 {
1023 int count = args.Count;
1024 bool ok = true;
1025
1026 atypes = new Type [count];
1027
1028 for (int i = 0; i < count; i++){
1029 TypeExpr te = ((Expression) args [i]).ResolveAsTypeTerminal (ec);
1030 if (te == null) {
1031 ok = false;
1032 continue;
1033 }
1034 if (te is TypeParameterExpr)
1035 has_type_args = true;
1036
1037 if (te.Type.IsPointer) {
1038 Report.Error (306, Location, "The type `{0}' may not be used " +
1039 "as a type argument.", TypeManager.CSharpName (te.Type));
1040 return false;
1041 }
1042
1043 atypes [i] = te.Type;
1044 }
1045 return ok;
1046 }
1047 }
1048
1049 public class ConstructedType : TypeExpr {
1050 string name, full_name;
1051 TypeArguments args;
1052 Type[] gen_params, atypes;
1053 Type gt;
1054
1055 public ConstructedType (string name, TypeArguments args, Location l)
1056 {
1057 loc = l;
1058 this.name = MemberName.MakeName (name, args.Count);
1059 this.args = args;
1060
1061 eclass = ExprClass.Type;
1062 full_name = name + "<" + args.ToString () + ">";
1063 }
1064
1065 public ConstructedType (string name, TypeParameter[] type_params, Location l)
1066 : this (type_params, l)
1067 {
1068 loc = l;
1069
1070 this.name = name;
1071 full_name = name + "<" + args.ToString () + ">";
1072 }
1073
1074 public ConstructedType (FullNamedExpression fname, TypeArguments args, Location l)
1075 {
1076 loc = l;
1077 this.name = fname.FullName;
1078 this.args = args;
1079
1080 eclass = ExprClass.Type;
1081 full_name = name + "<" + args.ToString () + ">";
1082 }
1083
1084 protected ConstructedType (TypeArguments args, Location l)
1085 {
1086 loc = l;
1087 this.args = args;
1088
1089 eclass = ExprClass.Type;
1090 }
1091
1092 protected ConstructedType (TypeParameter[] type_params, Location l)
1093 {
1094 loc = l;
1095
1096 args = new TypeArguments (l);
1097 foreach (TypeParameter type_param in type_params)
1098 args.Add (new TypeParameterExpr (type_param, l));
1099
1100 eclass = ExprClass.Type;
1101 }
1102
1103 public ConstructedType (Type t, TypeParameter[] type_params, Location l)
1104 : this (type_params, l)
1105 {
1106 gt = t.GetGenericTypeDefinition ();
1107
1108 this.name = gt.FullName;
1109 full_name = gt.FullName + "<" + args.ToString () + ">";
1110 }
1111
1112 public ConstructedType (Type t, TypeArguments args, Location l)
1113 : this (args, l)
1114 {
1115 gt = t.GetGenericTypeDefinition ();
1116
1117 this.name = gt.FullName;
1118 full_name = gt.FullName + "<" + args.ToString () + ">";
1119 }
1120
1121 public TypeArguments TypeArguments {
1122 get { return args; }
1123 }
1124
1125 protected string DeclarationName {
1126 get {
1127 StringBuilder sb = new StringBuilder ();
1128 sb.Append (gt.FullName);
1129 sb.Append ("<");
1130 for (int i = 0; i < gen_params.Length; i++) {
1131 if (i > 0)
1132 sb.Append (",");
1133 sb.Append (gen_params [i]);
1134 }
1135 sb.Append (">");
1136 return sb.ToString ();
1137 }
1138 }
1139
1140 protected bool CheckConstraint (EmitContext ec, Type ptype, Expression expr,
1141 Type ctype)
1142 {
1143 if (TypeManager.HasGenericArguments (ctype)) {
1144 Type[] types = TypeManager.GetTypeArguments (ctype);
1145
1146 TypeArguments new_args = new TypeArguments (loc);
1147
1148 for (int i = 0; i < types.Length; i++) {
1149 Type t = types [i];
1150
1151 if (t.IsGenericParameter) {
1152 int pos = t.GenericParameterPosition;
1153 t = args.Arguments [pos];
1154 }
1155 new_args.Add (new TypeExpression (t, loc));
1156 }
1157
1158 TypeExpr ct = new ConstructedType (ctype, new_args, loc);
1159 if (ct.ResolveAsTypeTerminal (ec) == null)
1160 return false;
1161 ctype = ct.Type;
1162 }
1163
1164 return Convert.WideningStandardConversionExists (ec, expr, ctype);
1165 }
1166
1167 protected bool CheckConstraints (EmitContext ec, int index)
1168 {
1169 Type atype = atypes [index];
1170 Type ptype = gen_params [index];
1171
1172 if (atype == ptype)
1173 return true;
1174
1175 Expression aexpr = new EmptyExpression (atype);
1176
1177 GenericConstraints gc = TypeManager.GetTypeParameterConstraints (ptype);
1178 if (gc == null)
1179 return true;
1180
1181 bool is_class, is_struct;
1182 if (atype.IsGenericParameter) {
1183 GenericConstraints agc = TypeManager.GetTypeParameterConstraints (atype);
1184 if (agc != null) {
1185 is_class = agc.HasReferenceTypeConstraint;
1186 is_struct = agc.HasValueTypeConstraint;
1187 } else {
1188 is_class = is_struct = false;
1189 }
1190 } else {
1191 is_class = atype.IsClass;
1192 is_struct = atype.IsValueType;
1193 }
1194
1195 //
1196 // First, check the `class' and `struct' constraints.
1197 //
1198 if (gc.HasReferenceTypeConstraint && !is_class) {
1199 Report.Error (452, loc, "The type `{0}' must be " +
1200 "a reference type in order to use it " +
1201 "as type parameter `{1}' in the " +
1202 "generic type or method `{2}'.",
1203 atype, ptype, DeclarationName);
1204 return false;
1205 } else if (gc.HasValueTypeConstraint && !is_struct) {
1206 Report.Error (453, loc, "The type `{0}' must be " +
1207 "a value type in order to use it " +
1208 "as type parameter `{1}' in the " +
1209 "generic type or method `{2}'.",
1210 atype, ptype, DeclarationName);
1211 return false;
1212 }
1213
1214 //
1215 // The class constraint comes next.
1216 //
1217 if (gc.HasClassConstraint) {
1218 if (!CheckConstraint (ec, ptype, aexpr, gc.ClassConstraint)) {
1219 Report.Error (309, loc, "The type `{0}' must be " +
1220 "convertible to `{1}' in order to " +
1221 "use it as parameter `{2}' in the " +
1222 "generic type or method `{3}'",
1223 atype, gc.ClassConstraint, ptype, DeclarationName);
1224 return false;
1225 }
1226 }
1227
1228 //
1229 // Now, check the interface constraints.
1230 //
1231 foreach (Type it in gc.InterfaceConstraints) {
1232 Type itype;
1233 if (it.IsGenericParameter)
1234 itype = atypes [it.GenericParameterPosition];
1235 else
1236 itype = it;
1237
1238 if (!CheckConstraint (ec, ptype, aexpr, itype)) {
1239 Report.Error (309, loc, "The type `{0}' must be " +
1240 "convertible to `{1}' in order to " +
1241 "use it as parameter `{2}' in the " +
1242 "generic type or method `{3}'",
1243 atype, itype, ptype, DeclarationName);
1244 return false;
1245 }
1246 }
1247
1248 //
1249 // Finally, check the constructor constraint.
1250 //
1251
1252 if (!gc.HasConstructorConstraint)
1253 return true;
1254
1255 if (TypeManager.IsBuiltinType (atype) || atype.IsValueType)
1256 return true;
1257
1258 MethodGroupExpr mg = Expression.MemberLookup (
1259 ec, atype, ".ctor", MemberTypes.Constructor,
1260 BindingFlags.Public | BindingFlags.Instance |
1261 BindingFlags.DeclaredOnly, loc)
1262 as MethodGroupExpr;
1263
1264 if (atype.IsAbstract || (mg == null) || !mg.IsInstance) {
1265 Report.Error (310, loc, "The type `{0}' must have a public " +
1266 "parameterless constructor in order to use it " +
1267 "as parameter `{1}' in the generic type or " +
1268 "method `{2}'", atype, ptype, DeclarationName);
1269 return false;
1270 }
1271
1272 return true;
1273 }
1274
1275 protected override TypeExpr DoResolveAsTypeStep (EmitContext ec)
1276 {
1277 if (!ResolveConstructedType (ec))
1278 return null;
1279
1280 return this;
1281 }
1282
1283 public bool CheckConstraints (EmitContext ec)
1284 {
1285 for (int i = 0; i < gen_params.Length; i++) {
1286 if (!CheckConstraints (ec, i))
1287 return false;
1288 }
1289
1290 return true;
1291 }
1292
1293 public override TypeExpr ResolveAsTypeTerminal (EmitContext ec)
1294 {
1295 if (base.ResolveAsTypeTerminal (ec) == null)
1296 return null;
1297
1298 if (!CheckConstraints (ec))
1299 return null;
1300
1301 return this;
1302 }
1303
1304 public bool ResolveConstructedType (EmitContext ec)
1305 {
1306 if (type != null)
1307 return true;
1308 if (gt != null)
1309 return DoResolveType (ec);
1310
1311 //
1312 // First, resolve the generic type.
1313 //
1314 DeclSpace ds;
1315 Type nested = ec.DeclSpace.FindNestedType (loc, name, out ds);
1316 if (nested != null) {
1317 gt = nested.GetGenericTypeDefinition ();
1318
1319 TypeArguments new_args = new TypeArguments (loc);
1320 if (ds.IsGeneric) {
1321 foreach (TypeParameter param in ds.TypeParameters)
1322 new_args.Add (new TypeParameterExpr (param, loc));
1323 }
1324 new_args.Add (args);
1325
1326 args = new_args;
1327 return DoResolveType (ec);
1328 }
1329
1330 Type t;
1331 int num_args;
1332
1333 SimpleName sn = new SimpleName (name, loc);
1334 TypeExpr resolved = sn.ResolveAsTypeTerminal (ec);
1335 if (resolved == null)
1336 return false;
1337
1338 t = resolved.Type;
1339 if (t == null) {
1340 Report.Error (246, loc, "Cannot find type `{0}'<...>",
1341 Basename);
1342 return false;
1343 }
1344
1345 num_args = TypeManager.GetNumberOfTypeArguments (t);
1346 if (num_args == 0) {
1347 Report.Error (308, loc,
1348 "The non-generic type `{0}' cannot " +
1349 "be used with type arguments.",
1350 TypeManager.CSharpName (t));
1351 return false;
1352 }
1353
1354 gt = t.GetGenericTypeDefinition ();
1355 return DoResolveType (ec);
1356 }
1357
1358 bool DoResolveType (EmitContext ec)
1359 {
1360 //
1361 // Resolve the arguments.
1362 //
1363 if (args.Resolve (ec) == false)
1364 return false;
1365
1366 gen_params = gt.GetGenericArguments ();
1367 atypes = args.Arguments;
1368
1369 if (atypes.Length != gen_params.Length) {
1370 Report.Error (305, loc,
1371 "Using the generic type `{0}' " +
1372 "requires {1} type arguments",
1373 TypeManager.GetFullName (gt),
1374 gen_params.Length);
1375 return false;
1376 }
1377
1378 //
1379 // Now bind the parameters.
1380 //
1381 type = gt.MakeGenericType (atypes);
1382 return true;
1383 }
1384
1385 public Expression GetSimpleName (EmitContext ec)
1386 {
1387 return new SimpleName (Basename, args, loc);
1388 }
1389
1390 public override bool CheckAccessLevel (DeclSpace ds)
1391 {
1392 return ds.CheckAccessLevel (gt);
1393 }
1394
1395 public override bool AsAccessible (DeclSpace ds, int flags)
1396 {
1397 return ds.AsAccessible (gt, flags);
1398 }
1399
1400 public override bool IsClass {
1401 get { return gt.IsClass; }
1402 }
1403
1404 public override bool IsValueType {
1405 get { return gt.IsValueType; }
1406 }
1407
1408 public override bool IsInterface {
1409 get { return gt.IsInterface; }
1410 }
1411
1412 public override bool IsSealed {
1413 get { return gt.IsSealed; }
1414 }
1415
1416 public override bool IsAttribute {
1417 get { return false; }
1418 }
1419
1420 public override bool Equals (object obj)
1421 {
1422 ConstructedType cobj = obj as ConstructedType;
1423 if (cobj == null)
1424 return false;
1425
1426 if ((type == null) || (cobj.type == null))
1427 return false;
1428
1429 return type == cobj.type;
1430 }
1431
1432 public override int GetHashCode ()
1433 {
1434 return base.GetHashCode ();
1435 }
1436
1437 public string Basename {
1438 get {
1439 int pos = name.LastIndexOf ('`');
1440 if (pos >= 0)
1441 return name.Substring (0, pos);
1442 else
1443 return name;
1444 }
1445 }
1446
1447 public override string Name {
1448 get {
1449 return full_name;
1450 }
1451 }
1452
1453
1454 public override string FullName {
1455 get {
1456 return full_name;
1457 }
1458 }
1459 }
1460
1461 public class GenericMethod : DeclSpace
1462 {
1463 public GenericMethod (NamespaceEntry ns, TypeContainer parent,
1464 MemberName name, Location l)
1465 : base (ns, parent, name, null, l)
1466 { }
1467
1468 public override TypeBuilder DefineType ()
1469 {
1470 throw new Exception ();
1471 }
1472
1473 public override bool Define ()
1474 {
1475 for (int i = 0; i < TypeParameters.Length; i++)
1476 if (!TypeParameters [i].Resolve (Parent))
1477 return false;
1478
1479 return true;
1480 }
1481
1482 public bool Define (MethodBuilder mb, Type return_type)
1483 {
1484 if (!Define ())
1485 return false;
1486
1487 GenericTypeParameterBuilder[] gen_params;
1488 string[] names = MemberName.TypeArguments.GetDeclarations ();
1489 gen_params = mb.DefineGenericParameters (names);
1490 for (int i = 0; i < TypeParameters.Length; i++)
1491 TypeParameters [i].Define (gen_params [i]);
1492
1493 ec = new EmitContext (
1494 this, this, Location, null, return_type, ModFlags, false);
1495
1496 for (int i = 0; i < TypeParameters.Length; i++) {
1497 if (!TypeParameters [i].ResolveType (ec))
1498 return false;
1499 }
1500
1501 return true;
1502 }
1503
1504 public bool DefineType (EmitContext ec, MethodBuilder mb,
1505 MethodInfo implementing, bool is_override)
1506 {
1507 for (int i = 0; i < TypeParameters.Length; i++)
1508 if (!TypeParameters [i].DefineType (
1509 ec, mb, implementing, is_override))
1510 return false;
1511
1512 return true;
1513 }
1514
1515 public override bool DefineMembers (TypeContainer parent)
1516 {
1517 return true;
1518 }
1519
1520 public override MemberList FindMembers (MemberTypes mt, BindingFlags bf,
1521 MemberFilter filter, object criteria)
1522 {
1523 throw new Exception ();
1524 }
1525
1526 public override MemberCache MemberCache {
1527 get {
1528 return null;
1529 }
1530 }
1531
1532 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
1533 {
1534 // FIXME
1535 }
1536
1537 protected override void VerifyObsoleteAttribute()
1538 {
1539 // FIXME
1540 }
1541
1542 public override AttributeTargets AttributeTargets {
1543 get {
1544 return AttributeTargets.Method | AttributeTargets.ReturnValue;
1545 }
1546 }
1547
1548 public override string DocCommentHeader {
1549 get { return "M:"; }
1550 }
1551 }
1552
1553 public class DefaultValueExpression : Expression
1554 {
1555 Expression expr;
1556 LocalTemporary temp_storage;
1557
1558 public DefaultValueExpression (Expression expr, Location loc)
1559 {
1560 this.expr = expr;
1561 this.loc = loc;
1562 }
1563
1564 public override Expression DoResolve (EmitContext ec)
1565 {
1566 TypeExpr texpr = expr.ResolveAsTypeTerminal (ec);
1567 if (texpr == null)
1568 return null;
1569
1570 type = texpr.Type;
1571 if (type.IsGenericParameter || TypeManager.IsValueType (type))
1572 temp_storage = new LocalTemporary (ec, type);
1573
1574 eclass = ExprClass.Variable;
1575 return this;
1576 }
1577
1578 public override void Emit (EmitContext ec)
1579 {
1580 if (temp_storage != null) {
1581 temp_storage.AddressOf (ec, AddressOp.LoadStore);
1582 ec.ig.Emit (OpCodes.Initobj, type);
1583 temp_storage.Emit (ec);
1584 } else
1585 ec.ig.Emit (OpCodes.Ldnull);
1586 }
1587 }
1588
1589 public class NullableType : TypeExpr
1590 {
1591 Expression underlying;
1592
1593 public NullableType (Expression underlying, Location l)
1594 {
1595 this.underlying = underlying;
1596 loc = l;
1597
1598 eclass = ExprClass.Type;
1599 }
1600
1601 public NullableType (Type type, Location loc)
1602 : this (new TypeExpression (type, loc), loc)
1603 { }
1604
1605 public override string Name {
1606 get { return underlying.ToString () + "?"; }
1607 }
1608
1609 public override string FullName {
1610 get { return underlying.ToString () + "?"; }
1611 }
1612
1613 protected override TypeExpr DoResolveAsTypeStep (EmitContext ec)
1614 {
1615 TypeArguments args = new TypeArguments (loc);
1616 args.Add (underlying);
1617
1618 ConstructedType ctype = new ConstructedType (TypeManager.generic_nullable_type, args, loc);
1619 return ctype.ResolveAsTypeTerminal (ec);
1620 }
1621 }
1622
1623 public partial class TypeManager
1624 {
1625 //
1626 // A list of core types that the compiler requires or uses
1627 //
1628 static public Type new_constraint_attr_type;
1629 static public Type activator_type;
1630 static public Type generic_ienumerator_type;
1631 static public Type generic_ienumerable_type;
1632 static public Type generic_nullable_type;
1633
1634 // <remarks>
1635 // Tracks the generic parameters.
1636 // </remarks>
1637 static PtrHashtable builder_to_type_param;
1638
1639 //
1640 // These methods are called by code generated by the compiler
1641 //
1642 static public MethodInfo activator_create_instance;
1643
1644 static void InitGenerics ()
1645 {
1646 builder_to_type_param = new PtrHashtable ();
1647 }
1648
1649 static void CleanUpGenerics ()
1650 {
1651 builder_to_type_param = null;
1652 }
1653
1654 static void InitGenericCoreTypes ()
1655 {
1656 activator_type = CoreLookupType ("System.Activator");
1657 new_constraint_attr_type = CoreLookupType (
1658 "System.Runtime.CompilerServices.NewConstraintAttribute");
1659
1660 generic_ienumerator_type = CoreLookupType ("System.Collections.Generic.IEnumerator", 1);
1661 generic_ienumerable_type = CoreLookupType ("System.Collections.Generic.IEnumerable", 1);
1662 generic_nullable_type = CoreLookupType ("System.Nullable", 1);
1663 }
1664
1665 static void InitGenericCodeHelpers ()
1666 {
1667 // Activator
1668 Type [] type_arg = { type_type };
1669 activator_create_instance = GetMethod (
1670 activator_type, "CreateInstance", type_arg);
1671 }
1672
1673 static Type CoreLookupType (string name, int arity)
1674 {
1675 return CoreLookupType (MemberName.MakeName (name, arity));
1676 }
1677
1678 public static void AddTypeParameter (Type t, TypeParameter tparam)
1679 {
1680 if (!builder_to_type_param.Contains (t))
1681 builder_to_type_param.Add (t, tparam);
1682 }
1683
1684 public static TypeContainer LookupGenericTypeContainer (Type t)
1685 {
1686 while (t.IsGenericInstance)
1687 t = t.GetGenericTypeDefinition ();
1688
1689 return LookupTypeContainer (t);
1690 }
1691
1692 public static TypeParameter LookupTypeParameter (Type t)
1693 {
1694 return (TypeParameter) builder_to_type_param [t];
1695 }
1696
1697 public static bool HasConstructorConstraint (Type t)
1698 {
1699 GenericConstraints gc = GetTypeParameterConstraints (t);
1700 if (gc == null)
1701 return false;
1702
1703 return (gc.Attributes & GenericParameterAttributes.DefaultConstructorConstraint) != 0;
1704 }
1705
1706 public static GenericConstraints GetTypeParameterConstraints (Type t)
1707 {
1708 if (!t.IsGenericParameter)
1709 throw new InvalidOperationException ();
1710
1711 TypeParameter tparam = LookupTypeParameter (t);
1712 if (tparam != null)
1713 return tparam.GenericConstraints;
1714
1715 return new ReflectionConstraints (t);
1716 }
1717
1718 public static bool IsGeneric (Type t)
1719 {
1720 DeclSpace ds = (DeclSpace) builder_to_declspace [t];
1721
1722 return ds.IsGeneric;
1723 }
1724
1725 public static bool HasGenericArguments (Type t)
1726 {
1727 return GetNumberOfTypeArguments (t) > 0;
1728 }
1729
1730 public static int GetNumberOfTypeArguments (Type t)
1731 {
1732 DeclSpace tc = LookupDeclSpace (t);
1733 if (tc != null)
1734 return tc.IsGeneric ? tc.CountTypeParameters : 0;
1735 else
1736 return t.IsGenericType ? t.GetGenericArguments ().Length : 0;
1737 }
1738
1739 public static Type[] GetTypeArguments (Type t)
1740 {
1741 DeclSpace tc = LookupDeclSpace (t);
1742 if (tc != null) {
1743 if (!tc.IsGeneric)
1744 return Type.EmptyTypes;
1745
1746 TypeParameter[] tparam = tc.TypeParameters;
1747 Type[] ret = new Type [tparam.Length];
1748 for (int i = 0; i < tparam.Length; i++) {
1749 ret [i] = tparam [i].Type;
1750 if (ret [i] == null)
1751 throw new InternalErrorException ();
1752 }
1753
1754 return ret;
1755 } else
1756 return t.GetGenericArguments ();
1757 }
1758
1759 //
1760 // Whether `array' is an array of T and `enumerator' is `IEnumerable<T>'.
1761 // For instance "string[]" -> "IEnumerable<string>".
1762 //
1763 public static bool IsIEnumerable (Type array, Type enumerator)
1764 {
1765 if (!array.IsArray || !enumerator.IsGenericInstance)
1766 return false;
1767
1768 if (enumerator.GetGenericTypeDefinition () != generic_ienumerable_type)
1769 return false;
1770
1771 Type[] args = GetTypeArguments (enumerator);
1772 return args [0] == GetElementType (array);
1773 }
1774
1775 public static bool IsEqual (Type a, Type b)
1776 {
1777 if (a.Equals (b))
1778 return true;
1779
1780 if ((a is TypeBuilder) && a.IsGenericTypeDefinition && b.IsGenericInstance) {
1781 //
1782 // `a' is a generic type definition's TypeBuilder and `b' is a
1783 // generic instance of the same type.
1784 //
1785 // Example:
1786 //
1787 // class Stack<T>
1788 // {
1789 // void Test (Stack<T> stack) { }
1790 // }
1791 //
1792 // The first argument of `Test' will be the generic instance
1793 // "Stack<!0>" - which is the same type than the "Stack" TypeBuilder.
1794 //
1795 //
1796 // We hit this via Closure.Filter() for gen-82.cs.
1797 //
1798 if (a != b.GetGenericTypeDefinition ())
1799 return false;
1800
1801 Type[] aparams = a.GetGenericArguments ();
1802 Type[] bparams = b.GetGenericArguments ();
1803
1804 if (aparams.Length != bparams.Length)
1805 return false;
1806
1807 for (int i = 0; i < aparams.Length; i++)
1808 if (!IsEqual (aparams [i], bparams [i]))
1809 return false;
1810
1811 return true;
1812 }
1813
1814 if ((b is TypeBuilder) && b.IsGenericTypeDefinition && a.IsGenericInstance)
1815 return IsEqual (b, a);
1816
1817 if (a.IsGenericParameter && b.IsGenericParameter) {
1818 if ((a.DeclaringMethod == null) || (b.DeclaringMethod == null))
1819 return false;
1820 return a.GenericParameterPosition == b.GenericParameterPosition;
1821 }
1822
1823 if (a.IsArray && b.IsArray) {
1824 if (a.GetArrayRank () != b.GetArrayRank ())
1825 return false;
1826 return IsEqual (a.GetElementType (), b.GetElementType ());
1827 }
1828
1829 if (a.IsGenericInstance && b.IsGenericInstance) {
1830 if (a.GetGenericTypeDefinition () != b.GetGenericTypeDefinition ())
1831 return false;
1832
1833 Type[] aargs = a.GetGenericArguments ();
1834 Type[] bargs = b.GetGenericArguments ();
1835
1836 if (aargs.Length != bargs.Length)
1837 return false;
1838
1839 for (int i = 0; i < aargs.Length; i++) {
1840 if (!IsEqual (aargs [i], bargs [i]))
1841 return false;
1842 }
1843
1844 return true;
1845 }
1846
1847 return false;
1848 }
1849
1850 public static bool MayBecomeEqualGenericTypes (Type a, Type b, Type[] class_infered, Type[] method_infered)
1851 {
1852 if (a.IsGenericParameter) {
1853 //
1854 // If a is an array of a's type, they may never
1855 // become equal.
1856 //
1857 while (b.IsArray) {
1858 b = b.GetElementType ();
1859 if (a.Equals (b))
1860 return false;
1861 }
1862
1863 //
1864 // If b is a generic parameter or an actual type,
1865 // they may become equal:
1866 //
1867 // class X<T,U> : I<T>, I<U>
1868 // class X<T> : I<T>, I<float>
1869 //
1870 if (b.IsGenericParameter || !b.IsGenericInstance) {
1871 int pos = a.GenericParameterPosition;
1872 Type[] args = a.DeclaringMethod != null ? method_infered : class_infered;
1873 if (args [pos] == null) {
1874 args [pos] = b;
1875 return true;
1876 }
1877
1878 return args [pos] == a;
1879 }
1880
1881 //
1882 // We're now comparing a type parameter with a
1883 // generic instance. They may become equal unless
1884 // the type parameter appears anywhere in the
1885 // generic instance:
1886 //
1887 // class X<T,U> : I<T>, I<X<U>>
1888 // -> error because you could instanciate it as
1889 // X<X<int>,int>
1890 //
1891 // class X<T> : I<T>, I<X<T>> -> ok
1892 //
1893
1894 Type[] bargs = GetTypeArguments (b);
1895 for (int i = 0; i < bargs.Length; i++) {
1896 if (a.Equals (bargs [i]))
1897 return false;
1898 }
1899
1900 return true;
1901 }
1902
1903 if (b.IsGenericParameter)
1904 return MayBecomeEqualGenericTypes (b, a, class_infered, method_infered);
1905
1906 //
1907 // At this point, neither a nor b are a type parameter.
1908 //
1909 // If one of them is a generic instance, let
1910 // MayBecomeEqualGenericInstances() compare them (if the
1911 // other one is not a generic instance, they can never
1912 // become equal).
1913 //
1914
1915 if (a.IsGenericInstance || b.IsGenericInstance)
1916 return MayBecomeEqualGenericInstances (a, b, class_infered, method_infered);
1917
1918 //
1919 // If both of them are arrays.
1920 //
1921
1922 if (a.IsArray && b.IsArray) {
1923 if (a.GetArrayRank () != b.GetArrayRank ())
1924 return false;
1925
1926 a = a.GetElementType ();
1927 b = b.GetElementType ();
1928
1929 return MayBecomeEqualGenericTypes (a, b, class_infered, method_infered);
1930 }
1931
1932 //
1933 // Ok, two ordinary types.
1934 //
1935
1936 return a.Equals (b);
1937 }
1938
1939 //
1940 // Checks whether two generic instances may become equal for some
1941 // particular instantiation (26.3.1).
1942 //
1943 public static bool MayBecomeEqualGenericInstances (Type a, Type b,
1944 Type[] class_infered, Type[] method_infered)
1945 {
1946 if (!a.IsGenericInstance || !b.IsGenericInstance)
1947 return false;
1948 if (a.GetGenericTypeDefinition () != b.GetGenericTypeDefinition ())
1949 return false;
1950
1951 return MayBecomeEqualGenericInstances (
1952 GetTypeArguments (a), GetTypeArguments (b), class_infered, method_infered);
1953 }
1954
1955 public static bool MayBecomeEqualGenericInstances (Type[] aargs, Type[] bargs,
1956 Type[] class_infered, Type[] method_infered)
1957 {
1958 if (aargs.Length != bargs.Length)
1959 return false;
1960
1961 for (int i = 0; i < aargs.Length; i++) {
1962 if (!MayBecomeEqualGenericTypes (aargs [i], bargs [i], class_infered, method_infered))
1963 return false;
1964 }
1965
1966 return true;
1967 }
1968
1969 public static bool IsEqualGenericInstance (Type type, Type parent)
1970 {
1971 int tcount = GetNumberOfTypeArguments (type);
1972 int pcount = GetNumberOfTypeArguments (parent);
1973
1974 if (type.IsGenericInstance)
1975 type = type.GetGenericTypeDefinition ();
1976 if (parent.IsGenericInstance)
1977 parent = parent.GetGenericTypeDefinition ();
1978
1979 if (tcount != pcount)
1980 return false;
1981
1982 return type.Equals (parent);
1983 }
1984
1985 static public bool IsGenericMethod (MethodBase mb)
1986 {
1987 if (mb.DeclaringType is TypeBuilder) {
1988 IMethodData method = (IMethodData) builder_to_method [mb];
1989 if (method == null)
1990 return false;
1991
1992 return method.GenericMethod != null;
1993 }
1994
1995 return mb.IsGenericMethodDefinition;
1996 }
1997
1998 //
1999 // Type inference.
2000 //
2001
2002 static bool InferType (Type pt, Type at, Type[] infered)
2003 {
2004 if (pt.IsGenericParameter && (pt.DeclaringMethod != null)) {
2005 int pos = pt.GenericParameterPosition;
2006
2007 if (infered [pos] == null) {
2008 Type check = at;
2009 while (check.IsArray)
2010 check = check.GetElementType ();
2011
2012 if (pt == check)
2013 return false;
2014
2015 infered [pos] = at;
2016 return true;
2017 }
2018
2019 if (infered [pos] != at)
2020 return false;
2021
2022 return true;
2023 }
2024
2025 if (!pt.ContainsGenericParameters) {
2026 if (at.ContainsGenericParameters)
2027 return InferType (at, pt, infered);
2028 else
2029 return true;
2030 }
2031
2032 if (at.IsArray) {
2033 if (!pt.IsArray ||
2034 (at.GetArrayRank () != pt.GetArrayRank ()))
2035 return false;
2036
2037 return InferType (pt.GetElementType (), at.GetElementType (), infered);
2038 }
2039
2040 if (pt.IsArray) {
2041 if (!at.IsArray ||
2042 (pt.GetArrayRank () != at.GetArrayRank ()))
2043 return false;
2044
2045 return InferType (pt.GetElementType (), at.GetElementType (), infered);
2046 }
2047
2048 if (pt.IsByRef && at.IsByRef)
2049 return InferType (pt.GetElementType (), at.GetElementType (), infered);
2050 ArrayList list = new ArrayList ();
2051 if (at.IsGenericInstance)
2052 list.Add (at);
2053 else {
2054 for (Type bt = at.BaseType; bt != null; bt = bt.BaseType)
2055 list.Add (bt);
2056
2057 list.AddRange (TypeManager.GetInterfaces (at));
2058 }
2059
2060 bool found_one = false;
2061
2062 foreach (Type type in list) {
2063 if (!type.IsGenericInstance)
2064 continue;
2065
2066 Type[] infered_types = new Type [infered.Length];
2067
2068 if (!InferGenericInstance (pt, type, infered_types))
2069 continue;
2070
2071 for (int i = 0; i < infered_types.Length; i++) {
2072 if (infered [i] == null) {
2073 infered [i] = infered_types [i];
2074 continue;
2075 }
2076
2077 if (infered [i] != infered_types [i])
2078 return false;
2079 }
2080
2081 found_one = true;
2082 }
2083
2084 return found_one;
2085 }
2086
2087 static bool InferGenericInstance (Type pt, Type at, Type[] infered_types)
2088 {
2089 Type[] at_args = at.GetGenericArguments ();
2090 Type[] pt_args = pt.GetGenericArguments ();
2091
2092 if (at_args.Length != pt_args.Length)
2093 return false;
2094
2095 for (int i = 0; i < at_args.Length; i++) {
2096 if (!InferType (pt_args [i], at_args [i], infered_types))
2097 return false;
2098 }
2099
2100 for (int i = 0; i < infered_types.Length; i++) {
2101 if (infered_types [i] == null)
2102 return false;
2103 }
2104
2105 return true;
2106 }
2107
2108 public static bool InferParamsTypeArguments (EmitContext ec, ArrayList arguments,
2109 ref MethodBase method)
2110 {
2111 if ((arguments == null) || !TypeManager.IsGenericMethod (method))
2112 return true;
2113
2114 int arg_count;
2115
2116 if (arguments == null)
2117 arg_count = 0;
2118 else
2119 arg_count = arguments.Count;
2120
2121 ParameterData pd = Invocation.GetParameterData (method);
2122
2123 int pd_count = pd.Count;
2124
2125 if (pd_count == 0)
2126 return false;
2127
2128 if (pd.ParameterModifier (pd_count - 1) != Parameter.Modifier.PARAMS)
2129 return false;
2130
2131 if (pd_count - 1 > arg_count)
2132 return false;
2133
2134 if (pd_count == 1 && arg_count == 0)
2135 return true;
2136
2137 Type[] method_args = method.GetGenericArguments ();
2138 Type[] infered_types = new Type [method_args.Length];
2139
2140 //
2141 // If we have come this far, the case which
2142 // remains is when the number of parameters is
2143 // less than or equal to the argument count.
2144 //
2145 for (int i = 0; i < pd_count - 1; ++i) {
2146 Argument a = (Argument) arguments [i];
2147
2148 if ((a.Expr is NullLiteral) || (a.Expr is MethodGroupExpr))
2149 continue;
2150
2151 Type pt = pd.ParameterType (i);
2152 Type at = a.Type;
2153
2154 if (!InferType (pt, at, infered_types))
2155 return false;
2156 }
2157
2158 Type element_type = TypeManager.GetElementType (pd.ParameterType (pd_count - 1));
2159
2160 for (int i = pd_count - 1; i < arg_count; i++) {
2161 Argument a = (Argument) arguments [i];
2162
2163 if ((a.Expr is NullLiteral) || (a.Expr is MethodGroupExpr))
2164 continue;
2165
2166 if (!InferType (element_type, a.Type, infered_types))
2167 return false;
2168 }
2169
2170 for (int i = 0; i < infered_types.Length; i++)
2171 if (infered_types [i] == null)
2172 return false;
2173
2174 method = ((MethodInfo)method).MakeGenericMethod (infered_types);
2175 return true;
2176 }
2177
2178 public static bool InferTypeArguments (Type[] param_types, Type[] arg_types, Type[] infered_types)
2179 {
2180 if (infered_types == null)
2181 return false;
2182
2183 for (int i = 0; i < arg_types.Length; i++) {
2184 if (arg_types [i] == null)
2185 continue;
2186
2187 if (!InferType (param_types [i], arg_types [i], infered_types))
2188 return false;
2189 }
2190
2191 for (int i = 0; i < infered_types.Length; i++)
2192 if (infered_types [i] == null)
2193 return false;
2194
2195 return true;
2196 }
2197
2198 public static bool InferTypeArguments (EmitContext ec, ArrayList arguments,
2199 ref MethodBase method)
2200 {
2201 if (!TypeManager.IsGenericMethod (method))
2202 return true;
2203
2204 int arg_count;
2205 if (arguments != null)
2206 arg_count = arguments.Count;
2207 else
2208 arg_count = 0;
2209
2210 ParameterData pd = Invocation.GetParameterData (method);
2211 if (arg_count != pd.Count)
2212 return false;
2213
2214 Type[] method_args = method.GetGenericArguments ();
2215
2216 bool is_open = false;
2217 for (int i = 0; i < method_args.Length; i++) {
2218 if (method_args [i].IsGenericParameter) {
2219 is_open = true;
2220 break;
2221 }
2222 }
2223 if (!is_open)
2224 return true;
2225
2226 Type[] infered_types = new Type [method_args.Length];
2227
2228 Type[] param_types = new Type [pd.Count];
2229 Type[] arg_types = new Type [pd.Count];
2230
2231 for (int i = 0; i < arg_count; i++) {
2232 param_types [i] = pd.ParameterType (i);
2233
2234 Argument a = (Argument) arguments [i];
2235 if ((a.Expr is NullLiteral) || (a.Expr is MethodGroupExpr))
2236 continue;
2237
2238 arg_types [i] = a.Type;
2239 }
2240
2241 if (!InferTypeArguments (param_types, arg_types, infered_types))
2242 return false;
2243
2244 method = ((MethodInfo)method).MakeGenericMethod (infered_types);
2245 return true;
2246 }
2247
2248 public static bool InferTypeArguments (EmitContext ec, ParameterData apd,
2249 ref MethodBase method)
2250 {
2251 if (!TypeManager.IsGenericMethod (method))
2252 return true;
2253
2254 ParameterData pd = Invocation.GetParameterData (method);
2255 if (apd.Count != pd.Count)
2256 return false;
2257
2258 Type[] method_args = method.GetGenericArguments ();
2259 Type[] infered_types = new Type [method_args.Length];
2260
2261 Type[] param_types = new Type [pd.Count];
2262 Type[] arg_types = new Type [pd.Count];
2263
2264 for (int i = 0; i < apd.Count; i++) {
2265 param_types [i] = pd.ParameterType (i);
2266 arg_types [i] = apd.ParameterType (i);
2267 }
2268
2269 if (!InferTypeArguments (param_types, arg_types, infered_types))
2270 return false;
2271
2272 method = ((MethodInfo)method).MakeGenericMethod (infered_types);
2273 return true;
2274 }
2275
2276 public static bool IsNullableType (Type t)
2277 {
2278 if (!t.IsGenericInstance)
2279 return false;
2280
2281 Type gt = t.GetGenericTypeDefinition ();
2282 return gt == generic_nullable_type;
2283 }
2284 }
2285
2286 public abstract class Nullable
2287 {
2288 protected sealed class NullableInfo
2289 {
2290 public readonly Type Type;
2291 public readonly Type UnderlyingType;
2292 public readonly MethodInfo HasValue;
2293 public readonly MethodInfo Value;
2294 public readonly ConstructorInfo Constructor;
2295
2296 public NullableInfo (Type type)
2297 {
2298 Type = type;
2299 UnderlyingType = TypeManager.GetTypeArguments (type) [0];
2300
2301 PropertyInfo has_value_pi = type.GetProperty ("HasValue");
2302 PropertyInfo value_pi = type.GetProperty ("Value");
2303
2304 HasValue = has_value_pi.GetGetMethod (false);
2305 Value = value_pi.GetGetMethod (false);
2306 Constructor = type.GetConstructor (new Type[] { UnderlyingType });
2307 }
2308 }
2309
2310 protected class Unwrap : Expression, IMemoryLocation, IAssignMethod
2311 {
2312 Expression expr;
2313 NullableInfo info;
2314
2315 LocalTemporary temp;
2316 bool has_temp;
2317
2318 public Unwrap (Expression expr, Location loc)
2319 {
2320 this.expr = expr;
2321 this.loc = loc;
2322 }
2323
2324 public override Expression DoResolve (EmitContext ec)
2325 {
2326 expr = expr.Resolve (ec);
2327 if (expr == null)
2328 return null;
2329
2330 if (!(expr is IMemoryLocation))
2331 temp = new LocalTemporary (ec, expr.Type);
2332
2333 info = new NullableInfo (expr.Type);
2334 type = info.UnderlyingType;
2335 eclass = expr.eclass;
2336 return this;
2337 }
2338
2339 public override void Emit (EmitContext ec)
2340 {
2341 AddressOf (ec, AddressOp.LoadStore);
2342 ec.ig.EmitCall (OpCodes.Call, info.Value, null);
2343 }
2344
2345 public void EmitCheck (EmitContext ec)
2346 {
2347 AddressOf (ec, AddressOp.LoadStore);
2348 ec.ig.EmitCall (OpCodes.Call, info.HasValue, null);
2349 }
2350
2351 void create_temp (EmitContext ec)
2352 {
2353 if ((temp != null) && !has_temp) {
2354 expr.Emit (ec);
2355 temp.Store (ec);
2356 has_temp = true;
2357 }
2358 }
2359
2360 public void AddressOf (EmitContext ec, AddressOp mode)
2361 {
2362 create_temp (ec);
2363 if (temp != null)
2364 temp.AddressOf (ec, AddressOp.LoadStore);
2365 else
2366 ((IMemoryLocation) expr).AddressOf (ec, AddressOp.LoadStore);
2367 }
2368
2369 public void Emit (EmitContext ec, bool leave_copy)
2370 {
2371 create_temp (ec);
2372 if (leave_copy) {
2373 if (temp != null)
2374 temp.Emit (ec);
2375 else
2376 expr.Emit (ec);
2377 }
2378
2379 Emit (ec);
2380 }
2381
2382 public void EmitAssign (EmitContext ec, Expression source,
2383 bool leave_copy, bool prepare_for_load)
2384 {
2385 source.Emit (ec);
2386 ec.ig.Emit (OpCodes.Newobj, info.Constructor);
2387
2388 if (leave_copy)
2389 ec.ig.Emit (OpCodes.Dup);
2390
2391 Expression empty = new EmptyExpression (expr.Type);
2392 ((IAssignMethod) expr).EmitAssign (ec, empty, false, prepare_for_load);
2393 }
2394 }
2395
2396 protected class Wrap : Expression
2397 {
2398 Expression expr;
2399 NullableInfo info;
2400
2401 public Wrap (Expression expr, Location loc)
2402 {
2403 this.expr = expr;
2404 this.loc = loc;
2405 }
2406
2407 public override Expression DoResolve (EmitContext ec)
2408 {
2409 expr = expr.Resolve (ec);
2410 if (expr == null)
2411 return null;
2412
2413 TypeExpr target_type = new NullableType (expr.Type, loc);
2414 target_type = target_type.ResolveAsTypeTerminal (ec);
2415 if (target_type == null)
2416 return null;
2417
2418 type = target_type.Type;
2419 info = new NullableInfo (type);
2420 eclass = ExprClass.Value;
2421 return this;
2422 }
2423
2424 public override void Emit (EmitContext ec)
2425 {
2426 expr.Emit (ec);
2427 ec.ig.Emit (OpCodes.Newobj, info.Constructor);
2428 }
2429 }
2430
2431 public class NullableLiteral : Expression, IMemoryLocation {
2432 public NullableLiteral (Type target_type, Location loc)
2433 {
2434 this.type = target_type;
2435 this.loc = loc;
2436
2437 eclass = ExprClass.Value;
2438 }
2439
2440 public override Expression DoResolve (EmitContext ec)
2441 {
2442 return this;
2443 }
2444
2445 public override void Emit (EmitContext ec)
2446 {
2447 LocalTemporary value_target = new LocalTemporary (ec, type);
2448
2449 value_target.AddressOf (ec, AddressOp.Store);
2450 ec.ig.Emit (OpCodes.Initobj, type);
2451 value_target.Emit (ec);
2452 }
2453
2454 public void AddressOf (EmitContext ec, AddressOp Mode)
2455 {
2456 LocalTemporary value_target = new LocalTemporary (ec, type);
2457
2458 value_target.AddressOf (ec, AddressOp.Store);
2459 ec.ig.Emit (OpCodes.Initobj, type);
2460 ((IMemoryLocation) value_target).AddressOf (ec, Mode);
2461 }
2462 }
2463
2464 public abstract class Lifted : Expression, IMemoryLocation
2465 {
2466 Expression expr, underlying, wrap, null_value;
2467 Unwrap unwrap;
2468
2469 protected Lifted (Expression expr, Location loc)
2470 {
2471 this.expr = expr;
2472 this.loc = loc;
2473 }
2474
2475 public override Expression DoResolve (EmitContext ec)
2476 {
2477 expr = expr.Resolve (ec);
2478 if (expr == null)
2479 return null;
2480
2481 unwrap = (Unwrap) new Unwrap (expr, loc).Resolve (ec);
2482 if (unwrap == null)
2483 return null;
2484
2485 underlying = ResolveUnderlying (unwrap, ec);
2486 if (underlying == null)
2487 return null;
2488
2489 wrap = new Wrap (underlying, loc).Resolve (ec);
2490 if (wrap == null)
2491 return null;
2492
2493 null_value = new NullableLiteral (wrap.Type, loc).Resolve (ec);
2494 if (null_value == null)
2495 return null;
2496
2497 type = wrap.Type;
2498 eclass = ExprClass.Value;
2499 return this;
2500 }
2501
2502 protected abstract Expression ResolveUnderlying (Expression unwrap, EmitContext ec);
2503
2504 public override void Emit (EmitContext ec)
2505 {
2506 ILGenerator ig = ec.ig;
2507 Label is_null_label = ig.DefineLabel ();
2508 Label end_label = ig.DefineLabel ();
2509
2510 unwrap.EmitCheck (ec);
2511 ig.Emit (OpCodes.Brfalse, is_null_label);
2512
2513 wrap.Emit (ec);
2514 ig.Emit (OpCodes.Br, end_label);
2515
2516 ig.MarkLabel (is_null_label);
2517 null_value.Emit (ec);
2518
2519 ig.MarkLabel (end_label);
2520 }
2521
2522 public void AddressOf (EmitContext ec, AddressOp mode)
2523 {
2524 unwrap.AddressOf (ec, mode);
2525 }
2526 }
2527
2528 public class LiftedConversion : Lifted
2529 {
2530 public readonly bool IsUser;
2531 public readonly bool IsExplicit;
2532 public readonly Type TargetType;
2533
2534 public LiftedConversion (Expression expr, Type target_type, bool is_user,
2535 bool is_explicit, Location loc)
2536 : base (expr, loc)
2537 {
2538 this.IsUser = is_user;
2539 this.IsExplicit = is_explicit;
2540 this.TargetType = target_type;
2541 }
2542
2543 protected override Expression ResolveUnderlying (Expression unwrap, EmitContext ec)
2544 {
2545 Type type = TypeManager.GetTypeArguments (TargetType) [0];
2546
2547 if (IsUser) {
2548 return Convert.UserDefinedConversion (ec, unwrap, type, loc, IsExplicit);
2549 } else {
2550 if (IsExplicit)
2551 return Convert.WideningAndNarrowingConversion (ec, unwrap, type, loc);
2552 else
2553 return Convert.WideningConversion (ec, unwrap, type, loc);
2554 }
2555 }
2556 }
2557
2558 public class LiftedUnaryOperator : Lifted
2559 {
2560 public readonly Unary.Operator Oper;
2561
2562 public LiftedUnaryOperator (Unary.Operator op, Expression expr, Location loc)
2563 : base (expr, loc)
2564 {
2565 this.Oper = op;
2566 }
2567
2568 protected override Expression ResolveUnderlying (Expression unwrap, EmitContext ec)
2569 {
2570 return new Unary (Oper, unwrap, loc);
2571 }
2572 }
2573
2574 public class LiftedConditional : Lifted
2575 {
2576 Expression expr, true_expr, false_expr;
2577 Unwrap unwrap;
2578
2579 public LiftedConditional (Expression expr, Expression true_expr, Expression false_expr,
2580 Location loc)
2581 : base (expr, loc)
2582 {
2583 this.true_expr = true_expr;
2584 this.false_expr = false_expr;
2585 }
2586
2587 protected override Expression ResolveUnderlying (Expression unwrap, EmitContext ec)
2588 {
2589 return new Conditional (unwrap, true_expr, false_expr, loc);
2590 }
2591 }
2592
2593 public class LiftedBinaryOperator : Expression
2594 {
2595 public readonly Binary.Operator Oper;
2596
2597 Expression left, right, underlying, null_value, bool_wrap;
2598 Unwrap left_unwrap, right_unwrap;
2599 bool is_equality, is_comparision, is_boolean;
2600
2601 public LiftedBinaryOperator (Binary.Operator op, Expression left, Expression right,
2602 Location loc)
2603 {
2604 this.Oper = op;
2605 this.left = left;
2606 this.right = right;
2607 this.loc = loc;
2608 }
2609
2610 public override Expression DoResolve (EmitContext ec)
2611 {
2612 if (TypeManager.IsNullableType (left.Type)) {
2613 left_unwrap = new Unwrap (left, loc);
2614 left = left_unwrap.Resolve (ec);
2615 if (left == null)
2616 return null;
2617 }
2618
2619 if (TypeManager.IsNullableType (right.Type)) {
2620 right_unwrap = new Unwrap (right, loc);
2621 right = right_unwrap.Resolve (ec);
2622 if (right == null)
2623 return null;
2624 }
2625
2626 if (((Oper == Binary.Operator.BitwiseAnd) || (Oper == Binary.Operator.BitwiseOr) ||
2627 (Oper == Binary.Operator.LogicalAndAlso) || (Oper == Binary.Operator.LogicalOrElse)) &&
2628 ((left.Type == TypeManager.bool_type) && (right.Type == TypeManager.bool_type))) {
2629 Expression empty = new EmptyExpression (TypeManager.bool_type);
2630 bool_wrap = new Wrap (empty, loc).Resolve (ec);
2631 null_value = new NullableLiteral (bool_wrap.Type, loc).Resolve (ec);
2632
2633 type = bool_wrap.Type;
2634 is_boolean = true;
2635 } else if ((Oper == Binary.Operator.Equality) || (Oper == Binary.Operator.Inequality)) {
2636 if (!(left is NullLiteral) && !(right is NullLiteral)) {
2637 underlying = new Binary (Oper, left, right, loc).Resolve (ec);
2638 if (underlying == null)
2639 return null;
2640 }
2641
2642 type = TypeManager.bool_type;
2643 is_equality = true;
2644 } else if ((Oper == Binary.Operator.LessThan) ||
2645 (Oper == Binary.Operator.GreaterThan) ||
2646 (Oper == Binary.Operator.LessThanOrEqual) ||
2647 (Oper == Binary.Operator.GreaterThanOrEqual)) {
2648 underlying = new Binary (Oper, left, right, loc).Resolve (ec);
2649 if (underlying == null)
2650 return null;
2651
2652 type = TypeManager.bool_type;
2653 is_comparision = true;
2654 } else {
2655 underlying = new Binary (Oper, left, right, loc).Resolve (ec);
2656 if (underlying == null)
2657 return null;
2658
2659 underlying = new Wrap (underlying, loc).Resolve (ec);
2660 if (underlying == null)
2661 return null;
2662
2663 type = underlying.Type;
2664 null_value = new NullableLiteral (type, loc).Resolve (ec);
2665 }
2666
2667 eclass = ExprClass.Value;
2668 return this;
2669 }
2670
2671 void EmitBoolean (EmitContext ec)
2672 {
2673 ILGenerator ig = ec.ig;
2674
2675 Label left_is_null_label = ig.DefineLabel ();
2676 Label right_is_null_label = ig.DefineLabel ();
2677 Label is_null_label = ig.DefineLabel ();
2678 Label wrap_label = ig.DefineLabel ();
2679 Label end_label = ig.DefineLabel ();
2680
2681 if (left_unwrap != null) {
2682 left_unwrap.EmitCheck (ec);
2683 ig.Emit (OpCodes.Brfalse, left_is_null_label);
2684 }
2685
2686 left.Emit (ec);
2687 ig.Emit (OpCodes.Dup);
2688 if ((Oper == Binary.Operator.BitwiseOr) || (Oper == Binary.Operator.LogicalOrElse))
2689 ig.Emit (OpCodes.Brtrue, wrap_label);
2690 else
2691 ig.Emit (OpCodes.Brfalse, wrap_label);
2692
2693 if (right_unwrap != null) {
2694 right_unwrap.EmitCheck (ec);
2695 ig.Emit (OpCodes.Brfalse, right_is_null_label);
2696 }
2697
2698 if ((Oper == Binary.Operator.LogicalAndAlso) || (Oper == Binary.Operator.LogicalOrElse))
2699 ig.Emit (OpCodes.Pop);
2700
2701 right.Emit (ec);
2702 if (Oper == Binary.Operator.BitwiseOr)
2703 ig.Emit (OpCodes.Or);
2704 else if (Oper == Binary.Operator.BitwiseAnd)
2705 ig.Emit (OpCodes.And);
2706 ig.Emit (OpCodes.Br, wrap_label);
2707
2708 ig.MarkLabel (left_is_null_label);
2709 if (right_unwrap != null) {
2710 right_unwrap.EmitCheck (ec);
2711 ig.Emit (OpCodes.Brfalse, is_null_label);
2712 }
2713
2714 right.Emit (ec);
2715 ig.Emit (OpCodes.Dup);
2716 if ((Oper == Binary.Operator.BitwiseOr) || (Oper == Binary.Operator.LogicalOrElse))
2717 ig.Emit (OpCodes.Brtrue, wrap_label);
2718 else
2719 ig.Emit (OpCodes.Brfalse, wrap_label);
2720
2721 ig.MarkLabel (right_is_null_label);
2722 ig.Emit (OpCodes.Pop);
2723 ig.MarkLabel (is_null_label);
2724 null_value.Emit (ec);
2725 ig.Emit (OpCodes.Br, end_label);
2726
2727 ig.MarkLabel (wrap_label);
2728 ig.Emit (OpCodes.Nop);
2729 bool_wrap.Emit (ec);
2730 ig.Emit (OpCodes.Nop);
2731
2732 ig.MarkLabel (end_label);
2733 }
2734
2735 void EmitEquality (EmitContext ec)
2736 {
2737 ILGenerator ig = ec.ig;
2738
2739 Label left_not_null_label = ig.DefineLabel ();
2740 Label false_label = ig.DefineLabel ();
2741 Label true_label = ig.DefineLabel ();
2742 Label end_label = ig.DefineLabel ();
2743
2744 if (left_unwrap != null) {
2745 left_unwrap.EmitCheck (ec);
2746 if (right is NullLiteral) {
2747 if (Oper == Binary.Operator.Equality)
2748 ig.Emit (OpCodes.Brfalse, true_label);
2749 else
2750 ig.Emit (OpCodes.Brfalse, false_label);
2751 } else if (right_unwrap != null) {
2752 ig.Emit (OpCodes.Dup);
2753 ig.Emit (OpCodes.Brtrue, left_not_null_label);
2754 right_unwrap.EmitCheck (ec);
2755 ig.Emit (OpCodes.Ceq);
2756 if (Oper == Binary.Operator.Inequality) {
2757 ig.Emit (OpCodes.Ldc_I4_0);
2758 ig.Emit (OpCodes.Ceq);
2759 }
2760 ig.Emit (OpCodes.Br, end_label);
2761
2762 ig.MarkLabel (left_not_null_label);
2763 ig.Emit (OpCodes.Pop);
2764 } else {
2765 if (Oper == Binary.Operator.Equality)
2766 ig.Emit (OpCodes.Brfalse, false_label);
2767 else
2768 ig.Emit (OpCodes.Brfalse, true_label);
2769 }
2770 }
2771
2772 if (right_unwrap != null) {
2773 right_unwrap.EmitCheck (ec);
2774 if (left is NullLiteral) {
2775 if (Oper == Binary.Operator.Equality)
2776 ig.Emit (OpCodes.Brfalse, true_label);
2777 else
2778 ig.Emit (OpCodes.Brfalse, false_label);
2779 } else {
2780 if (Oper == Binary.Operator.Equality)
2781 ig.Emit (OpCodes.Brfalse, false_label);
2782 else
2783 ig.Emit (OpCodes.Brfalse, true_label);
2784 }
2785 }
2786
2787 bool left_is_null = left is NullLiteral;
2788 bool right_is_null = right is NullLiteral;
2789 if (left_is_null || right_is_null) {
2790 if (((Oper == Binary.Operator.Equality) && (left_is_null == right_is_null)) ||
2791 ((Oper == Binary.Operator.Inequality) && (left_is_null != right_is_null)))
2792 ig.Emit (OpCodes.Br, true_label);
2793 else
2794 ig.Emit (OpCodes.Br, false_label);
2795 } else {
2796 underlying.Emit (ec);
2797 ig.Emit (OpCodes.Br, end_label);
2798 }
2799
2800 ig.MarkLabel (false_label);
2801 ig.Emit (OpCodes.Ldc_I4_0);
2802 ig.Emit (OpCodes.Br, end_label);
2803
2804 ig.MarkLabel (true_label);
2805 ig.Emit (OpCodes.Ldc_I4_1);
2806
2807 ig.MarkLabel (end_label);
2808 }
2809
2810 void EmitComparision (EmitContext ec)
2811 {
2812 ILGenerator ig = ec.ig;
2813
2814 Label is_null_label = ig.DefineLabel ();
2815 Label end_label = ig.DefineLabel ();
2816
2817 if (left_unwrap != null) {
2818 left_unwrap.EmitCheck (ec);
2819 ig.Emit (OpCodes.Brfalse, is_null_label);
2820 }
2821
2822 if (right_unwrap != null) {
2823 right_unwrap.EmitCheck (ec);
2824 ig.Emit (OpCodes.Brfalse, is_null_label);
2825 }
2826
2827 underlying.Emit (ec);
2828 ig.Emit (OpCodes.Br, end_label);
2829
2830 ig.MarkLabel (is_null_label);
2831 ig.Emit (OpCodes.Ldc_I4_0);
2832
2833 ig.MarkLabel (end_label);
2834 }
2835
2836 public override void Emit (EmitContext ec)
2837 {
2838 if (is_boolean) {
2839 EmitBoolean (ec);
2840 return;
2841 } else if (is_equality) {
2842 EmitEquality (ec);
2843 return;
2844 } else if (is_comparision) {
2845 EmitComparision (ec);
2846 return;
2847 }
2848
2849 ILGenerator ig = ec.ig;
2850
2851 Label is_null_label = ig.DefineLabel ();
2852 Label end_label = ig.DefineLabel ();
2853
2854 if (left_unwrap != null) {
2855 left_unwrap.EmitCheck (ec);
2856 ig.Emit (OpCodes.Brfalse, is_null_label);
2857 }
2858
2859 if (right_unwrap != null) {
2860 right_unwrap.EmitCheck (ec);
2861 ig.Emit (OpCodes.Brfalse, is_null_label);
2862 }
2863
2864 underlying.Emit (ec);
2865 ig.Emit (OpCodes.Br, end_label);
2866
2867 ig.MarkLabel (is_null_label);
2868 null_value.Emit (ec);
2869
2870 ig.MarkLabel (end_label);
2871 }
2872 }
2873
2874 public class OperatorTrueOrFalse : Expression
2875 {
2876 public readonly bool IsTrue;
2877
2878 Expression expr;
2879 Unwrap unwrap;
2880
2881 public OperatorTrueOrFalse (Expression expr, bool is_true, Location loc)
2882 {
2883 this.IsTrue = is_true;
2884 this.expr = expr;
2885 this.loc = loc;
2886 }
2887
2888 public override Expression DoResolve (EmitContext ec)
2889 {
2890 unwrap = new Unwrap (expr, loc);
2891 expr = unwrap.Resolve (ec);
2892 if (expr == null)
2893 return null;
2894
2895 if (unwrap.Type != TypeManager.bool_type)
2896 return null;
2897
2898 type = TypeManager.bool_type;
2899 eclass = ExprClass.Value;
2900 return this;
2901 }
2902
2903 public override void Emit (EmitContext ec)
2904 {
2905 ILGenerator ig = ec.ig;
2906
2907 Label is_null_label = ig.DefineLabel ();
2908 Label end_label = ig.DefineLabel ();
2909
2910 unwrap.EmitCheck (ec);
2911 ig.Emit (OpCodes.Brfalse, is_null_label);
2912
2913 unwrap.Emit (ec);
2914 if (!IsTrue) {
2915 ig.Emit (OpCodes.Ldc_I4_0);
2916 ig.Emit (OpCodes.Ceq);
2917 }
2918 ig.Emit (OpCodes.Br, end_label);
2919
2920 ig.MarkLabel (is_null_label);
2921 ig.Emit (OpCodes.Ldc_I4_0);
2922
2923 ig.MarkLabel (end_label);
2924 }
2925 }
2926
2927 public class NullCoalescingOperator : Expression
2928 {
2929 Expression left, right;
2930 Expression expr;
2931 Unwrap unwrap;
2932
2933 public NullCoalescingOperator (Expression left, Expression right, Location loc)
2934 {
2935 this.left = left;
2936 this.right = right;
2937 this.loc = loc;
2938
2939 eclass = ExprClass.Value;
2940 }
2941
2942 public override Expression DoResolve (EmitContext ec)
2943 {
2944 if (type != null)
2945 return this;
2946
2947 left = left.Resolve (ec);
2948 if (left == null)
2949 return null;
2950
2951 right = right.Resolve (ec);
2952 if (right == null)
2953 return null;
2954
2955 Type ltype = left.Type, rtype = right.Type;
2956
2957 if (!TypeManager.IsNullableType (ltype) && ltype.IsValueType) {
2958 Binary.Error_OperatorCannotBeApplied (loc, "??", ltype, rtype);
2959 return null;
2960 }
2961
2962 if (TypeManager.IsNullableType (ltype)) {
2963 NullableInfo info = new NullableInfo (ltype);
2964
2965 unwrap = (Unwrap) new Unwrap (left, loc).Resolve (ec);
2966 if (unwrap == null)
2967 return null;
2968
2969 expr = Convert.WideningConversion (ec, right, info.UnderlyingType, loc);
2970 if (expr != null) {
2971 left = unwrap;
2972 type = expr.Type;
2973 return this;
2974 }
2975 }
2976
2977 expr = Convert.WideningConversion (ec, right, ltype, loc);
2978 if (expr != null) {
2979 type = expr.Type;
2980 return this;
2981 }
2982
2983 if (unwrap != null) {
2984 expr = Convert.WideningConversion (ec, unwrap, rtype, loc);
2985 if (expr != null) {
2986 left = expr;
2987 expr = right;
2988 type = expr.Type;
2989 return this;
2990 }
2991 }
2992
2993 Binary.Error_OperatorCannotBeApplied (loc, "??", ltype, rtype);
2994 return null;
2995 }
2996
2997 public override void Emit (EmitContext ec)
2998 {
2999 ILGenerator ig = ec.ig;
3000
3001 Label is_null_label = ig.DefineLabel ();
3002 Label end_label = ig.DefineLabel ();
3003
3004 if (unwrap != null) {
3005 unwrap.EmitCheck (ec);
3006 ig.Emit (OpCodes.Brfalse, is_null_label);
3007 }
3008
3009 left.Emit (ec);
3010 ig.Emit (OpCodes.Br, end_label);
3011
3012 ig.MarkLabel (is_null_label);
3013 expr.Emit (ec);
3014
3015 ig.MarkLabel (end_label);
3016 }
3017 }
3018
3019 public class LiftedUnaryMutator : ExpressionStatement
3020 {
3021 public readonly UnaryMutator.Mode Mode;
3022 Expression expr, null_value;
3023 UnaryMutator underlying;
3024 Unwrap unwrap;
3025
3026 public LiftedUnaryMutator (UnaryMutator.Mode mode, Expression expr, Location loc)
3027 {
3028 this.expr = expr;
3029 this.Mode = mode;
3030 this.loc = loc;
3031
3032 eclass = ExprClass.Value;
3033 }
3034
3035 public override Expression DoResolve (EmitContext ec)
3036 {
3037 expr = expr.Resolve (ec);
3038 if (expr == null)
3039 return null;
3040
3041 unwrap = (Unwrap) new Unwrap (expr, loc).Resolve (ec);
3042 if (unwrap == null)
3043 return null;
3044
3045 underlying = (UnaryMutator) new UnaryMutator (Mode, unwrap, loc).Resolve (ec);
3046 if (underlying == null)
3047 return null;
3048
3049 null_value = new NullableLiteral (expr.Type, loc).Resolve (ec);
3050 if (null_value == null)
3051 return null;
3052
3053 type = expr.Type;
3054 return this;
3055 }
3056
3057 void DoEmit (EmitContext ec, bool is_expr)
3058 {
3059 ILGenerator ig = ec.ig;
3060 Label is_null_label = ig.DefineLabel ();
3061 Label end_label = ig.DefineLabel ();
3062
3063 unwrap.EmitCheck (ec);
3064 ig.Emit (OpCodes.Brfalse, is_null_label);
3065
3066 if (is_expr)
3067 underlying.Emit (ec);
3068 else
3069 underlying.EmitStatement (ec);
3070 ig.Emit (OpCodes.Br, end_label);
3071
3072 ig.MarkLabel (is_null_label);
3073 if (is_expr)
3074 null_value.Emit (ec);
3075
3076 ig.MarkLabel (end_label);
3077 }
3078
3079 public override void Emit (EmitContext ec)
3080 {
3081 DoEmit (ec, true);
3082 }
3083
3084 public override void EmitStatement (EmitContext ec)
3085 {
3086 DoEmit (ec, false);
3087 }
3088 }
3089 }
3090 }
git-svn mirror of mcs