2 // expression.cs: Expression representation for the IL tree.
5 // Miguel de Icaza (miguel@ximian.com)
7 // (C) 2001 Ximian, Inc.
11 // Maybe we should make Resolve be an instance method that just calls
12 // the virtual DoResolve function and checks conditions like the eclass
13 // and type being set if a non-null value is returned. For robustness
19 using System.Collections;
20 using System.Diagnostics;
21 using System.Reflection;
22 using System.Reflection.Emit;
26 // The ExprClass class contains the is used to pass the
27 // classification of an expression (value, variable, namespace,
28 // type, method group, property access, event access, indexer access,
31 public enum ExprClass {
46 // An interface provided by expressions that can be used as
47 // LValues and can store the value on the top of the stack on
50 public interface IStackStore {
53 // The Store method should store the contents of the top
54 // of the stack into the storage that is implemented by
55 // the particular implementation of LValue
57 void Store (EmitContext ec);
61 // This interface is implemented by variables
63 public interface IMemoryLocation {
65 // The AddressOf method should generate code that loads
66 // the address of the object and leaves it on the stack
68 void AddressOf (EmitContext ec);
72 // Base class for expressions
74 public abstract class Expression {
75 protected ExprClass eclass;
88 public ExprClass ExprClass {
99 // Utility wrapper routine for Error, just to beautify the code
101 static protected void Error (int error, string s)
103 Report.Error (error, s);
106 static protected void Error (int error, Location loc, string s)
108 Report.Error (error, loc, s);
112 // Utility wrapper routine for Warning, just to beautify the code
114 static protected void Warning (int warning, string s)
116 Report.Warning (warning, s);
120 // Performs semantic analysis on the Expression
124 // The Resolve method is invoked to perform the semantic analysis
127 // The return value is an expression (it can be the
128 // same expression in some cases) or a new
129 // expression that better represents this node.
131 // For example, optimizations of Unary (LiteralInt)
132 // would return a new LiteralInt with a negated
135 // If there is an error during semantic analysis,
136 // then an error should be reported (using Report)
137 // and a null value should be returned.
139 // There are two side effects expected from calling
140 // Resolve(): the the field variable "eclass" should
141 // be set to any value of the enumeration
142 // `ExprClass' and the type variable should be set
143 // to a valid type (this is the type of the
147 public abstract Expression DoResolve (EmitContext ec);
149 public virtual Expression DoResolveLValue (EmitContext ec, Expression right_side)
151 return DoResolve (ec);
155 // Currently Resolve wraps DoResolve to perform sanity
156 // checking and assertion checking on what we expect from Resolve
158 public Expression Resolve (EmitContext ec)
160 Expression e = DoResolve (ec);
166 if (e.ExprClass == ExprClass.Invalid)
167 throw new Exception ("Expression " + e +
168 " ExprClass is Invalid after resolve");
170 if (e.ExprClass != ExprClass.MethodGroup)
172 throw new Exception ("Expression " + e +
173 " did not set its type after Resolve");
180 // Currently ResolveLValue wraps DoResolveLValue to perform sanity
181 // checking and assertion checking on what we expect from Resolve
183 public Expression ResolveLValue (EmitContext ec, Expression right_side)
185 Expression e = DoResolveLValue (ec, right_side);
191 if (e.ExprClass == ExprClass.Invalid)
192 throw new Exception ("Expression " + e +
193 " ExprClass is Invalid after resolve");
195 if (e.ExprClass != ExprClass.MethodGroup)
197 throw new Exception ("Expression " + e +
198 " did not set its type after Resolve");
205 // Emits the code for the expression
210 // The Emit method is invoked to generate the code
211 // for the expression.
214 public abstract void Emit (EmitContext ec);
217 // Protected constructor. Only derivate types should
218 // be able to be created
221 protected Expression ()
223 eclass = ExprClass.Invalid;
228 // Returns a literalized version of a literal FieldInfo
230 static Expression Literalize (FieldInfo fi)
232 Type t = fi.FieldType;
233 object v = fi.GetValue (fi);
235 if (t == TypeManager.int32_type)
236 return new IntLiteral ((int) v);
237 else if (t == TypeManager.uint32_type)
238 return new UIntLiteral ((uint) v);
239 else if (t == TypeManager.int64_type)
240 return new LongLiteral ((long) v);
241 else if (t == TypeManager.uint64_type)
242 return new ULongLiteral ((ulong) v);
243 else if (t == TypeManager.float_type)
244 return new FloatLiteral ((float) v);
245 else if (t == TypeManager.double_type)
246 return new DoubleLiteral ((double) v);
247 else if (t == TypeManager.string_type)
248 return new StringLiteral ((string) v);
249 else if (t == TypeManager.short_type)
250 return new IntLiteral ((int) ((short)v));
251 else if (t == TypeManager.ushort_type)
252 return new IntLiteral ((int) ((ushort)v));
253 else if (t == TypeManager.sbyte_type)
254 return new IntLiteral ((int) ((sbyte)v));
255 else if (t == TypeManager.byte_type)
256 return new IntLiteral ((int) ((byte)v));
257 else if (t == TypeManager.char_type)
258 return new IntLiteral ((int) ((char)v));
260 throw new Exception ("Unknown type for literal (" + v.GetType () +
261 "), details: " + fi);
265 // Returns a fully formed expression after a MemberLookup
267 static Expression ExprClassFromMemberInfo (EmitContext ec, MemberInfo mi, Location loc)
269 if (mi is EventInfo){
270 return new EventExpr ((EventInfo) mi, loc);
271 } else if (mi is FieldInfo){
272 FieldInfo fi = (FieldInfo) mi;
275 Expression e = Literalize (fi);
280 return new FieldExpr (fi, loc);
281 } else if (mi is PropertyInfo){
282 return new PropertyExpr ((PropertyInfo) mi, loc);
283 } else if (mi is Type)
284 return new TypeExpr ((Type) mi);
290 // FIXME: Probably implement a cache for (t,name,current_access_set)?
292 // FIXME: We need to cope with access permissions here, or this wont
295 // This code could use some optimizations, but we need to do some
296 // measurements. For example, we could use a delegate to `flag' when
297 // something can not any longer be a method-group (because it is something
301 // If the return value is an Array, then it is an array of
304 // If the return value is an MemberInfo, it is anything, but a Method
308 // FIXME: When calling MemberLookup inside an `Invocation', we should pass
309 // the arguments here and have MemberLookup return only the methods that
310 // match the argument count/type, unlike we are doing now (we delay this
313 // This is so we can catch correctly attempts to invoke instance methods
314 // from a static body (scan for error 120 in ResolveSimpleName).
316 public static Expression MemberLookup (EmitContext ec, Type t, string name,
317 bool same_type, MemberTypes mt,
318 BindingFlags bf, Location loc)
321 bf |= BindingFlags.NonPublic;
323 MemberInfo [] mi = ec.TypeContainer.RootContext.TypeManager.FindMembers (
324 t, mt, bf, Type.FilterName, name);
329 // FIXME : How does this wierd case arise ?
333 if (mi.Length == 1 && !(mi [0] is MethodBase))
334 return Expression.ExprClassFromMemberInfo (ec, mi [0], loc);
336 for (int i = 0; i < mi.Length; i++)
337 if (!(mi [i] is MethodBase)){
338 Error (-5, "Do not know how to reproduce this case: " +
339 "Methods and non-Method with the same name, " +
340 "report this please");
342 for (i = 0; i < mi.Length; i++){
343 Type tt = mi [i].GetType ();
345 Console.WriteLine (i + ": " + mi [i]);
346 while (tt != TypeManager.object_type){
347 Console.WriteLine (tt);
353 return new MethodGroupExpr (mi);
356 public const MemberTypes AllMemberTypes =
357 MemberTypes.Constructor |
361 MemberTypes.NestedType |
362 MemberTypes.Property;
364 public const BindingFlags AllBindingsFlags =
365 BindingFlags.Public |
366 BindingFlags.Static |
367 BindingFlags.Instance;
369 public static Expression MemberLookup (EmitContext ec, Type t, string name,
370 bool same_type, Location loc)
372 return MemberLookup (ec, t, name, same_type, AllMemberTypes, AllBindingsFlags, loc);
375 static public Expression ImplicitReferenceConversion (Expression expr, Type target_type)
377 Type expr_type = expr.Type;
379 if (target_type == TypeManager.object_type) {
380 if (expr_type.IsClass)
381 return new EmptyCast (expr, target_type);
382 if (expr_type.IsValueType)
383 return new BoxedCast (expr);
384 } else if (expr_type.IsSubclassOf (target_type)) {
385 return new EmptyCast (expr, target_type);
387 // from any class-type S to any interface-type T.
388 if (expr_type.IsClass && target_type.IsInterface) {
390 if (TypeManager.ImplementsInterface (expr_type, target_type))
391 return new EmptyCast (expr, target_type);
396 // from any interface type S to interface-type T.
397 if (expr_type.IsInterface && target_type.IsInterface) {
399 if (TypeManager.ImplementsInterface (expr_type, target_type))
400 return new EmptyCast (expr, target_type);
405 // from an array-type S to an array-type of type T
406 if (expr_type.IsArray && target_type.IsArray) {
407 if (expr_type.GetArrayRank () == target_type.GetArrayRank ()) {
409 Type expr_element_type = expr_type.GetElementType ();
410 Type target_element_type = target_type.GetElementType ();
412 if (!expr_element_type.IsValueType && !target_element_type.IsValueType)
413 if (StandardConversionExists (expr_element_type,
414 target_element_type))
415 return new EmptyCast (expr, target_type);
420 // from an array-type to System.Array
421 if (expr_type.IsArray && target_type == TypeManager.array_type)
422 return new EmptyCast (expr, target_type);
424 // from any delegate type to System.Delegate
425 if (expr_type.IsSubclassOf (TypeManager.delegate_type) &&
426 target_type == TypeManager.delegate_type)
427 return new EmptyCast (expr, target_type);
429 // from any array-type or delegate type into System.ICloneable.
430 if (expr_type.IsArray || expr_type.IsSubclassOf (TypeManager.delegate_type))
431 if (target_type == TypeManager.icloneable_type)
432 return new EmptyCast (expr, target_type);
434 // from the null type to any reference-type.
435 if (expr is NullLiteral)
436 return new EmptyCast (expr, target_type);
446 // Handles expressions like this: decimal d; d = 1;
447 // and changes them into: decimal d; d = new System.Decimal (1);
449 static Expression InternalTypeConstructor (EmitContext ec, Expression expr, Type target)
451 ArrayList args = new ArrayList ();
453 args.Add (new Argument (expr, Argument.AType.Expression));
455 Expression ne = new New (target.FullName, args,
458 return ne.Resolve (ec);
462 // Implicit Numeric Conversions.
464 // expr is the expression to convert, returns a new expression of type
465 // target_type or null if an implicit conversion is not possible.
468 static public Expression ImplicitNumericConversion (EmitContext ec, Expression expr,
469 Type target_type, Location loc)
471 Type expr_type = expr.Type;
474 // Attempt to do the implicit constant expression conversions
476 if (expr is IntLiteral){
479 e = TryImplicitIntConversion (target_type, (IntLiteral) expr);
482 } else if (expr is LongLiteral){
484 // Try the implicit constant expression conversion
485 // from long to ulong, instead of a nice routine,
488 if (((LongLiteral) expr).Value > 0)
489 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
492 if (expr_type == TypeManager.sbyte_type){
494 // From sbyte to short, int, long, float, double.
496 if (target_type == TypeManager.int32_type)
497 return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
498 if (target_type == TypeManager.int64_type)
499 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
500 if (target_type == TypeManager.double_type)
501 return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
502 if (target_type == TypeManager.float_type)
503 return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
504 if (target_type == TypeManager.short_type)
505 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
506 if (target_type == TypeManager.decimal_type)
507 return InternalTypeConstructor (ec, expr, target_type);
508 } else if (expr_type == TypeManager.byte_type){
510 // From byte to short, ushort, int, uint, long, ulong, float, double
512 if ((target_type == TypeManager.short_type) ||
513 (target_type == TypeManager.ushort_type) ||
514 (target_type == TypeManager.int32_type) ||
515 (target_type == TypeManager.uint32_type))
516 return new EmptyCast (expr, target_type);
518 if (target_type == TypeManager.uint64_type)
519 return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
520 if (target_type == TypeManager.int64_type)
521 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
523 if (target_type == TypeManager.float_type)
524 return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
525 if (target_type == TypeManager.double_type)
526 return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
527 if (target_type == TypeManager.decimal_type)
528 return InternalTypeConstructor (ec, expr, target_type);
529 } else if (expr_type == TypeManager.short_type){
531 // From short to int, long, float, double
533 if (target_type == TypeManager.int32_type)
534 return new EmptyCast (expr, target_type);
535 if (target_type == TypeManager.int64_type)
536 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
537 if (target_type == TypeManager.double_type)
538 return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
539 if (target_type == TypeManager.float_type)
540 return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
541 if (target_type == TypeManager.decimal_type)
542 return InternalTypeConstructor (ec, expr, target_type);
543 } else if (expr_type == TypeManager.ushort_type){
545 // From ushort to int, uint, long, ulong, float, double
547 if (target_type == TypeManager.uint32_type)
548 return new EmptyCast (expr, target_type);
550 if (target_type == TypeManager.uint64_type)
551 return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
552 if (target_type == TypeManager.int32_type)
553 return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
554 if (target_type == TypeManager.int64_type)
555 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
556 if (target_type == TypeManager.double_type)
557 return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
558 if (target_type == TypeManager.float_type)
559 return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
560 if (target_type == TypeManager.decimal_type)
561 return InternalTypeConstructor (ec, expr, target_type);
562 } else if (expr_type == TypeManager.int32_type){
564 // From int to long, float, double
566 if (target_type == TypeManager.int64_type)
567 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
568 if (target_type == TypeManager.double_type)
569 return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
570 if (target_type == TypeManager.float_type)
571 return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
572 if (target_type == TypeManager.decimal_type)
573 return InternalTypeConstructor (ec, expr, target_type);
574 } else if (expr_type == TypeManager.uint32_type){
576 // From uint to long, ulong, float, double
578 if (target_type == TypeManager.int64_type)
579 return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
580 if (target_type == TypeManager.uint64_type)
581 return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
582 if (target_type == TypeManager.double_type)
583 return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
585 if (target_type == TypeManager.float_type)
586 return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
588 if (target_type == TypeManager.decimal_type)
589 return InternalTypeConstructor (ec, expr, target_type);
590 } else if ((expr_type == TypeManager.uint64_type) ||
591 (expr_type == TypeManager.int64_type)){
593 // From long/ulong to float, double
595 if (target_type == TypeManager.double_type)
596 return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
598 if (target_type == TypeManager.float_type)
599 return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
601 if (target_type == TypeManager.decimal_type)
602 return InternalTypeConstructor (ec, expr, target_type);
603 } else if (expr_type == TypeManager.char_type){
605 // From char to ushort, int, uint, long, ulong, float, double
607 if ((target_type == TypeManager.ushort_type) ||
608 (target_type == TypeManager.int32_type) ||
609 (target_type == TypeManager.uint32_type))
610 return new EmptyCast (expr, target_type);
611 if (target_type == TypeManager.uint64_type)
612 return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
613 if (target_type == TypeManager.int64_type)
614 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
615 if (target_type == TypeManager.float_type)
616 return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
617 if (target_type == TypeManager.double_type)
618 return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
619 if (target_type == TypeManager.decimal_type)
620 return InternalTypeConstructor (ec, expr, target_type);
621 } else if (expr_type == TypeManager.float_type){
625 if (target_type == TypeManager.double_type)
626 return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
633 // Determines if a standard implicit conversion exists from
634 // expr_type to target_type
636 public static bool StandardConversionExists (Type expr_type, Type target_type)
638 if (expr_type == target_type)
641 // First numeric conversions
643 if (expr_type == TypeManager.sbyte_type){
645 // From sbyte to short, int, long, float, double.
647 if ((target_type == TypeManager.int32_type) ||
648 (target_type == TypeManager.int64_type) ||
649 (target_type == TypeManager.double_type) ||
650 (target_type == TypeManager.float_type) ||
651 (target_type == TypeManager.short_type) ||
652 (target_type == TypeManager.decimal_type))
655 } else if (expr_type == TypeManager.byte_type){
657 // From byte to short, ushort, int, uint, long, ulong, float, double
659 if ((target_type == TypeManager.short_type) ||
660 (target_type == TypeManager.ushort_type) ||
661 (target_type == TypeManager.int32_type) ||
662 (target_type == TypeManager.uint32_type) ||
663 (target_type == TypeManager.uint64_type) ||
664 (target_type == TypeManager.int64_type) ||
665 (target_type == TypeManager.float_type) ||
666 (target_type == TypeManager.double_type) ||
667 (target_type == TypeManager.decimal_type))
670 } else if (expr_type == TypeManager.short_type){
672 // From short to int, long, float, double
674 if ((target_type == TypeManager.int32_type) ||
675 (target_type == TypeManager.int64_type) ||
676 (target_type == TypeManager.double_type) ||
677 (target_type == TypeManager.float_type) ||
678 (target_type == TypeManager.decimal_type))
681 } else if (expr_type == TypeManager.ushort_type){
683 // From ushort to int, uint, long, ulong, float, double
685 if ((target_type == TypeManager.uint32_type) ||
686 (target_type == TypeManager.uint64_type) ||
687 (target_type == TypeManager.int32_type) ||
688 (target_type == TypeManager.int64_type) ||
689 (target_type == TypeManager.double_type) ||
690 (target_type == TypeManager.float_type) ||
691 (target_type == TypeManager.decimal_type))
694 } else if (expr_type == TypeManager.int32_type){
696 // From int to long, float, double
698 if ((target_type == TypeManager.int64_type) ||
699 (target_type == TypeManager.double_type) ||
700 (target_type == TypeManager.float_type) ||
701 (target_type == TypeManager.decimal_type))
704 } else if (expr_type == TypeManager.uint32_type){
706 // From uint to long, ulong, float, double
708 if ((target_type == TypeManager.int64_type) ||
709 (target_type == TypeManager.uint64_type) ||
710 (target_type == TypeManager.double_type) ||
711 (target_type == TypeManager.float_type) ||
712 (target_type == TypeManager.decimal_type))
715 } else if ((expr_type == TypeManager.uint64_type) ||
716 (expr_type == TypeManager.int64_type)) {
718 // From long/ulong to float, double
720 if ((target_type == TypeManager.double_type) ||
721 (target_type == TypeManager.float_type) ||
722 (target_type == TypeManager.decimal_type))
725 } else if (expr_type == TypeManager.char_type){
727 // From char to ushort, int, uint, long, ulong, float, double
729 if ((target_type == TypeManager.ushort_type) ||
730 (target_type == TypeManager.int32_type) ||
731 (target_type == TypeManager.uint32_type) ||
732 (target_type == TypeManager.uint64_type) ||
733 (target_type == TypeManager.int64_type) ||
734 (target_type == TypeManager.float_type) ||
735 (target_type == TypeManager.double_type) ||
736 (target_type == TypeManager.decimal_type))
739 } else if (expr_type == TypeManager.float_type){
743 if (target_type == TypeManager.double_type)
747 // Next reference conversions
749 if (target_type == TypeManager.object_type) {
750 if ((expr_type.IsClass) ||
751 (expr_type.IsValueType))
754 } else if (expr_type.IsSubclassOf (target_type)) {
758 // from any class-type S to any interface-type T.
759 if (expr_type.IsClass && target_type.IsInterface)
762 // from any interface type S to interface-type T.
763 // FIXME : Is it right to use IsAssignableFrom ?
764 if (expr_type.IsInterface && target_type.IsInterface)
765 if (target_type.IsAssignableFrom (expr_type))
768 // from an array-type S to an array-type of type T
769 if (expr_type.IsArray && target_type.IsArray) {
770 if (expr_type.GetArrayRank () == target_type.GetArrayRank ()) {
772 Type expr_element_type = expr_type.GetElementType ();
773 Type target_element_type = target_type.GetElementType ();
775 if (!expr_element_type.IsValueType && !target_element_type.IsValueType)
776 if (StandardConversionExists (expr_element_type,
777 target_element_type))
782 // from an array-type to System.Array
783 if (expr_type.IsArray && target_type.IsAssignableFrom (expr_type))
786 // from any delegate type to System.Delegate
787 if (expr_type.IsSubclassOf (TypeManager.delegate_type) &&
788 target_type == TypeManager.delegate_type)
789 if (target_type.IsAssignableFrom (expr_type))
792 // from any array-type or delegate type into System.ICloneable.
793 if (expr_type.IsArray || expr_type.IsSubclassOf (TypeManager.delegate_type))
794 if (target_type == TypeManager.icloneable_type)
797 // from the null type to any reference-type.
798 // FIXME : How do we do this ?
806 // Finds "most encompassed type" according to the spec (13.4.2)
807 // amongst the methods in the MethodGroupExpr which convert from a
808 // type encompassing source_type
810 static Type FindMostEncompassedType (MethodGroupExpr me, Type source_type)
814 for (int i = me.Methods.Length; i > 0; ) {
817 MethodBase mb = me.Methods [i];
818 ParameterData pd = Invocation.GetParameterData (mb);
819 Type param_type = pd.ParameterType (0);
821 if (StandardConversionExists (source_type, param_type)) {
825 if (StandardConversionExists (param_type, best))
834 // Finds "most encompassing type" according to the spec (13.4.2)
835 // amongst the methods in the MethodGroupExpr which convert to a
836 // type encompassed by target_type
838 static Type FindMostEncompassingType (MethodGroupExpr me, Type target)
842 for (int i = me.Methods.Length; i > 0; ) {
845 MethodInfo mi = (MethodInfo) me.Methods [i];
846 Type ret_type = mi.ReturnType;
848 if (StandardConversionExists (ret_type, target)) {
852 if (!StandardConversionExists (ret_type, best))
864 // User-defined Implicit conversions
866 static public Expression ImplicitUserConversion (EmitContext ec, Expression source,
867 Type target, Location loc)
869 return UserDefinedConversion (ec, source, target, loc, false);
873 // User-defined Explicit conversions
875 static public Expression ExplicitUserConversion (EmitContext ec, Expression source,
876 Type target, Location loc)
878 return UserDefinedConversion (ec, source, target, loc, true);
882 // User-defined conversions
884 static public Expression UserDefinedConversion (EmitContext ec, Expression source,
885 Type target, Location loc,
886 bool look_for_explicit)
888 Expression mg1 = null, mg2 = null, mg3 = null, mg4 = null;
889 Expression mg5 = null, mg6 = null, mg7 = null, mg8 = null;
891 MethodBase method = null;
892 Type source_type = source.Type;
896 // If we have a boolean type, we need to check for the True operator
898 // FIXME : How does the False operator come into the picture ?
899 // FIXME : This doesn't look complete and very correct !
900 if (target == TypeManager.bool_type)
903 op_name = "op_Implicit";
905 mg1 = MemberLookup (ec, source_type, op_name, false, loc);
907 if (source_type.BaseType != null)
908 mg2 = MemberLookup (ec, source_type.BaseType, op_name, false, loc);
910 mg3 = MemberLookup (ec, target, op_name, false, loc);
912 if (target.BaseType != null)
913 mg4 = MemberLookup (ec, target.BaseType, op_name, false, loc);
915 MethodGroupExpr union1 = Invocation.MakeUnionSet (mg1, mg2);
916 MethodGroupExpr union2 = Invocation.MakeUnionSet (mg3, mg4);
918 MethodGroupExpr union3 = Invocation.MakeUnionSet (union1, union2);
920 MethodGroupExpr union4 = null;
922 if (look_for_explicit) {
924 op_name = "op_Explicit";
926 mg5 = MemberLookup (ec, source_type, op_name, false, loc);
928 if (source_type.BaseType != null)
929 mg6 = MemberLookup (ec, source_type.BaseType, op_name, false, loc);
931 mg7 = MemberLookup (ec, target, op_name, false, loc);
933 if (target.BaseType != null)
934 mg8 = MemberLookup (ec, target.BaseType, op_name, false, loc);
936 MethodGroupExpr union5 = Invocation.MakeUnionSet (mg5, mg6);
937 MethodGroupExpr union6 = Invocation.MakeUnionSet (mg7, mg8);
939 union4 = Invocation.MakeUnionSet (union5, union6);
942 MethodGroupExpr union = Invocation.MakeUnionSet (union3, union4);
946 Type most_specific_source, most_specific_target;
948 most_specific_source = FindMostEncompassedType (union, source_type);
949 if (most_specific_source == null)
952 most_specific_target = FindMostEncompassingType (union, target);
953 if (most_specific_target == null)
958 for (int i = union.Methods.Length; i > 0;) {
961 MethodBase mb = union.Methods [i];
962 ParameterData pd = Invocation.GetParameterData (mb);
963 MethodInfo mi = (MethodInfo) union.Methods [i];
965 if (pd.ParameterType (0) == most_specific_source &&
966 mi.ReturnType == most_specific_target) {
972 if (method == null || count > 1) {
973 Report.Error (-11, loc, "Ambiguous user defined conversion");
978 // This will do the conversion to the best match that we
979 // found. Now we need to perform an implict standard conversion
980 // if the best match was not the type that we were requested
983 if (look_for_explicit)
984 source = ConvertExplicitStandard (ec, source, most_specific_source, loc);
986 source = ConvertImplicitStandard (ec, source,
987 most_specific_source, loc);
992 e = new UserCast ((MethodInfo) method, source);
994 if (e.Type != target){
995 if (!look_for_explicit)
996 e = ConvertImplicitStandard (ec, e, target, loc);
998 e = ConvertExplicitStandard (ec, e, target, loc);
1009 // Converts implicitly the resolved expression `expr' into the
1010 // `target_type'. It returns a new expression that can be used
1011 // in a context that expects a `target_type'.
1013 static public Expression ConvertImplicit (EmitContext ec, Expression expr,
1014 Type target_type, Location loc)
1016 Type expr_type = expr.Type;
1019 if (expr_type == target_type)
1022 e = ImplicitNumericConversion (ec, expr, target_type, loc);
1026 e = ImplicitReferenceConversion (expr, target_type);
1030 e = ImplicitUserConversion (ec, expr, target_type, loc);
1034 if (target_type.IsSubclassOf (TypeManager.enum_type) && expr is IntLiteral){
1035 IntLiteral i = (IntLiteral) expr;
1038 return new EmptyCast (expr, target_type);
1046 // Attempts to apply the `Standard Implicit
1047 // Conversion' rules to the expression `expr' into
1048 // the `target_type'. It returns a new expression
1049 // that can be used in a context that expects a
1052 // This is different from `ConvertImplicit' in that the
1053 // user defined implicit conversions are excluded.
1055 static public Expression ConvertImplicitStandard (EmitContext ec, Expression expr,
1056 Type target_type, Location loc)
1058 Type expr_type = expr.Type;
1061 if (expr_type == target_type)
1064 e = ImplicitNumericConversion (ec, expr, target_type, loc);
1068 e = ImplicitReferenceConversion (expr, target_type);
1072 if (target_type.IsSubclassOf (TypeManager.enum_type) && expr is IntLiteral){
1073 IntLiteral i = (IntLiteral) expr;
1076 return new EmptyCast (expr, target_type);
1081 // Attemps to perform an implict constant conversion of the IntLiteral
1082 // into a different data type using casts (See Implicit Constant
1083 // Expression Conversions)
1085 static protected Expression TryImplicitIntConversion (Type target_type, IntLiteral il)
1087 int value = il.Value;
1089 if (target_type == TypeManager.sbyte_type){
1090 if (value >= SByte.MinValue && value <= SByte.MaxValue)
1092 } else if (target_type == TypeManager.byte_type){
1093 if (Byte.MinValue >= 0 && value <= Byte.MaxValue)
1095 } else if (target_type == TypeManager.short_type){
1096 if (value >= Int16.MinValue && value <= Int16.MaxValue)
1098 } else if (target_type == TypeManager.ushort_type){
1099 if (value >= UInt16.MinValue && value <= UInt16.MaxValue)
1101 } else if (target_type == TypeManager.uint32_type){
1103 // we can optimize this case: a positive int32
1104 // always fits on a uint32
1108 } else if (target_type == TypeManager.uint64_type){
1110 // we can optimize this case: a positive int32
1111 // always fits on a uint64. But we need an opcode
1115 return new OpcodeCast (il, target_type, OpCodes.Conv_I8);
1122 // Attemptes to implicityly convert `target' into `type', using
1123 // ConvertImplicit. If there is no implicit conversion, then
1124 // an error is signaled
1126 static public Expression ConvertImplicitRequired (EmitContext ec, Expression target,
1127 Type type, Location loc)
1131 e = ConvertImplicit (ec, target, type, loc);
1135 string msg = "Can not convert implicitly from `"+
1136 TypeManager.CSharpName (target.Type) + "' to `" +
1137 TypeManager.CSharpName (type) + "'";
1139 Error (29, loc, msg);
1145 // Performs the explicit numeric conversions
1147 static Expression ConvertNumericExplicit (EmitContext ec, Expression expr,
1150 Type expr_type = expr.Type;
1152 if (expr_type == TypeManager.sbyte_type){
1154 // From sbyte to byte, ushort, uint, ulong, char
1156 if (target_type == TypeManager.byte_type)
1157 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1158 if (target_type == TypeManager.ushort_type)
1159 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1160 if (target_type == TypeManager.uint32_type)
1161 return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
1162 if (target_type == TypeManager.uint64_type)
1163 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
1164 if (target_type == TypeManager.char_type)
1165 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1166 } else if (expr_type == TypeManager.byte_type){
1168 // From byte to sbyte and char
1170 if (target_type == TypeManager.sbyte_type)
1171 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1172 if (target_type == TypeManager.char_type)
1173 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1174 } else if (expr_type == TypeManager.short_type){
1176 // From short to sbyte, byte, ushort, uint, ulong, char
1178 if (target_type == TypeManager.sbyte_type)
1179 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1180 if (target_type == TypeManager.byte_type)
1181 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1182 if (target_type == TypeManager.ushort_type)
1183 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1184 if (target_type == TypeManager.uint32_type)
1185 return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
1186 if (target_type == TypeManager.uint64_type)
1187 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
1188 if (target_type == TypeManager.char_type)
1189 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1190 } else if (expr_type == TypeManager.ushort_type){
1192 // From ushort to sbyte, byte, short, char
1194 if (target_type == TypeManager.sbyte_type)
1195 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1196 if (target_type == TypeManager.byte_type)
1197 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1198 if (target_type == TypeManager.short_type)
1199 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1200 if (target_type == TypeManager.char_type)
1201 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1202 } else if (expr_type == TypeManager.int32_type){
1204 // From int to sbyte, byte, short, ushort, uint, ulong, char
1206 if (target_type == TypeManager.sbyte_type)
1207 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1208 if (target_type == TypeManager.byte_type)
1209 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1210 if (target_type == TypeManager.short_type)
1211 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1212 if (target_type == TypeManager.ushort_type)
1213 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1214 if (target_type == TypeManager.uint32_type)
1215 return new EmptyCast (expr, target_type);
1216 if (target_type == TypeManager.uint64_type)
1217 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
1218 if (target_type == TypeManager.char_type)
1219 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1220 } else if (expr_type == TypeManager.uint32_type){
1222 // From uint to sbyte, byte, short, ushort, int, char
1224 if (target_type == TypeManager.sbyte_type)
1225 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1226 if (target_type == TypeManager.byte_type)
1227 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1228 if (target_type == TypeManager.short_type)
1229 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1230 if (target_type == TypeManager.ushort_type)
1231 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1232 if (target_type == TypeManager.int32_type)
1233 return new EmptyCast (expr, target_type);
1234 if (target_type == TypeManager.char_type)
1235 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1236 } else if (expr_type == TypeManager.int64_type){
1238 // From long to sbyte, byte, short, ushort, int, uint, ulong, char
1240 if (target_type == TypeManager.sbyte_type)
1241 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1242 if (target_type == TypeManager.byte_type)
1243 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1244 if (target_type == TypeManager.short_type)
1245 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1246 if (target_type == TypeManager.ushort_type)
1247 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1248 if (target_type == TypeManager.int32_type)
1249 return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
1250 if (target_type == TypeManager.uint32_type)
1251 return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
1252 if (target_type == TypeManager.uint64_type)
1253 return new EmptyCast (expr, target_type);
1254 if (target_type == TypeManager.char_type)
1255 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1256 } else if (expr_type == TypeManager.uint64_type){
1258 // From ulong to sbyte, byte, short, ushort, int, uint, long, char
1260 if (target_type == TypeManager.sbyte_type)
1261 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1262 if (target_type == TypeManager.byte_type)
1263 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1264 if (target_type == TypeManager.short_type)
1265 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1266 if (target_type == TypeManager.ushort_type)
1267 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1268 if (target_type == TypeManager.int32_type)
1269 return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
1270 if (target_type == TypeManager.uint32_type)
1271 return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
1272 if (target_type == TypeManager.int64_type)
1273 return new EmptyCast (expr, target_type);
1274 if (target_type == TypeManager.char_type)
1275 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1276 } else if (expr_type == TypeManager.char_type){
1278 // From char to sbyte, byte, short
1280 if (target_type == TypeManager.sbyte_type)
1281 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1282 if (target_type == TypeManager.byte_type)
1283 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1284 if (target_type == TypeManager.short_type)
1285 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1286 } else if (expr_type == TypeManager.float_type){
1288 // From float to sbyte, byte, short,
1289 // ushort, int, uint, long, ulong, char
1292 if (target_type == TypeManager.sbyte_type)
1293 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1294 if (target_type == TypeManager.byte_type)
1295 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1296 if (target_type == TypeManager.short_type)
1297 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1298 if (target_type == TypeManager.ushort_type)
1299 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1300 if (target_type == TypeManager.int32_type)
1301 return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
1302 if (target_type == TypeManager.uint32_type)
1303 return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
1304 if (target_type == TypeManager.int64_type)
1305 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
1306 if (target_type == TypeManager.uint64_type)
1307 return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
1308 if (target_type == TypeManager.char_type)
1309 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1310 if (target_type == TypeManager.decimal_type)
1311 return InternalTypeConstructor (ec, expr, target_type);
1312 } else if (expr_type == TypeManager.double_type){
1314 // From double to byte, byte, short,
1315 // ushort, int, uint, long, ulong,
1316 // char, float or decimal
1318 if (target_type == TypeManager.sbyte_type)
1319 return new OpcodeCast (expr, target_type, OpCodes.Conv_I1);
1320 if (target_type == TypeManager.byte_type)
1321 return new OpcodeCast (expr, target_type, OpCodes.Conv_U1);
1322 if (target_type == TypeManager.short_type)
1323 return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
1324 if (target_type == TypeManager.ushort_type)
1325 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1326 if (target_type == TypeManager.int32_type)
1327 return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
1328 if (target_type == TypeManager.uint32_type)
1329 return new OpcodeCast (expr, target_type, OpCodes.Conv_U4);
1330 if (target_type == TypeManager.int64_type)
1331 return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
1332 if (target_type == TypeManager.uint64_type)
1333 return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
1334 if (target_type == TypeManager.char_type)
1335 return new OpcodeCast (expr, target_type, OpCodes.Conv_U2);
1336 if (target_type == TypeManager.float_type)
1337 return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
1338 if (target_type == TypeManager.decimal_type)
1339 return InternalTypeConstructor (ec, expr, target_type);
1342 // decimal is taken care of by the op_Explicit methods.
1348 // Returns whether an explicit reference conversion can be performed
1349 // from source_type to target_type
1351 static bool ExplicitReferenceConversionExists (Type source_type, Type target_type)
1353 bool target_is_value_type = target_type.IsValueType;
1355 if (source_type == target_type)
1359 // From object to any reference type
1361 if (source_type == TypeManager.object_type && !target_is_value_type)
1365 // From any class S to any class-type T, provided S is a base class of T
1367 if (target_type.IsSubclassOf (source_type))
1371 // From any interface type S to any interface T provided S is not derived from T
1373 if (source_type.IsInterface && target_type.IsInterface){
1374 if (!target_type.IsSubclassOf (source_type))
1379 // From any class type S to any interface T, provides S is not sealed
1380 // and provided S does not implement T.
1382 if (target_type.IsInterface && !source_type.IsSealed &&
1383 !target_type.IsAssignableFrom (source_type))
1387 // From any interface-type S to to any class type T, provided T is not
1388 // sealed, or provided T implements S.
1390 if (source_type.IsInterface &&
1391 (!target_type.IsSealed || source_type.IsAssignableFrom (target_type)))
1394 // From an array type S with an element type Se to an array type T with an
1395 // element type Te provided all the following are true:
1396 // * S and T differe only in element type, in other words, S and T
1397 // have the same number of dimensions.
1398 // * Both Se and Te are reference types
1399 // * An explicit referenc conversions exist from Se to Te
1401 if (source_type.IsArray && target_type.IsArray) {
1402 if (source_type.GetArrayRank () == target_type.GetArrayRank ()) {
1404 Type source_element_type = source_type.GetElementType ();
1405 Type target_element_type = target_type.GetElementType ();
1407 if (!source_element_type.IsValueType && !target_element_type.IsValueType)
1408 if (ExplicitReferenceConversionExists (source_element_type,
1409 target_element_type))
1415 // From System.Array to any array-type
1416 if (source_type == TypeManager.array_type &&
1417 target_type.IsSubclassOf (TypeManager.array_type)){
1422 // From System delegate to any delegate-type
1424 if (source_type == TypeManager.delegate_type &&
1425 target_type.IsSubclassOf (TypeManager.delegate_type))
1429 // From ICloneable to Array or Delegate types
1431 if (source_type == TypeManager.icloneable_type &&
1432 (target_type == TypeManager.array_type ||
1433 target_type == TypeManager.delegate_type))
1440 // Implements Explicit Reference conversions
1442 static Expression ConvertReferenceExplicit (Expression source, Type target_type)
1444 Type source_type = source.Type;
1445 bool target_is_value_type = target_type.IsValueType;
1448 // From object to any reference type
1450 if (source_type == TypeManager.object_type && !target_is_value_type)
1451 return new ClassCast (source, target_type);
1455 // From any class S to any class-type T, provided S is a base class of T
1457 if (target_type.IsSubclassOf (source_type))
1458 return new ClassCast (source, target_type);
1461 // From any interface type S to any interface T provided S is not derived from T
1463 if (source_type.IsInterface && target_type.IsInterface){
1465 Type [] ifaces = source_type.GetInterfaces ();
1467 if (TypeManager.ImplementsInterface (source_type, target_type))
1470 return new ClassCast (source, target_type);
1474 // From any class type S to any interface T, provides S is not sealed
1475 // and provided S does not implement T.
1477 if (target_type.IsInterface && !source_type.IsSealed) {
1479 if (TypeManager.ImplementsInterface (source_type, target_type))
1482 return new ClassCast (source, target_type);
1487 // From any interface-type S to to any class type T, provided T is not
1488 // sealed, or provided T implements S.
1490 if (source_type.IsInterface) {
1492 if (target_type.IsSealed)
1495 if (TypeManager.ImplementsInterface (target_type, source_type))
1496 return new ClassCast (source, target_type);
1501 // From an array type S with an element type Se to an array type T with an
1502 // element type Te provided all the following are true:
1503 // * S and T differe only in element type, in other words, S and T
1504 // have the same number of dimensions.
1505 // * Both Se and Te are reference types
1506 // * An explicit referenc conversions exist from Se to Te
1508 if (source_type.IsArray && target_type.IsArray) {
1509 if (source_type.GetArrayRank () == target_type.GetArrayRank ()) {
1511 Type source_element_type = source_type.GetElementType ();
1512 Type target_element_type = target_type.GetElementType ();
1514 if (!source_element_type.IsValueType && !target_element_type.IsValueType)
1515 if (ExplicitReferenceConversionExists (source_element_type,
1516 target_element_type))
1517 return new ClassCast (source, target_type);
1522 // From System.Array to any array-type
1523 if (source_type == TypeManager.array_type &&
1524 target_type.IsSubclassOf (TypeManager.array_type)){
1525 return new ClassCast (source, target_type);
1529 // From System delegate to any delegate-type
1531 if (source_type == TypeManager.delegate_type &&
1532 target_type.IsSubclassOf (TypeManager.delegate_type))
1533 return new ClassCast (source, target_type);
1536 // From ICloneable to Array or Delegate types
1538 if (source_type == TypeManager.icloneable_type &&
1539 (target_type == TypeManager.array_type ||
1540 target_type == TypeManager.delegate_type))
1541 return new ClassCast (source, target_type);
1547 // Performs an explicit conversion of the expression `expr' whose
1548 // type is expr.Type to `target_type'.
1550 static public Expression ConvertExplicit (EmitContext ec, Expression expr,
1551 Type target_type, Location loc)
1553 Expression ne = ConvertImplicitStandard (ec, expr, target_type, loc);
1558 ne = ConvertNumericExplicit (ec, expr, target_type);
1562 ne = ConvertReferenceExplicit (expr, target_type);
1566 ne = ExplicitUserConversion (ec, expr, target_type, loc);
1570 Report.Error (30, loc, "Cannot convert type '" + TypeManager.CSharpName (expr.Type) + "' to '"
1571 + TypeManager.CSharpName (target_type) + "'");
1576 // Same as ConverExplicit, only it doesn't include user defined conversions
1578 static public Expression ConvertExplicitStandard (EmitContext ec, Expression expr,
1579 Type target_type, Location l)
1581 Expression ne = ConvertImplicitStandard (ec, expr, target_type, l);
1586 ne = ConvertNumericExplicit (ec, expr, target_type);
1590 ne = ConvertReferenceExplicit (expr, target_type);
1594 Report.Error (30, l, "Cannot convert type '" +
1595 TypeManager.CSharpName (expr.Type) + "' to '" +
1596 TypeManager.CSharpName (target_type) + "'");
1600 static string ExprClassName (ExprClass c)
1603 case ExprClass.Invalid:
1605 case ExprClass.Value:
1607 case ExprClass.Variable:
1609 case ExprClass.Namespace:
1611 case ExprClass.Type:
1613 case ExprClass.MethodGroup:
1614 return "method group";
1615 case ExprClass.PropertyAccess:
1616 return "property access";
1617 case ExprClass.EventAccess:
1618 return "event access";
1619 case ExprClass.IndexerAccess:
1620 return "indexer access";
1621 case ExprClass.Nothing:
1624 throw new Exception ("Should not happen");
1628 // Reports that we were expecting `expr' to be of class `expected'
1630 protected void report118 (Location loc, Expression expr, string expected)
1632 string kind = "Unknown";
1635 kind = ExprClassName (expr.ExprClass);
1637 Error (118, loc, "Expression denotes a '" + kind +
1638 "' where an " + expected + " was expected");
1643 // This is just a base class for expressions that can
1644 // appear on statements (invocations, object creation,
1645 // assignments, post/pre increment and decrement). The idea
1646 // being that they would support an extra Emition interface that
1647 // does not leave a result on the stack.
1650 public abstract class ExpressionStatement : Expression {
1653 // Requests the expression to be emitted in a `statement'
1654 // context. This means that no new value is left on the
1655 // stack after invoking this method (constrasted with
1656 // Emit that will always leave a value on the stack).
1658 public abstract void EmitStatement (EmitContext ec);
1662 // This kind of cast is used to encapsulate the child
1663 // whose type is child.Type into an expression that is
1664 // reported to return "return_type". This is used to encapsulate
1665 // expressions which have compatible types, but need to be dealt
1666 // at higher levels with.
1668 // For example, a "byte" expression could be encapsulated in one
1669 // of these as an "unsigned int". The type for the expression
1670 // would be "unsigned int".
1674 public class EmptyCast : Expression {
1675 protected Expression child;
1677 public EmptyCast (Expression child, Type return_type)
1679 ExprClass = child.ExprClass;
1684 public override Expression DoResolve (EmitContext ec)
1686 // This should never be invoked, we are born in fully
1687 // initialized state.
1692 public override void Emit (EmitContext ec)
1699 // This kind of cast is used to encapsulate Value Types in objects.
1701 // The effect of it is to box the value type emitted by the previous
1704 public class BoxedCast : EmptyCast {
1706 public BoxedCast (Expression expr)
1707 : base (expr, TypeManager.object_type)
1711 public override Expression DoResolve (EmitContext ec)
1713 // This should never be invoked, we are born in fully
1714 // initialized state.
1719 public override void Emit (EmitContext ec)
1722 ec.ig.Emit (OpCodes.Box, child.Type);
1727 // This kind of cast is used to encapsulate a child expression
1728 // that can be trivially converted to a target type using one or
1729 // two opcodes. The opcodes are passed as arguments.
1731 public class OpcodeCast : EmptyCast {
1735 public OpcodeCast (Expression child, Type return_type, OpCode op)
1736 : base (child, return_type)
1740 second_valid = false;
1743 public OpcodeCast (Expression child, Type return_type, OpCode op, OpCode op2)
1744 : base (child, return_type)
1749 second_valid = true;
1752 public override Expression DoResolve (EmitContext ec)
1754 // This should never be invoked, we are born in fully
1755 // initialized state.
1760 public override void Emit (EmitContext ec)
1772 // This kind of cast is used to encapsulate a child and cast it
1773 // to the class requested
1775 public class ClassCast : EmptyCast {
1776 public ClassCast (Expression child, Type return_type)
1777 : base (child, return_type)
1782 public override Expression DoResolve (EmitContext ec)
1784 // This should never be invoked, we are born in fully
1785 // initialized state.
1790 public override void Emit (EmitContext ec)
1794 ec.ig.Emit (OpCodes.Castclass, type);
1800 // Unary expressions.
1804 // Unary implements unary expressions. It derives from
1805 // ExpressionStatement becuase the pre/post increment/decrement
1806 // operators can be used in a statement context.
1808 public class Unary : ExpressionStatement {
1809 public enum Operator {
1810 UnaryPlus, UnaryNegation, LogicalNot, OnesComplement,
1811 Indirection, AddressOf, PreIncrement,
1812 PreDecrement, PostIncrement, PostDecrement
1817 ArrayList Arguments;
1821 public Unary (Operator op, Expression expr, Location loc)
1828 public Expression Expr {
1838 public Operator Oper {
1849 // Returns a stringified representation of the Operator
1854 case Operator.UnaryPlus:
1856 case Operator.UnaryNegation:
1858 case Operator.LogicalNot:
1860 case Operator.OnesComplement:
1862 case Operator.AddressOf:
1864 case Operator.Indirection:
1866 case Operator.PreIncrement : case Operator.PostIncrement :
1868 case Operator.PreDecrement : case Operator.PostDecrement :
1872 return oper.ToString ();
1875 Expression ForceConversion (EmitContext ec, Expression expr, Type target_type)
1877 if (expr.Type == target_type)
1880 return ConvertImplicit (ec, expr, target_type, new Location (-1));
1883 void error23 (Type t)
1886 23, loc, "Operator " + OperName () +
1887 " cannot be applied to operand of type `" +
1888 TypeManager.CSharpName (t) + "'");
1892 // Returns whether an object of type `t' can be incremented
1893 // or decremented with add/sub (ie, basically whether we can
1894 // use pre-post incr-decr operations on it, but it is not a
1895 // System.Decimal, which we test elsewhere)
1897 static bool IsIncrementableNumber (Type t)
1899 return (t == TypeManager.sbyte_type) ||
1900 (t == TypeManager.byte_type) ||
1901 (t == TypeManager.short_type) ||
1902 (t == TypeManager.ushort_type) ||
1903 (t == TypeManager.int32_type) ||
1904 (t == TypeManager.uint32_type) ||
1905 (t == TypeManager.int64_type) ||
1906 (t == TypeManager.uint64_type) ||
1907 (t == TypeManager.char_type) ||
1908 (t.IsSubclassOf (TypeManager.enum_type)) ||
1909 (t == TypeManager.float_type) ||
1910 (t == TypeManager.double_type);
1913 Expression ResolveOperator (EmitContext ec)
1915 Type expr_type = expr.Type;
1918 // Step 1: Perform Operator Overload location
1923 if (oper == Operator.PostIncrement || oper == Operator.PreIncrement)
1924 op_name = "op_Increment";
1925 else if (oper == Operator.PostDecrement || oper == Operator.PreDecrement)
1926 op_name = "op_Decrement";
1928 op_name = "op_" + oper;
1930 mg = MemberLookup (ec, expr_type, op_name, false, loc);
1932 if (mg == null && expr_type.BaseType != null)
1933 mg = MemberLookup (ec, expr_type.BaseType, op_name, false, loc);
1936 Arguments = new ArrayList ();
1937 Arguments.Add (new Argument (expr, Argument.AType.Expression));
1939 method = Invocation.OverloadResolve (ec, (MethodGroupExpr) mg,
1941 if (method != null) {
1942 MethodInfo mi = (MethodInfo) method;
1943 type = mi.ReturnType;
1946 error23 (expr_type);
1953 // Step 2: Default operations on CLI native types.
1956 // Only perform numeric promotions on:
1959 if (expr_type == null)
1962 if (oper == Operator.LogicalNot){
1963 if (expr_type != TypeManager.bool_type) {
1964 error23 (expr.Type);
1968 type = TypeManager.bool_type;
1972 if (oper == Operator.OnesComplement) {
1973 if (!((expr_type == TypeManager.int32_type) ||
1974 (expr_type == TypeManager.uint32_type) ||
1975 (expr_type == TypeManager.int64_type) ||
1976 (expr_type == TypeManager.uint64_type) ||
1977 (expr_type.IsSubclassOf (TypeManager.enum_type)))){
1978 error23 (expr.Type);
1985 if (oper == Operator.UnaryPlus) {
1987 // A plus in front of something is just a no-op, so return the child.
1993 // Deals with -literals
1994 // int operator- (int x)
1995 // long operator- (long x)
1996 // float operator- (float f)
1997 // double operator- (double d)
1998 // decimal operator- (decimal d)
2000 if (oper == Operator.UnaryNegation){
2002 // Fold a "- Constant" into a negative constant
2005 Expression e = null;
2008 // Is this a constant?
2010 if (expr is IntLiteral)
2011 e = new IntLiteral (-((IntLiteral) expr).Value);
2012 else if (expr is LongLiteral)
2013 e = new LongLiteral (-((LongLiteral) expr).Value);
2014 else if (expr is FloatLiteral)
2015 e = new FloatLiteral (-((FloatLiteral) expr).Value);
2016 else if (expr is DoubleLiteral)
2017 e = new DoubleLiteral (-((DoubleLiteral) expr).Value);
2018 else if (expr is DecimalLiteral)
2019 e = new DecimalLiteral (-((DecimalLiteral) expr).Value);
2027 // Not a constant we can optimize, perform numeric
2028 // promotions to int, long, double.
2031 // The following is inneficient, because we call
2032 // ConvertImplicit too many times.
2034 // It is also not clear if we should convert to Float
2035 // or Double initially.
2037 if (expr_type == TypeManager.uint32_type){
2039 // FIXME: handle exception to this rule that
2040 // permits the int value -2147483648 (-2^31) to
2041 // bt written as a decimal interger literal
2043 type = TypeManager.int64_type;
2044 expr = ConvertImplicit (ec, expr, type, loc);
2048 if (expr_type == TypeManager.uint64_type){
2050 // FIXME: Handle exception of `long value'
2051 // -92233720368547758087 (-2^63) to be written as
2052 // decimal integer literal.
2054 error23 (expr_type);
2058 e = ConvertImplicit (ec, expr, TypeManager.int32_type, loc);
2065 e = ConvertImplicit (ec, expr, TypeManager.int64_type, loc);
2072 e = ConvertImplicit (ec, expr, TypeManager.double_type, loc);
2079 error23 (expr_type);
2084 // The operand of the prefix/postfix increment decrement operators
2085 // should be an expression that is classified as a variable,
2086 // a property access or an indexer access
2088 if (oper == Operator.PreDecrement || oper == Operator.PreIncrement ||
2089 oper == Operator.PostDecrement || oper == Operator.PostIncrement){
2090 if (expr.ExprClass == ExprClass.Variable){
2091 if (IsIncrementableNumber (expr_type) ||
2092 expr_type == TypeManager.decimal_type){
2096 } else if (expr.ExprClass == ExprClass.IndexerAccess){
2098 // FIXME: Verify that we have both get and set methods
2100 throw new Exception ("Implement me");
2101 } else if (expr.ExprClass == ExprClass.PropertyAccess){
2102 PropertyExpr pe = (PropertyExpr) expr;
2104 if (pe.VerifyAssignable ())
2108 report118 (loc, expr, "variable, indexer or property access");
2112 if (oper == Operator.AddressOf){
2113 if (expr.ExprClass != ExprClass.Variable){
2114 Error (211, "Cannot take the address of non-variables");
2117 type = Type.GetType (expr.Type.ToString () + "*");
2120 Error (187, "No such operator '" + OperName () + "' defined for type '" +
2121 TypeManager.CSharpName (expr_type) + "'");
2126 public override Expression DoResolve (EmitContext ec)
2128 expr = expr.Resolve (ec);
2133 eclass = ExprClass.Value;
2134 return ResolveOperator (ec);
2137 public override void Emit (EmitContext ec)
2139 ILGenerator ig = ec.ig;
2140 Type expr_type = expr.Type;
2143 if (method != null) {
2145 // Note that operators are static anyway
2147 if (Arguments != null)
2148 Invocation.EmitArguments (ec, method, Arguments);
2151 // Post increment/decrement operations need a copy at this
2154 if (oper == Operator.PostDecrement || oper == Operator.PostIncrement)
2155 ig.Emit (OpCodes.Dup);
2158 ig.Emit (OpCodes.Call, (MethodInfo) method);
2161 // Pre Increment and Decrement operators
2163 if (oper == Operator.PreIncrement || oper == Operator.PreDecrement){
2164 ig.Emit (OpCodes.Dup);
2168 // Increment and Decrement should store the result
2170 if (oper == Operator.PreDecrement || oper == Operator.PreIncrement ||
2171 oper == Operator.PostDecrement || oper == Operator.PostIncrement){
2172 ((IStackStore) expr).Store (ec);
2178 case Operator.UnaryPlus:
2179 throw new Exception ("This should be caught by Resolve");
2181 case Operator.UnaryNegation:
2183 ig.Emit (OpCodes.Neg);
2186 case Operator.LogicalNot:
2188 ig.Emit (OpCodes.Ldc_I4_0);
2189 ig.Emit (OpCodes.Ceq);
2192 case Operator.OnesComplement:
2194 ig.Emit (OpCodes.Not);
2197 case Operator.AddressOf:
2198 ((IMemoryLocation)expr).AddressOf (ec);
2201 case Operator.Indirection:
2202 throw new Exception ("Not implemented yet");
2204 case Operator.PreIncrement:
2205 case Operator.PreDecrement:
2206 if (expr.ExprClass == ExprClass.Variable){
2208 // Resolve already verified that it is an "incrementable"
2211 ig.Emit (OpCodes.Ldc_I4_1);
2213 if (oper == Operator.PreDecrement)
2214 ig.Emit (OpCodes.Sub);
2216 ig.Emit (OpCodes.Add);
2217 ig.Emit (OpCodes.Dup);
2218 ((IStackStore) expr).Store (ec);
2220 throw new Exception ("Handle Indexers and Properties here");
2224 case Operator.PostIncrement:
2225 case Operator.PostDecrement:
2226 eclass = expr.ExprClass;
2227 if (eclass == ExprClass.Variable){
2229 // Resolve already verified that it is an "incrementable"
2232 ig.Emit (OpCodes.Dup);
2233 ig.Emit (OpCodes.Ldc_I4_1);
2235 if (oper == Operator.PostDecrement)
2236 ig.Emit (OpCodes.Sub);
2238 ig.Emit (OpCodes.Add);
2239 ((IStackStore) expr).Store (ec);
2240 } else if (eclass == ExprClass.PropertyAccess){
2241 throw new Exception ("Handle Properties here");
2242 } else if (eclass == ExprClass.IndexerAccess) {
2243 throw new Exception ("Handle Indexers here");
2245 Console.WriteLine ("Unknown exprclass: " + eclass);
2250 throw new Exception ("This should not happen: Operator = "
2251 + oper.ToString ());
2256 public override void EmitStatement (EmitContext ec)
2259 // FIXME: we should rewrite this code to generate
2260 // better code for ++ and -- as we know we wont need
2261 // the values on the stack
2264 ec.ig.Emit (OpCodes.Pop);
2268 public class Probe : Expression {
2269 public readonly string ProbeType;
2270 public readonly Operator Oper;
2274 public enum Operator {
2278 public Probe (Operator oper, Expression expr, string probe_type)
2281 ProbeType = probe_type;
2285 public Expression Expr {
2291 public override Expression DoResolve (EmitContext ec)
2293 probe_type = ec.TypeContainer.LookupType (ProbeType, false);
2295 if (probe_type == null)
2298 expr = expr.Resolve (ec);
2300 type = TypeManager.bool_type;
2301 eclass = ExprClass.Value;
2306 public override void Emit (EmitContext ec)
2308 ILGenerator ig = ec.ig;
2312 if (Oper == Operator.Is){
2313 ig.Emit (OpCodes.Isinst, probe_type);
2314 ig.Emit (OpCodes.Ldnull);
2315 ig.Emit (OpCodes.Cgt_Un);
2317 ig.Emit (OpCodes.Isinst, probe_type);
2323 // This represents a typecast in the source language.
2325 // FIXME: Cast expressions have an unusual set of parsing
2326 // rules, we need to figure those out.
2328 public class Cast : Expression {
2333 public Cast (string cast_type, Expression expr, Location loc)
2335 this.target_type = cast_type;
2340 public string TargetType {
2346 public Expression Expr {
2355 public override Expression DoResolve (EmitContext ec)
2357 expr = expr.Resolve (ec);
2361 type = ec.TypeContainer.LookupType (target_type, false);
2362 eclass = ExprClass.Value;
2367 expr = ConvertExplicit (ec, expr, type, loc);
2372 public override void Emit (EmitContext ec)
2375 // This one will never happen
2377 throw new Exception ("Should not happen");
2381 public class Binary : Expression {
2382 public enum Operator {
2383 Multiply, Division, Modulus,
2384 Addition, Subtraction,
2385 LeftShift, RightShift,
2386 LessThan, GreaterThan, LessThanOrEqual, GreaterThanOrEqual,
2387 Equality, Inequality,
2396 Expression left, right;
2398 ArrayList Arguments;
2402 public Binary (Operator oper, Expression left, Expression right, Location loc)
2410 public Operator Oper {
2419 public Expression Left {
2428 public Expression Right {
2439 // Returns a stringified representation of the Operator
2444 case Operator.Multiply:
2446 case Operator.Division:
2448 case Operator.Modulus:
2450 case Operator.Addition:
2452 case Operator.Subtraction:
2454 case Operator.LeftShift:
2456 case Operator.RightShift:
2458 case Operator.LessThan:
2460 case Operator.GreaterThan:
2462 case Operator.LessThanOrEqual:
2464 case Operator.GreaterThanOrEqual:
2466 case Operator.Equality:
2468 case Operator.Inequality:
2470 case Operator.BitwiseAnd:
2472 case Operator.BitwiseOr:
2474 case Operator.ExclusiveOr:
2476 case Operator.LogicalOr:
2478 case Operator.LogicalAnd:
2482 return oper.ToString ();
2485 Expression ForceConversion (EmitContext ec, Expression expr, Type target_type)
2487 if (expr.Type == target_type)
2490 return ConvertImplicit (ec, expr, target_type, new Location (-1));
2494 // Note that handling the case l == Decimal || r == Decimal
2495 // is taken care of by the Step 1 Operator Overload resolution.
2497 void DoNumericPromotions (EmitContext ec, Type l, Type r)
2499 if (l == TypeManager.double_type || r == TypeManager.double_type){
2501 // If either operand is of type double, the other operand is
2502 // conveted to type double.
2504 if (r != TypeManager.double_type)
2505 right = ConvertImplicit (ec, right, TypeManager.double_type, loc);
2506 if (l != TypeManager.double_type)
2507 left = ConvertImplicit (ec, left, TypeManager.double_type, loc);
2509 type = TypeManager.double_type;
2510 } else if (l == TypeManager.float_type || r == TypeManager.float_type){
2512 // if either operand is of type float, th eother operand is
2513 // converd to type float.
2515 if (r != TypeManager.double_type)
2516 right = ConvertImplicit (ec, right, TypeManager.float_type, loc);
2517 if (l != TypeManager.double_type)
2518 left = ConvertImplicit (ec, left, TypeManager.float_type, loc);
2519 type = TypeManager.float_type;
2520 } else if (l == TypeManager.uint64_type || r == TypeManager.uint64_type){
2524 // If either operand is of type ulong, the other operand is
2525 // converted to type ulong. or an error ocurrs if the other
2526 // operand is of type sbyte, short, int or long
2529 if (l == TypeManager.uint64_type){
2530 if (r != TypeManager.uint64_type && right is IntLiteral){
2531 e = TryImplicitIntConversion (l, (IntLiteral) right);
2537 if (left is IntLiteral){
2538 e = TryImplicitIntConversion (r, (IntLiteral) left);
2545 if ((other == TypeManager.sbyte_type) ||
2546 (other == TypeManager.short_type) ||
2547 (other == TypeManager.int32_type) ||
2548 (other == TypeManager.int64_type)){
2549 string oper = OperName ();
2551 Error (34, loc, "Operator `" + OperName ()
2552 + "' is ambiguous on operands of type `"
2553 + TypeManager.CSharpName (l) + "' "
2554 + "and `" + TypeManager.CSharpName (r)
2557 type = TypeManager.uint64_type;
2558 } else if (l == TypeManager.int64_type || r == TypeManager.int64_type){
2560 // If either operand is of type long, the other operand is converted
2563 if (l != TypeManager.int64_type)
2564 left = ConvertImplicit (ec, left, TypeManager.int64_type, loc);
2565 if (r != TypeManager.int64_type)
2566 right = ConvertImplicit (ec, right, TypeManager.int64_type, loc);
2568 type = TypeManager.int64_type;
2569 } else if (l == TypeManager.uint32_type || r == TypeManager.uint32_type){
2571 // If either operand is of type uint, and the other
2572 // operand is of type sbyte, short or int, othe operands are
2573 // converted to type long.
2577 if (l == TypeManager.uint32_type)
2579 else if (r == TypeManager.uint32_type)
2582 if ((other == TypeManager.sbyte_type) ||
2583 (other == TypeManager.short_type) ||
2584 (other == TypeManager.int32_type)){
2585 left = ForceConversion (ec, left, TypeManager.int64_type);
2586 right = ForceConversion (ec, right, TypeManager.int64_type);
2587 type = TypeManager.int64_type;
2590 // if either operand is of type uint, the other
2591 // operand is converd to type uint
2593 left = ForceConversion (ec, left, TypeManager.uint32_type);
2594 right = ForceConversion (ec, right, TypeManager.uint32_type);
2595 type = TypeManager.uint32_type;
2597 } else if (l == TypeManager.decimal_type || r == TypeManager.decimal_type){
2598 if (l != TypeManager.decimal_type)
2599 left = ConvertImplicit (ec, left, TypeManager.decimal_type, loc);
2600 if (r != TypeManager.decimal_type)
2601 right = ConvertImplicit (ec, right, TypeManager.decimal_type, loc);
2603 type = TypeManager.decimal_type;
2605 Expression l_tmp, r_tmp;
2607 l_tmp = ForceConversion (ec, left, TypeManager.int32_type);
2608 if (l_tmp == null) {
2614 r_tmp = ForceConversion (ec, right, TypeManager.int32_type);
2615 if (r_tmp == null) {
2621 type = TypeManager.int32_type;
2628 "Operator " + OperName () + " cannot be applied to operands of type `" +
2629 TypeManager.CSharpName (left.Type) + "' and `" +
2630 TypeManager.CSharpName (right.Type) + "'");
2634 Expression CheckShiftArguments (EmitContext ec)
2638 Type r = right.Type;
2640 e = ForceConversion (ec, right, TypeManager.int32_type);
2647 if (((e = ConvertImplicit (ec, left, TypeManager.int32_type, loc)) != null) ||
2648 ((e = ConvertImplicit (ec, left, TypeManager.uint32_type, loc)) != null) ||
2649 ((e = ConvertImplicit (ec, left, TypeManager.int64_type, loc)) != null) ||
2650 ((e = ConvertImplicit (ec, left, TypeManager.uint64_type, loc)) != null)){
2660 Expression ResolveOperator (EmitContext ec)
2663 Type r = right.Type;
2666 // Step 1: Perform Operator Overload location
2668 Expression left_expr, right_expr;
2670 string op = "op_" + oper;
2672 left_expr = MemberLookup (ec, l, op, false, loc);
2673 if (left_expr == null && l.BaseType != null)
2674 left_expr = MemberLookup (ec, l.BaseType, op, false, loc);
2676 right_expr = MemberLookup (ec, r, op, false, loc);
2677 if (right_expr == null && r.BaseType != null)
2678 right_expr = MemberLookup (ec, r.BaseType, op, false, loc);
2680 MethodGroupExpr union = Invocation.MakeUnionSet (left_expr, right_expr);
2682 if (union != null) {
2683 Arguments = new ArrayList ();
2684 Arguments.Add (new Argument (left, Argument.AType.Expression));
2685 Arguments.Add (new Argument (right, Argument.AType.Expression));
2687 method = Invocation.OverloadResolve (ec, union, Arguments, loc);
2688 if (method != null) {
2689 MethodInfo mi = (MethodInfo) method;
2690 type = mi.ReturnType;
2699 // Step 2: Default operations on CLI native types.
2702 // Only perform numeric promotions on:
2703 // +, -, *, /, %, &, |, ^, ==, !=, <, >, <=, >=
2705 if (oper == Operator.Addition){
2707 // If any of the arguments is a string, cast to string
2709 if (l == TypeManager.string_type){
2710 if (r == TypeManager.string_type){
2712 method = TypeManager.string_concat_string_string;
2715 method = TypeManager.string_concat_object_object;
2716 right = ConvertImplicit (ec, right,
2717 TypeManager.object_type, loc);
2719 type = TypeManager.string_type;
2721 Arguments = new ArrayList ();
2722 Arguments.Add (new Argument (left, Argument.AType.Expression));
2723 Arguments.Add (new Argument (right, Argument.AType.Expression));
2727 } else if (r == TypeManager.string_type){
2729 method = TypeManager.string_concat_object_object;
2730 Arguments = new ArrayList ();
2731 Arguments.Add (new Argument (left, Argument.AType.Expression));
2732 Arguments.Add (new Argument (right, Argument.AType.Expression));
2734 left = ConvertImplicit (ec, left, TypeManager.object_type, loc);
2735 type = TypeManager.string_type;
2741 // FIXME: is Delegate operator + (D x, D y) handled?
2745 if (oper == Operator.LeftShift || oper == Operator.RightShift)
2746 return CheckShiftArguments (ec);
2748 if (oper == Operator.LogicalOr || oper == Operator.LogicalAnd){
2749 if (l != TypeManager.bool_type || r != TypeManager.bool_type)
2752 type = TypeManager.bool_type;
2757 // We are dealing with numbers
2760 DoNumericPromotions (ec, l, r);
2762 if (left == null || right == null)
2766 if (oper == Operator.BitwiseAnd ||
2767 oper == Operator.BitwiseOr ||
2768 oper == Operator.ExclusiveOr){
2769 if (!((l == TypeManager.int32_type) ||
2770 (l == TypeManager.uint32_type) ||
2771 (l == TypeManager.int64_type) ||
2772 (l == TypeManager.uint64_type))){
2779 if (oper == Operator.Equality ||
2780 oper == Operator.Inequality ||
2781 oper == Operator.LessThanOrEqual ||
2782 oper == Operator.LessThan ||
2783 oper == Operator.GreaterThanOrEqual ||
2784 oper == Operator.GreaterThan){
2785 type = TypeManager.bool_type;
2791 public override Expression DoResolve (EmitContext ec)
2793 left = left.Resolve (ec);
2794 right = right.Resolve (ec);
2796 if (left == null || right == null)
2799 if (left.Type == null)
2800 throw new Exception (
2801 "Resolve returned non null, but did not set the type! (" +
2802 left + ") at Line: " + loc.Row);
2803 if (right.Type == null)
2804 throw new Exception (
2805 "Resolve returned non null, but did not set the type! (" +
2806 right + ") at Line: "+ loc.Row);
2808 eclass = ExprClass.Value;
2810 return ResolveOperator (ec);
2813 public bool IsBranchable ()
2815 if (oper == Operator.Equality ||
2816 oper == Operator.Inequality ||
2817 oper == Operator.LessThan ||
2818 oper == Operator.GreaterThan ||
2819 oper == Operator.LessThanOrEqual ||
2820 oper == Operator.GreaterThanOrEqual){
2827 // This entry point is used by routines that might want
2828 // to emit a brfalse/brtrue after an expression, and instead
2829 // they could use a more compact notation.
2831 // Typically the code would generate l.emit/r.emit, followed
2832 // by the comparission and then a brtrue/brfalse. The comparissions
2833 // are sometimes inneficient (there are not as complete as the branches
2834 // look for the hacks in Emit using double ceqs).
2836 // So for those cases we provide EmitBranchable that can emit the
2837 // branch with the test
2839 public void EmitBranchable (EmitContext ec, int target)
2842 bool close_target = false;
2848 case Operator.Equality:
2850 opcode = OpCodes.Beq_S;
2852 opcode = OpCodes.Beq;
2855 case Operator.Inequality:
2857 opcode = OpCodes.Bne_Un_S;
2859 opcode = OpCodes.Bne_Un;
2862 case Operator.LessThan:
2864 opcode = OpCodes.Blt_S;
2866 opcode = OpCodes.Blt;
2869 case Operator.GreaterThan:
2871 opcode = OpCodes.Bgt_S;
2873 opcode = OpCodes.Bgt;
2876 case Operator.LessThanOrEqual:
2878 opcode = OpCodes.Ble_S;
2880 opcode = OpCodes.Ble;
2883 case Operator.GreaterThanOrEqual:
2885 opcode = OpCodes.Bge_S;
2887 opcode = OpCodes.Ble;
2891 throw new Exception ("EmitBranchable called on non-EmitBranchable operator: "
2892 + oper.ToString ());
2895 ec.ig.Emit (opcode, target);
2898 public override void Emit (EmitContext ec)
2900 ILGenerator ig = ec.ig;
2902 Type r = right.Type;
2905 if (method != null) {
2907 // Note that operators are static anyway
2909 if (Arguments != null)
2910 Invocation.EmitArguments (ec, method, Arguments);
2912 if (method is MethodInfo)
2913 ig.Emit (OpCodes.Call, (MethodInfo) method);
2915 ig.Emit (OpCodes.Call, (ConstructorInfo) method);
2924 case Operator.Multiply:
2926 if (l == TypeManager.int32_type || l == TypeManager.int64_type)
2927 opcode = OpCodes.Mul_Ovf;
2928 else if (l==TypeManager.uint32_type || l==TypeManager.uint64_type)
2929 opcode = OpCodes.Mul_Ovf_Un;
2931 opcode = OpCodes.Mul;
2933 opcode = OpCodes.Mul;
2937 case Operator.Division:
2938 if (l == TypeManager.uint32_type || l == TypeManager.uint64_type)
2939 opcode = OpCodes.Div_Un;
2941 opcode = OpCodes.Div;
2944 case Operator.Modulus:
2945 if (l == TypeManager.uint32_type || l == TypeManager.uint64_type)
2946 opcode = OpCodes.Rem_Un;
2948 opcode = OpCodes.Rem;
2951 case Operator.Addition:
2953 if (l == TypeManager.int32_type || l == TypeManager.int64_type)
2954 opcode = OpCodes.Add_Ovf;
2955 else if (l==TypeManager.uint32_type || l==TypeManager.uint64_type)
2956 opcode = OpCodes.Add_Ovf_Un;
2958 opcode = OpCodes.Mul;
2960 opcode = OpCodes.Add;
2963 case Operator.Subtraction:
2965 if (l == TypeManager.int32_type || l == TypeManager.int64_type)
2966 opcode = OpCodes.Sub_Ovf;
2967 else if (l==TypeManager.uint32_type || l==TypeManager.uint64_type)
2968 opcode = OpCodes.Sub_Ovf_Un;
2970 opcode = OpCodes.Sub;
2972 opcode = OpCodes.Sub;
2975 case Operator.RightShift:
2976 opcode = OpCodes.Shr;
2979 case Operator.LeftShift:
2980 opcode = OpCodes.Shl;
2983 case Operator.Equality:
2984 opcode = OpCodes.Ceq;
2987 case Operator.Inequality:
2988 ec.ig.Emit (OpCodes.Ceq);
2989 ec.ig.Emit (OpCodes.Ldc_I4_0);
2991 opcode = OpCodes.Ceq;
2994 case Operator.LessThan:
2995 opcode = OpCodes.Clt;
2998 case Operator.GreaterThan:
2999 opcode = OpCodes.Cgt;
3002 case Operator.LessThanOrEqual:
3003 ec.ig.Emit (OpCodes.Cgt);
3004 ec.ig.Emit (OpCodes.Ldc_I4_0);
3006 opcode = OpCodes.Ceq;
3009 case Operator.GreaterThanOrEqual:
3010 ec.ig.Emit (OpCodes.Clt);
3011 ec.ig.Emit (OpCodes.Ldc_I4_1);
3013 opcode = OpCodes.Sub;
3016 case Operator.LogicalOr:
3017 case Operator.BitwiseOr:
3018 opcode = OpCodes.Or;
3021 case Operator.LogicalAnd:
3022 case Operator.BitwiseAnd:
3023 opcode = OpCodes.And;
3026 case Operator.ExclusiveOr:
3027 opcode = OpCodes.Xor;
3031 throw new Exception ("This should not happen: Operator = "
3032 + oper.ToString ());
3039 public class Conditional : Expression {
3040 Expression expr, trueExpr, falseExpr;
3043 public Conditional (Expression expr, Expression trueExpr, Expression falseExpr, Location l)
3046 this.trueExpr = trueExpr;
3047 this.falseExpr = falseExpr;
3051 public Expression Expr {
3057 public Expression TrueExpr {
3063 public Expression FalseExpr {
3069 public override Expression DoResolve (EmitContext ec)
3071 expr = expr.Resolve (ec);
3073 if (expr.Type != TypeManager.bool_type)
3074 expr = Expression.ConvertImplicitRequired (
3075 ec, expr, TypeManager.bool_type, loc);
3077 trueExpr = trueExpr.Resolve (ec);
3078 falseExpr = falseExpr.Resolve (ec);
3080 if (expr == null || trueExpr == null || falseExpr == null)
3083 if (trueExpr.Type == falseExpr.Type)
3084 type = trueExpr.Type;
3089 // First, if an implicit conversion exists from trueExpr
3090 // to falseExpr, then the result type is of type falseExpr.Type
3092 conv = ConvertImplicit (ec, trueExpr, falseExpr.Type, loc);
3094 type = falseExpr.Type;
3096 } else if ((conv = ConvertImplicit(ec, falseExpr,trueExpr.Type,loc))!= null){
3097 type = trueExpr.Type;
3100 Error (173, loc, "The type of the conditional expression can " +
3101 "not be computed because there is no implicit conversion" +
3102 " from `" + TypeManager.CSharpName (trueExpr.Type) + "'" +
3103 " and `" + TypeManager.CSharpName (falseExpr.Type) + "'");
3108 eclass = ExprClass.Value;
3112 public override void Emit (EmitContext ec)
3114 ILGenerator ig = ec.ig;
3115 Label false_target = ig.DefineLabel ();
3116 Label end_target = ig.DefineLabel ();
3119 ig.Emit (OpCodes.Brfalse, false_target);
3121 ig.Emit (OpCodes.Br, end_target);
3122 ig.MarkLabel (false_target);
3123 falseExpr.Emit (ec);
3124 ig.MarkLabel (end_target);
3129 // SimpleName expressions are initially formed of a single
3130 // word and it only happens at the beginning of the expression.
3132 // The expression will try to be bound to a Field, a Method
3133 // group or a Property. If those fail we pass the name to our
3134 // caller and the SimpleName is compounded to perform a type
3135 // lookup. The idea behind this process is that we want to avoid
3136 // creating a namespace map from the assemblies, as that requires
3137 // the GetExportedTypes function to be called and a hashtable to
3138 // be constructed which reduces startup time. If later we find
3139 // that this is slower, we should create a `NamespaceExpr' expression
3140 // that fully participates in the resolution process.
3142 // For example `System.Console.WriteLine' is decomposed into
3143 // MemberAccess (MemberAccess (SimpleName ("System"), "Console"), "WriteLine")
3145 // The first SimpleName wont produce a match on its own, so it will
3147 // MemberAccess (SimpleName ("System.Console"), "WriteLine").
3149 // System.Console will produce a TypeExpr match.
3151 // The downside of this is that we might be hitting `LookupType' too many
3152 // times with this scheme.
3154 public class SimpleName : Expression {
3155 public readonly string Name;
3156 public readonly Location Location;
3158 public SimpleName (string name, Location l)
3164 public static void Error120 (Location l, string name)
3168 "An object reference is required " +
3169 "for the non-static field `"+name+"'");
3173 // Checks whether we are trying to access an instance
3174 // property, method or field from a static body.
3176 Expression MemberStaticCheck (Expression e)
3178 if (e is FieldExpr){
3179 FieldInfo fi = ((FieldExpr) e).FieldInfo;
3182 Error120 (Location, Name);
3185 } else if (e is MethodGroupExpr){
3186 MethodGroupExpr mg = (MethodGroupExpr) e;
3188 if (!mg.RemoveInstanceMethods ()){
3189 Error120 (Location, mg.Methods [0].Name);
3193 } else if (e is PropertyExpr){
3194 if (!((PropertyExpr) e).IsStatic){
3195 Error120 (Location, Name);
3204 // 7.5.2: Simple Names.
3206 // Local Variables and Parameters are handled at
3207 // parse time, so they never occur as SimpleNames.
3209 public override Expression DoResolve (EmitContext ec)
3214 // Stage 1: Performed by the parser (binding to local or parameters).
3218 // Stage 2: Lookup members
3220 e = MemberLookup (ec, ec.TypeContainer.TypeBuilder, Name, true, Location);
3223 // Stage 3: Lookup symbol in the various namespaces.
3227 if ((t = ec.TypeContainer.LookupType (Name, true)) != null)
3228 return new TypeExpr (t);
3231 // Stage 3 part b: Lookup up if we are an alias to a type
3234 // Since we are cheating: we only do the Alias lookup for
3235 // namespaces if the name does not include any dots in it
3238 // IMPLEMENT ME. Read mcs/mcs/TODO for ideas, or rewrite
3239 // using NamespaceExprs (dunno how that fixes the alias
3240 // per-file though).
3242 // No match, maybe our parent can compose us
3243 // into something meaningful.
3248 // Step 2, continues here.
3252 if (e is FieldExpr){
3253 FieldExpr fe = (FieldExpr) e;
3255 if (!fe.FieldInfo.IsStatic)
3256 fe.InstanceExpression = new This (Location.Null);
3260 return MemberStaticCheck (e);
3265 public override void Emit (EmitContext ec)
3268 // If this is ever reached, then we failed to
3269 // find the name as a namespace
3272 Error (103, Location, "The name `" + Name +
3273 "' does not exist in the class `" +
3274 ec.TypeContainer.Name + "'");
3278 public class LocalVariableReference : Expression, IStackStore, IMemoryLocation {
3279 public readonly string Name;
3280 public readonly Block Block;
3282 VariableInfo variable_info;
3284 public LocalVariableReference (Block block, string name)
3288 eclass = ExprClass.Variable;
3291 public VariableInfo VariableInfo {
3293 if (variable_info == null)
3294 variable_info = Block.GetVariableInfo (Name);
3295 return variable_info;
3299 public override Expression DoResolve (EmitContext ec)
3301 VariableInfo vi = VariableInfo;
3303 type = vi.VariableType;
3307 public override void Emit (EmitContext ec)
3309 VariableInfo vi = VariableInfo;
3310 ILGenerator ig = ec.ig;
3317 ig.Emit (OpCodes.Ldloc_0);
3321 ig.Emit (OpCodes.Ldloc_1);
3325 ig.Emit (OpCodes.Ldloc_2);
3329 ig.Emit (OpCodes.Ldloc_3);
3334 ig.Emit (OpCodes.Ldloc_S, (byte) idx);
3336 ig.Emit (OpCodes.Ldloc, idx);
3341 public static void Store (ILGenerator ig, int idx)
3345 ig.Emit (OpCodes.Stloc_0);
3349 ig.Emit (OpCodes.Stloc_1);
3353 ig.Emit (OpCodes.Stloc_2);
3357 ig.Emit (OpCodes.Stloc_3);
3362 ig.Emit (OpCodes.Stloc_S, (byte) idx);
3364 ig.Emit (OpCodes.Stloc, idx);
3369 public void Store (EmitContext ec)
3371 ILGenerator ig = ec.ig;
3372 VariableInfo vi = VariableInfo;
3376 // Funny seems the above generates optimal code for us, but
3377 // seems to take too long to generate what we need.
3378 // ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
3383 public void AddressOf (EmitContext ec)
3385 VariableInfo vi = VariableInfo;
3392 ec.ig.Emit (OpCodes.Ldloca_S, (byte) idx);
3394 ec.ig.Emit (OpCodes.Ldloca, idx);
3398 public class ParameterReference : Expression, IStackStore, IMemoryLocation {
3399 public readonly Parameters Pars;
3400 public readonly String Name;
3401 public readonly int Idx;
3404 public ParameterReference (Parameters pars, int idx, string name)
3409 eclass = ExprClass.Variable;
3412 public override Expression DoResolve (EmitContext ec)
3414 Type [] types = Pars.GetParameterInfo (ec.TypeContainer);
3425 public override void Emit (EmitContext ec)
3428 ec.ig.Emit (OpCodes.Ldarg_S, (byte) arg_idx);
3430 ec.ig.Emit (OpCodes.Ldarg, arg_idx);
3433 public void Store (EmitContext ec)
3436 ec.ig.Emit (OpCodes.Starg_S, (byte) arg_idx);
3438 ec.ig.Emit (OpCodes.Starg, arg_idx);
3442 public void AddressOf (EmitContext ec)
3445 ec.ig.Emit (OpCodes.Ldarga_S, (byte) arg_idx);
3447 ec.ig.Emit (OpCodes.Ldarga, arg_idx);
3452 // Used for arguments to New(), Invocation()
3454 public class Argument {
3461 public readonly AType Type;
3462 public Expression expr;
3464 public Argument (Expression expr, AType type)
3470 public Expression Expr {
3480 public bool Resolve (EmitContext ec)
3482 expr = expr.Resolve (ec);
3484 return expr != null;
3487 public void Emit (EmitContext ec)
3494 // Invocation of methods or delegates.
3496 public class Invocation : ExpressionStatement {
3497 public readonly ArrayList Arguments;
3498 public readonly Location Location;
3501 MethodBase method = null;
3503 static Hashtable method_parameter_cache;
3505 static Invocation ()
3507 method_parameter_cache = new Hashtable ();
3511 // arguments is an ArrayList, but we do not want to typecast,
3512 // as it might be null.
3514 // FIXME: only allow expr to be a method invocation or a
3515 // delegate invocation (7.5.5)
3517 public Invocation (Expression expr, ArrayList arguments, Location l)
3520 Arguments = arguments;
3524 public Expression Expr {
3531 // Returns the Parameters (a ParameterData interface) for the
3534 public static ParameterData GetParameterData (MethodBase mb)
3536 object pd = method_parameter_cache [mb];
3540 return (ParameterData) pd;
3543 ip = TypeContainer.LookupParametersByBuilder (mb);
3545 method_parameter_cache [mb] = ip;
3547 return (ParameterData) ip;
3549 ParameterInfo [] pi = mb.GetParameters ();
3550 ReflectionParameters rp = new ReflectionParameters (pi);
3551 method_parameter_cache [mb] = rp;
3553 return (ParameterData) rp;
3558 // Tells whether a user defined conversion from Type `from' to
3559 // Type `to' exists.
3561 // FIXME: we could implement a cache here.
3563 static bool ConversionExists (EmitContext ec, Type from, Type to, Location loc)
3565 // Locate user-defined implicit operators
3569 mg = MemberLookup (ec, to, "op_Implicit", false, loc);
3572 MethodGroupExpr me = (MethodGroupExpr) mg;
3574 for (int i = me.Methods.Length; i > 0;) {
3576 MethodBase mb = me.Methods [i];
3577 ParameterData pd = GetParameterData (mb);
3579 if (from == pd.ParameterType (0))
3584 mg = MemberLookup (ec, from, "op_Implicit", false, loc);
3587 MethodGroupExpr me = (MethodGroupExpr) mg;
3589 for (int i = me.Methods.Length; i > 0;) {
3591 MethodBase mb = me.Methods [i];
3592 MethodInfo mi = (MethodInfo) mb;
3594 if (mi.ReturnType == to)
3603 // Determines "better conversion" as specified in 7.4.2.3
3604 // Returns : 1 if a->p is better
3605 // 0 if a->q or neither is better
3607 static int BetterConversion (EmitContext ec, Argument a, Type p, Type q, bool use_standard,
3610 Type argument_type = a.Expr.Type;
3611 Expression argument_expr = a.Expr;
3613 if (argument_type == null)
3614 throw new Exception ("Expression of type " + a.Expr + " does not resolve its type");
3619 if (argument_type == p)
3622 if (argument_type == q)
3626 // Now probe whether an implicit constant expression conversion
3629 // An implicit constant expression conversion permits the following
3632 // * A constant-expression of type `int' can be converted to type
3633 // sbyte, byute, short, ushort, uint, ulong provided the value of
3634 // of the expression is withing the range of the destination type.
3636 // * A constant-expression of type long can be converted to type
3637 // ulong, provided the value of the constant expression is not negative
3639 // FIXME: Note that this assumes that constant folding has
3640 // taken place. We dont do constant folding yet.
3643 if (argument_expr is IntLiteral){
3644 IntLiteral ei = (IntLiteral) argument_expr;
3645 int value = ei.Value;
3647 if (p == TypeManager.sbyte_type){
3648 if (value >= SByte.MinValue && value <= SByte.MaxValue)
3650 } else if (p == TypeManager.byte_type){
3651 if (Byte.MinValue >= 0 && value <= Byte.MaxValue)
3653 } else if (p == TypeManager.short_type){
3654 if (value >= Int16.MinValue && value <= Int16.MaxValue)
3656 } else if (p == TypeManager.ushort_type){
3657 if (value >= UInt16.MinValue && value <= UInt16.MaxValue)
3659 } else if (p == TypeManager.uint32_type){
3661 // we can optimize this case: a positive int32
3662 // always fits on a uint32
3666 } else if (p == TypeManager.uint64_type){
3668 // we can optimize this case: a positive int32
3669 // always fits on a uint64
3674 } else if (argument_type == TypeManager.int64_type && argument_expr is LongLiteral){
3675 LongLiteral ll = (LongLiteral) argument_expr;
3677 if (p == TypeManager.uint64_type){
3688 tmp = ConvertImplicitStandard (ec, argument_expr, p, loc);
3690 tmp = ConvertImplicit (ec, argument_expr, p, loc);
3699 if (ConversionExists (ec, p, q, loc) == true &&
3700 ConversionExists (ec, q, p, loc) == false)
3703 if (p == TypeManager.sbyte_type)
3704 if (q == TypeManager.byte_type || q == TypeManager.ushort_type ||
3705 q == TypeManager.uint32_type || q == TypeManager.uint64_type)
3708 if (p == TypeManager.short_type)
3709 if (q == TypeManager.ushort_type || q == TypeManager.uint32_type ||
3710 q == TypeManager.uint64_type)
3713 if (p == TypeManager.int32_type)
3714 if (q == TypeManager.uint32_type || q == TypeManager.uint64_type)
3717 if (p == TypeManager.int64_type)
3718 if (q == TypeManager.uint64_type)
3725 // Determines "Better function" and returns an integer indicating :
3726 // 0 if candidate ain't better
3727 // 1 if candidate is better than the current best match
3729 static int BetterFunction (EmitContext ec, ArrayList args,
3730 MethodBase candidate, MethodBase best,
3731 bool use_standard, Location loc)
3733 ParameterData candidate_pd = GetParameterData (candidate);
3734 ParameterData best_pd;
3740 argument_count = args.Count;
3742 if (candidate_pd.Count == 0 && argument_count == 0)
3746 if (candidate_pd.Count == argument_count) {
3748 for (int j = argument_count; j > 0;) {
3751 Argument a = (Argument) args [j];
3753 x = BetterConversion (
3754 ec, a, candidate_pd.ParameterType (j), null,
3770 best_pd = GetParameterData (best);
3772 if (candidate_pd.Count == argument_count && best_pd.Count == argument_count) {
3773 int rating1 = 0, rating2 = 0;
3775 for (int j = argument_count; j > 0;) {
3779 Argument a = (Argument) args [j];
3781 x = BetterConversion (ec, a, candidate_pd.ParameterType (j),
3782 best_pd.ParameterType (j), use_standard, loc);
3783 y = BetterConversion (ec, a, best_pd.ParameterType (j),
3784 candidate_pd.ParameterType (j), use_standard,
3791 if (rating1 > rating2)
3800 public static string FullMethodDesc (MethodBase mb)
3802 StringBuilder sb = new StringBuilder (mb.Name);
3803 ParameterData pd = GetParameterData (mb);
3805 int count = pd.Count;
3808 for (int i = count; i > 0; ) {
3811 sb.Append (TypeManager.CSharpName (pd.ParameterType (count - i - 1)));
3817 return sb.ToString ();
3820 public static MethodGroupExpr MakeUnionSet (Expression mg1, Expression mg2)
3822 MemberInfo [] miset;
3823 MethodGroupExpr union;
3825 if (mg1 != null && mg2 != null) {
3827 MethodGroupExpr left_set = null, right_set = null;
3828 int length1 = 0, length2 = 0;
3830 left_set = (MethodGroupExpr) mg1;
3831 length1 = left_set.Methods.Length;
3833 right_set = (MethodGroupExpr) mg2;
3834 length2 = right_set.Methods.Length;
3836 ArrayList common = new ArrayList ();
3838 for (int i = 0; i < left_set.Methods.Length; i++) {
3839 for (int j = 0; j < right_set.Methods.Length; j++) {
3840 if (left_set.Methods [i] == right_set.Methods [j])
3841 common.Add (left_set.Methods [i]);
3845 miset = new MemberInfo [length1 + length2 - common.Count];
3847 left_set.Methods.CopyTo (miset, 0);
3851 for (int j = 0; j < right_set.Methods.Length; j++)
3852 if (!common.Contains (right_set.Methods [j]))
3853 miset [length1 + k++] = right_set.Methods [j];
3855 union = new MethodGroupExpr (miset);
3859 } else if (mg1 == null && mg2 != null) {
3861 MethodGroupExpr me = (MethodGroupExpr) mg2;
3863 miset = new MemberInfo [me.Methods.Length];
3864 me.Methods.CopyTo (miset, 0);
3866 union = new MethodGroupExpr (miset);
3870 } else if (mg2 == null && mg1 != null) {
3872 MethodGroupExpr me = (MethodGroupExpr) mg1;
3874 miset = new MemberInfo [me.Methods.Length];
3875 me.Methods.CopyTo (miset, 0);
3877 union = new MethodGroupExpr (miset);
3886 // Find the Applicable Function Members (7.4.2.1)
3888 // me: Method Group expression with the members to select.
3889 // it might contain constructors or methods (or anything
3890 // that maps to a method).
3892 // Arguments: ArrayList containing resolved Argument objects.
3894 // loc: The location if we want an error to be reported, or a Null
3895 // location for "probing" purposes.
3897 // inside_user_defined: controls whether OverloadResolve should use the
3898 // ConvertImplicit or ConvertImplicitStandard during overload resolution.
3900 // Returns: The MethodBase (either a ConstructorInfo or a MethodInfo)
3901 // that is the best match of me on Arguments.
3904 public static MethodBase OverloadResolve (EmitContext ec, MethodGroupExpr me,
3905 ArrayList Arguments, Location loc,
3908 ArrayList afm = new ArrayList ();
3909 int best_match_idx = -1;
3910 MethodBase method = null;
3913 for (int i = me.Methods.Length; i > 0; ){
3915 MethodBase candidate = me.Methods [i];
3918 x = BetterFunction (ec, Arguments, candidate, method, use_standard, loc);
3924 method = me.Methods [best_match_idx];
3928 if (Arguments == null)
3931 argument_count = Arguments.Count;
3935 // Now we see if we can at least find a method with the same number of arguments
3936 // and then try doing implicit conversion on the arguments
3937 if (best_match_idx == -1) {
3939 for (int i = me.Methods.Length; i > 0;) {
3941 MethodBase mb = me.Methods [i];
3942 pd = GetParameterData (mb);
3944 if (pd.Count == argument_count) {
3946 method = me.Methods [best_match_idx];
3957 // And now convert implicitly, each argument to the required type
3959 pd = GetParameterData (method);
3961 for (int j = argument_count; j > 0;) {
3963 Argument a = (Argument) Arguments [j];
3964 Expression a_expr = a.Expr;
3965 Type parameter_type = pd.ParameterType (j);
3967 if (a_expr.Type != parameter_type){
3971 conv = ConvertImplicitStandard (ec, a_expr, parameter_type,
3974 conv = ConvertImplicit (ec, a_expr, parameter_type,
3978 if (!Location.IsNull (loc)) {
3980 "The best overloaded match for method '" + FullMethodDesc (method) +
3981 "' has some invalid arguments");
3983 "Argument " + (j+1) +
3984 ": Cannot convert from '" + TypeManager.CSharpName (a_expr.Type)
3985 + "' to '" + TypeManager.CSharpName (pd.ParameterType (j)) + "'");
3990 // Update the argument with the implicit conversion
4000 public static MethodBase OverloadResolve (EmitContext ec, MethodGroupExpr me,
4001 ArrayList Arguments, Location loc)
4003 return OverloadResolve (ec, me, Arguments, loc, false);
4006 public override Expression DoResolve (EmitContext ec)
4008 bool IsDelegate = false;
4010 // First, resolve the expression that is used to
4011 // trigger the invocation
4013 expr = expr.Resolve (ec);
4018 // If SimpleNames make it here, it is an error
4020 if (expr is SimpleName){
4021 SimpleName s = (SimpleName) expr;
4023 Report.Error (246, s.Location,
4024 "The type or name `" + s.Name + "' could not be found, " +
4025 "maybe you are missing a using directive");
4029 if (!(expr is MethodGroupExpr)) {
4030 Type expr_type = expr.Type;
4032 if (expr_type == null){
4033 IsDelegate = TypeManager.IsDelegateType (expr_type);
4035 return (new DelegateInvocation (
4036 this.expr, Arguments, Location)).Resolve (ec);
4040 if (!(this.expr is MethodGroupExpr)){
4041 report118 (Location, this.expr, "method group");
4046 // Next, evaluate all the expressions in the argument list
4048 if (Arguments != null){
4049 for (int i = Arguments.Count; i > 0;){
4051 Argument a = (Argument) Arguments [i];
4053 if (!a.Resolve (ec))
4058 method = OverloadResolve (ec, (MethodGroupExpr) this.expr, Arguments,
4061 if (method == null){
4062 Error (-6, Location,
4063 "Could not find any applicable function for this argument list");
4067 if (method is MethodInfo)
4068 type = ((MethodInfo)method).ReturnType;
4070 eclass = ExprClass.Value;
4074 public static void EmitArguments (EmitContext ec, MethodBase method, ArrayList Arguments)
4078 if (Arguments != null)
4079 top = Arguments.Count;
4083 for (int i = 0; i < top; i++){
4084 Argument a = (Argument) Arguments [i];
4090 public static void EmitCall (EmitContext ec,
4091 bool is_static, Expression instance_expr,
4092 MethodBase method, ArrayList Arguments)
4094 ILGenerator ig = ec.ig;
4095 bool struct_call = false;
4099 // If this is ourselves, push "this"
4101 if (instance_expr == null){
4102 ig.Emit (OpCodes.Ldarg_0);
4105 // Push the instance expression
4107 if (instance_expr.Type.IsSubclassOf (TypeManager.value_type)){
4112 // If the expression implements IMemoryLocation, then
4113 // we can optimize and use AddressOf on the
4116 // If not we have to use some temporary storage for
4118 if (instance_expr is IMemoryLocation)
4119 ((IMemoryLocation) instance_expr).AddressOf (ec);
4121 Type t = instance_expr.Type;
4123 instance_expr.Emit (ec);
4124 LocalBuilder temp = ec.GetTemporaryStorage (t);
4125 ig.Emit (OpCodes.Stloc, temp);
4126 ig.Emit (OpCodes.Ldloca, temp);
4129 instance_expr.Emit (ec);
4133 if (Arguments != null)
4134 EmitArguments (ec, method, Arguments);
4136 if (is_static || struct_call){
4137 if (method is MethodInfo)
4138 ig.Emit (OpCodes.Call, (MethodInfo) method);
4140 ig.Emit (OpCodes.Call, (ConstructorInfo) method);
4142 if (method is MethodInfo)
4143 ig.Emit (OpCodes.Callvirt, (MethodInfo) method);
4145 ig.Emit (OpCodes.Callvirt, (ConstructorInfo) method);
4149 public override void Emit (EmitContext ec)
4151 MethodGroupExpr mg = (MethodGroupExpr) this.expr;
4152 EmitCall (ec, method.IsStatic, mg.InstanceExpression, method, Arguments);
4155 public override void EmitStatement (EmitContext ec)
4160 // Pop the return value if there is one
4162 if (method is MethodInfo){
4163 if (((MethodInfo)method).ReturnType != TypeManager.void_type)
4164 ec.ig.Emit (OpCodes.Pop);
4169 public class New : ExpressionStatement {
4176 public readonly NType NewType;
4177 public readonly ArrayList Arguments;
4178 public readonly string RequestedType;
4180 // These are for the case when we have an array
4181 public readonly string Rank;
4182 public readonly ArrayList Initializers;
4185 MethodBase method = null;
4188 // If set, the new expression is for a value_target, and
4189 // we will not leave anything on the stack.
4191 Expression value_target;
4193 public New (string requested_type, ArrayList arguments, Location loc)
4195 RequestedType = requested_type;
4196 Arguments = arguments;
4197 NewType = NType.Object;
4201 public New (string requested_type, ArrayList exprs, string rank, ArrayList initializers, Location loc)
4203 RequestedType = requested_type;
4205 Initializers = initializers;
4206 NewType = NType.Array;
4209 Arguments = new ArrayList ();
4211 foreach (Expression e in exprs)
4212 Arguments.Add (new Argument (e, Argument.AType.Expression));
4216 public static string FormLookupType (string base_type, int idx_count, string rank)
4218 StringBuilder sb = new StringBuilder (base_type);
4223 for (int i = 1; i < idx_count; i++)
4227 return sb.ToString ();
4230 public Expression ValueTypeVariable {
4232 return value_target;
4236 value_target = value;
4240 public override Expression DoResolve (EmitContext ec)
4242 if (NewType == NType.Object) {
4244 type = ec.TypeContainer.LookupType (RequestedType, false);
4249 bool IsDelegate = TypeManager.IsDelegateType (type);
4252 return (new NewDelegate (type, Arguments, Location)).Resolve (ec);
4256 ml = MemberLookup (ec, type, ".ctor", false,
4257 MemberTypes.Constructor, AllBindingsFlags, Location);
4259 bool is_struct = false;
4260 is_struct = type.IsSubclassOf (TypeManager.value_type);
4262 if (! (ml is MethodGroupExpr)){
4264 report118 (Location, ml, "method group");
4270 if (Arguments != null){
4271 for (int i = Arguments.Count; i > 0;){
4273 Argument a = (Argument) Arguments [i];
4275 if (!a.Resolve (ec))
4280 method = Invocation.OverloadResolve (ec, (MethodGroupExpr) ml,
4281 Arguments, Location);
4285 if (method == null && !is_struct) {
4286 Error (-6, Location,
4287 "New invocation: Can not find a constructor for " +
4288 "this argument list");
4292 eclass = ExprClass.Value;
4297 if (NewType == NType.Array) {
4298 throw new Exception ("Finish array creation");
4305 // This DoEmit can be invoked in two contexts:
4306 // * As a mechanism that will leave a value on the stack (new object)
4307 // * As one that wont (init struct)
4309 // You can control whether a value is required on the stack by passing
4310 // need_value_on_stack. The code *might* leave a value on the stack
4311 // so it must be popped manually
4313 // Returns whether a value is left on the stack
4315 bool DoEmit (EmitContext ec, bool need_value_on_stack)
4317 if (method == null){
4318 IMemoryLocation ml = (IMemoryLocation) value_target;
4322 Invocation.EmitArguments (ec, method, Arguments);
4323 ec.ig.Emit (OpCodes.Newobj, (ConstructorInfo) method);
4328 // It must be a value type, sanity check
4330 if (value_target != null){
4331 ec.ig.Emit (OpCodes.Initobj, type);
4333 if (need_value_on_stack){
4334 value_target.Emit (ec);
4340 throw new Exception ("No method and no value type");
4343 public override void Emit (EmitContext ec)
4348 public override void EmitStatement (EmitContext ec)
4350 if (DoEmit (ec, false))
4351 ec.ig.Emit (OpCodes.Pop);
4356 // Represents the `this' construct
4358 public class This : Expression, IStackStore, IMemoryLocation {
4361 public This (Location loc)
4366 public override Expression DoResolve (EmitContext ec)
4368 eclass = ExprClass.Variable;
4369 type = ec.TypeContainer.TypeBuilder;
4372 Report.Error (26, loc,
4373 "Keyword this not valid in static code");
4380 public Expression DoResolveLValue (EmitContext ec)
4384 if (ec.TypeContainer is Class){
4385 Report.Error (1604, loc, "Cannot assign to `this'");
4392 public override void Emit (EmitContext ec)
4394 ec.ig.Emit (OpCodes.Ldarg_0);
4397 public void Store (EmitContext ec)
4399 ec.ig.Emit (OpCodes.Starg, 0);
4402 public void AddressOf (EmitContext ec)
4404 ec.ig.Emit (OpCodes.Ldarga_S, (byte) 0);
4409 // Implements the typeof operator
4411 public class TypeOf : Expression {
4412 public readonly string QueriedType;
4415 public TypeOf (string queried_type)
4417 QueriedType = queried_type;
4420 public override Expression DoResolve (EmitContext ec)
4422 typearg = ec.TypeContainer.LookupType (QueriedType, false);
4424 if (typearg == null)
4427 type = TypeManager.type_type;
4428 eclass = ExprClass.Type;
4432 public override void Emit (EmitContext ec)
4434 ec.ig.Emit (OpCodes.Ldtoken, typearg);
4435 ec.ig.Emit (OpCodes.Call, TypeManager.system_type_get_type_from_handle);
4439 public class SizeOf : Expression {
4440 public readonly string QueriedType;
4442 public SizeOf (string queried_type)
4444 this.QueriedType = queried_type;
4447 public override Expression DoResolve (EmitContext ec)
4449 // FIXME: Implement;
4450 throw new Exception ("Unimplemented");
4454 public override void Emit (EmitContext ec)
4456 throw new Exception ("Implement me");
4460 public class MemberAccess : Expression {
4461 public readonly string Identifier;
4463 Expression member_lookup;
4466 public MemberAccess (Expression expr, string id, Location l)
4473 public Expression Expr {
4479 void error176 (Location loc, string name)
4481 Report.Error (176, loc, "Static member `" +
4482 name + "' cannot be accessed " +
4483 "with an instance reference, qualify with a " +
4484 "type name instead");
4487 public override Expression DoResolve (EmitContext ec)
4489 expr = expr.Resolve (ec);
4494 if (expr is SimpleName){
4495 SimpleName child_expr = (SimpleName) expr;
4497 expr = new SimpleName (child_expr.Name + "." + Identifier, loc);
4499 return expr.Resolve (ec);
4502 member_lookup = MemberLookup (ec, expr.Type, Identifier, false, loc);
4507 if (member_lookup is MethodGroupExpr){
4508 MethodGroupExpr mg = (MethodGroupExpr) member_lookup;
4513 if (expr is TypeExpr){
4514 if (!mg.RemoveInstanceMethods ()){
4515 SimpleName.Error120 (loc, mg.Methods [0].Name);
4519 return member_lookup;
4523 // Instance.MethodGroup
4525 if (!mg.RemoveStaticMethods ()){
4526 error176 (loc, mg.Methods [0].Name);
4530 mg.InstanceExpression = expr;
4532 return member_lookup;
4535 if (member_lookup is FieldExpr){
4536 FieldExpr fe = (FieldExpr) member_lookup;
4538 if (expr is TypeExpr){
4539 if (!fe.FieldInfo.IsStatic){
4540 error176 (loc, fe.FieldInfo.Name);
4543 return member_lookup;
4545 if (fe.FieldInfo.IsStatic){
4546 error176 (loc, fe.FieldInfo.Name);
4549 fe.InstanceExpression = expr;
4555 if (member_lookup is PropertyExpr){
4556 PropertyExpr pe = (PropertyExpr) member_lookup;
4558 if (expr is TypeExpr){
4560 SimpleName.Error120 (loc, pe.PropertyInfo.Name);
4566 error176 (loc, pe.PropertyInfo.Name);
4569 pe.InstanceExpression = expr;
4575 Console.WriteLine ("Support for " + member_lookup + " is not present yet");
4576 Environment.Exit (0);
4580 public override void Emit (EmitContext ec)
4582 throw new Exception ("Should not happen I think");
4588 // Fully resolved expression that evaluates to a type
4590 public class TypeExpr : Expression {
4591 public TypeExpr (Type t)
4594 eclass = ExprClass.Type;
4597 override public Expression DoResolve (EmitContext ec)
4602 override public void Emit (EmitContext ec)
4604 throw new Exception ("Implement me");
4609 // MethodGroup Expression.
4611 // This is a fully resolved expression that evaluates to a type
4613 public class MethodGroupExpr : Expression {
4614 public MethodBase [] Methods;
4615 Expression instance_expression = null;
4617 public MethodGroupExpr (MemberInfo [] mi)
4619 Methods = new MethodBase [mi.Length];
4620 mi.CopyTo (Methods, 0);
4621 eclass = ExprClass.MethodGroup;
4624 public MethodGroupExpr (ArrayList l)
4626 Methods = new MethodBase [l.Count];
4628 l.CopyTo (Methods, 0);
4629 eclass = ExprClass.MethodGroup;
4633 // `A method group may have associated an instance expression'
4635 public Expression InstanceExpression {
4637 return instance_expression;
4641 instance_expression = value;
4645 override public Expression DoResolve (EmitContext ec)
4650 override public void Emit (EmitContext ec)
4652 throw new Exception ("This should never be reached");
4655 bool RemoveMethods (bool keep_static)
4657 ArrayList smethods = new ArrayList ();
4658 int top = Methods.Length;
4661 for (i = 0; i < top; i++){
4662 MethodBase mb = Methods [i];
4664 if (mb.IsStatic == keep_static)
4668 if (smethods.Count == 0)
4671 Methods = new MethodBase [smethods.Count];
4672 smethods.CopyTo (Methods, 0);
4678 // Removes any instance methods from the MethodGroup, returns
4679 // false if the resulting set is empty.
4681 public bool RemoveInstanceMethods ()
4683 return RemoveMethods (true);
4687 // Removes any static methods from the MethodGroup, returns
4688 // false if the resulting set is empty.
4690 public bool RemoveStaticMethods ()
4692 return RemoveMethods (false);
4697 // Fully resolved expression that evaluates to a Field
4699 public class FieldExpr : Expression, IStackStore, IMemoryLocation {
4700 public readonly FieldInfo FieldInfo;
4701 public Expression InstanceExpression;
4704 public FieldExpr (FieldInfo fi, Location l)
4707 eclass = ExprClass.Variable;
4708 type = fi.FieldType;
4712 override public Expression DoResolve (EmitContext ec)
4714 if (!FieldInfo.IsStatic){
4715 if (InstanceExpression == null){
4716 throw new Exception ("non-static FieldExpr without instance var\n" +
4717 "You have to assign the Instance variable\n" +
4718 "Of the FieldExpr to set this\n");
4721 InstanceExpression = InstanceExpression.Resolve (ec);
4722 if (InstanceExpression == null)
4729 public Expression DoResolveLValue (EmitContext ec)
4731 if (!FieldInfo.IsInitOnly)
4735 // InitOnly fields can only be assigned in constructors
4738 if (ec.IsConstructor)
4741 Report.Error (191, loc,
4742 "Readonly field can not be assigned outside " +
4743 "of constructor or variable initializer");
4748 override public void Emit (EmitContext ec)
4750 ILGenerator ig = ec.ig;
4752 if (FieldInfo.IsStatic)
4753 ig.Emit (OpCodes.Ldsfld, FieldInfo);
4755 InstanceExpression.Emit (ec);
4757 ig.Emit (OpCodes.Ldfld, FieldInfo);
4761 public void Store (EmitContext ec)
4763 if (FieldInfo.IsStatic)
4764 ec.ig.Emit (OpCodes.Stsfld, FieldInfo);
4766 ec.ig.Emit (OpCodes.Stfld, FieldInfo);
4769 public void AddressOf (EmitContext ec)
4771 if (FieldInfo.IsStatic)
4772 ec.ig.Emit (OpCodes.Ldsflda, FieldInfo);
4774 InstanceExpression.Emit (ec);
4775 ec.ig.Emit (OpCodes.Ldflda, FieldInfo);
4781 // Expression that evaluates to a Property. The Assign class
4782 // might set the `Value' expression if we are in an assignment.
4784 // This is not an LValue because we need to re-write the expression, we
4785 // can not take data from the stack and store it.
4787 public class PropertyExpr : ExpressionStatement, IAssignMethod {
4788 public readonly PropertyInfo PropertyInfo;
4789 public readonly bool IsStatic;
4790 MethodInfo [] Accessors;
4793 Expression instance_expr;
4795 public PropertyExpr (PropertyInfo pi, Location l)
4798 eclass = ExprClass.PropertyAccess;
4801 Accessors = TypeManager.GetAccessors (pi);
4803 if (Accessors != null)
4804 for (int i = 0; i < Accessors.Length; i++){
4805 if (Accessors [i] != null)
4806 if (Accessors [i].IsStatic)
4810 Accessors = new MethodInfo [2];
4812 type = pi.PropertyType;
4816 // The instance expression associated with this expression
4818 public Expression InstanceExpression {
4820 instance_expr = value;
4824 return instance_expr;
4828 public bool VerifyAssignable ()
4830 if (!PropertyInfo.CanWrite){
4831 Report.Error (200, loc,
4832 "The property `" + PropertyInfo.Name +
4833 "' can not be assigned to, as it has not set accessor");
4840 override public Expression DoResolve (EmitContext ec)
4842 if (!PropertyInfo.CanRead){
4843 Report.Error (154, loc,
4844 "The property `" + PropertyInfo.Name +
4845 "' can not be used in " +
4846 "this context because it lacks a get accessor");
4853 override public void Emit (EmitContext ec)
4855 Invocation.EmitCall (ec, IsStatic, instance_expr, Accessors [0], null);
4860 // Implements the IAssignMethod interface for assignments
4862 public void EmitAssign (EmitContext ec, Expression source)
4864 Argument arg = new Argument (source, Argument.AType.Expression);
4865 ArrayList args = new ArrayList ();
4868 Invocation.EmitCall (ec, IsStatic, instance_expr, Accessors [1], args);
4871 override public void EmitStatement (EmitContext ec)
4874 ec.ig.Emit (OpCodes.Pop);
4879 // Fully resolved expression that evaluates to a Expression
4881 public class EventExpr : Expression {
4882 public readonly EventInfo EventInfo;
4885 public EventExpr (EventInfo ei, Location loc)
4889 eclass = ExprClass.EventAccess;
4892 override public Expression DoResolve (EmitContext ec)
4894 // We are born in resolved state.
4898 override public void Emit (EmitContext ec)
4900 throw new Exception ("Implement me");
4901 // FIXME: Implement.
4905 public class CheckedExpr : Expression {
4907 public Expression Expr;
4909 public CheckedExpr (Expression e)
4914 public override Expression DoResolve (EmitContext ec)
4916 Expr = Expr.Resolve (ec);
4921 eclass = Expr.ExprClass;
4926 public override void Emit (EmitContext ec)
4928 bool last_check = ec.CheckState;
4930 ec.CheckState = true;
4932 ec.CheckState = last_check;
4937 public class UnCheckedExpr : Expression {
4939 public Expression Expr;
4941 public UnCheckedExpr (Expression e)
4946 public override Expression DoResolve (EmitContext ec)
4948 Expr = Expr.Resolve (ec);
4953 eclass = Expr.ExprClass;
4958 public override void Emit (EmitContext ec)
4960 bool last_check = ec.CheckState;
4962 ec.CheckState = false;
4964 ec.CheckState = last_check;
4969 public class ElementAccess : Expression {
4971 public ArrayList Arguments;
4972 public Expression Expr;
4973 public Location loc;
4975 public ElementAccess (Expression e, ArrayList e_list, Location l)
4979 Arguments = new ArrayList ();
4980 foreach (Expression tmp in e_list)
4981 Arguments.Add (new Argument (tmp, Argument.AType.Expression));
4986 bool CommonResolve (EmitContext ec)
4988 Expr = Expr.Resolve (ec);
4993 if (Arguments == null)
4996 for (int i = Arguments.Count; i > 0;){
4998 Argument a = (Argument) Arguments [i];
5000 if (!a.Resolve (ec))
5007 public override Expression DoResolve (EmitContext ec)
5009 if (!CommonResolve (ec))
5013 // We perform some simple tests, and then to "split" the emit and store
5014 // code we create an instance of a different class, and return that.
5016 // I am experimenting with this pattern.
5018 if (Expr.Type == TypeManager.array_type)
5019 return (new ArrayAccess (this)).Resolve (ec);
5021 return (new IndexerAccess (this)).Resolve (ec);
5024 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
5026 if (!CommonResolve (ec))
5029 if (Expr.Type == TypeManager.array_type)
5030 return (new ArrayAccess (this)).ResolveLValue (ec, right_side);
5032 return (new IndexerAccess (this)).ResolveLValue (ec, right_side);
5035 public override void Emit (EmitContext ec)
5037 throw new Exception ("Should never be reached");
5041 public class ArrayAccess : Expression, IStackStore {
5043 // Points to our "data" repository
5047 public ArrayAccess (ElementAccess ea_data)
5050 eclass = ExprClass.Variable;
5053 // FIXME: Figure out the type here
5057 Expression CommonResolve (EmitContext ec)
5062 public override Expression DoResolve (EmitContext ec)
5064 if (ea.Expr.ExprClass != ExprClass.Variable) {
5065 report118 (ea.loc, ea.Expr, "variable");
5069 throw new Exception ("Implement me");
5072 public void Store (EmitContext ec)
5074 throw new Exception ("Implement me !");
5077 public override void Emit (EmitContext ec)
5079 throw new Exception ("Implement me !");
5084 public ArrayList getters, setters;
5085 static Hashtable map;
5089 map = new Hashtable ();
5092 Indexers (MemberInfo [] mi)
5094 foreach (PropertyInfo property in mi){
5095 MethodInfo get, set;
5097 get = property.GetGetMethod (true);
5099 if (getters == null)
5100 getters = new ArrayList ();
5105 set = property.GetSetMethod (true);
5107 if (setters == null)
5108 setters = new ArrayList ();
5114 static public Indexers GetIndexersForType (Type t, TypeManager tm, Location loc)
5116 Indexers ix = (Indexers) map [t];
5117 string p_name = TypeManager.IndexerPropertyName (t);
5122 MemberInfo [] mi = tm.FindMembers (
5123 t, MemberTypes.Property,
5124 BindingFlags.Public | BindingFlags.Instance,
5125 Type.FilterName, p_name);
5127 if (mi == null || mi.Length == 0){
5128 Report.Error (21, loc,
5129 "Type `" + TypeManager.CSharpName (t) + "' does not have " +
5130 "any indexers defined");
5134 ix = new Indexers (mi);
5141 public class IndexerAccess : Expression, IAssignMethod {
5143 // Points to our "data" repository
5146 MethodInfo get, set;
5148 ArrayList set_arguments;
5150 public IndexerAccess (ElementAccess ea_data)
5153 eclass = ExprClass.Value;
5156 public bool VerifyAssignable (Expression source)
5158 throw new Exception ("Implement me!");
5161 public override Expression DoResolve (EmitContext ec)
5163 Type indexer_type = ea.Expr.Type;
5166 // Step 1: Query for all `Item' *properties*. Notice
5167 // that the actual methods are pointed from here.
5169 // This is a group of properties, piles of them.
5172 ilist = Indexers.GetIndexersForType (
5173 indexer_type, ec.TypeContainer.RootContext.TypeManager, ea.loc);
5175 if (ilist != null && ilist.getters != null && ilist.getters.Count > 0)
5176 get = (MethodInfo) Invocation.OverloadResolve (
5177 ec, new MethodGroupExpr (ilist.getters), ea.Arguments, ea.loc);
5180 Report.Error (154, ea.loc,
5181 "indexer can not be used in this context, because " +
5182 "it lacks a `get' accessor");
5186 type = get.ReturnType;
5187 eclass = ExprClass.Value;
5191 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
5193 Type indexer_type = ea.Expr.Type;
5194 Type right_type = right_side.Type;
5197 ilist = Indexers.GetIndexersForType (
5198 indexer_type, ec.TypeContainer.RootContext.TypeManager, ea.loc);
5200 if (ilist != null && ilist.setters != null && ilist.setters.Count > 0){
5201 set_arguments = (ArrayList) ea.Arguments.Clone ();
5202 set_arguments.Add (new Argument (right_side, Argument.AType.Expression));
5204 set = (MethodInfo) Invocation.OverloadResolve (
5205 ec, new MethodGroupExpr (ilist.setters), set_arguments, ea.loc);
5209 Report.Error (200, ea.loc,
5210 "indexer X.this [" + TypeManager.CSharpName (right_type) +
5211 "] lacks a `set' accessor");
5215 type = TypeManager.void_type;
5216 eclass = ExprClass.IndexerAccess;
5220 public override void Emit (EmitContext ec)
5222 Invocation.EmitCall (ec, false, ea.Expr, get, ea.Arguments);
5226 // source is ignored, because we already have a copy of it from the
5227 // LValue resolution and we have already constructed a pre-cached
5228 // version of the arguments (ea.set_arguments);
5230 public void EmitAssign (EmitContext ec, Expression source)
5232 Invocation.EmitCall (ec, false, ea.Expr, set, set_arguments);
5236 public class BaseAccess : Expression {
5238 public enum BaseAccessType {
5243 public readonly BaseAccessType BAType;
5244 public readonly string Member;
5245 public readonly ArrayList Arguments;
5247 public BaseAccess (BaseAccessType t, string member, ArrayList args)
5255 public override Expression DoResolve (EmitContext ec)
5257 // FIXME: Implement;
5258 throw new Exception ("Unimplemented");
5262 public override void Emit (EmitContext ec)
5264 throw new Exception ("Unimplemented");
5269 // This class exists solely to pass the Type around and to be a dummy
5270 // that can be passed to the conversion functions (this is used by
5271 // foreach implementation to typecast the object return value from
5272 // get_Current into the proper type. All code has been generated and
5273 // we only care about the side effect conversions to be performed
5276 public class EmptyExpression : Expression {
5277 public EmptyExpression ()
5279 type = TypeManager.object_type;
5280 eclass = ExprClass.Value;
5283 public override Expression DoResolve (EmitContext ec)
5288 public override void Emit (EmitContext ec)
5290 // nothing, as we only exist to not do anything.
5294 public class UserCast : Expression {
5298 public UserCast (MethodInfo method, Expression source)
5300 this.method = method;
5301 this.source = source;
5302 type = method.ReturnType;
5303 eclass = ExprClass.Value;
5306 public override Expression DoResolve (EmitContext ec)
5309 // We are born fully resolved
5314 public override void Emit (EmitContext ec)
5316 ILGenerator ig = ec.ig;
5320 if (method is MethodInfo)
5321 ig.Emit (OpCodes.Call, (MethodInfo) method);
5323 ig.Emit (OpCodes.Call, (ConstructorInfo) method);
projects / mono.git / blob