mcs/mcs/expression.cs

   1 //
   2 // expression.cs: Expression representation for the IL tree.
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //   Marek Safar (marek.safar@seznam.cz)
   7 //
   8 // (C) 2001, 2002, 2003 Ximian, Inc.
   9 // (C) 2003, 2004 Novell, Inc.
  10 //
  11 #define USE_OLD
  12
  13 namespace Mono.CSharp {
  14         using System;
  15         using System.Collections;
  16         using System.Reflection;
  17         using System.Reflection.Emit;
  18         using System.Text;
  19
  20         /// <summary>
  21         ///   This is just a helper class, it is generated by Unary, UnaryMutator
  22         ///   when an overloaded method has been found.  It just emits the code for a
  23         ///   static call.
  24         /// </summary>
  25         public class StaticCallExpr : ExpressionStatement {
  26                 ArrayList args;
  27                 MethodInfo mi;
  28
  29                 public StaticCallExpr (MethodInfo m, ArrayList a, Location l)
  30                 {
  31                         mi = m;
  32                         args = a;
  33
  34                         type = m.ReturnType;
  35                         eclass = ExprClass.Value;
  36                         loc = l;
  37                 }
  38
  39                 public override Expression DoResolve (EmitContext ec)
  40                 {
  41                         //
  42                         // We are born fully resolved
  43                         //
  44                         return this;
  45                 }
  46
  47                 public override void Emit (EmitContext ec)
  48                 {
  49                         if (args != null)
  50                                 Invocation.EmitArguments (ec, mi, args, false, null);
  51
  52                         ec.ig.Emit (OpCodes.Call, mi);
  53                         return;
  54                 }
  55
  56                 static public StaticCallExpr MakeSimpleCall (EmitContext ec, MethodGroupExpr mg,
  57                                                          Expression e, Location loc)
  58                 {
  59                         ArrayList args;
  60                         MethodBase method;
  61
  62                         args = new ArrayList (1);
  63                         Argument a = new Argument (e, Argument.AType.Expression);
  64
  65                         // We need to resolve the arguments before sending them in !
  66                         if (!a.Resolve (ec, loc))
  67                                 return null;
  68
  69                         args.Add (a);
  70                         method = Invocation.OverloadResolve (
  71                                 ec, (MethodGroupExpr) mg, args, false, loc);
  72
  73                         if (method == null)
  74                                 return null;
  75
  76                         return new StaticCallExpr ((MethodInfo) method, args, loc);
  77                 }
  78
  79                 public override void EmitStatement (EmitContext ec)
  80                 {
  81                         Emit (ec);
  82                         if (TypeManager.TypeToCoreType (type) != TypeManager.void_type)
  83                                 ec.ig.Emit (OpCodes.Pop);
  84                 }
  85
  86                 public MethodInfo Method {
  87                         get { return mi; }
  88                 }
  89         }
  90
  91         public class ParenthesizedExpression : Expression
  92         {
  93                 public Expression Expr;
  94
  95                 public ParenthesizedExpression (Expression expr)
  96                 {
  97                         this.Expr = expr;
  98                 }
  99
 100                 public override Expression DoResolve (EmitContext ec)
 101                 {
 102                         Expr = Expr.Resolve (ec);
 103                         return Expr;
 104                 }
 105
 106                 public override void Emit (EmitContext ec)
 107                 {
 108                         throw new Exception ("Should not happen");
 109                 }
 110
 111                 public override Location Location
 112                 {
 113                         get {
 114                                 return Expr.Location;
 115                         }
 116                 }
 117         }
 118
 119         /// <summary>
 120         ///   Unary expressions.
 121         /// </summary>
 122         ///
 123         /// <remarks>
 124         ///   Unary implements unary expressions.   It derives from
 125         ///   ExpressionStatement becuase the pre/post increment/decrement
 126         ///   operators can be used in a statement context.
 127         /// </remarks>
 128         public class Unary : Expression {
 129                 public enum Operator : byte {
 130                         UnaryPlus, UnaryNegation, LogicalNot, OnesComplement,
 131                         Indirection, AddressOf,  TOP
 132                 }
 133
 134                 public Operator Oper;
 135                 public Expression Expr;
 136
 137                 public Unary (Operator op, Expression expr, Location loc)
 138                 {
 139                         this.Oper = op;
 140                         this.Expr = expr;
 141                         this.loc = loc;
 142                 }
 143
 144                 /// <summary>
 145                 ///   Returns a stringified representation of the Operator
 146                 /// </summary>
 147                 static public string OperName (Operator oper)
 148                 {
 149                         switch (oper){
 150                         case Operator.UnaryPlus:
 151                                 return "+";
 152                         case Operator.UnaryNegation:
 153                                 return "-";
 154                         case Operator.LogicalNot:
 155                                 return "!";
 156                         case Operator.OnesComplement:
 157                                 return "~";
 158                         case Operator.AddressOf:
 159                                 return "&";
 160                         case Operator.Indirection:
 161                                 return "*";
 162                         }
 163
 164                         return oper.ToString ();
 165                 }
 166
 167                 public static readonly string [] oper_names;
 168
 169                 static Unary ()
 170                 {
 171                         oper_names = new string [(int)Operator.TOP];
 172
 173                         oper_names [(int) Operator.UnaryPlus] = "op_UnaryPlus";
 174                         oper_names [(int) Operator.UnaryNegation] = "op_UnaryNegation";
 175                         oper_names [(int) Operator.LogicalNot] = "op_LogicalNot";
 176                         oper_names [(int) Operator.OnesComplement] = "op_OnesComplement";
 177                         oper_names [(int) Operator.Indirection] = "op_Indirection";
 178                         oper_names [(int) Operator.AddressOf] = "op_AddressOf";
 179                 }
 180
 181                 void Error23 (Type t)
 182                 {
 183                         Report.Error (23, loc, "Operator `{0}' cannot be applied to operand of type `{1}'",
 184                                 OperName (Oper), TypeManager.CSharpName (t));
 185                 }
 186
 187                 /// <remarks>
 188                 ///   The result has been already resolved:
 189                 ///
 190                 ///   FIXME: a minus constant -128 sbyte cant be turned into a
 191                 ///   constant byte.
 192                 /// </remarks>
 193                 static Expression TryReduceNegative (Constant expr)
 194                 {
 195                         Expression e = null;
 196
 197                         if (expr is IntConstant)
 198                                 e = new IntConstant (-((IntConstant) expr).Value, expr.Location);
 199                         else if (expr is UIntConstant){
 200                                 uint value = ((UIntConstant) expr).Value;
 201
 202                                 if (value < 2147483649)
 203                                         return new IntConstant (-(int)value, expr.Location);
 204                                 else
 205                                         e = new LongConstant (-value, expr.Location);
 206                         }
 207                         else if (expr is LongConstant)
 208                                 e = new LongConstant (-((LongConstant) expr).Value, expr.Location);
 209                         else if (expr is ULongConstant){
 210                                 ulong value = ((ULongConstant) expr).Value;
 211
 212                                 if (value < 9223372036854775809)
 213                                         return new LongConstant(-(long)value, expr.Location);
 214                         }
 215                         else if (expr is FloatConstant)
 216                                 e = new FloatConstant (-((FloatConstant) expr).Value, expr.Location);
 217                         else if (expr is DoubleConstant)
 218                                 e = new DoubleConstant (-((DoubleConstant) expr).Value, expr.Location);
 219                         else if (expr is DecimalConstant)
 220                                 e = new DecimalConstant (-((DecimalConstant) expr).Value, expr.Location);
 221                         else if (expr is ShortConstant)
 222                                 e = new IntConstant (-((ShortConstant) expr).Value, expr.Location);
 223                         else if (expr is UShortConstant)
 224                                 e = new IntConstant (-((UShortConstant) expr).Value, expr.Location);
 225                         else if (expr is SByteConstant)
 226                                 e = new IntConstant (-((SByteConstant) expr).Value, expr.Location);
 227                         else if (expr is ByteConstant)
 228                                 e = new IntConstant (-((ByteConstant) expr).Value, expr.Location);
 229                         return e;
 230                 }
 231
 232                 // <summary>
 233                 //   This routine will attempt to simplify the unary expression when the
 234                 //   argument is a constant.  The result is returned in `result' and the
 235                 //   function returns true or false depending on whether a reduction
 236                 //   was performed or not
 237                 // </summary>
 238                 bool Reduce (EmitContext ec, Constant e, out Expression result)
 239                 {
 240                         Type expr_type = e.Type;
 241
 242                         switch (Oper){
 243                         case Operator.UnaryPlus:
 244                                 if (expr_type == TypeManager.bool_type){
 245                                         result = null;
 246                                         Error23 (expr_type);
 247                                         return false;
 248                                 }
 249
 250                                 result = e;
 251                                 return true;
 252
 253                         case Operator.UnaryNegation:
 254                                 result = TryReduceNegative (e);
 255                                 return result != null;
 256
 257                         case Operator.LogicalNot:
 258                                 if (expr_type != TypeManager.bool_type) {
 259                                         result = null;
 260                                         Error23 (expr_type);
 261                                         return false;
 262                                 }
 263
 264                                 BoolConstant b = (BoolConstant) e;
 265                                 result = new BoolConstant (!(b.Value), b.Location);
 266                                 return true;
 267
 268                         case Operator.OnesComplement:
 269                                 if (!((expr_type == TypeManager.int32_type) ||
 270                                       (expr_type == TypeManager.uint32_type) ||
 271                                       (expr_type == TypeManager.int64_type) ||
 272                                       (expr_type == TypeManager.uint64_type) ||
 273                                       (expr_type.IsSubclassOf (TypeManager.enum_type)))){
 274
 275                                         result = null;
 276                                         if (Convert.ImplicitConversionExists (ec, e, TypeManager.int32_type)){
 277                                                 result = new Cast (new TypeExpression (TypeManager.int32_type, loc), e, loc);
 278                                                 result = result.Resolve (ec);
 279                                         } else if (Convert.ImplicitConversionExists (ec, e, TypeManager.uint32_type)){
 280                                                 result = new Cast (new TypeExpression (TypeManager.uint32_type, loc), e, loc);
 281                                                 result = result.Resolve (ec);
 282                                         } else if (Convert.ImplicitConversionExists (ec, e, TypeManager.int64_type)){
 283                                                 result = new Cast (new TypeExpression (TypeManager.int64_type, loc), e, loc);
 284                                                 result = result.Resolve (ec);
 285                                         } else if (Convert.ImplicitConversionExists (ec, e, TypeManager.uint64_type)){
 286                                                 result = new Cast (new TypeExpression (TypeManager.uint64_type, loc), e, loc);
 287                                                 result = result.Resolve (ec);
 288                                         }
 289
 290                                         if (result == null || !(result is Constant)){
 291                                                 result = null;
 292                                                 Error23 (expr_type);
 293                                                 return false;
 294                                         }
 295
 296                                         expr_type = result.Type;
 297                                         e = (Constant) result;
 298                                 }
 299
 300                                 if (e is EnumConstant){
 301                                         EnumConstant enum_constant = (EnumConstant) e;
 302                                         Expression reduced;
 303
 304                                         if (Reduce (ec, enum_constant.Child, out reduced)){
 305                                                 result = new EnumConstant ((Constant) reduced, enum_constant.Type);
 306                                                 return true;
 307                                         } else {
 308                                                 result = null;
 309                                                 return false;
 310                                         }
 311                                 }
 312
 313                                 if (expr_type == TypeManager.int32_type){
 314                                         result = new IntConstant (~ ((IntConstant) e).Value, e.Location);
 315                                 } else if (expr_type == TypeManager.uint32_type){
 316                                         result = new UIntConstant (~ ((UIntConstant) e).Value, e.Location);
 317                                 } else if (expr_type == TypeManager.int64_type){
 318                                         result = new LongConstant (~ ((LongConstant) e).Value, e.Location);
 319                                 } else if (expr_type == TypeManager.uint64_type){
 320                                         result = new ULongConstant (~ ((ULongConstant) e).Value, e.Location);
 321                                 } else {
 322                                         result = null;
 323                                         Error23 (expr_type);
 324                                         return false;
 325                                 }
 326                                 return true;
 327
 328                         case Operator.AddressOf:
 329                                 result = this;
 330                                 return false;
 331
 332                         case Operator.Indirection:
 333                                 result = this;
 334                                 return false;
 335                         }
 336                         throw new Exception ("Can not constant fold: " + Oper.ToString());
 337                 }
 338
 339                 Expression ResolveOperator (EmitContext ec)
 340                 {
 341                         //
 342                         // Step 1: Default operations on CLI native types.
 343                         //
 344
 345                         // Attempt to use a constant folding operation.
 346                         if (Expr is Constant){
 347                                 Expression result;
 348
 349                                 if (Reduce (ec, (Constant) Expr, out result))
 350                                         return result;
 351                         }
 352
 353                         //
 354                         // Step 2: Perform Operator Overload location
 355                         //
 356                         Type expr_type = Expr.Type;
 357                         Expression mg;
 358                         string op_name;
 359
 360                         op_name = oper_names [(int) Oper];
 361
 362                         mg = MemberLookup (ec, expr_type, op_name, MemberTypes.Method, AllBindingFlags, loc);
 363
 364                         if (mg != null) {
 365                                 Expression e = StaticCallExpr.MakeSimpleCall (
 366                                         ec, (MethodGroupExpr) mg, Expr, loc);
 367
 368                                 if (e == null){
 369                                         Error23 (expr_type);
 370                                         return null;
 371                                 }
 372
 373                                 return e;
 374                         }
 375
 376                         // Only perform numeric promotions on:
 377                         // +, -
 378
 379                         if (expr_type == null)
 380                                 return null;
 381
 382                         switch (Oper){
 383                         case Operator.LogicalNot:
 384                                 if (expr_type != TypeManager.bool_type) {
 385                                         Expr = ResolveBoolean (ec, Expr, loc);
 386                                         if (Expr == null){
 387                                                 Error23 (expr_type);
 388                                                 return null;
 389                                         }
 390                                 }
 391
 392                                 type = TypeManager.bool_type;
 393                                 return this;
 394
 395                         case Operator.OnesComplement:
 396                                 if (!((expr_type == TypeManager.int32_type) ||
 397                                       (expr_type == TypeManager.uint32_type) ||
 398                                       (expr_type == TypeManager.int64_type) ||
 399                                       (expr_type == TypeManager.uint64_type) ||
 400                                       (expr_type.IsSubclassOf (TypeManager.enum_type)))){
 401                                         Expression e;
 402
 403                                         e = Convert.ImplicitConversion (ec, Expr, TypeManager.int32_type, loc);
 404                                         if (e != null)
 405                                                 goto ok;
 406                                         e = Convert.ImplicitConversion (ec, Expr, TypeManager.uint32_type, loc);
 407                                         if (e != null)
 408                                                 goto ok;
 409                                         e = Convert.ImplicitConversion (ec, Expr, TypeManager.int64_type, loc);
 410                                         if (e != null)
 411                                                 goto ok;
 412                                         e = Convert.ImplicitConversion (ec, Expr, TypeManager.uint64_type, loc);
 413                                         if (e != null)
 414                                                 goto ok;
 415                                         Error23 (expr_type);
 416                                         return null;
 417                                 ok:
 418                                         Expr = e;
 419                                         expr_type = e.Type;
 420                                 }
 421
 422                                 type = expr_type;
 423                                 return this;
 424
 425                         case Operator.AddressOf:
 426                                 if (!ec.InUnsafe) {
 427                                         UnsafeError (loc);
 428                                         return null;
 429                                 }
 430
 431                                 if (!TypeManager.VerifyUnManaged (Expr.Type, loc)){
 432                                         return null;
 433                                 }
 434
 435                                 IVariable variable = Expr as IVariable;
 436                                 bool is_fixed = variable != null && variable.VerifyFixed ();
 437
 438                                 if (!ec.InFixedInitializer && !is_fixed) {
 439                                         Error (212, "You can only take the address of unfixed expression inside " +
 440                                                "of a fixed statement initializer");
 441                                         return null;
 442                                 }
 443
 444                                 if (ec.InFixedInitializer && is_fixed) {
 445                                         Error (213, "You cannot use the fixed statement to take the address of an already fixed expression");
 446                                         return null;
 447                                 }
 448
 449                                 LocalVariableReference lr = Expr as LocalVariableReference;
 450                                 if (lr != null){
 451                                         if (lr.local_info.IsCaptured){
 452                                                 AnonymousMethod.Error_AddressOfCapturedVar (lr.Name, loc);
 453                                                 return null;
 454                                         }
 455                                         lr.local_info.AddressTaken = true;
 456                                         lr.local_info.Used = true;
 457                                 }
 458
 459                                 // According to the specs, a variable is considered definitely assigned if you take
 460                                 // its address.
 461                                 if ((variable != null) && (variable.VariableInfo != null)){
 462                                         variable.VariableInfo.SetAssigned (ec);
 463                                 }
 464
 465                                 type = TypeManager.GetPointerType (Expr.Type);
 466                                 return this;
 467
 468                         case Operator.Indirection:
 469                                 if (!ec.InUnsafe){
 470                                         UnsafeError (loc);
 471                                         return null;
 472                                 }
 473
 474                                 if (!expr_type.IsPointer){
 475                                         Error (193, "The * or -> operator must be applied to a pointer");
 476                                         return null;
 477                                 }
 478
 479                                 //
 480                                 // We create an Indirection expression, because
 481                                 // it can implement the IMemoryLocation.
 482                                 //
 483                                 return new Indirection (Expr, loc);
 484
 485                         case Operator.UnaryPlus:
 486                                 //
 487                                 // A plus in front of something is just a no-op, so return the child.
 488                                 //
 489                                 return Expr;
 490
 491                         case Operator.UnaryNegation:
 492                                 //
 493                                 // Deals with -literals
 494                                 // int     operator- (int x)
 495                                 // long    operator- (long x)
 496                                 // float   operator- (float f)
 497                                 // double  operator- (double d)
 498                                 // decimal operator- (decimal d)
 499                                 //
 500                                 Expression expr = null;
 501
 502                                 //
 503                                 // transform - - expr into expr
 504                                 //
 505                                 if (Expr is Unary){
 506                                         Unary unary = (Unary) Expr;
 507
 508                                         if (unary.Oper == Operator.UnaryNegation)
 509                                                 return unary.Expr;
 510                                 }
 511
 512                                 //
 513                                 // perform numeric promotions to int,
 514                                 // long, double.
 515                                 //
 516                                 //
 517                                 // The following is inneficient, because we call
 518                                 // ImplicitConversion too many times.
 519                                 //
 520                                 // It is also not clear if we should convert to Float
 521                                 // or Double initially.
 522                                 //
 523                                 if (expr_type == TypeManager.uint32_type){
 524                                         //
 525                                         // FIXME: handle exception to this rule that
 526                                         // permits the int value -2147483648 (-2^31) to
 527                                         // bt wrote as a decimal interger literal
 528                                         //
 529                                         type = TypeManager.int64_type;
 530                                         Expr = Convert.ImplicitConversion (ec, Expr, type, loc);
 531                                         return this;
 532                                 }
 533
 534                                 if (expr_type == TypeManager.uint64_type){
 535                                         //
 536                                         // FIXME: Handle exception of `long value'
 537                                         // -92233720368547758087 (-2^63) to be wrote as
 538                                         // decimal integer literal.
 539                                         //
 540                                         Error23 (expr_type);
 541                                         return null;
 542                                 }
 543
 544                                 if (expr_type == TypeManager.float_type){
 545                                         type = expr_type;
 546                                         return this;
 547                                 }
 548
 549                                 expr = Convert.ImplicitConversion (ec, Expr, TypeManager.int32_type, loc);
 550                                 if (expr != null){
 551                                         Expr = expr;
 552                                         type = expr.Type;
 553                                         return this;
 554                                 }
 555
 556                                 expr = Convert.ImplicitConversion (ec, Expr, TypeManager.int64_type, loc);
 557                                 if (expr != null){
 558                                         Expr = expr;
 559                                         type = expr.Type;
 560                                         return this;
 561                                 }
 562
 563                                 expr = Convert.ImplicitConversion (ec, Expr, TypeManager.double_type, loc);
 564                                 if (expr != null){
 565                                         Expr = expr;
 566                                         type = expr.Type;
 567                                         return this;
 568                                 }
 569
 570                                 Error23 (expr_type);
 571                                 return null;
 572                         }
 573
 574                         Error (187, "No such operator '" + OperName (Oper) + "' defined for type '" +
 575                                TypeManager.CSharpName (expr_type) + "'");
 576                         return null;
 577                 }
 578
 579                 public override Expression DoResolve (EmitContext ec)
 580                 {
 581                         if (Oper == Operator.AddressOf) {
 582                                 Expr = Expr.DoResolveLValue (ec, new EmptyExpression ());
 583
 584                                 if (Expr == null || Expr.eclass != ExprClass.Variable){
 585                                         Error (211, "Cannot take the address of the given expression");
 586                                         return null;
 587                                 }
 588                         }
 589                         else
 590                                 Expr = Expr.Resolve (ec);
 591
 592                         if (Expr == null)
 593                                 return null;
 594
 595                         eclass = ExprClass.Value;
 596                         return ResolveOperator (ec);
 597                 }
 598
 599                 public override Expression DoResolveLValue (EmitContext ec, Expression right)
 600                 {
 601                         if (Oper == Operator.Indirection)
 602                                 return DoResolve (ec);
 603
 604                         return null;
 605                 }
 606
 607                 public override void Emit (EmitContext ec)
 608                 {
 609                         ILGenerator ig = ec.ig;
 610
 611                         switch (Oper) {
 612                         case Operator.UnaryPlus:
 613                                 throw new Exception ("This should be caught by Resolve");
 614
 615                         case Operator.UnaryNegation:
 616                                 if (ec.CheckState) {
 617                                         ig.Emit (OpCodes.Ldc_I4_0);
 618                                         if (type == TypeManager.int64_type)
 619                                                 ig.Emit (OpCodes.Conv_U8);
 620                                         Expr.Emit (ec);
 621                                         ig.Emit (OpCodes.Sub_Ovf);
 622                                 } else {
 623                                         Expr.Emit (ec);
 624                                         ig.Emit (OpCodes.Neg);
 625                                 }
 626
 627                                 break;
 628
 629                         case Operator.LogicalNot:
 630                                 Expr.Emit (ec);
 631                                 ig.Emit (OpCodes.Ldc_I4_0);
 632                                 ig.Emit (OpCodes.Ceq);
 633                                 break;
 634
 635                         case Operator.OnesComplement:
 636                                 Expr.Emit (ec);
 637                                 ig.Emit (OpCodes.Not);
 638                                 break;
 639
 640                         case Operator.AddressOf:
 641                                 ((IMemoryLocation)Expr).AddressOf (ec, AddressOp.LoadStore);
 642                                 break;
 643
 644                         default:
 645                                 throw new Exception ("This should not happen: Operator = "
 646                                                      + Oper.ToString ());
 647                         }
 648                 }
 649
 650                 public override void EmitBranchable (EmitContext ec, Label target, bool onTrue)
 651                 {
 652                         if (Oper == Operator.LogicalNot)
 653                                 Expr.EmitBranchable (ec, target, !onTrue);
 654                         else
 655                                 base.EmitBranchable (ec, target, onTrue);
 656                 }
 657
 658                 public override string ToString ()
 659                 {
 660                         return "Unary (" + Oper + ", " + Expr + ")";
 661                 }
 662
 663         }
 664
 665         //
 666         // Unary operators are turned into Indirection expressions
 667         // after semantic analysis (this is so we can take the address
 668         // of an indirection).
 669         //
 670         public class Indirection : Expression, IMemoryLocation, IAssignMethod, IVariable {
 671                 Expression expr;
 672                 LocalTemporary temporary;
 673                 bool prepared;
 674
 675                 public Indirection (Expression expr, Location l)
 676                 {
 677                         this.expr = expr;
 678                         type = TypeManager.HasElementType (expr.Type) ? TypeManager.GetElementType (expr.Type) : expr.Type;
 679                         eclass = ExprClass.Variable;
 680                         loc = l;
 681                 }
 682
 683                 public override void Emit (EmitContext ec)
 684                 {
 685                         if (!prepared)
 686                                 expr.Emit (ec);
 687
 688                         LoadFromPtr (ec.ig, Type);
 689                 }
 690
 691                 public void Emit (EmitContext ec, bool leave_copy)
 692                 {
 693                         Emit (ec);
 694                         if (leave_copy) {
 695                                 ec.ig.Emit (OpCodes.Dup);
 696                                 temporary = new LocalTemporary (ec, expr.Type);
 697                                 temporary.Store (ec);
 698                         }
 699                 }
 700
 701                 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
 702                 {
 703                         prepared = prepare_for_load;
 704
 705                         expr.Emit (ec);
 706
 707                         if (prepare_for_load)
 708                                 ec.ig.Emit (OpCodes.Dup);
 709
 710                         source.Emit (ec);
 711                         if (leave_copy) {
 712                                 ec.ig.Emit (OpCodes.Dup);
 713                                 temporary = new LocalTemporary (ec, expr.Type);
 714                                 temporary.Store (ec);
 715                         }
 716
 717                         StoreFromPtr (ec.ig, type);
 718
 719                         if (temporary != null)
 720                                 temporary.Emit (ec);
 721                 }
 722
 723                 public void AddressOf (EmitContext ec, AddressOp Mode)
 724                 {
 725                         expr.Emit (ec);
 726                 }
 727
 728                 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
 729                 {
 730                         return DoResolve (ec);
 731                 }
 732
 733                 public override Expression DoResolve (EmitContext ec)
 734                 {
 735                         //
 736                         // Born fully resolved
 737                         //
 738                         return this;
 739                 }
 740
 741                 public override string ToString ()
 742                 {
 743                         return "*(" + expr + ")";
 744                 }
 745
 746                 #region IVariable Members
 747
 748                 public VariableInfo VariableInfo {
 749                         get {
 750                                 return null;
 751                         }
 752                 }
 753
 754                 public bool VerifyFixed ()
 755                 {
 756                         // A pointer-indirection is always fixed.
 757                         return true;
 758                 }
 759
 760                 #endregion
 761         }
 762
 763         /// <summary>
 764         ///   Unary Mutator expressions (pre and post ++ and --)
 765         /// </summary>
 766         ///
 767         /// <remarks>
 768         ///   UnaryMutator implements ++ and -- expressions.   It derives from
 769         ///   ExpressionStatement becuase the pre/post increment/decrement
 770         ///   operators can be used in a statement context.
 771         ///
 772         /// FIXME: Idea, we could split this up in two classes, one simpler
 773         /// for the common case, and one with the extra fields for more complex
 774         /// classes (indexers require temporary access;  overloaded require method)
 775         ///
 776         /// </remarks>
 777         public class UnaryMutator : ExpressionStatement {
 778                 [Flags]
 779                 public enum Mode : byte {
 780                         IsIncrement    = 0,
 781                         IsDecrement    = 1,
 782                         IsPre          = 0,
 783                         IsPost         = 2,
 784
 785                         PreIncrement   = 0,
 786                         PreDecrement   = IsDecrement,
 787                         PostIncrement  = IsPost,
 788                         PostDecrement  = IsPost | IsDecrement
 789                 }
 790
 791                 Mode mode;
 792                 bool is_expr = false;
 793                 bool recurse = false;
 794
 795                 Expression expr;
 796
 797                 //
 798                 // This is expensive for the simplest case.
 799                 //
 800                 StaticCallExpr method;
 801
 802                 public UnaryMutator (Mode m, Expression e, Location l)
 803                 {
 804                         mode = m;
 805                         loc = l;
 806                         expr = e;
 807                 }
 808
 809                 static string OperName (Mode mode)
 810                 {
 811                         return (mode == Mode.PreIncrement || mode == Mode.PostIncrement) ?
 812                                 "++" : "--";
 813                 }
 814
 815                 /// <summary>
 816                 ///   Returns whether an object of type `t' can be incremented
 817                 ///   or decremented with add/sub (ie, basically whether we can
 818                 ///   use pre-post incr-decr operations on it, but it is not a
 819                 ///   System.Decimal, which we require operator overloading to catch)
 820                 /// </summary>
 821                 static bool IsIncrementableNumber (Type t)
 822                 {
 823                         return (t == TypeManager.sbyte_type) ||
 824                                 (t == TypeManager.byte_type) ||
 825                                 (t == TypeManager.short_type) ||
 826                                 (t == TypeManager.ushort_type) ||
 827                                 (t == TypeManager.int32_type) ||
 828                                 (t == TypeManager.uint32_type) ||
 829                                 (t == TypeManager.int64_type) ||
 830                                 (t == TypeManager.uint64_type) ||
 831                                 (t == TypeManager.char_type) ||
 832                                 (t.IsSubclassOf (TypeManager.enum_type)) ||
 833                                 (t == TypeManager.float_type) ||
 834                                 (t == TypeManager.double_type) ||
 835                                 (t.IsPointer && t != TypeManager.void_ptr_type);
 836                 }
 837
 838                 Expression ResolveOperator (EmitContext ec)
 839                 {
 840                         Type expr_type = expr.Type;
 841
 842                         //
 843                         // Step 1: Perform Operator Overload location
 844                         //
 845                         Expression mg;
 846                         string op_name;
 847
 848                         if (mode == Mode.PreIncrement || mode == Mode.PostIncrement)
 849                                 op_name = "op_Increment";
 850                         else
 851                                 op_name = "op_Decrement";
 852
 853                         mg = MemberLookup (ec, expr_type, op_name, MemberTypes.Method, AllBindingFlags, loc);
 854
 855                         if (mg != null) {
 856                                 method = StaticCallExpr.MakeSimpleCall (
 857                                         ec, (MethodGroupExpr) mg, expr, loc);
 858
 859                                 type = method.Type;
 860                         } else if (!IsIncrementableNumber (expr_type)) {
 861                                 Error (187, "No such operator '" + OperName (mode) + "' defined for type '" +
 862                                        TypeManager.CSharpName (expr_type) + "'");
 863                                    return null;
 864                         }
 865
 866                         //
 867                         // The operand of the prefix/postfix increment decrement operators
 868                         // should be an expression that is classified as a variable,
 869                         // a property access or an indexer access
 870                         //
 871                         type = expr_type;
 872                         if (expr.eclass == ExprClass.Variable){
 873                                 LocalVariableReference var = expr as LocalVariableReference;
 874                                 if ((var != null) && var.IsReadOnly) {
 875                                         Error (1604, "cannot assign to `" + var.Name + "' because it is readonly");
 876                                         return null;
 877                                 }
 878                         } else if (expr.eclass == ExprClass.IndexerAccess || expr.eclass == ExprClass.PropertyAccess){
 879                                 expr = expr.ResolveLValue (ec, this, Location);
 880                                 if (expr == null)
 881                                         return null;
 882                         } else {
 883                                 expr.Error_UnexpectedKind (ec, "variable, indexer or property access", loc);
 884                                 return null;
 885                         }
 886
 887                         return this;
 888                 }
 889
 890                 public override Expression DoResolve (EmitContext ec)
 891                 {
 892                         expr = expr.Resolve (ec);
 893
 894                         if (expr == null)
 895                                 return null;
 896
 897                         eclass = ExprClass.Value;
 898                         return ResolveOperator (ec);
 899                 }
 900
 901                 static int PtrTypeSize (Type t)
 902                 {
 903                         return GetTypeSize (TypeManager.GetElementType (t));
 904                 }
 905
 906                 //
 907                 // Loads the proper "1" into the stack based on the type, then it emits the
 908                 // opcode for the operation requested
 909                 //
 910                 void LoadOneAndEmitOp (EmitContext ec, Type t)
 911                 {
 912                         //
 913                         // Measure if getting the typecode and using that is more/less efficient
 914                         // that comparing types.  t.GetTypeCode() is an internal call.
 915                         //
 916                         ILGenerator ig = ec.ig;
 917
 918                         if (t == TypeManager.uint64_type || t == TypeManager.int64_type)
 919                                 LongConstant.EmitLong (ig, 1);
 920                         else if (t == TypeManager.double_type)
 921                                 ig.Emit (OpCodes.Ldc_R8, 1.0);
 922                         else if (t == TypeManager.float_type)
 923                                 ig.Emit (OpCodes.Ldc_R4, 1.0F);
 924                         else if (t.IsPointer){
 925                                 int n = PtrTypeSize (t);
 926
 927                                 if (n == 0)
 928                                         ig.Emit (OpCodes.Sizeof, t);
 929                                 else
 930                                         IntConstant.EmitInt (ig, n);
 931                         } else
 932                                 ig.Emit (OpCodes.Ldc_I4_1);
 933
 934                         //
 935                         // Now emit the operation
 936                         //
 937                         if (ec.CheckState){
 938                                 if (t == TypeManager.int32_type ||
 939                                     t == TypeManager.int64_type){
 940                                         if ((mode & Mode.IsDecrement) != 0)
 941                                                 ig.Emit (OpCodes.Sub_Ovf);
 942                                         else
 943                                                 ig.Emit (OpCodes.Add_Ovf);
 944                                 } else if (t == TypeManager.uint32_type ||
 945                                            t == TypeManager.uint64_type){
 946                                         if ((mode & Mode.IsDecrement) != 0)
 947                                                 ig.Emit (OpCodes.Sub_Ovf_Un);
 948                                         else
 949                                                 ig.Emit (OpCodes.Add_Ovf_Un);
 950                                 } else {
 951                                         if ((mode & Mode.IsDecrement) != 0)
 952                                                 ig.Emit (OpCodes.Sub_Ovf);
 953                                         else
 954                                                 ig.Emit (OpCodes.Add_Ovf);
 955                                 }
 956                         } else {
 957                                 if ((mode & Mode.IsDecrement) != 0)
 958                                         ig.Emit (OpCodes.Sub);
 959                                 else
 960                                         ig.Emit (OpCodes.Add);
 961                         }
 962
 963                         if (t == TypeManager.sbyte_type){
 964                                 if (ec.CheckState)
 965                                         ig.Emit (OpCodes.Conv_Ovf_I1);
 966                                 else
 967                                         ig.Emit (OpCodes.Conv_I1);
 968                         } else if (t == TypeManager.byte_type){
 969                                 if (ec.CheckState)
 970                                         ig.Emit (OpCodes.Conv_Ovf_U1);
 971                                 else
 972                                         ig.Emit (OpCodes.Conv_U1);
 973                         } else if (t == TypeManager.short_type){
 974                                 if (ec.CheckState)
 975                                         ig.Emit (OpCodes.Conv_Ovf_I2);
 976                                 else
 977                                         ig.Emit (OpCodes.Conv_I2);
 978                         } else if (t == TypeManager.ushort_type || t == TypeManager.char_type){
 979                                 if (ec.CheckState)
 980                                         ig.Emit (OpCodes.Conv_Ovf_U2);
 981                                 else
 982                                         ig.Emit (OpCodes.Conv_U2);
 983                         }
 984
 985                 }
 986
 987                 void EmitCode (EmitContext ec, bool is_expr)
 988                 {
 989                         recurse = true;
 990                         this.is_expr = is_expr;
 991                         ((IAssignMethod) expr).EmitAssign (ec, this, is_expr && (mode == Mode.PreIncrement || mode == Mode.PreDecrement), true);
 992                 }
 993
 994
 995                 public override void Emit (EmitContext ec)
 996                 {
 997                         //
 998                         // We use recurse to allow ourselfs to be the source
 999                         // of an assignment. This little hack prevents us from
1000                         // having to allocate another expression
1001                         //
1002                         if (recurse) {
1003                                 ((IAssignMethod) expr).Emit (ec, is_expr && (mode == Mode.PostIncrement  || mode == Mode.PostDecrement));
1004                                 if (method == null)
1005                                         LoadOneAndEmitOp (ec, expr.Type);
1006                                 else
1007                                         ec.ig.Emit (OpCodes.Call, method.Method);
1008                                 recurse = false;
1009                                 return;
1010                         }
1011
1012                         EmitCode (ec, true);
1013                 }
1014
1015                 public override void EmitStatement (EmitContext ec)
1016                 {
1017                         EmitCode (ec, false);
1018                 }
1019         }
1020
1021         /// <summary>
1022         ///   Base class for the `Is' and `As' classes.
1023         /// </summary>
1024         ///
1025         /// <remarks>
1026         ///   FIXME: Split this in two, and we get to save the `Operator' Oper
1027         ///   size.
1028         /// </remarks>
1029         public abstract class Probe : Expression {
1030                 public Expression ProbeType;
1031                 protected Expression expr;
1032                 protected Type probe_type;
1033
1034                 public Probe (Expression expr, Expression probe_type, Location l)
1035                 {
1036                         ProbeType = probe_type;
1037                         loc = l;
1038                         this.expr = expr;
1039                 }
1040
1041                 public Expression Expr {
1042                         get {
1043                                 return expr;
1044                         }
1045                 }
1046
1047                 public override Expression DoResolve (EmitContext ec)
1048                 {
1049                         TypeExpr texpr = ProbeType.ResolveAsTypeTerminal (ec, false);
1050                         if (texpr == null)
1051                                 return null;
1052                         probe_type = texpr.ResolveType (ec);
1053
1054                         expr = expr.Resolve (ec);
1055                         if (expr == null)
1056                                 return null;
1057
1058                         if (expr.Type.IsPointer) {
1059                                 Report.Error (244, loc, "\"is\" or \"as\" are not valid on pointer types");
1060                                 return null;
1061                         }
1062                         return this;
1063                 }
1064         }
1065
1066         /// <summary>
1067         ///   Implementation of the `is' operator.
1068         /// </summary>
1069         public class Is : Probe {
1070                 public Is (Expression expr, Expression probe_type, Location l)
1071                         : base (expr, probe_type, l)
1072                 {
1073                 }
1074
1075                 enum Action {
1076                         AlwaysTrue, AlwaysNull, AlwaysFalse, LeaveOnStack, Probe
1077                 }
1078
1079                 Action action;
1080
1081                 public override void Emit (EmitContext ec)
1082                 {
1083                         ILGenerator ig = ec.ig;
1084
1085                         expr.Emit (ec);
1086
1087                         switch (action){
1088                         case Action.AlwaysFalse:
1089                                 ig.Emit (OpCodes.Pop);
1090                                 IntConstant.EmitInt (ig, 0);
1091                                 return;
1092                         case Action.AlwaysTrue:
1093                                 ig.Emit (OpCodes.Pop);
1094                                 IntConstant.EmitInt (ig, 1);
1095                                 return;
1096                         case Action.LeaveOnStack:
1097                                 // the `e != null' rule.
1098                                 ig.Emit (OpCodes.Ldnull);
1099                                 ig.Emit (OpCodes.Ceq);
1100                                 ig.Emit (OpCodes.Ldc_I4_0);
1101                                 ig.Emit (OpCodes.Ceq);
1102                                 return;
1103                         case Action.Probe:
1104                                 ig.Emit (OpCodes.Isinst, probe_type);
1105                                 ig.Emit (OpCodes.Ldnull);
1106                                 ig.Emit (OpCodes.Cgt_Un);
1107                                 return;
1108                         }
1109                         throw new Exception ("never reached");
1110                 }
1111
1112                 public override void EmitBranchable (EmitContext ec, Label target, bool onTrue)
1113                 {
1114                         ILGenerator ig = ec.ig;
1115
1116                         switch (action){
1117                         case Action.AlwaysFalse:
1118                                 if (! onTrue)
1119                                         ig.Emit (OpCodes.Br, target);
1120
1121                                 return;
1122                         case Action.AlwaysTrue:
1123                                 if (onTrue)
1124                                         ig.Emit (OpCodes.Br, target);
1125
1126                                 return;
1127                         case Action.LeaveOnStack:
1128                                 // the `e != null' rule.
1129                                 expr.Emit (ec);
1130                                 ig.Emit (onTrue ? OpCodes.Brtrue : OpCodes.Brfalse, target);
1131                                 return;
1132                         case Action.Probe:
1133                                 expr.Emit (ec);
1134                                 ig.Emit (OpCodes.Isinst, probe_type);
1135                                 ig.Emit (onTrue ? OpCodes.Brtrue : OpCodes.Brfalse, target);
1136                                 return;
1137                         }
1138                         throw new Exception ("never reached");
1139                 }
1140
1141                 public override Expression DoResolve (EmitContext ec)
1142                 {
1143                         Expression e = base.DoResolve (ec);
1144
1145                         if ((e == null) || (expr == null))
1146                                 return null;
1147
1148                         Type etype = expr.Type;
1149                         bool warning_always_matches = false;
1150                         bool warning_never_matches = false;
1151
1152                         type = TypeManager.bool_type;
1153                         eclass = ExprClass.Value;
1154
1155                         //
1156                         // First case, if at compile time, there is an implicit conversion
1157                         // then e != null (objects) or true (value types)
1158                         //
1159                         e = Convert.ImplicitConversionStandard (ec, expr, probe_type, loc);
1160                         if (e != null && !(e is NullCast)){
1161                                 expr = e;
1162                                 if (etype.IsValueType)
1163                                         action = Action.AlwaysTrue;
1164                                 else
1165                                         action = Action.LeaveOnStack;
1166
1167                                 warning_always_matches = true;
1168                         } else if (Convert.ExplicitReferenceConversionExists (etype, probe_type)){
1169                                 //
1170                                 // Second case: explicit reference convresion
1171                                 //
1172                                 if (expr is NullLiteral)
1173                                         action = Action.AlwaysFalse;
1174                                 else
1175                                         action = Action.Probe;
1176                         } else {
1177                                 action = Action.AlwaysFalse;
1178                                 warning_never_matches = true;
1179                         }
1180
1181                         if (warning_always_matches)
1182                                 Report.Warning (183, 1, loc, "The given expression is always of the provided (`{0}') type", TypeManager.CSharpName (probe_type));
1183                         else if (warning_never_matches){
1184                                 if (!(probe_type.IsInterface || expr.Type.IsInterface))
1185                                         Report.Warning (184, 1, loc, "The given expression is never of the provided (`{0}') type", TypeManager.CSharpName (probe_type));
1186                         }
1187
1188                         return this;
1189                 }
1190         }
1191
1192         /// <summary>
1193         ///   Implementation of the `as' operator.
1194         /// </summary>
1195         public class As : Probe {
1196                 public As (Expression expr, Expression probe_type, Location l)
1197                         : base (expr, probe_type, l)
1198                 {
1199                 }
1200
1201                 bool do_isinst = false;
1202                 Expression resolved_type;
1203
1204                 public override void Emit (EmitContext ec)
1205                 {
1206                         ILGenerator ig = ec.ig;
1207
1208                         expr.Emit (ec);
1209
1210                         if (do_isinst)
1211                                 ig.Emit (OpCodes.Isinst, probe_type);
1212                 }
1213
1214                 static void Error_CannotConvertType (Type source, Type target, Location loc)
1215                 {
1216                         Report.Error (39, loc, "Cannot convert type `{0}' to `{1}' via a built-in conversion",
1217                                 TypeManager.CSharpName (source),
1218                                 TypeManager.CSharpName (target));
1219                 }
1220
1221                 public override Expression DoResolve (EmitContext ec)
1222                 {
1223                         if (resolved_type == null) {
1224                                 resolved_type = base.DoResolve (ec);
1225
1226                                 if (resolved_type == null)
1227                                         return null;
1228                         }
1229
1230                         type = probe_type;
1231                         eclass = ExprClass.Value;
1232                         Type etype = expr.Type;
1233
1234                         if (TypeManager.IsValueType (probe_type)){
1235                                 Report.Error (77, loc, "The as operator must be used with a reference type (`" +
1236                                               TypeManager.CSharpName (probe_type) + "' is a value type)");
1237                                 return null;
1238
1239                         }
1240
1241                         Expression e = Convert.ImplicitConversion (ec, expr, probe_type, loc);
1242                         if (e != null){
1243                                 expr = e;
1244                                 do_isinst = false;
1245                                 return this;
1246                         }
1247
1248                         if (Convert.ExplicitReferenceConversionExists (etype, probe_type)){
1249                                 do_isinst = true;
1250                                 return this;
1251                         }
1252
1253                         Error_CannotConvertType (etype, probe_type, loc);
1254                         return null;
1255                 }
1256         }
1257
1258         /// <summary>
1259         ///   This represents a typecast in the source language.
1260         ///
1261         ///   FIXME: Cast expressions have an unusual set of parsing
1262         ///   rules, we need to figure those out.
1263         /// </summary>
1264         public class Cast : Expression {
1265                 Expression target_type;
1266                 Expression expr;
1267
1268                 public Cast (Expression cast_type, Expression expr)
1269                         : this (cast_type, expr, cast_type.Location)
1270                 {
1271                 }
1272
1273                 public Cast (Expression cast_type, Expression expr, Location loc)
1274                 {
1275                         this.target_type = cast_type;
1276                         this.expr = expr;
1277                         this.loc = loc;
1278                 }
1279
1280                 public Expression TargetType {
1281                         get {
1282                                 return target_type;
1283                         }
1284                 }
1285
1286                 public Expression Expr {
1287                         get {
1288                                 return expr;
1289                         }
1290                         set {
1291                                 expr = value;
1292                         }
1293                 }
1294
1295                 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
1296                 {
1297                         expr = expr.DoResolveLValue (ec, right_side);
1298                         if (expr == null)
1299                                 return null;
1300
1301                         return ResolveRest (ec);
1302                 }
1303
1304                 public override Expression DoResolve (EmitContext ec)
1305                 {
1306                         expr = expr.Resolve (ec);
1307                         if (expr == null)
1308                                 return null;
1309
1310                         return ResolveRest (ec);
1311                 }
1312
1313                 Expression ResolveRest (EmitContext ec)
1314                 {
1315                         TypeExpr target = target_type.ResolveAsTypeTerminal (ec, false);
1316                         if (target == null)
1317                                 return null;
1318
1319                         type = target.ResolveType (ec);
1320
1321                         if (type.IsAbstract && type.IsSealed) {
1322                                 Report.Error (716, loc, "Cannot convert to static type `{0}'", TypeManager.CSharpName (type));
1323                                 return null;
1324                         }
1325
1326                         eclass = ExprClass.Value;
1327
1328                         Constant c = expr as Constant;
1329                         if (c != null) {
1330                                 c = c.TryReduce (ec, type, loc);
1331                                 if (c != null)
1332                                         return c;
1333                         }
1334
1335                         if (type.IsPointer && !ec.InUnsafe) {
1336                                 UnsafeError (loc);
1337                                 return null;
1338                         }
1339                         expr = Convert.ExplicitConversion (ec, expr, type, loc);
1340                         return expr;
1341                 }
1342
1343                 public override void Emit (EmitContext ec)
1344                 {
1345                         //
1346                         // This one will never happen
1347                         //
1348                         throw new Exception ("Should not happen");
1349                 }
1350         }
1351
1352         /// <summary>
1353         ///   Binary operators
1354         /// </summary>
1355         public class Binary : Expression {
1356                 public enum Operator : byte {
1357                         Multiply, Division, Modulus,
1358                         Addition, Subtraction,
1359                         LeftShift, RightShift,
1360                         LessThan, GreaterThan, LessThanOrEqual, GreaterThanOrEqual,
1361                         Equality, Inequality,
1362                         BitwiseAnd,
1363                         ExclusiveOr,
1364                         BitwiseOr,
1365                         LogicalAnd,
1366                         LogicalOr,
1367                         TOP
1368                 }
1369
1370                 Operator oper;
1371                 Expression left, right;
1372
1373                 // This must be kept in sync with Operator!!!
1374                 public static readonly string [] oper_names;
1375
1376                 static Binary ()
1377                 {
1378                         oper_names = new string [(int) Operator.TOP];
1379
1380                         oper_names [(int) Operator.Multiply] = "op_Multiply";
1381                         oper_names [(int) Operator.Division] = "op_Division";
1382                         oper_names [(int) Operator.Modulus] = "op_Modulus";
1383                         oper_names [(int) Operator.Addition] = "op_Addition";
1384                         oper_names [(int) Operator.Subtraction] = "op_Subtraction";
1385                         oper_names [(int) Operator.LeftShift] = "op_LeftShift";
1386                         oper_names [(int) Operator.RightShift] = "op_RightShift";
1387                         oper_names [(int) Operator.LessThan] = "op_LessThan";
1388                         oper_names [(int) Operator.GreaterThan] = "op_GreaterThan";
1389                         oper_names [(int) Operator.LessThanOrEqual] = "op_LessThanOrEqual";
1390                         oper_names [(int) Operator.GreaterThanOrEqual] = "op_GreaterThanOrEqual";
1391                         oper_names [(int) Operator.Equality] = "op_Equality";
1392                         oper_names [(int) Operator.Inequality] = "op_Inequality";
1393                         oper_names [(int) Operator.BitwiseAnd] = "op_BitwiseAnd";
1394                         oper_names [(int) Operator.BitwiseOr] = "op_BitwiseOr";
1395                         oper_names [(int) Operator.ExclusiveOr] = "op_ExclusiveOr";
1396                         oper_names [(int) Operator.LogicalOr] = "op_LogicalOr";
1397                         oper_names [(int) Operator.LogicalAnd] = "op_LogicalAnd";
1398                 }
1399
1400                 public Binary (Operator oper, Expression left, Expression right)
1401                 {
1402                         this.oper = oper;
1403                         this.left = left;
1404                         this.right = right;
1405                         this.loc = left.Location;
1406                 }
1407
1408                 public Operator Oper {
1409                         get {
1410                                 return oper;
1411                         }
1412                         set {
1413                                 oper = value;
1414                         }
1415                 }
1416
1417                 public Expression Left {
1418                         get {
1419                                 return left;
1420                         }
1421                         set {
1422                                 left = value;
1423                         }
1424                 }
1425
1426                 public Expression Right {
1427                         get {
1428                                 return right;
1429                         }
1430                         set {
1431                                 right = value;
1432                         }
1433                 }
1434
1435
1436                 /// <summary>
1437                 ///   Returns a stringified representation of the Operator
1438                 /// </summary>
1439                 public static string OperName (Operator oper)
1440                 {
1441                         switch (oper){
1442                         case Operator.Multiply:
1443                                 return "*";
1444                         case Operator.Division:
1445                                 return "/";
1446                         case Operator.Modulus:
1447                                 return "%";
1448                         case Operator.Addition:
1449                                 return "+";
1450                         case Operator.Subtraction:
1451                                 return "-";
1452                         case Operator.LeftShift:
1453                                 return "<<";
1454                         case Operator.RightShift:
1455                                 return ">>";
1456                         case Operator.LessThan:
1457                                 return "<";
1458                         case Operator.GreaterThan:
1459                                 return ">";
1460                         case Operator.LessThanOrEqual:
1461                                 return "<=";
1462                         case Operator.GreaterThanOrEqual:
1463                                 return ">=";
1464                         case Operator.Equality:
1465                                 return "==";
1466                         case Operator.Inequality:
1467                                 return "!=";
1468                         case Operator.BitwiseAnd:
1469                                 return "&";
1470                         case Operator.BitwiseOr:
1471                                 return "|";
1472                         case Operator.ExclusiveOr:
1473                                 return "^";
1474                         case Operator.LogicalOr:
1475                                 return "||";
1476                         case Operator.LogicalAnd:
1477                                 return "&&";
1478                         }
1479
1480                         return oper.ToString ();
1481                 }
1482
1483                 public override string ToString ()
1484                 {
1485                         return "operator " + OperName (oper) + "(" + left.ToString () + ", " +
1486                                 right.ToString () + ")";
1487                 }
1488
1489                 Expression ForceConversion (EmitContext ec, Expression expr, Type target_type)
1490                 {
1491                         if (expr.Type == target_type)
1492                                 return expr;
1493
1494                         return Convert.ImplicitConversion (ec, expr, target_type, loc);
1495                 }
1496
1497                 public static void Error_OperatorAmbiguous (Location loc, Operator oper, Type l, Type r)
1498                 {
1499                         Report.Error (
1500                                 34, loc, "Operator `" + OperName (oper)
1501                                 + "' is ambiguous on operands of type `"
1502                                 + TypeManager.CSharpName (l) + "' "
1503                                 + "and `" + TypeManager.CSharpName (r)
1504                                 + "'");
1505                 }
1506
1507                 bool IsOfType (EmitContext ec, Type l, Type r, Type t, bool check_user_conversions)
1508                 {
1509                         if ((l == t) || (r == t))
1510                                 return true;
1511
1512                         if (!check_user_conversions)
1513                                 return false;
1514
1515                         if (Convert.ImplicitUserConversionExists (ec, l, t))
1516                                 return true;
1517                         else if (Convert.ImplicitUserConversionExists (ec, r, t))
1518                                 return true;
1519                         else
1520                                 return false;
1521                 }
1522
1523                 //
1524                 // Note that handling the case l == Decimal || r == Decimal
1525                 // is taken care of by the Step 1 Operator Overload resolution.
1526                 //
1527                 // If `check_user_conv' is true, we also check whether a user-defined conversion
1528                 // exists.  Note that we only need to do this if both arguments are of a user-defined
1529                 // type, otherwise ConvertImplict() already finds the user-defined conversion for us,
1530                 // so we don't explicitly check for performance reasons.
1531                 //
1532                 bool DoNumericPromotions (EmitContext ec, Type l, Type r, Expression lexpr, Expression rexpr, bool check_user_conv)
1533                 {
1534                         if (IsOfType (ec, l, r, TypeManager.double_type, check_user_conv)){
1535                                 //
1536                                 // If either operand is of type double, the other operand is
1537                                 // conveted to type double.
1538                                 //
1539                                 if (r != TypeManager.double_type)
1540                                         right = Convert.ImplicitConversion (ec, right, TypeManager.double_type, loc);
1541                                 if (l != TypeManager.double_type)
1542                                         left = Convert.ImplicitConversion (ec, left, TypeManager.double_type, loc);
1543
1544                                 type = TypeManager.double_type;
1545                         } else if (IsOfType (ec, l, r, TypeManager.float_type, check_user_conv)){
1546                                 //
1547                                 // if either operand is of type float, the other operand is
1548                                 // converted to type float.
1549                                 //
1550                                 if (r != TypeManager.double_type)
1551                                         right = Convert.ImplicitConversion (ec, right, TypeManager.float_type, loc);
1552                                 if (l != TypeManager.double_type)
1553                                         left = Convert.ImplicitConversion (ec, left, TypeManager.float_type, loc);
1554                                 type = TypeManager.float_type;
1555                         } else if (IsOfType (ec, l, r, TypeManager.uint64_type, check_user_conv)){
1556                                 Expression e;
1557                                 Type other;
1558                                 //
1559                                 // If either operand is of type ulong, the other operand is
1560                                 // converted to type ulong.  or an error ocurrs if the other
1561                                 // operand is of type sbyte, short, int or long
1562                                 //
1563                                 if (l == TypeManager.uint64_type){
1564                                         if (r != TypeManager.uint64_type){
1565                                                 if (right is IntConstant){
1566                                                         IntConstant ic = (IntConstant) right;
1567
1568                                                         e = Convert.TryImplicitIntConversion (l, ic);
1569                                                         if (e != null)
1570                                                                 right = e;
1571                                                 } else if (right is LongConstant){
1572                                                         long ll = ((LongConstant) right).Value;
1573
1574                                                         if (ll >= 0)
1575                                                                 right = new ULongConstant ((ulong) ll, right.Location);
1576                                                 } else {
1577                                                         e = Convert.ImplicitNumericConversion (ec, right, l);
1578                                                         if (e != null)
1579                                                                 right = e;
1580                                                 }
1581                                         }
1582                                         other = right.Type;
1583                                 } else {
1584                                         if (left is IntConstant){
1585                                                 e = Convert.TryImplicitIntConversion (r, (IntConstant) left);
1586                                                 if (e != null)
1587                                                         left = e;
1588                                         } else if (left is LongConstant){
1589                                                 long ll = ((LongConstant) left).Value;
1590
1591                                                 if (ll > 0)
1592                                                         left = new ULongConstant ((ulong) ll, right.Location);
1593                                         } else {
1594                                                 e = Convert.ImplicitNumericConversion (ec, left, r);
1595                                                 if (e != null)
1596                                                         left = e;
1597                                         }
1598                                         other = left.Type;
1599                                 }
1600
1601                                 if ((other == TypeManager.sbyte_type) ||
1602                                     (other == TypeManager.short_type) ||
1603                                     (other == TypeManager.int32_type) ||
1604                                     (other == TypeManager.int64_type))
1605                                         Error_OperatorAmbiguous (loc, oper, l, r);
1606                                 else {
1607                                         left = ForceConversion (ec, left, TypeManager.uint64_type);
1608                                         right = ForceConversion (ec, right, TypeManager.uint64_type);
1609                                 }
1610                                 type = TypeManager.uint64_type;
1611                         } else if (IsOfType (ec, l, r, TypeManager.int64_type, check_user_conv)){
1612                                 //
1613                                 // If either operand is of type long, the other operand is converted
1614                                 // to type long.
1615                                 //
1616                                 if (l != TypeManager.int64_type)
1617                                         left = Convert.ImplicitConversion (ec, left, TypeManager.int64_type, loc);
1618                                 if (r != TypeManager.int64_type)
1619                                         right = Convert.ImplicitConversion (ec, right, TypeManager.int64_type, loc);
1620
1621                                 type = TypeManager.int64_type;
1622                         } else if (IsOfType (ec, l, r, TypeManager.uint32_type, check_user_conv)){
1623                                 //
1624                                 // If either operand is of type uint, and the other
1625                                 // operand is of type sbyte, short or int, othe operands are
1626                                 // converted to type long (unless we have an int constant).
1627                                 //
1628                                 Type other = null;
1629
1630                                 if (l == TypeManager.uint32_type){
1631                                         if (right is IntConstant){
1632                                                 IntConstant ic = (IntConstant) right;
1633                                                 int val = ic.Value;
1634
1635                                                 if (val >= 0){
1636                                                         right = new UIntConstant ((uint) val, ic.Location);
1637                                                         type = l;
1638
1639                                                         return true;
1640                                                 }
1641                                         }
1642                                         other = r;
1643                                 } else if (r == TypeManager.uint32_type){
1644                                         if (left is IntConstant){
1645                                                 IntConstant ic = (IntConstant) left;
1646                                                 int val = ic.Value;
1647
1648                                                 if (val >= 0){
1649                                                         left = new UIntConstant ((uint) val, ic.Location);
1650                                                         type = r;
1651                                                         return true;
1652                                                 }
1653                                         }
1654
1655                                         other = l;
1656                                 }
1657
1658                                 if ((other == TypeManager.sbyte_type) ||
1659                                     (other == TypeManager.short_type) ||
1660                                     (other == TypeManager.int32_type)){
1661                                         left = ForceConversion (ec, left, TypeManager.int64_type);
1662                                         right = ForceConversion (ec, right, TypeManager.int64_type);
1663                                         type = TypeManager.int64_type;
1664                                 } else {
1665                                         //
1666                                         // if either operand is of type uint, the other
1667                                         // operand is converd to type uint
1668                                         //
1669                                         left = ForceConversion (ec, left, TypeManager.uint32_type);
1670                                         right = ForceConversion (ec, right, TypeManager.uint32_type);
1671                                         type = TypeManager.uint32_type;
1672                                 }
1673                         } else if (l == TypeManager.decimal_type || r == TypeManager.decimal_type){
1674                                 if (l != TypeManager.decimal_type)
1675                                         left = Convert.ImplicitConversion (ec, left, TypeManager.decimal_type, loc);
1676
1677                                 if (r != TypeManager.decimal_type)
1678                                         right = Convert.ImplicitConversion (ec, right, TypeManager.decimal_type, loc);
1679                                 type = TypeManager.decimal_type;
1680                         } else {
1681                                 left = ForceConversion (ec, left, TypeManager.int32_type);
1682                                 right = ForceConversion (ec, right, TypeManager.int32_type);
1683
1684                                 bool strConv =
1685                                         Convert.ImplicitConversionExists (ec, lexpr, TypeManager.string_type) &&
1686                                         Convert.ImplicitConversionExists (ec, rexpr, TypeManager.string_type);
1687                                 if (strConv && left != null && right != null)
1688                                         Error_OperatorAmbiguous (loc, oper, l, r);
1689
1690                                 type = TypeManager.int32_type;
1691                         }
1692
1693                         return (left != null) && (right != null);
1694                 }
1695
1696                 static public void Error_OperatorCannotBeApplied (Location loc, string name, Type l, Type r)
1697                 {
1698                         Error_OperatorCannotBeApplied (loc, name, TypeManager.CSharpName (l), TypeManager.CSharpName (r));
1699                 }
1700
1701                 public static void Error_OperatorCannotBeApplied (Location loc, string name, string left, string right)
1702                 {
1703                         Report.Error (19, loc, "Operator `{0}' cannot be applied to operands of type `{1}' and `{2}'",
1704                                 name, left, right);
1705                 }
1706
1707                 void Error_OperatorCannotBeApplied ()
1708                 {
1709                         Error_OperatorCannotBeApplied (Location, OperName (oper), left.GetSignatureForError (), right.GetSignatureForError ());
1710                 }
1711
1712                 static bool is_unsigned (Type t)
1713                 {
1714                         return (t == TypeManager.uint32_type || t == TypeManager.uint64_type ||
1715                                 t == TypeManager.short_type || t == TypeManager.byte_type);
1716                 }
1717
1718                 static bool is_user_defined (Type t)
1719                 {
1720                         if (t.IsSubclassOf (TypeManager.value_type) &&
1721                             (!TypeManager.IsBuiltinType (t) || t == TypeManager.decimal_type))
1722                                 return true;
1723                         else
1724                                 return false;
1725                 }
1726
1727                 Expression Make32or64 (EmitContext ec, Expression e)
1728                 {
1729                         Type t= e.Type;
1730
1731                         if (t == TypeManager.int32_type || t == TypeManager.uint32_type ||
1732                             t == TypeManager.int64_type || t == TypeManager.uint64_type)
1733                                 return e;
1734                         Expression ee = Convert.ImplicitConversion (ec, e, TypeManager.int32_type, loc);
1735                         if (ee != null)
1736                                 return ee;
1737                         ee = Convert.ImplicitConversion (ec, e, TypeManager.uint32_type, loc);
1738                         if (ee != null)
1739                                 return ee;
1740                         ee = Convert.ImplicitConversion (ec, e, TypeManager.int64_type, loc);
1741                         if (ee != null)
1742                                 return ee;
1743                         ee = Convert.ImplicitConversion (ec, e, TypeManager.uint64_type, loc);
1744                         if (ee != null)
1745                                 return ee;
1746                         return null;
1747                 }
1748
1749                 Expression CheckShiftArguments (EmitContext ec)
1750                 {
1751                         Expression e;
1752
1753                         e = ForceConversion (ec, right, TypeManager.int32_type);
1754                         if (e == null){
1755                                 Error_OperatorCannotBeApplied ();
1756                                 return null;
1757                         }
1758                         right = e;
1759
1760                         if (((e = Convert.ImplicitConversion (ec, left, TypeManager.int32_type, loc)) != null) ||
1761                             ((e = Convert.ImplicitConversion (ec, left, TypeManager.uint32_type, loc)) != null) ||
1762                             ((e = Convert.ImplicitConversion (ec, left, TypeManager.int64_type, loc)) != null) ||
1763                             ((e = Convert.ImplicitConversion (ec, left, TypeManager.uint64_type, loc)) != null)){
1764                                 left = e;
1765                                 type = e.Type;
1766
1767                                 if (type == TypeManager.int32_type || type == TypeManager.uint32_type){
1768                                         right = new Binary (Binary.Operator.BitwiseAnd, right, new IntConstant (31, loc));
1769                                         right = right.DoResolve (ec);
1770                                 } else {
1771                                         right = new Binary (Binary.Operator.BitwiseAnd, right, new IntConstant (63, loc));
1772                                         right = right.DoResolve (ec);
1773                                 }
1774
1775                                 return this;
1776                         }
1777                         Error_OperatorCannotBeApplied ();
1778                         return null;
1779                 }
1780
1781                 //
1782                 // This is used to check if a test 'x == null' can be optimized to a reference equals,
1783                 // i.e., not invoke op_Equality.
1784                 //
1785                 static bool EqualsNullIsReferenceEquals (Type t)
1786                 {
1787                         return t == TypeManager.object_type || t == TypeManager.string_type ||
1788                                 t == TypeManager.delegate_type || t.IsSubclassOf (TypeManager.delegate_type);
1789                 }
1790
1791                 static void Warning_UnintendedReferenceComparison (Location loc, string side, Type type)
1792                 {
1793                         Report.Warning ((side == "left" ? 252 : 253), 2, loc,
1794                                 "Possible unintended reference comparison; to get a value comparison, " +
1795                                 "cast the {0} hand side to type `{1}'.", side, TypeManager.CSharpName (type));
1796                 }
1797
1798                 Expression ResolveOperator (EmitContext ec)
1799                 {
1800                         Type l = left.Type;
1801                         Type r = right.Type;
1802
1803                         if (oper == Operator.Equality || oper == Operator.Inequality){
1804                                 //
1805                                 // Optimize out call to op_Equality in a few cases.
1806                                 //
1807                                 if ((l == TypeManager.null_type && EqualsNullIsReferenceEquals (r)) ||
1808                                     (r == TypeManager.null_type && EqualsNullIsReferenceEquals (l))) {
1809
1810                                         Type = TypeManager.bool_type;
1811
1812                                         return this;
1813                                 }
1814
1815                                 // IntPtr equality
1816                                 if (l == TypeManager.intptr_type && r == TypeManager.intptr_type) {
1817                                         Type = TypeManager.bool_type;
1818
1819                                         return this;
1820                                 }
1821                         }
1822
1823                         //
1824                         // Do not perform operator overload resolution when both sides are
1825                         // built-in types
1826                         //
1827                         Expression left_operators = null, right_operators = null;
1828                         if (!(TypeManager.IsPrimitiveType (l) && TypeManager.IsPrimitiveType (r))){
1829                                 //
1830                                 // Step 1: Perform Operator Overload location
1831                                 //
1832                                 string op = oper_names [(int) oper];
1833
1834                                 MethodGroupExpr union;
1835                                 left_operators = MemberLookup (ec, l, op, MemberTypes.Method, AllBindingFlags, loc);
1836                                 if (r != l){
1837                                         right_operators = MemberLookup (
1838                                                 ec, r, op, MemberTypes.Method, AllBindingFlags, loc);
1839                                         union = Invocation.MakeUnionSet (left_operators, right_operators, loc);
1840                                 } else
1841                                         union = (MethodGroupExpr) left_operators;
1842
1843                                 if (union != null) {
1844                                         ArrayList args = new ArrayList (2);
1845                                         args.Add (new Argument (left, Argument.AType.Expression));
1846                                         args.Add (new Argument (right, Argument.AType.Expression));
1847
1848                                         MethodBase method = Invocation.OverloadResolve (
1849                                                 ec, union, args, true, Location.Null);
1850
1851                                         if (method != null) {
1852                                                 MethodInfo mi = (MethodInfo) method;
1853
1854                                                 return new BinaryMethod (mi.ReturnType, method, args);
1855                                         }
1856                                 }
1857                         }
1858
1859                         //
1860                         // Step 0: String concatenation (because overloading will get this wrong)
1861                         //
1862                         if (oper == Operator.Addition){
1863                                 //
1864                                 // If any of the arguments is a string, cast to string
1865                                 //
1866
1867                                 // Simple constant folding
1868                                 if (left is StringConstant && right is StringConstant)
1869                                         return new StringConstant (((StringConstant) left).Value + ((StringConstant) right).Value, left.Location);
1870
1871                                 if (l == TypeManager.string_type || r == TypeManager.string_type) {
1872
1873                                         if (r == TypeManager.void_type || l == TypeManager.void_type) {
1874                                                 Error_OperatorCannotBeApplied ();
1875                                                 return null;
1876                                         }
1877
1878                                         // try to fold it in on the left
1879                                         if (left is StringConcat) {
1880
1881                                                 //
1882                                                 // We have to test here for not-null, since we can be doubly-resolved
1883                                                 // take care of not appending twice
1884                                                 //
1885                                                 if (type == null){
1886                                                         type = TypeManager.string_type;
1887                                                         ((StringConcat) left).Append (ec, right);
1888                                                         return left.Resolve (ec);
1889                                                 } else {
1890                                                         return left;
1891                                                 }
1892                                         }
1893
1894                                         // Otherwise, start a new concat expression
1895                                         return new StringConcat (ec, loc, left, right).Resolve (ec);
1896                                 }
1897
1898                                 //
1899                                 // Transform a + ( - b) into a - b
1900                                 //
1901                                 if (right is Unary){
1902                                         Unary right_unary = (Unary) right;
1903
1904                                         if (right_unary.Oper == Unary.Operator.UnaryNegation){
1905                                                 oper = Operator.Subtraction;
1906                                                 right = right_unary.Expr;
1907                                                 r = right.Type;
1908                                         }
1909                                 }
1910                         }
1911
1912                         if (oper == Operator.Equality || oper == Operator.Inequality){
1913                                 if (l == TypeManager.bool_type || r == TypeManager.bool_type){
1914                                         if (r != TypeManager.bool_type || l != TypeManager.bool_type){
1915                                                 Error_OperatorCannotBeApplied ();
1916                                                 return null;
1917                                         }
1918
1919                                         type = TypeManager.bool_type;
1920                                         return this;
1921                                 }
1922
1923                                 if (l.IsPointer || r.IsPointer) {
1924                                         if (l.IsPointer && r.IsPointer) {
1925                                                 type = TypeManager.bool_type;
1926                                                 return this;
1927                                         }
1928
1929                                         if (l.IsPointer && r == TypeManager.null_type) {
1930                                                 right = new EmptyCast (NullPointer.Null, l);
1931                                                 type = TypeManager.bool_type;
1932                                                 return this;
1933                                         }
1934
1935                                         if (r.IsPointer && l == TypeManager.null_type) {
1936                                                 left = new EmptyCast (NullPointer.Null, r);
1937                                                 type = TypeManager.bool_type;
1938                                                 return this;
1939                                         }
1940                                 }
1941
1942                                 //
1943                                 // operator != (object a, object b)
1944                                 // operator == (object a, object b)
1945                                 //
1946                                 // For this to be used, both arguments have to be reference-types.
1947                                 // Read the rationale on the spec (14.9.6)
1948                                 //
1949                                 if (!(l.IsValueType || r.IsValueType)){
1950                                         type = TypeManager.bool_type;
1951
1952                                         if (l == r)
1953                                                 return this;
1954
1955                                         //
1956                                         // Also, a standard conversion must exist from either one
1957                                         //
1958                                         bool left_to_right =
1959                                                 Convert.ImplicitStandardConversionExists (ec, left, r);
1960                                         bool right_to_left = !left_to_right &&
1961                                                 Convert.ImplicitStandardConversionExists (ec, right, l);
1962
1963                                         if (!left_to_right && !right_to_left) {
1964                                                 Error_OperatorCannotBeApplied ();
1965                                                 return null;
1966                                         }
1967
1968                                         if (left_to_right && left_operators != null &&
1969                                             RootContext.WarningLevel >= 2) {
1970                                                 ArrayList args = new ArrayList (2);
1971                                                 args.Add (new Argument (left, Argument.AType.Expression));
1972                                                 args.Add (new Argument (left, Argument.AType.Expression));
1973                                                 MethodBase method = Invocation.OverloadResolve (
1974                                                         ec, (MethodGroupExpr) left_operators, args, true, Location.Null);
1975                                                 if (method != null)
1976                                                         Warning_UnintendedReferenceComparison (loc, "right", l);
1977                                         }
1978
1979                                         if (right_to_left && right_operators != null &&
1980                                             RootContext.WarningLevel >= 2) {
1981                                                 ArrayList args = new ArrayList (2);
1982                                                 args.Add (new Argument (right, Argument.AType.Expression));
1983                                                 args.Add (new Argument (right, Argument.AType.Expression));
1984                                                 MethodBase method = Invocation.OverloadResolve (
1985                                                         ec, (MethodGroupExpr) right_operators, args, true, Location.Null);
1986                                                 if (method != null)
1987                                                         Warning_UnintendedReferenceComparison (loc, "left", r);
1988                                         }
1989
1990                                         //
1991                                         // We are going to have to convert to an object to compare
1992                                         //
1993                                         if (l != TypeManager.object_type)
1994                                                 left = new EmptyCast (left, TypeManager.object_type);
1995                                         if (r != TypeManager.object_type)
1996                                                 right = new EmptyCast (right, TypeManager.object_type);
1997
1998                                         //
1999                                         // FIXME: CSC here catches errors cs254 and cs252
2000                                         //
2001                                         return this;
2002                                 }
2003
2004                                 //
2005                                 // One of them is a valuetype, but the other one is not.
2006                                 //
2007                                 if (!l.IsValueType || !r.IsValueType) {
2008                                         Error_OperatorCannotBeApplied ();
2009                                         return null;
2010                                 }
2011                         }
2012
2013                         // Only perform numeric promotions on:
2014                         // +, -, *, /, %, &, |, ^, ==, !=, <, >, <=, >=
2015                         //
2016                         if (oper == Operator.Addition || oper == Operator.Subtraction) {
2017                                 if (l.IsSubclassOf (TypeManager.delegate_type)){
2018                                         if (((right.eclass == ExprClass.MethodGroup) ||
2019                                              (r == TypeManager.anonymous_method_type))){
2020                                                 if ((RootContext.Version != LanguageVersion.ISO_1)){
2021                                                         Expression tmp = Convert.ImplicitConversionRequired (ec, right, l, loc);
2022                                                         if (tmp == null)
2023                                                                 return null;
2024                                                         right = tmp;
2025                                                         r = right.Type;
2026                                                 }
2027                                         }
2028
2029                                         if (r.IsSubclassOf (TypeManager.delegate_type)){
2030                                                 MethodInfo method;
2031                                                 ArrayList args = new ArrayList (2);
2032
2033                                                 args = new ArrayList (2);
2034                                                 args.Add (new Argument (left, Argument.AType.Expression));
2035                                                 args.Add (new Argument (right, Argument.AType.Expression));
2036
2037                                                 if (oper == Operator.Addition)
2038                                                         method = TypeManager.delegate_combine_delegate_delegate;
2039                                                 else
2040                                                         method = TypeManager.delegate_remove_delegate_delegate;
2041
2042                                                 if (l != r) {
2043                                                         Error_OperatorCannotBeApplied ();
2044                                                         return null;
2045                                                 }
2046
2047                                                 return new BinaryDelegate (l, method, args);
2048                                         }
2049                                 }
2050
2051                                 //
2052                                 // Pointer arithmetic:
2053                                 //
2054                                 // T* operator + (T* x, int y);
2055                                 // T* operator + (T* x, uint y);
2056                                 // T* operator + (T* x, long y);
2057                                 // T* operator + (T* x, ulong y);
2058                                 //
2059                                 // T* operator + (int y,   T* x);
2060                                 // T* operator + (uint y,  T *x);
2061                                 // T* operator + (long y,  T *x);
2062                                 // T* operator + (ulong y, T *x);
2063                                 //
2064                                 // T* operator - (T* x, int y);
2065                                 // T* operator - (T* x, uint y);
2066                                 // T* operator - (T* x, long y);
2067                                 // T* operator - (T* x, ulong y);
2068                                 //
2069                                 // long operator - (T* x, T *y)
2070                                 //
2071                                 if (l.IsPointer){
2072                                         if (r.IsPointer && oper == Operator.Subtraction){
2073                                                 if (r == l)
2074                                                         return new PointerArithmetic (
2075                                                                 false, left, right, TypeManager.int64_type,
2076                                                                 loc).Resolve (ec);
2077                                         } else {
2078                                                 Expression t = Make32or64 (ec, right);
2079                                                 if (t != null)
2080                                                         return new PointerArithmetic (oper == Operator.Addition, left, t, l, loc).Resolve (ec);
2081                                         }
2082                                 } else if (r.IsPointer && oper == Operator.Addition){
2083                                         Expression t = Make32or64 (ec, left);
2084                                         if (t != null)
2085                                                 return new PointerArithmetic (true, right, t, r, loc).Resolve (ec);
2086                                 }
2087                         }
2088
2089                         //
2090                         // Enumeration operators
2091                         //
2092                         bool lie = TypeManager.IsEnumType (l);
2093                         bool rie = TypeManager.IsEnumType (r);
2094                         if (lie || rie){
2095                                 Expression temp;
2096
2097                                 // U operator - (E e, E f)
2098                                 if (lie && rie){
2099                                         if (oper == Operator.Subtraction){
2100                                                 if (l == r){
2101                                                         type = TypeManager.EnumToUnderlying (l);
2102                                                         return this;
2103                                                 }
2104                                                 Error_OperatorCannotBeApplied ();
2105                                                 return null;
2106                                         }
2107                                 }
2108
2109                                 //
2110                                 // operator + (E e, U x)
2111                                 // operator - (E e, U x)
2112                                 //
2113                                 if (oper == Operator.Addition || oper == Operator.Subtraction){
2114                                         Type enum_type = lie ? l : r;
2115                                         Type other_type = lie ? r : l;
2116                                         Type underlying_type = TypeManager.EnumToUnderlying (enum_type);
2117
2118                                         if (underlying_type != other_type){
2119                                                 temp = Convert.ImplicitConversion (ec, lie ? right : left, underlying_type, loc);
2120                                                 if (temp != null){
2121                                                         if (lie)
2122                                                                 right = temp;
2123                                                         else
2124                                                                 left = temp;
2125                                                         type = enum_type;
2126                                                         return this;
2127                                                 }
2128
2129                                                 Error_OperatorCannotBeApplied ();
2130                                                 return null;
2131                                         }
2132
2133                                         type = enum_type;
2134                                         return this;
2135                                 }
2136
2137                                 if (!rie){
2138                                         temp = Convert.ImplicitConversion (ec, right, l, loc);
2139                                         if (temp != null)
2140                                                 right = temp;
2141                                         else {
2142                                                 Error_OperatorCannotBeApplied ();
2143                                                 return null;
2144                                         }
2145                                 } if (!lie){
2146                                         temp = Convert.ImplicitConversion (ec, left, r, loc);
2147                                         if (temp != null){
2148                                                 left = temp;
2149                                                 l = r;
2150                                         } else {
2151                                                 Error_OperatorCannotBeApplied ();
2152                                                 return null;
2153                                         }
2154                                 }
2155
2156                                 if (oper == Operator.Equality || oper == Operator.Inequality ||
2157                                     oper == Operator.LessThanOrEqual || oper == Operator.LessThan ||
2158                                     oper == Operator.GreaterThanOrEqual || oper == Operator.GreaterThan){
2159                                         if (left.Type != right.Type){
2160                                                 Error_OperatorCannotBeApplied ();
2161                                                 return null;
2162                                         }
2163                                         type = TypeManager.bool_type;
2164                                         return this;
2165                                 }
2166
2167                                 if (oper == Operator.BitwiseAnd ||
2168                                     oper == Operator.BitwiseOr ||
2169                                     oper == Operator.ExclusiveOr){
2170                                         if (left.Type != right.Type){
2171                                                 Error_OperatorCannotBeApplied ();
2172                                                 return null;
2173                                         }
2174                                         type = l;
2175                                         return this;
2176                                 }
2177                                 Error_OperatorCannotBeApplied ();
2178                                 return null;
2179                         }
2180
2181                         if (oper == Operator.LeftShift || oper == Operator.RightShift)
2182                                 return CheckShiftArguments (ec);
2183
2184                         if (oper == Operator.LogicalOr || oper == Operator.LogicalAnd){
2185                                 if (l == TypeManager.bool_type && r == TypeManager.bool_type) {
2186                                         type = TypeManager.bool_type;
2187                                         return this;
2188                                 }
2189
2190                                 if (l != r) {
2191                                         Error_OperatorCannotBeApplied ();
2192                                         return null;
2193                                 }
2194
2195                                 Expression e = new ConditionalLogicalOperator (
2196                                         oper == Operator.LogicalAnd, left, right, l, loc);
2197                                 return e.Resolve (ec);
2198                         }
2199
2200                         //
2201                         // operator & (bool x, bool y)
2202                         // operator | (bool x, bool y)
2203                         // operator ^ (bool x, bool y)
2204                         //
2205                         if (l == TypeManager.bool_type && r == TypeManager.bool_type){
2206                                 if (oper == Operator.BitwiseAnd ||
2207                                     oper == Operator.BitwiseOr ||
2208                                     oper == Operator.ExclusiveOr){
2209                                         type = l;
2210                                         return this;
2211                                 }
2212                         }
2213
2214                         //
2215                         // Pointer comparison
2216                         //
2217                         if (l.IsPointer && r.IsPointer){
2218                                 if (oper == Operator.LessThan || oper == Operator.LessThanOrEqual ||
2219                                     oper == Operator.GreaterThan || oper == Operator.GreaterThanOrEqual){
2220                                         type = TypeManager.bool_type;
2221                                         return this;
2222                                 }
2223                         }
2224
2225                         //
2226                         // This will leave left or right set to null if there is an error
2227                         //
2228                         bool check_user_conv = is_user_defined (l) && is_user_defined (r);
2229                         DoNumericPromotions (ec, l, r, left, right, check_user_conv);
2230                         if (left == null || right == null){
2231                                 Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
2232                                 return null;
2233                         }
2234
2235                         //
2236                         // reload our cached types if required
2237                         //
2238                         l = left.Type;
2239                         r = right.Type;
2240
2241                         if (oper == Operator.BitwiseAnd ||
2242                             oper == Operator.BitwiseOr ||
2243                             oper == Operator.ExclusiveOr){
2244                                 if (l == r){
2245                                         if (((l == TypeManager.int32_type) ||
2246                                              (l == TypeManager.uint32_type) ||
2247                                              (l == TypeManager.short_type) ||
2248                                              (l == TypeManager.ushort_type) ||
2249                                              (l == TypeManager.int64_type) ||
2250                                              (l == TypeManager.uint64_type))){
2251                                                 type = l;
2252                                         } else {
2253                                                 Error_OperatorCannotBeApplied ();
2254                                                 return null;
2255                                         }
2256                                 } else {
2257                                         Error_OperatorCannotBeApplied ();
2258                                         return null;
2259                                 }
2260                         }
2261
2262                         if (oper == Operator.Equality ||
2263                             oper == Operator.Inequality ||
2264                             oper == Operator.LessThanOrEqual ||
2265                             oper == Operator.LessThan ||
2266                             oper == Operator.GreaterThanOrEqual ||
2267                             oper == Operator.GreaterThan){
2268                                 type = TypeManager.bool_type;
2269                         }
2270
2271                         return this;
2272                 }
2273
2274                 Constant EnumLiftUp (EmitContext ec, Constant left, Constant right)
2275                 {
2276                         switch (oper) {
2277                                 case Operator.BitwiseOr:
2278                                 case Operator.BitwiseAnd:
2279                                 case Operator.ExclusiveOr:
2280                                 case Operator.Equality:
2281                                 case Operator.Inequality:
2282                                 case Operator.LessThan:
2283                                 case Operator.LessThanOrEqual:
2284                                 case Operator.GreaterThan:
2285                                 case Operator.GreaterThanOrEqual:
2286                                         if (left is EnumConstant)
2287                                                 return left;
2288
2289                                         if (left.IsZeroInteger)
2290                                                 return new EnumConstant (left, right.Type);
2291
2292                                         break;
2293
2294                                 case Operator.Addition:
2295                                 case Operator.Subtraction:
2296                                         return left;
2297
2298                                 case Operator.Multiply:
2299                                 case Operator.Division:
2300                                 case Operator.Modulus:
2301                                 case Operator.LeftShift:
2302                                 case Operator.RightShift:
2303                                         if (right is EnumConstant || left is EnumConstant)
2304                                                 break;
2305                                         return left;
2306                         }
2307                         Error_OperatorCannotBeApplied (loc, Binary.OperName (oper), left.Type, right.Type);
2308                         return null;
2309                 }
2310
2311                 public override Expression DoResolve (EmitContext ec)
2312                 {
2313                         if (left == null)
2314                                 return null;
2315
2316                         if ((oper == Operator.Subtraction) && (left is ParenthesizedExpression)) {
2317                                 left = ((ParenthesizedExpression) left).Expr;
2318                                 left = left.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.Type);
2319                                 if (left == null)
2320                                         return null;
2321
2322                                 if (left.eclass == ExprClass.Type) {
2323                                         Report.Error (75, loc, "To cast a negative value, you must enclose the value in parentheses");
2324                                         return null;
2325                                 }
2326                         } else
2327                                 left = left.Resolve (ec);
2328
2329                         if (left == null)
2330                                 return null;
2331
2332                         Constant lc = left as Constant;
2333                         if (lc != null && lc.Type == TypeManager.bool_type &&
2334                                 ((oper == Operator.LogicalAnd && (bool)lc.GetValue () == false) ||
2335                                  (oper == Operator.LogicalOr && (bool)lc.GetValue () == true))) {
2336
2337                                 // TODO: make a sense to resolve unreachable expression as we do for statement
2338                                 Report.Warning (429, 4, loc, "Unreachable expression code detected");
2339                                 return left;
2340                         }
2341
2342                         right = right.Resolve (ec);
2343                         if (right == null)
2344                                 return null;
2345
2346                         eclass = ExprClass.Value;
2347                         Constant rc = right as Constant;
2348
2349                         // The conversion rules are ignored in enum context but why
2350                         if (!ec.InEnumContext && lc != null && rc != null && (TypeManager.IsEnumType (left.Type) || TypeManager.IsEnumType (right.Type))) {
2351                                 left = lc = EnumLiftUp (ec, lc, rc);
2352                                 if (lc == null)
2353                                         return null;
2354
2355                                 right = rc = EnumLiftUp (ec, rc, lc);
2356                                 if (rc == null)
2357                                         return null;
2358                         }
2359
2360                         if (oper == Operator.BitwiseAnd) {
2361                                 if (rc != null && rc.IsZeroInteger) {
2362                                         return lc is EnumConstant ?
2363                                                 new EnumConstant (rc, lc.Type):
2364                                                 rc;
2365                                 }
2366
2367                                 if (lc != null && lc.IsZeroInteger) {
2368                                         return rc is EnumConstant ?
2369                                                 new EnumConstant (lc, rc.Type):
2370                                                 lc;
2371                                 }
2372                         }
2373                         else if (oper == Operator.BitwiseOr) {
2374                                 if (lc is EnumConstant &&
2375                                     rc != null && rc.IsZeroInteger)
2376                                         return lc;
2377                                 if (rc is EnumConstant &&
2378                                     lc != null && lc.IsZeroInteger)
2379                                         return rc;
2380                         } else if (oper == Operator.LogicalAnd) {
2381                                 if (rc != null && rc.IsDefaultValue && rc.Type == TypeManager.bool_type)
2382                                         return rc;
2383                                 if (lc != null && lc.IsDefaultValue && lc.Type == TypeManager.bool_type)
2384                                         return lc;
2385                         }
2386
2387                         if (rc != null && lc != null){
2388                                 int prev_e = Report.Errors;
2389                                 Expression e = ConstantFold.BinaryFold (
2390                                         ec, oper, lc, rc, loc);
2391                                 if (e != null || Report.Errors != prev_e)
2392                                         return e;
2393                         }
2394
2395                         // Comparison warnings
2396                         if (oper == Operator.Equality || oper == Operator.Inequality ||
2397                             oper == Operator.LessThanOrEqual || oper == Operator.LessThan ||
2398                             oper == Operator.GreaterThanOrEqual || oper == Operator.GreaterThan){
2399                                 if (left.Equals (right)) {
2400                                         Report.Warning (1718, 3, loc, "Comparison made to same variable; did you mean to compare something else?");
2401                                 }
2402                                 CheckUselessComparison (lc, right.Type);
2403                                 CheckUselessComparison (rc, left.Type);
2404                         }
2405
2406                         return ResolveOperator (ec);
2407                 }
2408
2409                 private void CheckUselessComparison (Constant c, Type type)
2410                 {
2411                         if (c == null || !IsTypeIntegral (type)
2412                                 || c is StringConstant
2413                                 || c is BoolConstant
2414                                 || c is CharConstant
2415                                 || c is FloatConstant
2416                                 || c is DoubleConstant
2417                                 || c is DecimalConstant
2418                                 )
2419                                 return;
2420
2421                         long value = 0;
2422
2423                         if (c is ULongConstant) {
2424                                 ulong uvalue = ((ULongConstant) c).Value;
2425                                 if (uvalue > long.MaxValue) {
2426                                         if (type == TypeManager.byte_type ||
2427                                             type == TypeManager.sbyte_type ||
2428                                             type == TypeManager.short_type ||
2429                                             type == TypeManager.ushort_type ||
2430                                             type == TypeManager.int32_type ||
2431                                             type == TypeManager.uint32_type ||
2432                                             type == TypeManager.int64_type)
2433                                                 WarnUselessComparison (type);
2434                                         return;
2435                                 }
2436                                 value = (long) uvalue;
2437                         }
2438                         else if (c is ByteConstant)
2439                                 value = ((ByteConstant) c).Value;
2440                         else if (c is SByteConstant)
2441                                 value = ((SByteConstant) c).Value;
2442                         else if (c is ShortConstant)
2443                                 value = ((ShortConstant) c).Value;
2444                         else if (c is UShortConstant)
2445                                 value = ((UShortConstant) c).Value;
2446                         else if (c is IntConstant)
2447                                 value = ((IntConstant) c).Value;
2448                         else if (c is UIntConstant)
2449                                 value = ((UIntConstant) c).Value;
2450                         else if (c is LongConstant)
2451                                 value = ((LongConstant) c).Value;
2452
2453                         if (value != 0) {
2454                                 if (IsValueOutOfRange (value, type))
2455                                         WarnUselessComparison (type);
2456                                 return;
2457                         }
2458                 }
2459
2460                 private bool IsValueOutOfRange (long value, Type type)
2461                 {
2462                         if (IsTypeUnsigned (type) && value < 0)
2463                                 return true;
2464                         return type == TypeManager.sbyte_type && (value >= 0x80 || value < -0x80) ||
2465                                 type == TypeManager.byte_type && value >= 0x100 ||
2466                                 type == TypeManager.short_type && (value >= 0x8000 || value < -0x8000) ||
2467                                 type == TypeManager.ushort_type && value >= 0x10000 ||
2468                                 type == TypeManager.int32_type && (value >= 0x80000000 || value < -0x80000000) ||
2469                                 type == TypeManager.uint32_type && value >= 0x100000000;
2470                 }
2471
2472                 private static bool IsTypeIntegral (Type type)
2473                 {
2474                         return type == TypeManager.uint64_type ||
2475                                 type == TypeManager.int64_type ||
2476                                 type == TypeManager.uint32_type ||
2477                                 type == TypeManager.int32_type ||
2478                                 type == TypeManager.ushort_type ||
2479                                 type == TypeManager.short_type ||
2480                                 type == TypeManager.sbyte_type ||
2481                                 type == TypeManager.byte_type;
2482                 }
2483
2484                 private static bool IsTypeUnsigned (Type type)
2485                 {
2486                         return type == TypeManager.uint64_type ||
2487                                 type == TypeManager.uint32_type ||
2488                                 type == TypeManager.ushort_type ||
2489                                 type == TypeManager.byte_type;
2490                 }
2491
2492                 private void WarnUselessComparison (Type type)
2493                 {
2494                         Report.Warning (652, 2, loc, "Comparison to integral constant is useless; the constant is outside the range of type `{0}'",
2495                                 TypeManager.CSharpName (type));
2496                 }
2497
2498                 /// <remarks>
2499                 ///   EmitBranchable is called from Statement.EmitBoolExpression in the
2500                 ///   context of a conditional bool expression.  This function will return
2501                 ///   false if it is was possible to use EmitBranchable, or true if it was.
2502                 ///
2503                 ///   The expression's code is generated, and we will generate a branch to `target'
2504                 ///   if the resulting expression value is equal to isTrue
2505                 /// </remarks>
2506                 public override void EmitBranchable (EmitContext ec, Label target, bool onTrue)
2507                 {
2508                         ILGenerator ig = ec.ig;
2509
2510                         //
2511                         // This is more complicated than it looks, but its just to avoid
2512                         // duplicated tests: basically, we allow ==, !=, >, <, >= and <=
2513                         // but on top of that we want for == and != to use a special path
2514                         // if we are comparing against null
2515                         //
2516                         if ((oper == Operator.Equality || oper == Operator.Inequality) && (left is Constant || right is Constant)) {
2517                                 bool my_on_true = oper == Operator.Inequality ? onTrue : !onTrue;
2518
2519                                 //
2520                                 // put the constant on the rhs, for simplicity
2521                                 //
2522                                 if (left is Constant) {
2523                                         Expression swap = right;
2524                                         right = left;
2525                                         left = swap;
2526                                 }
2527
2528                                 if (((Constant) right).IsZeroInteger) {
2529                                         left.Emit (ec);
2530                                         if (my_on_true)
2531                                                 ig.Emit (OpCodes.Brtrue, target);
2532                                         else
2533                                                 ig.Emit (OpCodes.Brfalse, target);
2534
2535                                         return;
2536                                 } else if (right is BoolConstant) {
2537                                         left.Emit (ec);
2538                                         if (my_on_true != ((BoolConstant) right).Value)
2539                                                 ig.Emit (OpCodes.Brtrue, target);
2540                                         else
2541                                                 ig.Emit (OpCodes.Brfalse, target);
2542
2543                                         return;
2544                                 }
2545
2546                         } else if (oper == Operator.LogicalAnd) {
2547
2548                                 if (onTrue) {
2549                                         Label tests_end = ig.DefineLabel ();
2550
2551                                         left.EmitBranchable (ec, tests_end, false);
2552                                         right.EmitBranchable (ec, target, true);
2553                                         ig.MarkLabel (tests_end);
2554                                 } else {
2555                                         left.EmitBranchable (ec, target, false);
2556                                         right.EmitBranchable (ec, target, false);
2557                                 }
2558
2559                                 return;
2560
2561                         } else if (oper == Operator.LogicalOr){
2562                                 if (onTrue) {
2563                                         left.EmitBranchable (ec, target, true);
2564                                         right.EmitBranchable (ec, target, true);
2565
2566                                 } else {
2567                                         Label tests_end = ig.DefineLabel ();
2568                                         left.EmitBranchable (ec, tests_end, true);
2569                                         right.EmitBranchable (ec, target, false);
2570                                         ig.MarkLabel (tests_end);
2571                                 }
2572
2573                                 return;
2574
2575                         } else if (!(oper == Operator.LessThan        || oper == Operator.GreaterThan ||
2576                                      oper == Operator.LessThanOrEqual || oper == Operator.GreaterThanOrEqual ||
2577                                      oper == Operator.Equality        || oper == Operator.Inequality)) {
2578                                 base.EmitBranchable (ec, target, onTrue);
2579                                 return;
2580                         }
2581
2582                         left.Emit (ec);
2583                         right.Emit (ec);
2584
2585                         Type t = left.Type;
2586                         bool isUnsigned = is_unsigned (t) || t == TypeManager.double_type || t == TypeManager.float_type;
2587
2588                         switch (oper){
2589                         case Operator.Equality:
2590                                 if (onTrue)
2591                                         ig.Emit (OpCodes.Beq, target);
2592                                 else
2593                                         ig.Emit (OpCodes.Bne_Un, target);
2594                                 break;
2595
2596                         case Operator.Inequality:
2597                                 if (onTrue)
2598                                         ig.Emit (OpCodes.Bne_Un, target);
2599                                 else
2600                                         ig.Emit (OpCodes.Beq, target);
2601                                 break;
2602
2603                         case Operator.LessThan:
2604                                 if (onTrue)
2605                                         if (isUnsigned)
2606                                                 ig.Emit (OpCodes.Blt_Un, target);
2607                                         else
2608                                                 ig.Emit (OpCodes.Blt, target);
2609                                 else
2610                                         if (isUnsigned)
2611                                                 ig.Emit (OpCodes.Bge_Un, target);
2612                                         else
2613                                                 ig.Emit (OpCodes.Bge, target);
2614                                 break;
2615
2616                         case Operator.GreaterThan:
2617                                 if (onTrue)
2618                                         if (isUnsigned)
2619                                                 ig.Emit (OpCodes.Bgt_Un, target);
2620                                         else
2621                                                 ig.Emit (OpCodes.Bgt, target);
2622                                 else
2623                                         if (isUnsigned)
2624                                                 ig.Emit (OpCodes.Ble_Un, target);
2625                                         else
2626                                                 ig.Emit (OpCodes.Ble, target);
2627                                 break;
2628
2629                         case Operator.LessThanOrEqual:
2630                                 if (onTrue)
2631                                         if (isUnsigned)
2632                                                 ig.Emit (OpCodes.Ble_Un, target);
2633                                         else
2634                                                 ig.Emit (OpCodes.Ble, target);
2635                                 else
2636                                         if (isUnsigned)
2637                                                 ig.Emit (OpCodes.Bgt_Un, target);
2638                                         else
2639                                                 ig.Emit (OpCodes.Bgt, target);
2640                                 break;
2641
2642
2643                         case Operator.GreaterThanOrEqual:
2644                                 if (onTrue)
2645                                         if (isUnsigned)
2646                                                 ig.Emit (OpCodes.Bge_Un, target);
2647                                         else
2648                                                 ig.Emit (OpCodes.Bge, target);
2649                                 else
2650                                         if (isUnsigned)
2651                                                 ig.Emit (OpCodes.Blt_Un, target);
2652                                         else
2653                                                 ig.Emit (OpCodes.Blt, target);
2654                                 break;
2655                         default:
2656                                 Console.WriteLine (oper);
2657                                 throw new Exception ("what is THAT");
2658                         }
2659                 }
2660
2661                 public override void Emit (EmitContext ec)
2662                 {
2663                         ILGenerator ig = ec.ig;
2664                         Type l = left.Type;
2665                         OpCode opcode;
2666
2667                         //
2668                         // Handle short-circuit operators differently
2669                         // than the rest
2670                         //
2671                         if (oper == Operator.LogicalAnd) {
2672                                 Label load_zero = ig.DefineLabel ();
2673                                 Label end = ig.DefineLabel ();
2674
2675                                 left.EmitBranchable (ec, load_zero, false);
2676                                 right.Emit (ec);
2677                                 ig.Emit (OpCodes.Br, end);
2678
2679                                 ig.MarkLabel (load_zero);
2680                                 ig.Emit (OpCodes.Ldc_I4_0);
2681                                 ig.MarkLabel (end);
2682                                 return;
2683                         } else if (oper == Operator.LogicalOr) {
2684                                 Label load_one = ig.DefineLabel ();
2685                                 Label end = ig.DefineLabel ();
2686
2687                                 left.EmitBranchable (ec, load_one, true);
2688                                 right.Emit (ec);
2689                                 ig.Emit (OpCodes.Br, end);
2690
2691                                 ig.MarkLabel (load_one);
2692                                 ig.Emit (OpCodes.Ldc_I4_1);
2693                                 ig.MarkLabel (end);
2694                                 return;
2695                         }
2696
2697                         left.Emit (ec);
2698                         right.Emit (ec);
2699
2700                         bool isUnsigned = is_unsigned (left.Type);
2701
2702                         switch (oper){
2703                         case Operator.Multiply:
2704                                 if (ec.CheckState){
2705                                         if (l == TypeManager.int32_type || l == TypeManager.int64_type)
2706                                                 opcode = OpCodes.Mul_Ovf;
2707                                         else if (isUnsigned)
2708                                                 opcode = OpCodes.Mul_Ovf_Un;
2709                                         else
2710                                                 opcode = OpCodes.Mul;
2711                                 } else
2712                                         opcode = OpCodes.Mul;
2713
2714                                 break;
2715
2716                         case Operator.Division:
2717                                 if (isUnsigned)
2718                                         opcode = OpCodes.Div_Un;
2719                                 else
2720                                         opcode = OpCodes.Div;
2721                                 break;
2722
2723                         case Operator.Modulus:
2724                                 if (isUnsigned)
2725                                         opcode = OpCodes.Rem_Un;
2726                                 else
2727                                         opcode = OpCodes.Rem;
2728                                 break;
2729
2730                         case Operator.Addition:
2731                                 if (ec.CheckState){
2732                                         if (l == TypeManager.int32_type || l == TypeManager.int64_type)
2733                                                 opcode = OpCodes.Add_Ovf;
2734                                         else if (isUnsigned)
2735                                                 opcode = OpCodes.Add_Ovf_Un;
2736                                         else
2737                                                 opcode = OpCodes.Add;
2738                                 } else
2739                                         opcode = OpCodes.Add;
2740                                 break;
2741
2742                         case Operator.Subtraction:
2743                                 if (ec.CheckState){
2744                                         if (l == TypeManager.int32_type || l == TypeManager.int64_type)
2745                                                 opcode = OpCodes.Sub_Ovf;
2746                                         else if (isUnsigned)
2747                                                 opcode = OpCodes.Sub_Ovf_Un;
2748                                         else
2749                                                 opcode = OpCodes.Sub;
2750                                 } else
2751                                         opcode = OpCodes.Sub;
2752                                 break;
2753
2754                         case Operator.RightShift:
2755                                 if (isUnsigned)
2756                                         opcode = OpCodes.Shr_Un;
2757                                 else
2758                                         opcode = OpCodes.Shr;
2759                                 break;
2760
2761                         case Operator.LeftShift:
2762                                 opcode = OpCodes.Shl;
2763                                 break;
2764
2765                         case Operator.Equality:
2766                                 opcode = OpCodes.Ceq;
2767                                 break;
2768
2769                         case Operator.Inequality:
2770                                 ig.Emit (OpCodes.Ceq);
2771                                 ig.Emit (OpCodes.Ldc_I4_0);
2772
2773                                 opcode = OpCodes.Ceq;
2774                                 break;
2775
2776                         case Operator.LessThan:
2777                                 if (isUnsigned)
2778                                         opcode = OpCodes.Clt_Un;
2779                                 else
2780                                         opcode = OpCodes.Clt;
2781                                 break;
2782
2783                         case Operator.GreaterThan:
2784                                 if (isUnsigned)
2785                                         opcode = OpCodes.Cgt_Un;
2786                                 else
2787                                         opcode = OpCodes.Cgt;
2788                                 break;
2789
2790                         case Operator.LessThanOrEqual:
2791                                 Type lt = left.Type;
2792
2793                                 if (isUnsigned || (lt == TypeManager.double_type || lt == TypeManager.float_type))
2794                                         ig.Emit (OpCodes.Cgt_Un);
2795                                 else
2796                                         ig.Emit (OpCodes.Cgt);
2797                                 ig.Emit (OpCodes.Ldc_I4_0);
2798
2799                                 opcode = OpCodes.Ceq;
2800                                 break;
2801
2802                         case Operator.GreaterThanOrEqual:
2803                                 Type le = left.Type;
2804
2805                                 if (isUnsigned || (le == TypeManager.double_type || le == TypeManager.float_type))
2806                                         ig.Emit (OpCodes.Clt_Un);
2807                                 else
2808                                         ig.Emit (OpCodes.Clt);
2809
2810                                 ig.Emit (OpCodes.Ldc_I4_0);
2811
2812                                 opcode = OpCodes.Ceq;
2813                                 break;
2814
2815                         case Operator.BitwiseOr:
2816                                 opcode = OpCodes.Or;
2817                                 break;
2818
2819                         case Operator.BitwiseAnd:
2820                                 opcode = OpCodes.And;
2821                                 break;
2822
2823                         case Operator.ExclusiveOr:
2824                                 opcode = OpCodes.Xor;
2825                                 break;
2826
2827                         default:
2828                                 throw new Exception ("This should not happen: Operator = "
2829                                                      + oper.ToString ());
2830                         }
2831
2832                         ig.Emit (opcode);
2833                 }
2834         }
2835
2836         //
2837         // Object created by Binary when the binary operator uses an method instead of being
2838         // a binary operation that maps to a CIL binary operation.
2839         //
2840         public class BinaryMethod : Expression {
2841                 public MethodBase method;
2842                 public ArrayList  Arguments;
2843
2844                 public BinaryMethod (Type t, MethodBase m, ArrayList args)
2845                 {
2846                         method = m;
2847                         Arguments = args;
2848                         type = t;
2849                         eclass = ExprClass.Value;
2850                 }
2851
2852                 public override Expression DoResolve (EmitContext ec)
2853                 {
2854                         return this;
2855                 }
2856
2857                 public override void Emit (EmitContext ec)
2858                 {
2859                         ILGenerator ig = ec.ig;
2860
2861                         if (Arguments != null)
2862                                 Invocation.EmitArguments (ec, method, Arguments, false, null);
2863
2864                         if (method is MethodInfo)
2865                                 ig.Emit (OpCodes.Call, (MethodInfo) method);
2866                         else
2867                                 ig.Emit (OpCodes.Call, (ConstructorInfo) method);
2868                 }
2869         }
2870
2871         //
2872         // Represents the operation a + b [+ c [+ d [+ ...]]], where a is a string
2873         // b, c, d... may be strings or objects.
2874         //
2875         public class StringConcat : Expression {
2876                 ArrayList operands;
2877                 bool invalid = false;
2878                 bool emit_conv_done = false;
2879                 //
2880                 // Are we also concating objects?
2881                 //
2882                 bool is_strings_only = true;
2883
2884                 public StringConcat (EmitContext ec, Location loc, Expression left, Expression right)
2885                 {
2886                         this.loc = loc;
2887                         type = TypeManager.string_type;
2888                         eclass = ExprClass.Value;
2889
2890                         operands = new ArrayList (2);
2891                         Append (ec, left);
2892                         Append (ec, right);
2893                 }
2894
2895                 public override Expression DoResolve (EmitContext ec)
2896                 {
2897                         if (invalid)
2898                                 return null;
2899
2900                         return this;
2901                 }
2902
2903                 public void Append (EmitContext ec, Expression operand)
2904                 {
2905                         //
2906                         // Constant folding
2907                         //
2908                         if (operand is StringConstant && operands.Count != 0) {
2909                                 StringConstant last_operand = operands [operands.Count - 1] as StringConstant;
2910                                 if (last_operand != null) {
2911                                         operands [operands.Count - 1] = new StringConstant (last_operand.Value + ((StringConstant) operand).Value, last_operand.Location);
2912                                         return;
2913                                 }
2914                         }
2915
2916                         //
2917                         // Conversion to object
2918                         //
2919                         if (operand.Type != TypeManager.string_type) {
2920                                 Expression no = Convert.ImplicitConversion (ec, operand, TypeManager.object_type, loc);
2921
2922                                 if (no == null) {
2923                                         Binary.Error_OperatorCannotBeApplied (loc, "+", TypeManager.string_type, operand.Type);
2924                                         invalid = true;
2925                                 }
2926                                 operand = no;
2927                         }
2928
2929                         operands.Add (operand);
2930                 }
2931
2932                 public override void Emit (EmitContext ec)
2933                 {
2934                         MethodInfo concat_method = null;
2935
2936                         //
2937                         // Do conversion to arguments; check for strings only
2938                         //
2939
2940                         // This can get called multiple times, so we have to deal with that.
2941                         if (!emit_conv_done) {
2942                                 emit_conv_done = true;
2943                                 for (int i = 0; i < operands.Count; i ++) {
2944                                         Expression e = (Expression) operands [i];
2945                                         is_strings_only &= e.Type == TypeManager.string_type;
2946                                 }
2947
2948                                 for (int i = 0; i < operands.Count; i ++) {
2949                                         Expression e = (Expression) operands [i];
2950
2951                                         if (! is_strings_only && e.Type == TypeManager.string_type) {
2952                                                 // need to make sure this is an object, because the EmitParams
2953                                                 // method might look at the type of this expression, see it is a
2954                                                 // string and emit a string [] when we want an object [];
2955
2956                                                 e = new EmptyCast (e, TypeManager.object_type);
2957                                         }
2958                                         operands [i] = new Argument (e, Argument.AType.Expression);
2959                                 }
2960                         }
2961
2962                         //
2963                         // Find the right method
2964                         //
2965                         switch (operands.Count) {
2966                         case 1:
2967                                 //
2968                                 // This should not be possible, because simple constant folding
2969                                 // is taken care of in the Binary code.
2970                                 //
2971                                 throw new Exception ("how did you get here?");
2972
2973                         case 2:
2974                                 concat_method = is_strings_only ?
2975                                         TypeManager.string_concat_string_string :
2976                                         TypeManager.string_concat_object_object ;
2977                                 break;
2978                         case 3:
2979                                 concat_method = is_strings_only ?
2980                                         TypeManager.string_concat_string_string_string :
2981                                         TypeManager.string_concat_object_object_object ;
2982                                 break;
2983                         case 4:
2984                                 //
2985                                 // There is not a 4 param overlaod for object (the one that there is
2986                                 // is actually a varargs methods, and is only in corlib because it was
2987                                 // introduced there before.).
2988                                 //
2989                                 if (!is_strings_only)
2990                                         goto default;
2991
2992                                 concat_method = TypeManager.string_concat_string_string_string_string;
2993                                 break;
2994                         default:
2995                                 concat_method = is_strings_only ?
2996                                         TypeManager.string_concat_string_dot_dot_dot :
2997                                         TypeManager.string_concat_object_dot_dot_dot ;
2998                                 break;
2999                         }
3000
3001                         Invocation.EmitArguments (ec, concat_method, operands, false, null);
3002                         ec.ig.Emit (OpCodes.Call, concat_method);
3003                 }
3004         }
3005
3006         //
3007         // Object created with +/= on delegates
3008         //
3009         public class BinaryDelegate : Expression {
3010                 MethodInfo method;
3011                 ArrayList  args;
3012
3013                 public BinaryDelegate (Type t, MethodInfo mi, ArrayList args)
3014                 {
3015                         method = mi;
3016                         this.args = args;
3017                         type = t;
3018                         eclass = ExprClass.Value;
3019                 }
3020
3021                 public override Expression DoResolve (EmitContext ec)
3022                 {
3023                         return this;
3024                 }
3025
3026                 public override void Emit (EmitContext ec)
3027                 {
3028                         ILGenerator ig = ec.ig;
3029
3030                         Invocation.EmitArguments (ec, method, args, false, null);
3031
3032                         ig.Emit (OpCodes.Call, (MethodInfo) method);
3033                         ig.Emit (OpCodes.Castclass, type);
3034                 }
3035
3036                 public Expression Right {
3037                         get {
3038                                 Argument arg = (Argument) args [1];
3039                                 return arg.Expr;
3040                         }
3041                 }
3042
3043                 public bool IsAddition {
3044                         get {
3045                                 return method == TypeManager.delegate_combine_delegate_delegate;
3046                         }
3047                 }
3048         }
3049
3050         //
3051         // User-defined conditional logical operator
3052         public class ConditionalLogicalOperator : Expression {
3053                 Expression left, right;
3054                 bool is_and;
3055
3056                 public ConditionalLogicalOperator (bool is_and, Expression left, Expression right, Type t, Location loc)
3057                 {
3058                         type = t;
3059                         eclass = ExprClass.Value;
3060                         this.loc = loc;
3061                         this.left = left;
3062                         this.right = right;
3063                         this.is_and = is_and;
3064                 }
3065
3066                 protected void Error19 ()
3067                 {
3068                         Binary.Error_OperatorCannotBeApplied (loc, is_and ? "&&" : "||", left.GetSignatureForError (), right.GetSignatureForError ());
3069                 }
3070
3071                 protected void Error218 ()
3072                 {
3073                         Error (218, "The type ('" + TypeManager.CSharpName (type) + "') must contain " +
3074                                "declarations of operator true and operator false");
3075                 }
3076
3077                 Expression op_true, op_false, op;
3078                 LocalTemporary left_temp;
3079
3080                 public override Expression DoResolve (EmitContext ec)
3081                 {
3082                         MethodInfo method;
3083                         Expression operator_group;
3084
3085                         operator_group = MethodLookup (ec, type, is_and ? "op_BitwiseAnd" : "op_BitwiseOr", loc);
3086                         if (operator_group == null) {
3087                                 Error19 ();
3088                                 return null;
3089                         }
3090
3091                         left_temp = new LocalTemporary (ec, type);
3092
3093                         ArrayList arguments = new ArrayList ();
3094                         arguments.Add (new Argument (left_temp, Argument.AType.Expression));
3095                         arguments.Add (new Argument (right, Argument.AType.Expression));
3096                         method = Invocation.OverloadResolve (
3097                                 ec, (MethodGroupExpr) operator_group, arguments, false, loc)
3098                                 as MethodInfo;
3099                         if (method == null) {
3100                                 Error19 ();
3101                                 return null;
3102                         }
3103
3104                         if (method.ReturnType != type) {
3105                                 Report.Error (217, loc, "In order to be applicable as a short circuit operator a user-defined logical operator `{0}' " +
3106                                                 "must have the same return type as the type of its 2 parameters", TypeManager.CSharpSignature (method));
3107                                 return null;
3108                         }
3109
3110                         op = new StaticCallExpr (method, arguments, loc);
3111
3112                         op_true = GetOperatorTrue (ec, left_temp, loc);
3113                         op_false = GetOperatorFalse (ec, left_temp, loc);
3114                         if ((op_true == null) || (op_false == null)) {
3115                                 Error218 ();
3116                                 return null;
3117                         }
3118
3119                         return this;
3120                 }
3121
3122                 public override void Emit (EmitContext ec)
3123                 {
3124                         ILGenerator ig = ec.ig;
3125                         Label false_target = ig.DefineLabel ();
3126                         Label end_target = ig.DefineLabel ();
3127
3128                         left.Emit (ec);
3129                         left_temp.Store (ec);
3130
3131                         (is_and ? op_false : op_true).EmitBranchable (ec, false_target, false);
3132                         left_temp.Emit (ec);
3133                         ig.Emit (OpCodes.Br, end_target);
3134                         ig.MarkLabel (false_target);
3135                         op.Emit (ec);
3136                         ig.MarkLabel (end_target);
3137                 }
3138         }
3139
3140         public class PointerArithmetic : Expression {
3141                 Expression left, right;
3142                 bool is_add;
3143
3144                 //
3145                 // We assume that `l' is always a pointer
3146                 //
3147                 public PointerArithmetic (bool is_addition, Expression l, Expression r, Type t, Location loc)
3148                 {
3149                         type = t;
3150                         this.loc = loc;
3151                         left = l;
3152                         right = r;
3153                         is_add = is_addition;
3154                 }
3155
3156                 public override Expression DoResolve (EmitContext ec)
3157                 {
3158                         eclass = ExprClass.Variable;
3159
3160                         if (left.Type == TypeManager.void_ptr_type) {
3161                                 Error (242, "The operation in question is undefined on void pointers");
3162                                 return null;
3163                         }
3164
3165                         return this;
3166                 }
3167
3168                 public override void Emit (EmitContext ec)
3169                 {
3170                         Type op_type = left.Type;
3171                         ILGenerator ig = ec.ig;
3172
3173                         // It must be either array or fixed buffer
3174                         Type element = TypeManager.HasElementType (op_type) ?
3175                                 element = TypeManager.GetElementType (op_type) :
3176                                 element = AttributeTester.GetFixedBuffer (((FieldExpr)left).FieldInfo).ElementType;
3177
3178                         int size = GetTypeSize (element);
3179                         Type rtype = right.Type;
3180
3181                         if (rtype.IsPointer){
3182                                 //
3183                                 // handle (pointer - pointer)
3184                                 //
3185                                 left.Emit (ec);
3186                                 right.Emit (ec);
3187                                 ig.Emit (OpCodes.Sub);
3188
3189                                 if (size != 1){
3190                                         if (size == 0)
3191                                                 ig.Emit (OpCodes.Sizeof, element);
3192                                         else
3193                                                 IntLiteral.EmitInt (ig, size);
3194                                         ig.Emit (OpCodes.Div);
3195                                 }
3196                                 ig.Emit (OpCodes.Conv_I8);
3197                         } else {
3198                                 //
3199                                 // handle + and - on (pointer op int)
3200                                 //
3201                                 left.Emit (ec);
3202                                 ig.Emit (OpCodes.Conv_I);
3203
3204                                 Constant right_const = right as Constant;
3205                                 if (right_const != null && size != 0) {
3206                                         Expression ex = ConstantFold.BinaryFold (ec, Binary.Operator.Multiply, new IntConstant (size, right.Location), right_const, loc);
3207                                         if (ex == null)
3208                                                 return;
3209                                         ex.Emit (ec);
3210                                 } else {
3211                                         right.Emit (ec);
3212                                         if (size != 1){
3213                                                 if (size == 0)
3214                                                         ig.Emit (OpCodes.Sizeof, element);
3215                                                 else
3216                                                         IntLiteral.EmitInt (ig, size);
3217                                                 if (rtype == TypeManager.int64_type)
3218                                                         ig.Emit (OpCodes.Conv_I8);
3219                                                 else if (rtype == TypeManager.uint64_type)
3220                                                         ig.Emit (OpCodes.Conv_U8);
3221                                                 ig.Emit (OpCodes.Mul);
3222                                         }
3223                                 }
3224
3225                                 if (rtype == TypeManager.int64_type || rtype == TypeManager.uint64_type)
3226                                         ig.Emit (OpCodes.Conv_I);
3227
3228                                 if (is_add)
3229                                         ig.Emit (OpCodes.Add);
3230                                 else
3231                                         ig.Emit (OpCodes.Sub);
3232                         }
3233                 }
3234         }
3235
3236         /// <summary>
3237         ///   Implements the ternary conditional operator (?:)
3238         /// </summary>
3239         public class Conditional : Expression {
3240                 Expression expr, trueExpr, falseExpr;
3241
3242                 public Conditional (Expression expr, Expression trueExpr, Expression falseExpr)
3243                 {
3244                         this.expr = expr;
3245                         this.trueExpr = trueExpr;
3246                         this.falseExpr = falseExpr;
3247                         this.loc = expr.Location;
3248                 }
3249
3250                 public Expression Expr {
3251                         get {
3252                                 return expr;
3253                         }
3254                 }
3255
3256                 public Expression TrueExpr {
3257                         get {
3258                                 return trueExpr;
3259                         }
3260                 }
3261
3262                 public Expression FalseExpr {
3263                         get {
3264                                 return falseExpr;
3265                         }
3266                 }
3267
3268                 public override Expression DoResolve (EmitContext ec)
3269                 {
3270                         expr = expr.Resolve (ec);
3271
3272                         if (expr == null)
3273                                 return null;
3274
3275                         if (expr.Type != TypeManager.bool_type){
3276                                 expr = Expression.ResolveBoolean (
3277                                         ec, expr, loc);
3278
3279                                 if (expr == null)
3280                                         return null;
3281                         }
3282
3283                         Assign ass = expr as Assign;
3284                         if (ass != null && ass.Source is Constant) {
3285                                 Report.Warning (665, 3, loc, "Assignment in conditional expression is always constant; did you mean to use == instead of = ?");
3286                         }
3287
3288                         trueExpr = trueExpr.Resolve (ec);
3289                         falseExpr = falseExpr.Resolve (ec);
3290
3291                         if (trueExpr == null || falseExpr == null)
3292                                 return null;
3293
3294                         eclass = ExprClass.Value;
3295                         if (trueExpr.Type == falseExpr.Type)
3296                                 type = trueExpr.Type;
3297                         else {
3298                                 Expression conv;
3299                                 Type true_type = trueExpr.Type;
3300                                 Type false_type = falseExpr.Type;
3301
3302                                 //
3303                                 // First, if an implicit conversion exists from trueExpr
3304                                 // to falseExpr, then the result type is of type falseExpr.Type
3305                                 //
3306                                 conv = Convert.ImplicitConversion (ec, trueExpr, false_type, loc);
3307                                 if (conv != null){
3308                                         //
3309                                         // Check if both can convert implicitl to each other's type
3310                                         //
3311                                         if (Convert.ImplicitConversion (ec, falseExpr, true_type, loc) != null){
3312                                                 Error (172,
3313                                                        "Can not compute type of conditional expression " +
3314                                                        "as `" + TypeManager.CSharpName (trueExpr.Type) +
3315                                                        "' and `" + TypeManager.CSharpName (falseExpr.Type) +
3316                                                        "' convert implicitly to each other");
3317                                                 return null;
3318                                         }
3319                                         type = false_type;
3320                                         trueExpr = conv;
3321                                 } else if ((conv = Convert.ImplicitConversion(ec, falseExpr, true_type,loc))!= null){
3322                                         type = true_type;
3323                                         falseExpr = conv;
3324                                 } else {
3325                                         Report.Error (173, loc, "Type of conditional expression cannot be determined because there is no implicit conversion between `{0}' and `{1}'",
3326                                                 trueExpr.GetSignatureForError (), falseExpr.GetSignatureForError ());
3327                                         return null;
3328                                 }
3329                         }
3330
3331                         // Dead code optimalization
3332                         if (expr is BoolConstant){
3333                                 BoolConstant bc = (BoolConstant) expr;
3334
3335                                 Report.Warning (429, 4, bc.Value ? falseExpr.Location : trueExpr.Location, "Unreachable expression code detected");
3336                                 return bc.Value ? trueExpr : falseExpr;
3337                         }
3338
3339                         return this;
3340                 }
3341
3342                 public override void Emit (EmitContext ec)
3343                 {
3344                         ILGenerator ig = ec.ig;
3345                         Label false_target = ig.DefineLabel ();
3346                         Label end_target = ig.DefineLabel ();
3347
3348                         expr.EmitBranchable (ec, false_target, false);
3349                         trueExpr.Emit (ec);
3350                         ig.Emit (OpCodes.Br, end_target);
3351                         ig.MarkLabel (false_target);
3352                         falseExpr.Emit (ec);
3353                         ig.MarkLabel (end_target);
3354                 }
3355
3356         }
3357
3358         /// <summary>
3359         ///   Local variables
3360         /// </summary>
3361         public class LocalVariableReference : Expression, IAssignMethod, IMemoryLocation, IVariable {
3362                 public readonly string Name;
3363                 public readonly Block Block;
3364                 public LocalInfo local_info;
3365                 bool is_readonly;
3366                 bool prepared;
3367                 LocalTemporary temp;
3368
3369                 public LocalVariableReference (Block block, string name, Location l)
3370                 {
3371                         Block = block;
3372                         Name = name;
3373                         loc = l;
3374                         eclass = ExprClass.Variable;
3375                 }
3376
3377                 //
3378                 // Setting `is_readonly' to false will allow you to create a writable
3379                 // reference to a read-only variable.  This is used by foreach and using.
3380                 //
3381                 public LocalVariableReference (Block block, string name, Location l,
3382                                                LocalInfo local_info, bool is_readonly)
3383                         : this (block, name, l)
3384                 {
3385                         this.local_info = local_info;
3386                         this.is_readonly = is_readonly;
3387                 }
3388
3389                 public VariableInfo VariableInfo {
3390                         get {
3391                                 return local_info.VariableInfo;
3392                         }
3393                 }
3394
3395                 public bool IsReadOnly {
3396                         get {
3397                                 return is_readonly;
3398                         }
3399                 }
3400
3401                 public bool VerifyAssigned (EmitContext ec)
3402                 {
3403                         VariableInfo variable_info = local_info.VariableInfo;
3404                         return variable_info == null || variable_info.IsAssigned (ec, loc);
3405                 }
3406
3407                 protected Expression DoResolveBase (EmitContext ec, Expression lvalue_right_side)
3408                 {
3409                         if (local_info == null) {
3410                                 local_info = Block.GetLocalInfo (Name);
3411
3412                                 // is out param
3413                                 if (lvalue_right_side == EmptyExpression.Null)
3414                                         local_info.Used = true;
3415
3416                                 is_readonly = local_info.ReadOnly;
3417                         }
3418
3419                         type = local_info.VariableType;
3420
3421                         VariableInfo variable_info = local_info.VariableInfo;
3422                         if (lvalue_right_side != null){
3423                                 if (is_readonly){
3424                                         if (lvalue_right_side is LocalVariableReference || lvalue_right_side == EmptyExpression.Null)
3425                                                 Report.Error (1657, loc, "Cannot pass `{0}' as a ref or out argument because it is a `{1}'",
3426                                                         Name, local_info.GetReadOnlyContext ());
3427                                         else
3428                                                 Report.Error (1656, loc, "Cannot assign to `{0}' because it is a `{1}'",
3429                                                         Name, local_info.GetReadOnlyContext ());
3430                                         return null;
3431                                 }
3432
3433                                 if (variable_info != null)
3434                                         variable_info.SetAssigned (ec);
3435                         }
3436
3437                         Expression e = Block.GetConstantExpression (Name);
3438                         if (e != null) {
3439                                 local_info.Used = true;
3440                                 eclass = ExprClass.Value;
3441                                 return e.Resolve (ec);
3442                         }
3443
3444                         if (!VerifyAssigned (ec))
3445                                 return null;
3446
3447                         if (lvalue_right_side == null)
3448                                 local_info.Used = true;
3449
3450                         if (ec.CurrentAnonymousMethod != null){
3451                                 //
3452                                 // If we are referencing a variable from the external block
3453                                 // flag it for capturing
3454                                 //
3455                                 if ((local_info.Block.Toplevel != ec.CurrentBlock.Toplevel) ||
3456                                     ec.CurrentAnonymousMethod.IsIterator)
3457                                 {
3458                                         if (local_info.AddressTaken){
3459                                                 AnonymousMethod.Error_AddressOfCapturedVar (local_info.Name, loc);
3460                                                 return null;
3461                                         }
3462                                         ec.CaptureVariable (local_info);
3463                                 }
3464                         }
3465
3466                         return this;
3467                 }
3468
3469                 public override Expression DoResolve (EmitContext ec)
3470                 {
3471                         return DoResolveBase (ec, null);
3472                 }
3473
3474                 override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
3475                 {
3476                         return DoResolveBase (ec, right_side);
3477                 }
3478
3479                 public bool VerifyFixed ()
3480                 {
3481                         // A local Variable is always fixed.
3482                         return true;
3483                 }
3484
3485                 public override int GetHashCode()
3486                 {
3487                         return Name.GetHashCode ();
3488                 }
3489
3490                 public override bool Equals (object obj)
3491                 {
3492                         LocalVariableReference lvr = obj as LocalVariableReference;
3493                         if (lvr == null)
3494                                 return false;
3495
3496                         return Name == lvr.Name && Block == lvr.Block;
3497                 }
3498
3499                 public override void Emit (EmitContext ec)
3500                 {
3501                         ILGenerator ig = ec.ig;
3502
3503                         if (local_info.FieldBuilder == null){
3504                                 //
3505                                 // A local variable on the local CLR stack
3506                                 //
3507                                 ig.Emit (OpCodes.Ldloc, local_info.LocalBuilder);
3508                         } else {
3509                                 //
3510                                 // A local variable captured by anonymous methods.
3511                                 //
3512                                 if (!prepared)
3513                                         ec.EmitCapturedVariableInstance (local_info);
3514
3515                                 ig.Emit (OpCodes.Ldfld, local_info.FieldBuilder);
3516                         }
3517                 }
3518
3519                 public void Emit (EmitContext ec, bool leave_copy)
3520                 {
3521                         Emit (ec);
3522                         if (leave_copy){
3523                                 ec.ig.Emit (OpCodes.Dup);
3524                                 if (local_info.FieldBuilder != null){
3525                                         temp = new LocalTemporary (ec, Type);
3526                                         temp.Store (ec);
3527                                 }
3528                         }
3529                 }
3530
3531                 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
3532                 {
3533                         ILGenerator ig = ec.ig;
3534                         prepared = prepare_for_load;
3535
3536                         if (local_info.FieldBuilder == null){
3537                                 //
3538                                 // A local variable on the local CLR stack
3539                                 //
3540                                 if (local_info.LocalBuilder == null)
3541                                         throw new Exception ("This should not happen: both Field and Local are null");
3542
3543                                 source.Emit (ec);
3544                                 if (leave_copy)
3545                                         ec.ig.Emit (OpCodes.Dup);
3546                                 ig.Emit (OpCodes.Stloc, local_info.LocalBuilder);
3547                         } else {
3548                                 //
3549                                 // A local variable captured by anonymous methods or itereators.
3550                                 //
3551                                 ec.EmitCapturedVariableInstance (local_info);
3552
3553                                 if (prepare_for_load)
3554                                         ig.Emit (OpCodes.Dup);
3555                                 source.Emit (ec);
3556                                 if (leave_copy){
3557                                         ig.Emit (OpCodes.Dup);
3558                                         temp = new LocalTemporary (ec, Type);
3559                                         temp.Store (ec);
3560                                 }
3561                                 ig.Emit (OpCodes.Stfld, local_info.FieldBuilder);
3562                                 if (temp != null)
3563                                         temp.Emit (ec);
3564                         }
3565                 }
3566
3567                 public void AddressOf (EmitContext ec, AddressOp mode)
3568                 {
3569                         ILGenerator ig = ec.ig;
3570
3571                         if (local_info.FieldBuilder == null){
3572                                 //
3573                                 // A local variable on the local CLR stack
3574                                 //
3575                                 ig.Emit (OpCodes.Ldloca, local_info.LocalBuilder);
3576                         } else {
3577                                 //
3578                                 // A local variable captured by anonymous methods or iterators
3579                                 //
3580                                 ec.EmitCapturedVariableInstance (local_info);
3581                                 ig.Emit (OpCodes.Ldflda, local_info.FieldBuilder);
3582                         }
3583                 }
3584
3585                 public override string ToString ()
3586                 {
3587                         return String.Format ("{0} ({1}:{2})", GetType (), Name, loc);
3588                 }
3589         }
3590
3591         /// <summary>
3592         ///   This represents a reference to a parameter in the intermediate
3593         ///   representation.
3594         /// </summary>
3595         public class ParameterReference : Expression, IAssignMethod, IMemoryLocation, IVariable {
3596                 Parameter par;
3597                 string name;
3598                 int idx;
3599                 Block block;
3600                 VariableInfo vi;
3601                 public bool is_ref, is_out, prepared;
3602
3603                 public bool IsOut {
3604                         get {
3605                                 return is_out;
3606                         }
3607                 }
3608
3609                 public bool IsRef {
3610                         get {
3611                                 return is_ref;
3612                         }
3613                 }
3614
3615                 LocalTemporary temp;
3616
3617                 public ParameterReference (Parameter par, Block block, int idx, Location loc)
3618                 {
3619                         this.par = par;
3620                         this.name = par.Name;
3621                         this.block = block;
3622                         this.idx  = idx;
3623                         this.loc = loc;
3624                         eclass = ExprClass.Variable;
3625                 }
3626
3627                 public VariableInfo VariableInfo {
3628                         get { return vi; }
3629                 }
3630
3631                 public bool VerifyFixed ()
3632                 {
3633                         // A parameter is fixed if it's a value parameter (i.e., no modifier like out, ref, param).
3634                         return par.ModFlags == Parameter.Modifier.NONE;
3635                 }
3636
3637                 public bool IsAssigned (EmitContext ec, Location loc)
3638                 {
3639                         if (!ec.DoFlowAnalysis || !is_out || ec.CurrentBranching.IsAssigned (vi))
3640                                 return true;
3641
3642                         Report.Error (269, loc,
3643                                       "Use of unassigned out parameter `{0}'", par.Name);
3644                         return false;
3645                 }
3646
3647                 public bool IsFieldAssigned (EmitContext ec, string field_name, Location loc)
3648                 {
3649                         if (!ec.DoFlowAnalysis || !is_out || ec.CurrentBranching.IsFieldAssigned (vi, field_name))
3650                                 return true;
3651
3652                         Report.Error (170, loc,
3653                                       "Use of possibly unassigned field `" + field_name + "'");
3654                         return false;
3655                 }
3656
3657                 public void SetAssigned (EmitContext ec)
3658                 {
3659                         if (is_out && ec.DoFlowAnalysis)
3660                                 ec.CurrentBranching.SetAssigned (vi);
3661                 }
3662
3663                 public void SetFieldAssigned (EmitContext ec, string field_name)
3664                 {
3665                         if (is_out && ec.DoFlowAnalysis)
3666                                 ec.CurrentBranching.SetFieldAssigned (vi, field_name);
3667                 }
3668
3669                 protected void DoResolveBase (EmitContext ec)
3670                 {
3671                         if (!par.Resolve (ec)) {
3672                                 //TODO:
3673                         }
3674
3675                         type = par.ParameterType;
3676                         Parameter.Modifier mod = par.ModFlags;
3677                         is_ref = (mod & Parameter.Modifier.ISBYREF) != 0;
3678                         is_out = (mod & Parameter.Modifier.OUT) == Parameter.Modifier.OUT;
3679                         eclass = ExprClass.Variable;
3680
3681                         if (is_out)
3682                                 vi = block.ParameterMap [idx];
3683
3684                         if (ec.CurrentAnonymousMethod != null){
3685                                 if (is_ref){
3686                                         Report.Error (1628, Location, "Cannot use ref or out parameter `{0}' inside an anonymous method block",
3687                                                 par.Name);
3688                                         return;
3689                                 }
3690
3691                                 //
3692                                 // If we are referencing the parameter from the external block
3693                                 // flag it for capturing
3694                                 //
3695                                 //Console.WriteLine ("Is parameter `{0}' local? {1}", name, block.IsLocalParameter (name));
3696                                 if (!block.Toplevel.IsLocalParameter (name)){
3697                                         ec.CaptureParameter (name, type, idx);
3698                                 }
3699                         }
3700                 }
3701
3702                 public override int GetHashCode()
3703                 {
3704                         return name.GetHashCode ();
3705                 }
3706
3707                 public override bool Equals (object obj)
3708                 {
3709                         ParameterReference pr = obj as ParameterReference;
3710                         if (pr == null)
3711                                 return false;
3712
3713                         return name == pr.name && block == pr.block;
3714                 }
3715
3716                 //
3717                 // Notice that for ref/out parameters, the type exposed is not the
3718                 // same type exposed externally.
3719                 //
3720                 // for "ref int a":
3721                 //   externally we expose "int&"
3722                 //   here we expose       "int".
3723                 //
3724                 // We record this in "is_ref".  This means that the type system can treat
3725                 // the type as it is expected, but when we generate the code, we generate
3726                 // the alternate kind of code.
3727                 //
3728                 public override Expression DoResolve (EmitContext ec)
3729                 {
3730                         DoResolveBase (ec);
3731
3732                         if (is_out && ec.DoFlowAnalysis && (!ec.OmitStructFlowAnalysis || !vi.TypeInfo.IsStruct) && !IsAssigned (ec, loc))
3733                                 return null;
3734
3735                         return this;
3736                 }
3737
3738                 override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
3739                 {
3740                         DoResolveBase (ec);
3741
3742                         SetAssigned (ec);
3743
3744                         return this;
3745                 }
3746
3747                 static public void EmitLdArg (ILGenerator ig, int x)
3748                 {
3749                         if (x <= 255){
3750                                 switch (x){
3751                                 case 0: ig.Emit (OpCodes.Ldarg_0); break;
3752                                 case 1: ig.Emit (OpCodes.Ldarg_1); break;
3753                                 case 2: ig.Emit (OpCodes.Ldarg_2); break;
3754                                 case 3: ig.Emit (OpCodes.Ldarg_3); break;
3755                                 default: ig.Emit (OpCodes.Ldarg_S, (byte) x); break;
3756                                 }
3757                         } else
3758                                 ig.Emit (OpCodes.Ldarg, x);
3759                 }
3760
3761                 //
3762                 // This method is used by parameters that are references, that are
3763                 // being passed as references:  we only want to pass the pointer (that
3764                 // is already stored in the parameter, not the address of the pointer,
3765                 // and not the value of the variable).
3766                 //
3767                 public void EmitLoad (EmitContext ec)
3768                 {
3769                         ILGenerator ig = ec.ig;
3770                         int arg_idx = idx;
3771
3772                         if (!ec.MethodIsStatic)
3773                                 arg_idx++;
3774
3775                         EmitLdArg (ig, arg_idx);
3776
3777                         //
3778                         // FIXME: Review for anonymous methods
3779                         //
3780                 }
3781
3782                 public override void Emit (EmitContext ec)
3783                 {
3784                         Emit (ec, false);
3785                 }
3786
3787                 public void Emit (EmitContext ec, bool leave_copy)
3788                 {
3789                         ILGenerator ig = ec.ig;
3790                         int arg_idx = idx;
3791
3792                         if (ec.HaveCaptureInfo && ec.IsParameterCaptured (name)){
3793                                 ec.EmitParameter (name, leave_copy, prepared, ref temp);
3794                                 return;
3795                         }
3796
3797                         if (!ec.MethodIsStatic)
3798                                 arg_idx++;
3799
3800                         EmitLdArg (ig, arg_idx);
3801
3802                         if (is_ref) {
3803                                 if (prepared)
3804                                         ec.ig.Emit (OpCodes.Dup);
3805
3806                                 //
3807                                 // If we are a reference, we loaded on the stack a pointer
3808                                 // Now lets load the real value
3809                                 //
3810                                 LoadFromPtr (ig, type);
3811                         }
3812
3813                         if (leave_copy) {
3814                                 ec.ig.Emit (OpCodes.Dup);
3815
3816                                 if (is_ref) {
3817                                         temp = new LocalTemporary (ec, type);
3818                                         temp.Store (ec);
3819                                 }
3820                         }
3821                 }
3822
3823                 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
3824                 {
3825                         prepared = prepare_for_load;
3826                         if (ec.HaveCaptureInfo && ec.IsParameterCaptured (name)){
3827                                 ec.EmitAssignParameter (name, source, leave_copy, prepare_for_load, ref temp);
3828                                 return;
3829                         }
3830
3831                         ILGenerator ig = ec.ig;
3832                         int arg_idx = idx;
3833
3834
3835
3836                         if (!ec.MethodIsStatic)
3837                                 arg_idx++;
3838
3839                         if (is_ref && !prepared)
3840                                 EmitLdArg (ig, arg_idx);
3841
3842                         source.Emit (ec);
3843
3844                         if (leave_copy)
3845                                 ec.ig.Emit (OpCodes.Dup);
3846
3847                         if (is_ref) {
3848                                 if (leave_copy) {
3849                                         temp = new LocalTemporary (ec, type);
3850                                         temp.Store (ec);
3851                                 }
3852
3853                                 StoreFromPtr (ig, type);
3854
3855                                 if (temp != null)
3856                                         temp.Emit (ec);
3857                         } else {
3858                                 if (arg_idx <= 255)
3859                                         ig.Emit (OpCodes.Starg_S, (byte) arg_idx);
3860                                 else
3861                                         ig.Emit (OpCodes.Starg, arg_idx);
3862                         }
3863                 }
3864
3865                 public void AddressOf (EmitContext ec, AddressOp mode)
3866                 {
3867                         if (ec.HaveCaptureInfo && ec.IsParameterCaptured (name)){
3868                                 ec.EmitAddressOfParameter (name);
3869                                 return;
3870                         }
3871
3872                         int arg_idx = idx;
3873
3874                         if (!ec.MethodIsStatic)
3875                                 arg_idx++;
3876
3877                         if (is_ref){
3878                                 if (arg_idx <= 255)
3879                                         ec.ig.Emit (OpCodes.Ldarg_S, (byte) arg_idx);
3880                                 else
3881                                         ec.ig.Emit (OpCodes.Ldarg, arg_idx);
3882                         } else {
3883                                 if (arg_idx <= 255)
3884                                         ec.ig.Emit (OpCodes.Ldarga_S, (byte) arg_idx);
3885                                 else
3886                                         ec.ig.Emit (OpCodes.Ldarga, arg_idx);
3887                         }
3888                 }
3889
3890                 public override string ToString ()
3891                 {
3892                         return "ParameterReference[" + name + "]";
3893                 }
3894         }
3895
3896         /// <summary>
3897         ///   Used for arguments to New(), Invocation()
3898         /// </summary>
3899         public class Argument {
3900                 public enum AType : byte {
3901                         Expression,
3902                         Ref,
3903                         Out,
3904                         ArgList
3905                 };
3906
3907                 public readonly AType ArgType;
3908                 public Expression Expr;
3909
3910                 public Argument (Expression expr, AType type)
3911                 {
3912                         this.Expr = expr;
3913                         this.ArgType = type;
3914                 }
3915
3916                 public Argument (Expression expr)
3917                 {
3918                         this.Expr = expr;
3919                         this.ArgType = AType.Expression;
3920                 }
3921
3922                 public Type Type {
3923                         get {
3924                                 if (ArgType == AType.Ref || ArgType == AType.Out)
3925                                         return TypeManager.GetReferenceType (Expr.Type);
3926                                 else
3927                                         return Expr.Type;
3928                         }
3929                 }
3930
3931                 public Parameter.Modifier Modifier
3932                 {
3933                         get {
3934                                 switch (ArgType) {
3935                                         case AType.Out:
3936                                                 return Parameter.Modifier.OUT;
3937
3938                                         case AType.Ref:
3939                                                 return Parameter.Modifier.REF;
3940
3941                                         default:
3942                                                 return Parameter.Modifier.NONE;
3943                                 }
3944                         }
3945                 }
3946
3947                 public static string FullDesc (Argument a)
3948                 {
3949                         if (a.ArgType == AType.ArgList)
3950                                 return "__arglist";
3951
3952                         return (a.ArgType == AType.Ref ? "ref " :
3953                                 (a.ArgType == AType.Out ? "out " : "")) +
3954                                 TypeManager.CSharpName (a.Expr.Type);
3955                 }
3956
3957                 public bool ResolveMethodGroup (EmitContext ec, Location loc)
3958                 {
3959                         // FIXME: csc doesn't report any error if you try to use `ref' or
3960                         //        `out' in a delegate creation expression.
3961                         Expr = Expr.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
3962                         if (Expr == null)
3963                                 return false;
3964
3965                         return true;
3966                 }
3967
3968                 void Error_LValueRequired (Location loc)
3969                 {
3970                         Report.Error (1510, loc, "A ref or out argument must be an assignable variable");
3971                 }
3972
3973                 public bool Resolve (EmitContext ec, Location loc)
3974                 {
3975                         bool old_do_flow_analysis = ec.DoFlowAnalysis;
3976                         ec.DoFlowAnalysis = true;
3977
3978                         if (ArgType == AType.Ref) {
3979                                 ec.InRefOutArgumentResolving = true;
3980                                 Expr = Expr.Resolve (ec);
3981                                 ec.InRefOutArgumentResolving = false;
3982                                 if (Expr == null) {
3983                                         ec.DoFlowAnalysis = old_do_flow_analysis;
3984                                         return false;
3985                                 }
3986
3987                                 Expr = Expr.DoResolveLValue (ec, Expr);
3988                                 if (Expr == null)
3989                                         Error_LValueRequired (loc);
3990                         } else if (ArgType == AType.Out) {
3991                                 ec.InRefOutArgumentResolving = true;
3992                                 Expr = Expr.DoResolveLValue (ec, EmptyExpression.Null);
3993                                 ec.InRefOutArgumentResolving = false;
3994
3995                                 if (Expr == null)
3996                                         Error_LValueRequired (loc);
3997                         }
3998                         else
3999                                 Expr = Expr.Resolve (ec);
4000
4001                         ec.DoFlowAnalysis = old_do_flow_analysis;
4002
4003                         if (Expr == null)
4004                                 return false;
4005
4006                         if (ArgType == AType.Expression)
4007                                 return true;
4008                         else {
4009                                 //
4010                                 // Catch errors where fields of a MarshalByRefObject are passed as ref or out
4011                                 // This is only allowed for `this'
4012                                 //
4013                                 FieldExpr fe = Expr as FieldExpr;
4014                                 if (fe != null && !fe.IsStatic){
4015                                         Expression instance = fe.InstanceExpression;
4016
4017                                         if (instance.GetType () != typeof (This)){
4018                                                 if (fe.InstanceExpression.Type.IsSubclassOf (TypeManager.mbr_type)){
4019                                                         Report.SymbolRelatedToPreviousError (fe.InstanceExpression.Type);
4020                                                         Report.Warning (197, 1, loc,
4021                                                                 "Passing `{0}' as ref or out or taking its address may cause a runtime exception because it is a field of a marshal-by-reference class",
4022                                                                 fe.GetSignatureForError ());
4023                                                         return false;
4024                                                 }
4025                                         }
4026                                 }
4027                         }
4028
4029                         if (Expr.eclass != ExprClass.Variable){
4030                                 //
4031                                 // We just probe to match the CSC output
4032                                 //
4033                                 if (Expr.eclass == ExprClass.PropertyAccess ||
4034                                     Expr.eclass == ExprClass.IndexerAccess){
4035                                         Report.Error (206, loc, "A property or indexer `{0}' may not be passed as an out or ref parameter",
4036                                                 Expr.GetSignatureForError ());
4037                                 } else {
4038                                         Error_LValueRequired (loc);
4039                                 }
4040                                 return false;
4041                         }
4042
4043                         return true;
4044                 }
4045
4046                 public void Emit (EmitContext ec)
4047                 {
4048                         //
4049                         // Ref and Out parameters need to have their addresses taken.
4050                         //
4051                         // ParameterReferences might already be references, so we want
4052                         // to pass just the value
4053                         //
4054                         if (ArgType == AType.Ref || ArgType == AType.Out){
4055                                 AddressOp mode = AddressOp.Store;
4056
4057                                 if (ArgType == AType.Ref)
4058                                         mode |= AddressOp.Load;
4059
4060                                 if (Expr is ParameterReference){
4061                                         ParameterReference pr = (ParameterReference) Expr;
4062
4063                                         if (pr.IsRef)
4064                                                 pr.EmitLoad (ec);
4065                                         else {
4066
4067                                                 pr.AddressOf (ec, mode);
4068                                         }
4069                                 } else {
4070                                         if (Expr is IMemoryLocation)
4071                                                ((IMemoryLocation) Expr).AddressOf (ec, mode);
4072                                         else {
4073                                                 Error_LValueRequired (Expr.Location);
4074                                                 return;
4075                                         }
4076                                 }
4077                         } else
4078                                 Expr.Emit (ec);
4079                 }
4080         }
4081
4082         /// <summary>
4083         ///   Invocation of methods or delegates.
4084         /// </summary>
4085         public class Invocation : ExpressionStatement {
4086                 public readonly ArrayList Arguments;
4087
4088                 Expression expr;
4089                 MethodBase method = null;
4090
4091                 //
4092                 // arguments is an ArrayList, but we do not want to typecast,
4093                 // as it might be null.
4094                 //
4095                 // FIXME: only allow expr to be a method invocation or a
4096                 // delegate invocation (7.5.5)
4097                 //
4098                 public Invocation (Expression expr, ArrayList arguments)
4099                 {
4100                         this.expr = expr;
4101                         Arguments = arguments;
4102                         loc = expr.Location;
4103                 }
4104
4105                 public Expression Expr {
4106                         get {
4107                                 return expr;
4108                         }
4109                 }
4110
4111                 /// <summary>
4112                 ///   Determines "better conversion" as specified in 14.4.2.3
4113                 ///
4114                 ///    Returns : p    if a->p is better,
4115                 ///              q    if a->q is better,
4116                 ///              null if neither is better
4117                 /// </summary>
4118                 static Type BetterConversion (EmitContext ec, Argument a, Type p, Type q, Location loc)
4119                 {
4120                         Type argument_type = a.Type;
4121                         Expression argument_expr = a.Expr;
4122
4123                         if (argument_type == null)
4124                                 throw new Exception ("Expression of type " + a.Expr +
4125                                                      " does not resolve its type");
4126
4127                         if (p == null || q == null)
4128                                 throw new InternalErrorException ("BetterConversion Got a null conversion");
4129
4130                         if (p == q)
4131                                 return null;
4132
4133                         if (argument_expr is NullLiteral) {
4134                                 //
4135                                 // If the argument is null and one of the types to compare is 'object' and
4136                                 // the other is a reference type, we prefer the other.
4137                                 //
4138                                 // This follows from the usual rules:
4139                                 //   * There is an implicit conversion from 'null' to type 'object'
4140                                 //   * There is an implicit conversion from 'null' to any reference type
4141                                 //   * There is an implicit conversion from any reference type to type 'object'
4142                                 //   * There is no implicit conversion from type 'object' to other reference types
4143                                 //  => Conversion of 'null' to a reference type is better than conversion to 'object'
4144                                 //
4145                                 //  FIXME: This probably isn't necessary, since the type of a NullLiteral is the
4146                                 //         null type. I think it used to be 'object' and thus needed a special
4147                                 //         case to avoid the immediately following two checks.
4148                                 //
4149                                 if (!p.IsValueType && q == TypeManager.object_type)
4150                                         return p;
4151                                 if (!q.IsValueType && p == TypeManager.object_type)
4152                                         return q;
4153                         }
4154
4155                         if (argument_type == p)
4156                                 return p;
4157
4158                         if (argument_type == q)
4159                                 return q;
4160
4161                         Expression p_tmp = new EmptyExpression (p);
4162                         Expression q_tmp = new EmptyExpression (q);
4163
4164                         bool p_to_q = Convert.ImplicitConversionExists (ec, p_tmp, q);
4165                         bool q_to_p = Convert.ImplicitConversionExists (ec, q_tmp, p);
4166
4167                         if (p_to_q && !q_to_p)
4168                                 return p;
4169
4170                         if (q_to_p && !p_to_q)
4171                                 return q;
4172
4173                         if (p == TypeManager.sbyte_type)
4174                                 if (q == TypeManager.byte_type || q == TypeManager.ushort_type ||
4175                                     q == TypeManager.uint32_type || q == TypeManager.uint64_type)
4176                                         return p;
4177                         if (q == TypeManager.sbyte_type)
4178                                 if (p == TypeManager.byte_type || p == TypeManager.ushort_type ||
4179                                     p == TypeManager.uint32_type || p == TypeManager.uint64_type)
4180                                         return q;
4181
4182                         if (p == TypeManager.short_type)
4183                                 if (q == TypeManager.ushort_type || q == TypeManager.uint32_type ||
4184                                     q == TypeManager.uint64_type)
4185                                         return p;
4186                         if (q == TypeManager.short_type)
4187                                 if (p == TypeManager.ushort_type || p == TypeManager.uint32_type ||
4188                                     p == TypeManager.uint64_type)
4189                                         return q;
4190
4191                         if (p == TypeManager.int32_type)
4192                                 if (q == TypeManager.uint32_type || q == TypeManager.uint64_type)
4193                                         return p;
4194                         if (q == TypeManager.int32_type)
4195                                 if (p == TypeManager.uint32_type || p == TypeManager.uint64_type)
4196                                         return q;
4197
4198                         if (p == TypeManager.int64_type)
4199                                 if (q == TypeManager.uint64_type)
4200                                         return p;
4201                         if (q == TypeManager.int64_type)
4202                                 if (p == TypeManager.uint64_type)
4203                                         return q;
4204
4205                         return null;
4206                 }
4207
4208                 /// <summary>
4209                 ///   Determines "Better function" between candidate
4210                 ///   and the current best match
4211                 /// </summary>
4212                 /// <remarks>
4213                 ///    Returns an integer indicating :
4214                 ///     false if candidate ain't better
4215                 ///     true if candidate is better than the current best match
4216                 /// </remarks>
4217                 static bool BetterFunction (EmitContext ec, ArrayList args, int argument_count,
4218                                             MethodBase candidate, bool candidate_params,
4219                                             MethodBase best, bool best_params, Location loc)
4220                 {
4221                         ParameterData candidate_pd = TypeManager.GetParameterData (candidate);
4222                         ParameterData best_pd = TypeManager.GetParameterData (best);
4223
4224                         bool better_at_least_one = false;
4225                         bool same = true;
4226                         for (int j = 0; j < argument_count; ++j) {
4227                                 Argument a = (Argument) args [j];
4228
4229                                 Type ct = TypeManager.TypeToCoreType (candidate_pd.ParameterType (j));
4230                                 Type bt = TypeManager.TypeToCoreType (best_pd.ParameterType (j));
4231
4232                                 if (candidate_pd.ParameterModifier (j) == Parameter.Modifier.PARAMS)
4233                                         if (candidate_params)
4234                                                 ct = TypeManager.GetElementType (ct);
4235
4236                                 if (best_pd.ParameterModifier (j) == Parameter.Modifier.PARAMS)
4237                                         if (best_params)
4238                                                 bt = TypeManager.GetElementType (bt);
4239
4240                                 if (ct == bt)
4241                                         continue;
4242
4243                                 same = false;
4244                                 Type better = BetterConversion (ec, a, ct, bt, loc);
4245
4246                                 // for each argument, the conversion to 'ct' should be no worse than
4247                                 // the conversion to 'bt'.
4248                                 if (better == bt)
4249                                         return false;
4250
4251                                 // for at least one argument, the conversion to 'ct' should be better than
4252                                 // the conversion to 'bt'.
4253                                 if (better == ct)
4254                                         better_at_least_one = true;
4255                         }
4256
4257                         if (better_at_least_one)
4258                                 return true;
4259
4260                         //
4261                         // This handles the case
4262                         //
4263                         //   Add (float f1, float f2, float f3);
4264                         //   Add (params decimal [] foo);
4265                         //
4266                         // The call Add (3, 4, 5) should be ambiguous.  Without this check, the
4267                         // first candidate would've chosen as better.
4268                         //
4269                         if (!same)
4270                                 return false;
4271
4272                         //
4273                         // This handles the following cases:
4274                         //
4275                         //   Trim () is better than Trim (params char[] chars)
4276                         //   Concat (string s1, string s2, string s3) is better than
4277                         //     Concat (string s1, params string [] srest)
4278                         //
4279                         return !candidate_params && best_params;
4280                 }
4281
4282                 internal static bool IsOverride (MethodBase cand_method, MethodBase base_method)
4283                 {
4284                         if (!IsAncestralType (base_method.DeclaringType, cand_method.DeclaringType))
4285                                 return false;
4286
4287                         ParameterData cand_pd = TypeManager.GetParameterData (cand_method);
4288                         ParameterData base_pd = TypeManager.GetParameterData (base_method);
4289
4290                         if (cand_pd.Count != base_pd.Count)
4291                                 return false;
4292
4293                         for (int j = 0; j < cand_pd.Count; ++j) {
4294                                 Parameter.Modifier cm = cand_pd.ParameterModifier (j);
4295                                 Parameter.Modifier bm = base_pd.ParameterModifier (j);
4296                                 Type ct = TypeManager.TypeToCoreType (cand_pd.ParameterType (j));
4297                                 Type bt = TypeManager.TypeToCoreType (base_pd.ParameterType (j));
4298
4299                                 if (cm != bm || ct != bt)
4300                                         return false;
4301                         }
4302
4303                         return true;
4304                 }
4305
4306                 public static string FullMethodDesc (MethodBase mb)
4307                 {
4308                         if (mb == null)
4309                                 return "";
4310
4311                         StringBuilder sb;
4312                         if (mb is MethodInfo) {
4313                                 sb = new StringBuilder (TypeManager.CSharpName (((MethodInfo) mb).ReturnType));
4314                                 sb.Append (" ");
4315                         }
4316                         else
4317                                 sb = new StringBuilder ();
4318
4319                         sb.Append (TypeManager.CSharpSignature (mb));
4320                         return sb.ToString ();
4321                 }
4322
4323                 public static MethodGroupExpr MakeUnionSet (Expression mg1, Expression mg2, Location loc)
4324                 {
4325                         MemberInfo [] miset;
4326                         MethodGroupExpr union;
4327
4328                         if (mg1 == null) {
4329                                 if (mg2 == null)
4330                                         return null;
4331                                 return (MethodGroupExpr) mg2;
4332                         } else {
4333                                 if (mg2 == null)
4334                                         return (MethodGroupExpr) mg1;
4335                         }
4336
4337                         MethodGroupExpr left_set = null, right_set = null;
4338                         int length1 = 0, length2 = 0;
4339
4340                         left_set = (MethodGroupExpr) mg1;
4341                         length1 = left_set.Methods.Length;
4342
4343                         right_set = (MethodGroupExpr) mg2;
4344                         length2 = right_set.Methods.Length;
4345
4346                         ArrayList common = new ArrayList ();
4347
4348                         foreach (MethodBase r in right_set.Methods){
4349                                 if (TypeManager.ArrayContainsMethod (left_set.Methods, r))
4350                                         common.Add (r);
4351                         }
4352
4353                         miset = new MemberInfo [length1 + length2 - common.Count];
4354                         left_set.Methods.CopyTo (miset, 0);
4355
4356                         int k = length1;
4357
4358                         foreach (MethodBase r in right_set.Methods) {
4359                                 if (!common.Contains (r))
4360                                         miset [k++] = r;
4361                         }
4362
4363                         union = new MethodGroupExpr (miset, loc);
4364
4365                         return union;
4366                 }
4367
4368                 public static bool IsParamsMethodApplicable (EmitContext ec,
4369                                                              ArrayList arguments, int arg_count,
4370                                                              MethodBase candidate)
4371                 {
4372                         return IsParamsMethodApplicable (
4373                                 ec, arguments, arg_count, candidate, false) ||
4374                                 IsParamsMethodApplicable (
4375                                         ec, arguments, arg_count, candidate, true);
4376
4377
4378                 }
4379
4380                 /// <summary>
4381                 ///   Determines if the candidate method, if a params method, is applicable
4382                 ///   in its expanded form to the given set of arguments
4383                 /// </summary>
4384                 static bool IsParamsMethodApplicable (EmitContext ec, ArrayList arguments,
4385                                                       int arg_count, MethodBase candidate,
4386                                                       bool do_varargs)
4387                 {
4388                         ParameterData pd = TypeManager.GetParameterData (candidate);
4389
4390                         int pd_count = pd.Count;
4391                         if (pd_count == 0)
4392                                 return false;
4393
4394                         int count = pd_count - 1;
4395                         if (do_varargs) {
4396                                 if (pd.ParameterModifier (count) != Parameter.Modifier.ARGLIST)
4397                                         return false;
4398                                 if (pd_count != arg_count)
4399                                         return false;
4400                         } else {
4401                                 if (!pd.HasParams)
4402                                         return false;
4403                         }
4404
4405                         if (count > arg_count)
4406                                 return false;
4407
4408                         if (pd_count == 1 && arg_count == 0)
4409                                 return true;
4410
4411                         //
4412                         // If we have come this far, the case which
4413                         // remains is when the number of parameters is
4414                         // less than or equal to the argument count.
4415                         //
4416                         for (int i = 0; i < count; ++i) {
4417
4418                                 Argument a = (Argument) arguments [i];
4419
4420                                 Parameter.Modifier a_mod = a.Modifier &
4421                                         (unchecked (~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK)));
4422                                 Parameter.Modifier p_mod = pd.ParameterModifier (i) &
4423                                         (unchecked (~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK)));
4424
4425                                 if (a_mod == p_mod) {
4426
4427                                         if (a_mod == Parameter.Modifier.NONE)
4428                                                 if (!Convert.ImplicitConversionExists (ec,
4429                                                                                        a.Expr,
4430                                                                                        pd.ParameterType (i)))
4431                                 return false;
4432
4433                                         if ((a_mod & Parameter.Modifier.ISBYREF) != 0) {
4434                                                 Type pt = pd.ParameterType (i);
4435
4436                                                 if (!pt.IsByRef)
4437                                                         pt = TypeManager.GetReferenceType (pt);
4438
4439                                                 if (pt != a.Type)
4440                                                         return false;
4441                                         }
4442                                 } else
4443                                         return false;
4444
4445                         }
4446
4447                         if (do_varargs) {
4448                                 Argument a = (Argument) arguments [count];
4449                                 if (!(a.Expr is Arglist))
4450                                         return false;
4451
4452                                 return true;
4453                         }
4454
4455                         Type element_type = TypeManager.GetElementType (pd.ParameterType (pd_count - 1));
4456
4457                         for (int i = pd_count - 1; i < arg_count; i++) {
4458                                 Argument a = (Argument) arguments [i];
4459
4460                                 if (!Convert.ImplicitConversionExists (ec, a.Expr, element_type))
4461                                         return false;
4462                         }
4463
4464                         return true;
4465                 }
4466
4467                 /// <summary>
4468                 ///   Determines if the candidate method is applicable (section 14.4.2.1)
4469                 ///   to the given set of arguments
4470                 /// </summary>
4471                 public static bool IsApplicable (EmitContext ec, ArrayList arguments, int arg_count,
4472                         MethodBase candidate)
4473                 {
4474                         ParameterData pd = TypeManager.GetParameterData (candidate);
4475
4476                         if (arg_count != pd.Count)
4477                                 return false;
4478
4479                         for (int i = arg_count; i > 0; ) {
4480                                 i--;
4481
4482                                 Argument a = (Argument) arguments [i];
4483
4484                                 Parameter.Modifier a_mod = a.Modifier &
4485                                         ~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK);
4486
4487                                 Parameter.Modifier p_mod = pd.ParameterModifier (i) &
4488                                         ~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK | Parameter.Modifier.PARAMS);
4489
4490                                 if (a_mod == p_mod) {
4491                                         Type pt = pd.ParameterType (i);
4492
4493                                         if (a_mod == Parameter.Modifier.NONE) {
4494                                                 if (!Convert.ImplicitConversionExists (ec, a.Expr, pt))
4495                                                         return false;
4496                                                 continue;
4497                                         }
4498
4499                                         if (pt != a.Type)
4500                                                 return false;
4501                                 } else
4502                                         return false;
4503                         }
4504
4505                         return true;
4506                 }
4507
4508                 static internal bool IsAncestralType (Type first_type, Type second_type)
4509                 {
4510                         return first_type != second_type &&
4511                                 (second_type.IsSubclassOf (first_type) ||
4512                                  TypeManager.ImplementsInterface (second_type, first_type));
4513                 }
4514
4515                 /// <summary>
4516                 ///   Find the Applicable Function Members (7.4.2.1)
4517                 ///
4518                 ///   me: Method Group expression with the members to select.
4519                 ///       it might contain constructors or methods (or anything
4520                 ///       that maps to a method).
4521                 ///
4522                 ///   Arguments: ArrayList containing resolved Argument objects.
4523                 ///
4524                 ///   loc: The location if we want an error to be reported, or a Null
4525                 ///        location for "probing" purposes.
4526                 ///
4527                 ///   Returns: The MethodBase (either a ConstructorInfo or a MethodInfo)
4528                 ///            that is the best match of me on Arguments.
4529                 ///
4530                 /// </summary>
4531                 public static MethodBase OverloadResolve (EmitContext ec, MethodGroupExpr me,
4532                                                           ArrayList Arguments, bool may_fail,
4533                                                           Location loc)
4534                 {
4535                         MethodBase method = null;
4536                         bool method_params = false;
4537                         Type applicable_type = null;
4538                         int arg_count = 0;
4539                         ArrayList candidates = new ArrayList (2);
4540                         ArrayList candidate_overrides = null;
4541
4542                         //
4543                         // Used to keep a map between the candidate
4544                         // and whether it is being considered in its
4545                         // normal or expanded form
4546                         //
4547                         // false is normal form, true is expanded form
4548                         //
4549                         Hashtable candidate_to_form = null;
4550
4551                         if (Arguments != null)
4552                                 arg_count = Arguments.Count;
4553
4554                         if ((me.Name == "Invoke") &&
4555                                 TypeManager.IsDelegateType (me.DeclaringType)) {
4556                                 Error_InvokeOnDelegate (loc);
4557                                 return null;
4558                         }
4559
4560                         MethodBase[] methods = me.Methods;
4561
4562                         //
4563                         // First we construct the set of applicable methods
4564                         //
4565                         bool is_sorted = true;
4566                         for (int i = 0; i < methods.Length; i++){
4567                                 Type decl_type = methods [i].DeclaringType;
4568
4569                                 //
4570                                 // If we have already found an applicable method
4571                                 // we eliminate all base types (Section 14.5.5.1)
4572                                 //
4573                                 if ((applicable_type != null) &&
4574                                         IsAncestralType (decl_type, applicable_type))
4575                                         continue;
4576
4577                                 //
4578                                 // Methods marked 'override' don't take part in 'applicable_type'
4579                                 // computation, nor in the actual overload resolution.
4580                                 // However, they still need to be emitted instead of a base virtual method.
4581                                 // We avoid doing the 'applicable' test here, since it'll anyway be applied
4582                                 // to the base virtual function, and IsOverride is much faster than IsApplicable.
4583                                 //
4584                                 if (!me.IsBase && TypeManager.IsOverride (methods [i])) {
4585                                         if (candidate_overrides == null)
4586                                                 candidate_overrides = new ArrayList ();
4587                                         candidate_overrides.Add (methods [i]);
4588                                         continue;
4589                                 }
4590
4591                                 //
4592                                 // Check if candidate is applicable (section 14.4.2.1)
4593                                 //   Is candidate applicable in normal form?
4594                                 //
4595                                 bool is_applicable = IsApplicable (
4596                                         ec, Arguments, arg_count, methods [i]);
4597
4598                                 if (!is_applicable &&
4599                                         (IsParamsMethodApplicable (
4600                                         ec, Arguments, arg_count, methods [i]))) {
4601                                         MethodBase candidate = methods [i];
4602                                         if (candidate_to_form == null)
4603                                                 candidate_to_form = new PtrHashtable ();
4604                                         candidate_to_form [candidate] = candidate;
4605                                         // Candidate is applicable in expanded form
4606                                         is_applicable = true;
4607                                 }
4608
4609                                 if (!is_applicable)
4610                                         continue;
4611
4612                                 candidates.Add (methods [i]);
4613
4614                                 if (applicable_type == null)
4615                                         applicable_type = decl_type;
4616                                 else if (applicable_type != decl_type) {
4617                                         is_sorted = false;
4618                                         if (IsAncestralType (applicable_type, decl_type))
4619                                                 applicable_type = decl_type;
4620                                 }
4621                         }
4622
4623                         int candidate_top = candidates.Count;
4624
4625                         if (applicable_type == null) {
4626                                 //
4627                                 // Okay so we have failed to find anything so we
4628                                 // return by providing info about the closest match
4629                                 //
4630                                 int errors = Report.Errors;
4631                                 for (int i = 0; i < methods.Length; ++i) {
4632                                         MethodBase c = (MethodBase) methods [i];
4633                                         ParameterData pd = TypeManager.GetParameterData (c);
4634
4635                                         if (pd.Count != arg_count)
4636                                                 continue;
4637
4638                                         VerifyArgumentsCompat (ec, Arguments, arg_count,
4639                                                 c, false, null, may_fail, loc);
4640
4641                                         if (!may_fail && errors == Report.Errors)
4642                                                 throw new InternalErrorException (
4643                                                         "VerifyArgumentsCompat and IsApplicable do not agree; " +
4644                                                         "likely reason: ImplicitConversion and ImplicitConversionExists have gone out of sync");
4645
4646                                         break;
4647                                 }
4648
4649                                 if (!may_fail && errors == Report.Errors) {
4650                                         string report_name = me.Name;
4651                                         if (report_name == ".ctor")
4652                                                 report_name = me.DeclaringType.ToString ();
4653                                         Error_WrongNumArguments (loc, report_name, arg_count);
4654                                 }
4655
4656                                 return null;
4657                         }
4658
4659                         if (!is_sorted) {
4660                                 //
4661                                 // At this point, applicable_type is _one_ of the most derived types
4662                                 // in the set of types containing the methods in this MethodGroup.
4663                                 // Filter the candidates so that they only contain methods from the
4664                                 // most derived types.
4665                                 //
4666
4667                                 int finalized = 0; // Number of finalized candidates
4668
4669                                 do {
4670                                         // Invariant: applicable_type is a most derived type
4671
4672                                         // We'll try to complete Section 14.5.5.1 for 'applicable_type' by
4673                                         // eliminating all it's base types.  At the same time, we'll also move
4674                                         // every unrelated type to the end of the array, and pick the next
4675                                         // 'applicable_type'.
4676
4677                                         Type next_applicable_type = null;
4678                                         int j = finalized; // where to put the next finalized candidate
4679                                         int k = finalized; // where to put the next undiscarded candidate
4680                                         for (int i = finalized; i < candidate_top; ++i) {
4681                                                 MethodBase candidate = (MethodBase) candidates [i];
4682                                                 Type decl_type = candidate.DeclaringType;
4683
4684                                                 if (decl_type == applicable_type) {
4685                                                         candidates [k++] = candidates [j];
4686                                                         candidates [j++] = candidates [i];
4687                                                         continue;
4688                                                 }
4689
4690                                                 if (IsAncestralType (decl_type, applicable_type))
4691                                                         continue;
4692
4693                                                 if (next_applicable_type != null &&
4694                                                     IsAncestralType (decl_type, next_applicable_type))
4695                                                         continue;
4696
4697                                                 candidates [k++] = candidates [i];
4698
4699                                                 if (next_applicable_type == null ||
4700                                                     IsAncestralType (next_applicable_type, decl_type))
4701                                                         next_applicable_type = decl_type;
4702                                         }
4703
4704                                         applicable_type = next_applicable_type;
4705                                         finalized = j;
4706                                         candidate_top = k;
4707                                 } while (applicable_type != null);
4708                         }
4709
4710                         //
4711                         // Now we actually find the best method
4712                         //
4713
4714                         method = (MethodBase) candidates [0];
4715                         method_params = candidate_to_form != null && candidate_to_form.Contains (method);
4716                         for (int ix = 1; ix < candidate_top; ix++){
4717                                 MethodBase candidate = (MethodBase) candidates [ix];
4718
4719                                 if (candidate == method)
4720                                         continue;
4721
4722                                 bool cand_params = candidate_to_form != null && candidate_to_form.Contains (candidate);
4723
4724                                 if (BetterFunction (ec, Arguments, arg_count,
4725                                                     candidate, cand_params,
4726                                                     method, method_params, loc)) {
4727                                         method = candidate;
4728                                         method_params = cand_params;
4729                                 }
4730                         }
4731                         //
4732                         // Now check that there are no ambiguities i.e the selected method
4733                         // should be better than all the others
4734                         //
4735                         MethodBase ambiguous = null;
4736                         for (int ix = 0; ix < candidate_top; ix++){
4737                                 MethodBase candidate = (MethodBase) candidates [ix];
4738
4739                                 if (candidate == method)
4740                                         continue;
4741
4742                                 bool cand_params = candidate_to_form != null && candidate_to_form.Contains (candidate);
4743                                 if (!BetterFunction (ec, Arguments, arg_count,
4744                                                      method, method_params,
4745                                                      candidate, cand_params,
4746                                                      loc)) {
4747                                         Report.SymbolRelatedToPreviousError (candidate);
4748                                         ambiguous = candidate;
4749                                 }
4750                         }
4751
4752                         if (ambiguous != null) {
4753                                 Report.SymbolRelatedToPreviousError (method);
4754                                 Report.Error (121, loc, "The call is ambiguous between the following methods or properties: `{0}' and `{1}'",
4755                                         TypeManager.CSharpSignature (ambiguous), TypeManager.CSharpSignature (method));
4756                                 return null;
4757                         }
4758
4759                         //
4760                         // If the method is a virtual function, pick an override closer to the LHS type.
4761                         //
4762                         if (!me.IsBase && method.IsVirtual) {
4763                                 if (TypeManager.IsOverride (method))
4764                                         throw new InternalErrorException (
4765                                                 "Should not happen.  An 'override' method took part in overload resolution: " + method);
4766
4767                                 if (candidate_overrides != null)
4768                                         foreach (MethodBase candidate in candidate_overrides) {
4769                                                 if (IsOverride (candidate, method))
4770                                                         method = candidate;
4771                                         }
4772                         }
4773
4774                         //
4775                         // And now check if the arguments are all
4776                         // compatible, perform conversions if
4777                         // necessary etc. and return if everything is
4778                         // all right
4779                         //
4780                         if (!VerifyArgumentsCompat (ec, Arguments, arg_count, method,
4781                                                     method_params, null, may_fail, loc))
4782                                 return null;
4783
4784                         if (method != null) {
4785                                 IMethodData data = TypeManager.GetMethod (method);
4786                                 if (data != null)
4787                                         data.SetMemberIsUsed ();
4788                         }
4789                         return method;
4790                 }
4791
4792                 public static void Error_WrongNumArguments (Location loc, String name, int arg_count)
4793                 {
4794                         Report.Error (1501, loc, "No overload for method `{0}' takes `{1}' arguments",
4795                                 name, arg_count.ToString ());
4796                 }
4797
4798                 static void Error_InvokeOnDelegate (Location loc)
4799                 {
4800                         Report.Error (1533, loc,
4801                                       "Invoke cannot be called directly on a delegate");
4802                 }
4803
4804                 static void Error_InvalidArguments (Location loc, int idx, MethodBase method,
4805                                                     Type delegate_type, Argument a, ParameterData expected_par)
4806                 {
4807                         if (delegate_type == null)
4808                                 Report.Error (1502, loc, "The best overloaded method match for `{0}' has some invalid arguments",
4809                                               TypeManager.CSharpSignature (method));
4810                         else
4811                                 Report.Error (1594, loc, "Delegate `{0}' has some invalid arguments",
4812                                         TypeManager.CSharpName (delegate_type));
4813
4814                         Parameter.Modifier mod = expected_par.ParameterModifier (idx);
4815
4816                         string index = (idx + 1).ToString ();
4817                         if (mod != Parameter.Modifier.ARGLIST && mod != a.Modifier) {
4818                                 if ((mod & (Parameter.Modifier.REF | Parameter.Modifier.OUT)) == 0)
4819                                         Report.Error (1615, loc, "Argument `{0}' should not be passed with the `{1}' keyword",
4820                                                 index, Parameter.GetModifierSignature (a.Modifier));
4821                                 else
4822                                         Report.Error (1620, loc, "Argument `{0}' must be passed with the `{1}' keyword",
4823                                                 index, Parameter.GetModifierSignature (mod));
4824                         } else {
4825                                 Report.Error (1503, loc, "Argument {0}: Cannot convert from `{1}' to `{2}'",
4826                                         index, Argument.FullDesc (a), expected_par.ParameterDesc (idx));
4827                         }
4828                 }
4829
4830                 public static bool VerifyArgumentsCompat (EmitContext ec, ArrayList Arguments,
4831                                                           int arg_count, MethodBase method,
4832                                                           bool chose_params_expanded,
4833                                                           Type delegate_type, bool may_fail,
4834                                                           Location loc)
4835                 {
4836                         ParameterData pd = TypeManager.GetParameterData (method);
4837                         int pd_count = pd.Count;
4838
4839                         for (int j = 0; j < arg_count; j++) {
4840                                 Argument a = (Argument) Arguments [j];
4841                                 Expression a_expr = a.Expr;
4842                                 Type parameter_type = pd.ParameterType (j);
4843                                 Parameter.Modifier pm = pd.ParameterModifier (j);
4844
4845                                 if (pm == Parameter.Modifier.PARAMS){
4846                                         if ((pm & ~Parameter.Modifier.PARAMS) != a.Modifier) {
4847                                                 if (!may_fail)
4848                                                         Error_InvalidArguments (loc, j, method, delegate_type, a, pd);
4849                                                 return false;
4850                                         }
4851
4852                                         if (chose_params_expanded)
4853                                                 parameter_type = TypeManager.GetElementType (parameter_type);
4854                                 } else if (pm == Parameter.Modifier.ARGLIST) {
4855                                         if (!(a.Expr is Arglist)) {
4856                                                 if (!may_fail)
4857                                                         Error_InvalidArguments (loc, j, method, delegate_type, a, pd);
4858                                                 return false;
4859                                         }
4860                                         continue;
4861                                 } else {
4862                                         //
4863                                         // Check modifiers
4864                                         //
4865                                         if (pd.ParameterModifier (j) != a.Modifier){
4866                                                 if (!may_fail)
4867                                                         Error_InvalidArguments (loc, j, method, delegate_type, a, pd);
4868                                                 return false;
4869                                         }
4870                                 }
4871
4872                                 //
4873                                 // Check Type
4874                                 //
4875                                 if (!a.Type.Equals (parameter_type)){
4876                                         Expression conv;
4877
4878                                         conv = Convert.ImplicitConversion (ec, a_expr, parameter_type, loc);
4879
4880                                         if (conv == null) {
4881                                                 if (!may_fail)
4882                                                         Error_InvalidArguments (loc, j, method, delegate_type, a, pd);
4883                                                 return false;
4884                                         }
4885
4886                                         //
4887                                         // Update the argument with the implicit conversion
4888                                         //
4889                                         if (a_expr != conv)
4890                                                 a.Expr = conv;
4891                                 }
4892
4893                                 if (parameter_type.IsPointer){
4894                                         if (!ec.InUnsafe){
4895                                                 UnsafeError (loc);
4896                                                 return false;
4897                                         }
4898                                 }
4899
4900                                 Parameter.Modifier a_mod = a.Modifier &
4901                                         unchecked (~(Parameter.Modifier.OUT | Parameter.Modifier.REF));
4902                                 Parameter.Modifier p_mod = pd.ParameterModifier (j) &
4903                                         unchecked (~(Parameter.Modifier.OUT | Parameter.Modifier.REF));
4904
4905                                 if (a_mod != p_mod &&
4906                                     pd.ParameterModifier (pd_count - 1) != Parameter.Modifier.PARAMS) {
4907                                         if (!may_fail) {
4908                                                 Invocation.Error_InvalidArguments (loc, j, method, null, a, pd);
4909                                         }
4910
4911                                         return false;
4912                                 }
4913                         }
4914
4915                         return true;
4916                 }
4917
4918                 public override Expression DoResolve (EmitContext ec)
4919                 {
4920                         //
4921                         // First, resolve the expression that is used to
4922                         // trigger the invocation
4923                         //
4924                         expr = expr.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
4925                         if (expr == null)
4926                                 return null;
4927
4928                         if (!(expr is MethodGroupExpr)) {
4929                                 Type expr_type = expr.Type;
4930
4931                                 if (expr_type != null){
4932                                         bool IsDelegate = TypeManager.IsDelegateType (expr_type);
4933                                         if (IsDelegate)
4934                                                 return (new DelegateInvocation (
4935                                                         this.expr, Arguments, loc)).Resolve (ec);
4936                                 }
4937                         }
4938
4939                         if (!(expr is MethodGroupExpr)){
4940                                 expr.Error_UnexpectedKind (ResolveFlags.MethodGroup, loc);
4941                                 return null;
4942                         }
4943
4944                         //
4945                         // Next, evaluate all the expressions in the argument list
4946                         //
4947                         if (Arguments != null){
4948                                 foreach (Argument a in Arguments){
4949                                         if (!a.Resolve (ec, loc))
4950                                                 return null;
4951                                 }
4952                         }
4953
4954                         MethodGroupExpr mg = (MethodGroupExpr) expr;
4955                         method = OverloadResolve (ec, mg, Arguments, false, loc);
4956
4957                         if (method == null)
4958                                 return null;
4959
4960                         MethodInfo mi = method as MethodInfo;
4961                         if (mi != null) {
4962                                 type = TypeManager.TypeToCoreType (mi.ReturnType);
4963                                 Expression iexpr = mg.InstanceExpression;
4964                                 if (mi.IsStatic) {
4965                                         if (iexpr == null ||
4966                                             iexpr is This || iexpr is EmptyExpression ||
4967                                             mg.IdenticalTypeName) {
4968                                                 mg.InstanceExpression = null;
4969                                         } else {
4970                                                 MemberExpr.error176 (loc, TypeManager.CSharpSignature (mi));
4971                                                 return null;
4972                                         }
4973                                 } else {
4974                                         if (iexpr == null || iexpr is EmptyExpression) {
4975                                                 SimpleName.Error_ObjectRefRequired (ec, loc, TypeManager.CSharpSignature (mi));
4976                                                 return null;
4977                                         }
4978                                 }
4979                         }
4980
4981                         if (type.IsPointer){
4982                                 if (!ec.InUnsafe){
4983                                         UnsafeError (loc);
4984                                         return null;
4985                                 }
4986                         }
4987
4988                         //
4989                         // Only base will allow this invocation to happen.
4990                         //
4991                         if (mg.IsBase && method.IsAbstract){
4992                                 Error_CannotCallAbstractBase (TypeManager.CSharpSignature (method));
4993                                 return null;
4994                         }
4995
4996                         if (Arguments == null && method.Name == "Finalize") {
4997                                 if (mg.IsBase)
4998                                         Report.Error (250, loc, "Do not directly call your base class Finalize method. It is called automatically from your destructor");
4999                                 else
5000                                         Report.Error (245, loc, "Destructors and object.Finalize cannot be called directly. Consider calling IDisposable.Dispose if available");
5001                                 return null;
5002                         }
5003
5004                         if ((method.Attributes & MethodAttributes.SpecialName) != 0 && IsSpecialMethodInvocation (method)) {
5005                                 return null;
5006                         }
5007
5008                         if (mg.InstanceExpression != null)
5009                                 mg.InstanceExpression.CheckMarshallByRefAccess (ec.ContainerType);
5010
5011                         eclass = ExprClass.Value;
5012                         return this;
5013                 }
5014
5015                 bool IsSpecialMethodInvocation (MethodBase method)
5016                 {
5017                         IMethodData md = TypeManager.GetMethod (method);
5018                         if (md != null) {
5019                                 if (!(md is AbstractPropertyEventMethod) && !(md is Operator))
5020                                         return false;
5021                         } else {
5022                                 if (!TypeManager.IsSpecialMethod (method))
5023                                         return false;
5024
5025                                 int args = TypeManager.GetParameterData (method).Count;
5026                                 if (method.Name.StartsWith ("get_") && args > 0)
5027                                         return false;
5028                                 else if (method.Name.StartsWith ("set_") && args > 2)
5029                                         return false;
5030
5031                                 // TODO: check operators and events as well ?
5032                         }
5033
5034                         Report.SymbolRelatedToPreviousError (method);
5035                         Report.Error (571, loc, "`{0}': cannot explicitly call operator or accessor",
5036                                 TypeManager.CSharpSignature (method, true));
5037
5038                         return true;
5039                 }
5040
5041                 // <summary>
5042                 //   Emits the list of arguments as an array
5043                 // </summary>
5044                 static void EmitParams (EmitContext ec, int idx, ArrayList arguments)
5045                 {
5046                         ILGenerator ig = ec.ig;
5047                         int count = arguments.Count - idx;
5048                         Argument a = (Argument) arguments [idx];
5049                         Type t = a.Expr.Type;
5050
5051                         IntConstant.EmitInt (ig, count);
5052                         ig.Emit (OpCodes.Newarr, TypeManager.TypeToCoreType (t));
5053
5054                         int top = arguments.Count;
5055                         for (int j = idx; j < top; j++){
5056                                 a = (Argument) arguments [j];
5057
5058                                 ig.Emit (OpCodes.Dup);
5059                                 IntConstant.EmitInt (ig, j - idx);
5060
5061                                 bool is_stobj;
5062                                 OpCode op = ArrayAccess.GetStoreOpcode (t, out is_stobj);
5063                                 if (is_stobj)
5064                                         ig.Emit (OpCodes.Ldelema, t);
5065
5066                                 a.Emit (ec);
5067
5068                                 if (is_stobj)
5069                                         ig.Emit (OpCodes.Stobj, t);
5070                                 else
5071                                         ig.Emit (op);
5072                         }
5073                 }
5074
5075                 /// <summary>
5076                 ///   Emits a list of resolved Arguments that are in the arguments
5077                 ///   ArrayList.
5078                 ///
5079                 ///   The MethodBase argument might be null if the
5080                 ///   emission of the arguments is known not to contain
5081                 ///   a `params' field (for example in constructors or other routines
5082                 ///   that keep their arguments in this structure)
5083                 ///
5084                 ///   if `dup_args' is true, a copy of the arguments will be left
5085                 ///   on the stack. If `dup_args' is true, you can specify `this_arg'
5086                 ///   which will be duplicated before any other args. Only EmitCall
5087                 ///   should be using this interface.
5088                 /// </summary>
5089                 public static void EmitArguments (EmitContext ec, MethodBase mb, ArrayList arguments, bool dup_args, LocalTemporary this_arg)
5090                 {
5091                         ParameterData pd = mb == null ? null : TypeManager.GetParameterData (mb);
5092                         int top = arguments == null ? 0 : arguments.Count;
5093                         LocalTemporary [] temps = null;
5094
5095                         if (dup_args && top != 0)
5096                                 temps = new LocalTemporary [top];
5097
5098                         for (int i = 0; i < top; i++){
5099                                 Argument a = (Argument) arguments [i];
5100
5101                                 if (pd != null){
5102                                         if (pd.ParameterModifier (i) == Parameter.Modifier.PARAMS){
5103                                                 //
5104                                                 // Special case if we are passing the same data as the
5105                                                 // params argument, do not put it in an array.
5106                                                 //
5107                                                 if (pd.ParameterType (i) == a.Type)
5108                                                         a.Emit (ec);
5109                                                 else
5110                                                         EmitParams (ec, i, arguments);
5111                                                 return;
5112                                         }
5113                                 }
5114
5115                                 a.Emit (ec);
5116                                 if (dup_args) {
5117                                         ec.ig.Emit (OpCodes.Dup);
5118                                         (temps [i] = new LocalTemporary (ec, a.Type)).Store (ec);
5119                                 }
5120                         }
5121
5122                         if (dup_args) {
5123                                 if (this_arg != null)
5124                                         this_arg.Emit (ec);
5125
5126                                 for (int i = 0; i < top; i ++)
5127                                         temps [i].Emit (ec);
5128                         }
5129
5130                         if (pd != null && pd.Count > top &&
5131                             pd.ParameterModifier (top) == Parameter.Modifier.PARAMS){
5132                                 ILGenerator ig = ec.ig;
5133
5134                                 IntConstant.EmitInt (ig, 0);
5135                                 ig.Emit (OpCodes.Newarr, TypeManager.GetElementType (pd.ParameterType (top)));
5136                         }
5137                 }
5138
5139                 static Type[] GetVarargsTypes (EmitContext ec, MethodBase mb,
5140                                                ArrayList arguments)
5141                 {
5142                         ParameterData pd = TypeManager.GetParameterData (mb);
5143
5144                         if (arguments == null)
5145                                 return new Type [0];
5146
5147                         Argument a = (Argument) arguments [pd.Count - 1];
5148                         Arglist list = (Arglist) a.Expr;
5149
5150                         return list.ArgumentTypes;
5151                 }
5152
5153                 /// <summary>
5154                 /// This checks the ConditionalAttribute on the method
5155                 /// </summary>
5156                 static bool IsMethodExcluded (MethodBase method, EmitContext ec)
5157                 {
5158                         if (method.IsConstructor)
5159                                 return false;
5160
5161                         IMethodData md = TypeManager.GetMethod (method);
5162                         if (md != null)
5163                                 return md.IsExcluded (ec);
5164
5165                         // For some methods (generated by delegate class) GetMethod returns null
5166                         // because they are not included in builder_to_method table
5167                         if (method.DeclaringType is TypeBuilder)
5168                                 return false;
5169
5170                         return AttributeTester.IsConditionalMethodExcluded (method);
5171                 }
5172
5173                 /// <remarks>
5174                 ///   is_base tells whether we want to force the use of the `call'
5175                 ///   opcode instead of using callvirt.  Call is required to call
5176                 ///   a specific method, while callvirt will always use the most
5177                 ///   recent method in the vtable.
5178                 ///
5179                 ///   is_static tells whether this is an invocation on a static method
5180                 ///
5181                 ///   instance_expr is an expression that represents the instance
5182                 ///   it must be non-null if is_static is false.
5183                 ///
5184                 ///   method is the method to invoke.
5185                 ///
5186                 ///   Arguments is the list of arguments to pass to the method or constructor.
5187                 /// </remarks>
5188                 public static void EmitCall (EmitContext ec, bool is_base,
5189                                              bool is_static, Expression instance_expr,
5190                                              MethodBase method, ArrayList Arguments, Location loc)
5191                 {
5192                         EmitCall (ec, is_base, is_static, instance_expr, method, Arguments, loc, false, false);
5193                 }
5194
5195                 // `dup_args' leaves an extra copy of the arguments on the stack
5196                 // `omit_args' does not leave any arguments at all.
5197                 // So, basically, you could make one call with `dup_args' set to true,
5198                 // and then another with `omit_args' set to true, and the two calls
5199                 // would have the same set of arguments. However, each argument would
5200                 // only have been evaluated once.
5201                 public static void EmitCall (EmitContext ec, bool is_base,
5202                                              bool is_static, Expression instance_expr,
5203                                              MethodBase method, ArrayList Arguments, Location loc,
5204                                              bool dup_args, bool omit_args)
5205                 {
5206                         ILGenerator ig = ec.ig;
5207                         bool struct_call = false;
5208                         bool this_call = false;
5209                         LocalTemporary this_arg = null;
5210
5211                         Type decl_type = method.DeclaringType;
5212
5213                         if (!RootContext.StdLib) {
5214                                 // Replace any calls to the system's System.Array type with calls to
5215                                 // the newly created one.
5216                                 if (method == TypeManager.system_int_array_get_length)
5217                                         method = TypeManager.int_array_get_length;
5218                                 else if (method == TypeManager.system_int_array_get_rank)
5219                                         method = TypeManager.int_array_get_rank;
5220                                 else if (method == TypeManager.system_object_array_clone)
5221                                         method = TypeManager.object_array_clone;
5222                                 else if (method == TypeManager.system_int_array_get_length_int)
5223                                         method = TypeManager.int_array_get_length_int;
5224                                 else if (method == TypeManager.system_int_array_get_lower_bound_int)
5225                                         method = TypeManager.int_array_get_lower_bound_int;
5226                                 else if (method == TypeManager.system_int_array_get_upper_bound_int)
5227                                         method = TypeManager.int_array_get_upper_bound_int;
5228                                 else if (method == TypeManager.system_void_array_copyto_array_int)
5229                                         method = TypeManager.void_array_copyto_array_int;
5230                         }
5231
5232                         if (ec.TestObsoleteMethodUsage) {
5233                                 //
5234                                 // This checks ObsoleteAttribute on the method and on the declaring type
5235                                 //
5236                                 ObsoleteAttribute oa = AttributeTester.GetMethodObsoleteAttribute (method);
5237                                 if (oa != null)
5238                                         AttributeTester.Report_ObsoleteMessage (oa, TypeManager.CSharpSignature (method), loc);
5239
5240
5241                                 oa = AttributeTester.GetObsoleteAttribute (method.DeclaringType);
5242                                 if (oa != null) {
5243                                         AttributeTester.Report_ObsoleteMessage (oa, method.DeclaringType.FullName, loc);
5244                                 }
5245                         }
5246
5247                         if (IsMethodExcluded (method, ec))
5248                                 return;
5249
5250                         if (!is_static){
5251                                 if (instance_expr == EmptyExpression.Null) {
5252                                         SimpleName.Error_ObjectRefRequired (ec, loc, TypeManager.CSharpSignature (method));
5253                                         return;
5254                                 }
5255
5256                                 this_call = instance_expr is This;
5257                                 if (decl_type.IsValueType || (!this_call && instance_expr.Type.IsValueType))
5258                                         struct_call = true;
5259
5260                                 if (!omit_args) {
5261                                         Type t = null;
5262                                         //
5263                                         // Push the instance expression
5264                                         //
5265                                         if (instance_expr.Type.IsValueType) {
5266                                                 //
5267                                                 // Special case: calls to a function declared in a
5268                                                 // reference-type with a value-type argument need
5269                                                 // to have their value boxed.
5270                                                 if (decl_type.IsValueType) {
5271                                                         //
5272                                                         // If the expression implements IMemoryLocation, then
5273                                                         // we can optimize and use AddressOf on the
5274                                                         // return.
5275                                                         //
5276                                                         // If not we have to use some temporary storage for
5277                                                         // it.
5278                                                         if (instance_expr is IMemoryLocation) {
5279                                                                 ((IMemoryLocation)instance_expr).
5280                                                                         AddressOf (ec, AddressOp.LoadStore);
5281                                                         } else {
5282                                                                 LocalTemporary temp = new LocalTemporary (ec, instance_expr.Type);
5283                                                                 instance_expr.Emit (ec);
5284                                                                 temp.Store (ec);
5285                                                                 temp.AddressOf (ec, AddressOp.Load);
5286                                                         }
5287
5288                                                         // avoid the overhead of doing this all the time.
5289                                                         if (dup_args)
5290                                                                 t = TypeManager.GetReferenceType (instance_expr.Type);
5291                                                 } else {
5292                                                         instance_expr.Emit (ec);
5293                                                         ig.Emit (OpCodes.Box, instance_expr.Type);
5294                                                         t = TypeManager.object_type;
5295                                                 }
5296                                         } else {
5297                                                 instance_expr.Emit (ec);
5298                                                 t = instance_expr.Type;
5299                                         }
5300
5301                                         if (dup_args) {
5302                                                 ig.Emit (OpCodes.Dup);
5303                                                 if (Arguments != null && Arguments.Count != 0) {
5304                                                         this_arg = new LocalTemporary (ec, t);
5305                                                         this_arg.Store (ec);
5306                                                 }
5307                                         }
5308                                 }
5309                         }
5310
5311                         if (!omit_args)
5312                                 EmitArguments (ec, method, Arguments, dup_args, this_arg);
5313
5314                         OpCode call_op;
5315                         if (is_static || struct_call || is_base || (this_call && !method.IsVirtual))
5316                                 call_op = OpCodes.Call;
5317                         else
5318                                 call_op = OpCodes.Callvirt;
5319
5320                         if ((method.CallingConvention & CallingConventions.VarArgs) != 0) {
5321                                 Type[] varargs_types = GetVarargsTypes (ec, method, Arguments);
5322                                 ig.EmitCall (call_op, (MethodInfo) method, varargs_types);
5323                                 return;
5324                         }
5325
5326                         //
5327                         // If you have:
5328                         // this.DoFoo ();
5329                         // and DoFoo is not virtual, you can omit the callvirt,
5330                         // because you don't need the null checking behavior.
5331                         //
5332                         if (method is MethodInfo)
5333                                 ig.Emit (call_op, (MethodInfo) method);
5334                         else
5335                                 ig.Emit (call_op, (ConstructorInfo) method);
5336                 }
5337
5338                 public override void Emit (EmitContext ec)
5339                 {
5340                         MethodGroupExpr mg = (MethodGroupExpr) this.expr;
5341
5342                         EmitCall (ec, mg.IsBase, method.IsStatic, mg.InstanceExpression, method, Arguments, loc);
5343                 }
5344
5345                 public override void EmitStatement (EmitContext ec)
5346                 {
5347                         Emit (ec);
5348
5349                         //
5350                         // Pop the return value if there is one
5351                         //
5352                         if (method is MethodInfo){
5353                                 Type ret = ((MethodInfo)method).ReturnType;
5354                                 if (TypeManager.TypeToCoreType (ret) != TypeManager.void_type)
5355                                         ec.ig.Emit (OpCodes.Pop);
5356                         }
5357                 }
5358         }
5359
5360         public class InvocationOrCast : ExpressionStatement
5361         {
5362                 Expression expr;
5363                 Expression argument;
5364
5365                 public InvocationOrCast (Expression expr, Expression argument)
5366                 {
5367                         this.expr = expr;
5368                         this.argument = argument;
5369                         this.loc = expr.Location;
5370                 }
5371
5372                 public override Expression DoResolve (EmitContext ec)
5373                 {
5374                         //
5375                         // First try to resolve it as a cast.
5376                         //
5377                         TypeExpr te = expr.ResolveAsTypeTerminal (ec, true);
5378                         if (te != null) {
5379                                 Cast cast = new Cast (te, argument, loc);
5380                                 return cast.Resolve (ec);
5381                         }
5382
5383                         //
5384                         // This can either be a type or a delegate invocation.
5385                         // Let's just resolve it and see what we'll get.
5386                         //
5387                         expr = expr.Resolve (ec, ResolveFlags.Type | ResolveFlags.VariableOrValue);
5388                         if (expr == null)
5389                                 return null;
5390
5391                         //
5392                         // Ok, so it's a Cast.
5393                         //
5394                         if (expr.eclass == ExprClass.Type) {
5395                                 Cast cast = new Cast (new TypeExpression (expr.Type, loc), argument, loc);
5396                                 return cast.Resolve (ec);
5397                         }
5398
5399                         //
5400                         // It's a delegate invocation.
5401                         //
5402                         if (!TypeManager.IsDelegateType (expr.Type)) {
5403                                 Error (149, "Method name expected");
5404                                 return null;
5405                         }
5406
5407                         ArrayList args = new ArrayList ();
5408                         args.Add (new Argument (argument, Argument.AType.Expression));
5409                         DelegateInvocation invocation = new DelegateInvocation (expr, args, loc);
5410                         return invocation.Resolve (ec);
5411                 }
5412
5413                 void error201 ()
5414                 {
5415                         Error (201, "Only assignment, call, increment, decrement and new object " +
5416                                "expressions can be used as a statement");
5417                 }
5418
5419                 public override ExpressionStatement ResolveStatement (EmitContext ec)
5420                 {
5421                         //
5422                         // First try to resolve it as a cast.
5423                         //
5424                         TypeExpr te = expr.ResolveAsTypeTerminal (ec, true);
5425                         if (te != null) {
5426                                 error201 ();
5427                                 return null;
5428                         }
5429
5430                         //
5431                         // This can either be a type or a delegate invocation.
5432                         // Let's just resolve it and see what we'll get.
5433                         //
5434                         expr = expr.Resolve (ec, ResolveFlags.Type | ResolveFlags.VariableOrValue);
5435                         if ((expr == null) || (expr.eclass == ExprClass.Type)) {
5436                                 error201 ();
5437                                 return null;
5438                         }
5439
5440                         //
5441                         // It's a delegate invocation.
5442                         //
5443                         if (!TypeManager.IsDelegateType (expr.Type)) {
5444                                 Error (149, "Method name expected");
5445                                 return null;
5446                         }
5447
5448                         ArrayList args = new ArrayList ();
5449                         args.Add (new Argument (argument, Argument.AType.Expression));
5450                         DelegateInvocation invocation = new DelegateInvocation (expr, args, loc);
5451                         return invocation.ResolveStatement (ec);
5452                 }
5453
5454                 public override void Emit (EmitContext ec)
5455                 {
5456                         throw new Exception ("Cannot happen");
5457                 }
5458
5459                 public override void EmitStatement (EmitContext ec)
5460                 {
5461                         throw new Exception ("Cannot happen");
5462                 }
5463         }
5464
5465         //
5466         // This class is used to "disable" the code generation for the
5467         // temporary variable when initializing value types.
5468         //
5469         class EmptyAddressOf : EmptyExpression, IMemoryLocation {
5470                 public void AddressOf (EmitContext ec, AddressOp Mode)
5471                 {
5472                         // nothing
5473                 }
5474         }
5475
5476         /// <summary>
5477         ///    Implements the new expression
5478         /// </summary>
5479         public class New : ExpressionStatement, IMemoryLocation {
5480                 public readonly ArrayList Arguments;
5481
5482                 //
5483                 // During bootstrap, it contains the RequestedType,
5484                 // but if `type' is not null, it *might* contain a NewDelegate
5485                 // (because of field multi-initialization)
5486                 //
5487                 public Expression RequestedType;
5488
5489                 MethodBase method = null;
5490
5491                 //
5492                 // If set, the new expression is for a value_target, and
5493                 // we will not leave anything on the stack.
5494                 //
5495                 Expression value_target;
5496                 bool value_target_set = false;
5497
5498                 public New (Expression requested_type, ArrayList arguments, Location l)
5499                 {
5500                         RequestedType = requested_type;
5501                         Arguments = arguments;
5502                         loc = l;
5503                 }
5504
5505                 public bool SetValueTypeVariable (Expression value)
5506                 {
5507                         value_target = value;
5508                         value_target_set = true;
5509                         if (!(value_target is IMemoryLocation)){
5510                                 Error_UnexpectedKind (null, "variable", loc);
5511                                 return false;
5512                         }
5513                         return true;
5514                 }
5515
5516                 //
5517                 // This function is used to disable the following code sequence for
5518                 // value type initialization:
5519                 //
5520                 // AddressOf (temporary)
5521                 // Construct/Init
5522                 // LoadTemporary
5523                 //
5524                 // Instead the provide will have provided us with the address on the
5525                 // stack to store the results.
5526                 //
5527                 static Expression MyEmptyExpression;
5528
5529                 public void DisableTemporaryValueType ()
5530                 {
5531                         if (MyEmptyExpression == null)
5532                                 MyEmptyExpression = new EmptyAddressOf ();
5533
5534                         //
5535                         // To enable this, look into:
5536                         // test-34 and test-89 and self bootstrapping.
5537                         //
5538                         // For instance, we can avoid a copy by using `newobj'
5539                         // instead of Call + Push-temp on value types.
5540 //                      value_target = MyEmptyExpression;
5541                 }
5542
5543
5544                 /// <summary>
5545                 /// Converts complex core type syntax like 'new int ()' to simple constant
5546                 /// </summary>
5547                 public static Constant Constantify (Type t)
5548                 {
5549                         if (t == TypeManager.int32_type)
5550                                 return new IntConstant (0, Location.Null);
5551                         if (t == TypeManager.uint32_type)
5552                                 return new UIntConstant (0, Location.Null);
5553                         if (t == TypeManager.int64_type)
5554                                 return new LongConstant (0, Location.Null);
5555                         if (t == TypeManager.uint64_type)
5556                                 return new ULongConstant (0, Location.Null);
5557                         if (t == TypeManager.float_type)
5558                                 return new FloatConstant (0, Location.Null);
5559                         if (t == TypeManager.double_type)
5560                                 return new DoubleConstant (0, Location.Null);
5561                         if (t == TypeManager.short_type)
5562                                 return new ShortConstant (0, Location.Null);
5563                         if (t == TypeManager.ushort_type)
5564                                 return new UShortConstant (0, Location.Null);
5565                         if (t == TypeManager.sbyte_type)
5566                                 return new SByteConstant (0, Location.Null);
5567                         if (t == TypeManager.byte_type)
5568                                 return new ByteConstant (0, Location.Null);
5569                         if (t == TypeManager.char_type)
5570                                 return new CharConstant ('\0', Location.Null);
5571                         if (t == TypeManager.bool_type)
5572                                 return new BoolConstant (false, Location.Null);
5573                         if (t == TypeManager.decimal_type)
5574                                 return new DecimalConstant (0, Location.Null);
5575
5576                         return null;
5577                 }
5578
5579                 //
5580                 // Checks whether the type is an interface that has the
5581                 // [ComImport, CoClass] attributes and must be treated
5582                 // specially
5583                 //
5584                 public Expression CheckComImport (EmitContext ec)
5585                 {
5586                         if (!type.IsInterface)
5587                                 return null;
5588
5589                         //
5590                         // Turn the call into:
5591                         // (the-interface-stated) (new class-referenced-in-coclassattribute ())
5592                         //
5593                         Type real_class = AttributeTester.GetCoClassAttribute (type);
5594                         if (real_class == null)
5595                                 return null;
5596
5597                         New proxy = new New (new TypeExpression (real_class, loc), Arguments, loc);
5598                         Cast cast = new Cast (new TypeExpression (type, loc), proxy, loc);
5599                         return cast.Resolve (ec);
5600                 }
5601
5602                 public override Expression DoResolve (EmitContext ec)
5603                 {
5604                         //
5605                         // The New DoResolve might be called twice when initializing field
5606                         // expressions (see EmitFieldInitializers, the call to
5607                         // GetInitializerExpression will perform a resolve on the expression,
5608                         // and later the assign will trigger another resolution
5609                         //
5610                         // This leads to bugs (#37014)
5611                         //
5612                         if (type != null){
5613                                 if (RequestedType is NewDelegate)
5614                                         return RequestedType;
5615                                 return this;
5616                         }
5617
5618                         TypeExpr texpr = RequestedType.ResolveAsTypeTerminal (ec, false);
5619                         if (texpr == null)
5620                                 return null;
5621
5622                         type = texpr.ResolveType (ec);
5623
5624                         if (Arguments == null) {
5625                                 Expression c = Constantify (type);
5626                                 if (c != null)
5627                                         return c;
5628                         }
5629
5630                         if (TypeManager.IsDelegateType (type)) {
5631                                 RequestedType = (new NewDelegate (type, Arguments, loc)).Resolve (ec);
5632                                 if (RequestedType != null)
5633                                         if (!(RequestedType is DelegateCreation))
5634                                                 throw new Exception ("NewDelegate.Resolve returned a non NewDelegate: " + RequestedType.GetType ());
5635                                 return RequestedType;
5636                         }
5637
5638                         if (type.IsAbstract && type.IsSealed) {
5639                                 Report.SymbolRelatedToPreviousError (type);
5640                                 Report.Error (712, loc, "Cannot create an instance of the static class `{0}'", TypeManager.CSharpName (type));
5641                                 return null;
5642                         }
5643
5644                         if (type.IsInterface || type.IsAbstract){
5645                                 RequestedType = CheckComImport (ec);
5646                                 if (RequestedType != null)
5647                                         return RequestedType;
5648
5649                                 Report.SymbolRelatedToPreviousError (type);
5650                                 Report.Error (144, loc, "Cannot create an instance of the abstract class or interface `{0}'", TypeManager.CSharpName (type));
5651                                 return null;
5652                         }
5653
5654                         bool is_struct = type.IsValueType;
5655                         eclass = ExprClass.Value;
5656
5657                         //
5658                         // SRE returns a match for .ctor () on structs (the object constructor),
5659                         // so we have to manually ignore it.
5660                         //
5661                         if (is_struct && Arguments == null)
5662                                 return this;
5663
5664                         // For member-lookup, treat 'new Foo (bar)' as call to 'foo.ctor (bar)', where 'foo' is of type 'Foo'.
5665                         Expression ml = MemberLookupFinal (ec, type, type, ".ctor",
5666                                 MemberTypes.Constructor, AllBindingFlags | BindingFlags.DeclaredOnly, loc);
5667
5668                         if (ml == null)
5669                                 return null;
5670
5671                         MethodGroupExpr mg = ml as MethodGroupExpr;
5672
5673                         if (mg == null) {
5674                                 ml.Error_UnexpectedKind (ec, "method group", loc);
5675                                 return null;
5676                         }
5677
5678                         if (Arguments != null){
5679                                 foreach (Argument a in Arguments){
5680                                         if (!a.Resolve (ec, loc))
5681                                                 return null;
5682                                 }
5683                         }
5684
5685                         method = Invocation.OverloadResolve (ec, mg, Arguments, false, loc);
5686                         if (method == null) {
5687                                 if (almostMatchedMembers.Count != 0)
5688                                         MemberLookupFailed (ec, type, type, ".ctor", null, true, loc);
5689                                 return null;
5690                         }
5691
5692                         return this;
5693                 }
5694
5695                 //
5696                 // This DoEmit can be invoked in two contexts:
5697                 //    * As a mechanism that will leave a value on the stack (new object)
5698                 //    * As one that wont (init struct)
5699                 //
5700                 // You can control whether a value is required on the stack by passing
5701                 // need_value_on_stack.  The code *might* leave a value on the stack
5702                 // so it must be popped manually
5703                 //
5704                 // If we are dealing with a ValueType, we have a few
5705                 // situations to deal with:
5706                 //
5707                 //    * The target is a ValueType, and we have been provided
5708                 //      the instance (this is easy, we are being assigned).
5709                 //
5710                 //    * The target of New is being passed as an argument,
5711                 //      to a boxing operation or a function that takes a
5712                 //      ValueType.
5713                 //
5714                 //      In this case, we need to create a temporary variable
5715                 //      that is the argument of New.
5716                 //
5717                 // Returns whether a value is left on the stack
5718                 //
5719                 bool DoEmit (EmitContext ec, bool need_value_on_stack)
5720                 {
5721                         bool is_value_type = type.IsValueType;
5722                         ILGenerator ig = ec.ig;
5723
5724                         if (is_value_type){
5725                                 IMemoryLocation ml;
5726
5727                                 // Allow DoEmit() to be called multiple times.
5728                                 // We need to create a new LocalTemporary each time since
5729                                 // you can't share LocalBuilders among ILGeneators.
5730                                 if (!value_target_set)
5731                                         value_target = new LocalTemporary (ec, type);
5732
5733                                 ml = (IMemoryLocation) value_target;
5734                                 ml.AddressOf (ec, AddressOp.Store);
5735                         }
5736
5737                         if (method != null)
5738                                 Invocation.EmitArguments (ec, method, Arguments, false, null);
5739
5740                         if (is_value_type){
5741                                 if (method == null)
5742                                         ig.Emit (OpCodes.Initobj, type);
5743                                 else
5744                                         ig.Emit (OpCodes.Call, (ConstructorInfo) method);
5745                                 if (need_value_on_stack){
5746                                         value_target.Emit (ec);
5747                                         return true;
5748                                 }
5749                                 return false;
5750                         } else {
5751                                 ig.Emit (OpCodes.Newobj, (ConstructorInfo) method);
5752                                 return true;
5753                         }
5754                 }
5755
5756                 public override void Emit (EmitContext ec)
5757                 {
5758                         DoEmit (ec, true);
5759                 }
5760
5761                 public override void EmitStatement (EmitContext ec)
5762                 {
5763                         if (DoEmit (ec, false))
5764                                 ec.ig.Emit (OpCodes.Pop);
5765                 }
5766
5767                 public void AddressOf (EmitContext ec, AddressOp Mode)
5768                 {
5769                         if (!type.IsValueType){
5770                                 //
5771                                 // We throw an exception.  So far, I believe we only need to support
5772                                 // value types:
5773                                 // foreach (int j in new StructType ())
5774                                 // see bug 42390
5775                                 //
5776                                 throw new Exception ("AddressOf should not be used for classes");
5777                         }
5778
5779                         if (!value_target_set)
5780                                 value_target = new LocalTemporary (ec, type);
5781
5782                         IMemoryLocation ml = (IMemoryLocation) value_target;
5783                         ml.AddressOf (ec, AddressOp.Store);
5784                         if (method != null)
5785                                 Invocation.EmitArguments (ec, method, Arguments, false, null);
5786
5787                         if (method == null)
5788                                 ec.ig.Emit (OpCodes.Initobj, type);
5789                         else
5790                                 ec.ig.Emit (OpCodes.Call, (ConstructorInfo) method);
5791
5792                         ((IMemoryLocation) value_target).AddressOf (ec, Mode);
5793                 }
5794         }
5795
5796         /// <summary>
5797         ///   14.5.10.2: Represents an array creation expression.
5798         /// </summary>
5799         ///
5800         /// <remarks>
5801         ///   There are two possible scenarios here: one is an array creation
5802         ///   expression that specifies the dimensions and optionally the
5803         ///   initialization data and the other which does not need dimensions
5804         ///   specified but where initialization data is mandatory.
5805         /// </remarks>
5806         public class ArrayCreation : Expression {
5807                 Expression requested_base_type;
5808                 ArrayList initializers;
5809
5810                 //
5811                 // The list of Argument types.
5812                 // This is used to construct the `newarray' or constructor signature
5813                 //
5814                 ArrayList arguments;
5815
5816                 //
5817                 // Method used to create the array object.
5818                 //
5819                 MethodBase new_method = null;
5820
5821                 Type array_element_type;
5822                 Type underlying_type;
5823                 bool is_one_dimensional = false;
5824                 bool is_builtin_type = false;
5825                 bool expect_initializers = false;
5826                 int num_arguments = 0;
5827                 int dimensions = 0;
5828                 string rank;
5829
5830                 ArrayList array_data;
5831
5832                 Hashtable bounds;
5833
5834                 //
5835                 // The number of array initializers that we can handle
5836                 // via the InitializeArray method - through EmitStaticInitializers
5837                 //
5838                 int num_automatic_initializers;
5839
5840                 const int max_automatic_initializers = 6;
5841
5842                 public ArrayCreation (Expression requested_base_type, ArrayList exprs, string rank, ArrayList initializers, Location l)
5843                 {
5844                         this.requested_base_type = requested_base_type;
5845                         this.initializers = initializers;
5846                         this.rank = rank;
5847                         loc = l;
5848
5849                         arguments = new ArrayList ();
5850
5851                         foreach (Expression e in exprs) {
5852                                 arguments.Add (new Argument (e, Argument.AType.Expression));
5853                                 num_arguments++;
5854                         }
5855                 }
5856
5857                 public ArrayCreation (Expression requested_base_type, string rank, ArrayList initializers, Location l)
5858                 {
5859                         this.requested_base_type = requested_base_type;
5860                         this.initializers = initializers;
5861                         this.rank = rank;
5862                         loc = l;
5863
5864                         //this.rank = rank.Substring (0, rank.LastIndexOf ('['));
5865                         //
5866                         //string tmp = rank.Substring (rank.LastIndexOf ('['));
5867                         //
5868                         //dimensions = tmp.Length - 1;
5869                         expect_initializers = true;
5870                 }
5871
5872                 public Expression FormArrayType (Expression base_type, int idx_count, string rank)
5873                 {
5874                         StringBuilder sb = new StringBuilder (rank);
5875
5876                         sb.Append ("[");
5877                         for (int i = 1; i < idx_count; i++)
5878                                 sb.Append (",");
5879
5880                         sb.Append ("]");
5881
5882                         return new ComposedCast (base_type, sb.ToString (), loc);
5883                 }
5884
5885                 void Error_IncorrectArrayInitializer ()
5886                 {
5887                         Error (178, "Invalid rank specifier: expected `,' or `]'");
5888                 }
5889
5890                 public bool CheckIndices (EmitContext ec, ArrayList probe, int idx, bool specified_dims)
5891                 {
5892                         if (specified_dims) {
5893                                 Argument a = (Argument) arguments [idx];
5894
5895                                 if (!a.Resolve (ec, loc))
5896                                         return false;
5897
5898                                 Constant c = a.Expr as Constant;
5899                                 if (c != null) {
5900                                         c = c.ToType (TypeManager.int32_type, a.Expr.Location);
5901                                 }
5902
5903                                 if (c == null) {
5904                                         Report.Error (150, a.Expr.Location, "A constant value is expected");
5905                                         return false;
5906                                 }
5907
5908                                 int value = (int) c.GetValue ();
5909
5910                                 if (value != probe.Count) {
5911                                         Error_IncorrectArrayInitializer ();
5912                                         return false;
5913                                 }
5914
5915                                 bounds [idx] = value;
5916                         }
5917
5918                         int child_bounds = -1;
5919                         for (int i = 0; i < probe.Count; ++i) {
5920                                 object o = probe [i];
5921                                 if (o is ArrayList) {
5922                                         ArrayList sub_probe = o as ArrayList;
5923                                         int current_bounds = sub_probe.Count;
5924
5925                                         if (child_bounds == -1)
5926                                                 child_bounds = current_bounds;
5927
5928                                         else if (child_bounds != current_bounds){
5929                                                 Error_IncorrectArrayInitializer ();
5930                                                 return false;
5931                                         }
5932                                         if (specified_dims && (idx + 1 >= arguments.Count)){
5933                                                 Error (623, "Array initializers can only be used in a variable or field initializer. Try using a new expression instead");
5934                                                 return false;
5935                                         }
5936
5937                                         bool ret = CheckIndices (ec, sub_probe, idx + 1, specified_dims);
5938                                         if (!ret)
5939                                                 return false;
5940                                 } else {
5941                                         if (child_bounds != -1){
5942                                                 Error_IncorrectArrayInitializer ();
5943                                                 return false;
5944                                         }
5945
5946                                         Expression tmp = (Expression) o;
5947                                         tmp = tmp.Resolve (ec);
5948                                         probe [i] = tmp;
5949                                         if (tmp == null)
5950                                                 return false;
5951
5952                                         // Console.WriteLine ("I got: " + tmp);
5953                                         // Handle initialization from vars, fields etc.
5954
5955                                         Expression conv = Convert.ImplicitConversionRequired (
5956                                                 ec, tmp, underlying_type, loc);
5957
5958                                         if (conv == null)
5959                                                 return false;
5960
5961                                         if (conv is StringConstant || conv is DecimalConstant || conv is NullCast) {
5962                                                 // These are subclasses of Constant that can appear as elements of an
5963                                                 // array that cannot be statically initialized (with num_automatic_initializers
5964                                                 // > max_automatic_initializers), so num_automatic_initializers should be left as zero.
5965                                                 array_data.Add (conv);
5966                                         } else if (conv is Constant) {
5967                                                 // These are the types of Constant that can appear in arrays that can be
5968                                                 // statically allocated.
5969                                                 array_data.Add (conv);
5970                                                 num_automatic_initializers++;
5971                                         } else
5972                                                 array_data.Add (conv);
5973                                 }
5974                         }
5975
5976                         return true;
5977                 }
5978
5979                 public void UpdateIndices (EmitContext ec)
5980                 {
5981                         int i = 0;
5982                         for (ArrayList probe = initializers; probe != null;) {
5983                                 if (probe.Count > 0 && probe [0] is ArrayList) {
5984                                         Expression e = new IntConstant (probe.Count, Location.Null);
5985                                         arguments.Add (new Argument (e, Argument.AType.Expression));
5986
5987                                         bounds [i++] =  probe.Count;
5988
5989                                         probe = (ArrayList) probe [0];
5990
5991                                 } else {
5992                                         Expression e = new IntConstant (probe.Count, Location.Null);
5993                                         arguments.Add (new Argument (e, Argument.AType.Expression));
5994
5995                                         bounds [i++] = probe.Count;
5996                                         probe = null;
5997                                 }
5998                         }
5999
6000                 }
6001
6002                 public bool ValidateInitializers (EmitContext ec, Type array_type)
6003                 {
6004                         if (initializers == null) {
6005                                 if (expect_initializers)
6006                                         return false;
6007                                 else
6008                                         return true;
6009                         }
6010
6011                         if (underlying_type == null)
6012                                 return false;
6013
6014                         //
6015                         // We use this to store all the date values in the order in which we
6016                         // will need to store them in the byte blob later
6017                         //
6018                         array_data = new ArrayList ();
6019                         bounds = new Hashtable ();
6020
6021                         bool ret;
6022
6023                         if (arguments != null) {
6024                                 ret = CheckIndices (ec, initializers, 0, true);
6025                                 return ret;
6026                         } else {
6027                                 arguments = new ArrayList ();
6028
6029                                 ret = CheckIndices (ec, initializers, 0, false);
6030
6031                                 if (!ret)
6032                                         return false;
6033
6034                                 UpdateIndices (ec);
6035
6036                                 if (arguments.Count != dimensions) {
6037                                         Error_IncorrectArrayInitializer ();
6038                                         return false;
6039                                 }
6040
6041                                 return ret;
6042                         }
6043                 }
6044
6045                 //
6046                 // Creates the type of the array
6047                 //
6048                 bool LookupType (EmitContext ec)
6049                 {
6050                         StringBuilder array_qualifier = new StringBuilder (rank);
6051
6052                         //
6053                         // `In the first form allocates an array instace of the type that results
6054                         // from deleting each of the individual expression from the expression list'
6055                         //
6056                         if (num_arguments > 0) {
6057                                 array_qualifier.Append ("[");
6058                                 for (int i = num_arguments-1; i > 0; i--)
6059                                         array_qualifier.Append (",");
6060                                 array_qualifier.Append ("]");
6061                         }
6062
6063                         //
6064                         // Lookup the type
6065                         //
6066                         TypeExpr array_type_expr;
6067                         array_type_expr = new ComposedCast (requested_base_type, array_qualifier.ToString (), loc);
6068                         array_type_expr = array_type_expr.ResolveAsTypeTerminal (ec, false);
6069                         if (array_type_expr == null)
6070                                 return false;
6071
6072                         type = array_type_expr.ResolveType (ec);
6073                         underlying_type = TypeManager.GetElementType (type);
6074                         dimensions = type.GetArrayRank ();
6075
6076                         return true;
6077                 }
6078
6079                 public override Expression DoResolve (EmitContext ec)
6080                 {
6081                         int arg_count;
6082
6083                         if (!LookupType (ec))
6084                                 return null;
6085
6086                         //
6087                         // First step is to validate the initializers and fill
6088                         // in any missing bits
6089                         //
6090                         if (!ValidateInitializers (ec, type))
6091                                 return null;
6092
6093                         if (arguments == null)
6094                                 arg_count = 0;
6095                         else {
6096                                 arg_count = arguments.Count;
6097                                 foreach (Argument a in arguments){
6098                                         if (!a.Resolve (ec, loc))
6099                                                 return null;
6100
6101                                         Expression real_arg = ExpressionToArrayArgument (ec, a.Expr, loc);
6102                                         if (real_arg == null)
6103                                                 return null;
6104
6105                                         a.Expr = real_arg;
6106                                 }
6107                         }
6108
6109                         array_element_type = TypeManager.GetElementType (type);
6110
6111                         if (array_element_type.IsAbstract && array_element_type.IsSealed) {
6112                                 Report.Error (719, loc, "`{0}': array elements cannot be of static type", TypeManager.CSharpName (array_element_type));
6113                                 return null;
6114                         }
6115
6116                         if (arg_count == 1) {
6117                                 is_one_dimensional = true;
6118                                 eclass = ExprClass.Value;
6119                                 return this;
6120                         }
6121
6122                         is_builtin_type = TypeManager.IsBuiltinType (type);
6123
6124                         if (is_builtin_type) {
6125                                 Expression ml;
6126
6127                                 ml = MemberLookup (ec, type, ".ctor", MemberTypes.Constructor,
6128                                                    AllBindingFlags, loc);
6129
6130                                 if (!(ml is MethodGroupExpr)) {
6131                                         ml.Error_UnexpectedKind (ec, "method group", loc);
6132                                         return null;
6133                                 }
6134
6135                                 if (ml == null) {
6136                                         Error (-6, "New invocation: Can not find a constructor for " +
6137                                                       "this argument list");
6138                                         return null;
6139                                 }
6140
6141                                 new_method = Invocation.OverloadResolve (
6142                                         ec, (MethodGroupExpr) ml, arguments, false, loc);
6143
6144                                 if (new_method == null) {
6145                                         Error (-6, "New invocation: Can not find a constructor for " +
6146                                                       "this argument list");
6147                                         return null;
6148                                 }
6149
6150                                 eclass = ExprClass.Value;
6151                                 return this;
6152                         } else {
6153                                 ModuleBuilder mb = CodeGen.Module.Builder;
6154                                 ArrayList args = new ArrayList ();
6155
6156                                 if (arguments != null) {
6157                                         for (int i = 0; i < arg_count; i++)
6158                                                 args.Add (TypeManager.int32_type);
6159                                 }
6160
6161                                 Type [] arg_types = null;
6162
6163                                 if (args.Count > 0)
6164                                         arg_types = new Type [args.Count];
6165
6166                                 args.CopyTo (arg_types, 0);
6167
6168                                 new_method = mb.GetArrayMethod (type, ".ctor", CallingConventions.HasThis, null,
6169                                                             arg_types);
6170
6171                                 if (new_method == null) {
6172                                         Error (-6, "New invocation: Can not find a constructor for " +
6173                                                       "this argument list");
6174                                         return null;
6175                                 }
6176
6177                                 eclass = ExprClass.Value;
6178                                 return this;
6179                         }
6180                 }
6181
6182                 public static byte [] MakeByteBlob (ArrayList array_data, Type underlying_type, Location loc)
6183                 {
6184                         int factor;
6185                         byte [] data;
6186                         byte [] element;
6187                         int count = array_data.Count;
6188
6189                         if (underlying_type.IsEnum)
6190                                 underlying_type = TypeManager.EnumToUnderlying (underlying_type);
6191
6192                         factor = GetTypeSize (underlying_type);
6193                         if (factor == 0)
6194                                 throw new Exception ("unrecognized type in MakeByteBlob: " + underlying_type);
6195
6196                         data = new byte [(count * factor + 4) & ~3];
6197                         int idx = 0;
6198
6199                         for (int i = 0; i < count; ++i) {
6200                                 object v = array_data [i];
6201
6202                                 if (v is EnumConstant)
6203                                         v = ((EnumConstant) v).Child;
6204
6205                                 if (v is Constant && !(v is StringConstant))
6206                                         v = ((Constant) v).GetValue ();
6207                                 else {
6208                                         idx += factor;
6209                                         continue;
6210                                 }
6211
6212                                 if (underlying_type == TypeManager.int64_type){
6213                                         if (!(v is Expression)){
6214                                                 long val = (long) v;
6215
6216                                                 for (int j = 0; j < factor; ++j) {
6217                                                         data [idx + j] = (byte) (val & 0xFF);
6218                                                         val = (val >> 8);
6219                                                 }
6220                                         }
6221                                 } else if (underlying_type == TypeManager.uint64_type){
6222                                         if (!(v is Expression)){
6223                                                 ulong val = (ulong) v;
6224
6225                                                 for (int j = 0; j < factor; ++j) {
6226                                                         data [idx + j] = (byte) (val & 0xFF);
6227                                                         val = (val >> 8);
6228                                                 }
6229                                         }
6230                                 } else if (underlying_type == TypeManager.float_type) {
6231                                         if (!(v is Expression)){
6232                                                 element = BitConverter.GetBytes ((float) v);
6233
6234                                                 for (int j = 0; j < factor; ++j)
6235                                                         data [idx + j] = element [j];
6236                                         }
6237                                 } else if (underlying_type == TypeManager.double_type) {
6238                                         if (!(v is Expression)){
6239                                                 element = BitConverter.GetBytes ((double) v);
6240
6241                                                 for (int j = 0; j < factor; ++j)
6242                                                         data [idx + j] = element [j];
6243                                         }
6244                                 } else if (underlying_type == TypeManager.char_type){
6245                                         if (!(v is Expression)){
6246                                                 int val = (int) ((char) v);
6247
6248                                                 data [idx] = (byte) (val & 0xff);
6249                                                 data [idx+1] = (byte) (val >> 8);
6250                                         }
6251                                 } else if (underlying_type == TypeManager.short_type){
6252                                         if (!(v is Expression)){
6253                                                 int val = (int) ((short) v);
6254
6255                                                 data [idx] = (byte) (val & 0xff);
6256                                                 data [idx+1] = (byte) (val >> 8);
6257                                         }
6258                                 } else if (underlying_type == TypeManager.ushort_type){
6259                                         if (!(v is Expression)){
6260                                                 int val = (int) ((ushort) v);
6261
6262                                                 data [idx] = (byte) (val & 0xff);
6263                                                 data [idx+1] = (byte) (val >> 8);
6264                                         }
6265                                 } else if (underlying_type == TypeManager.int32_type) {
6266                                         if (!(v is Expression)){
6267                                                 int val = (int) v;
6268
6269                                                 data [idx]   = (byte) (val & 0xff);
6270                                                 data [idx+1] = (byte) ((val >> 8) & 0xff);
6271                                                 data [idx+2] = (byte) ((val >> 16) & 0xff);
6272                                                 data [idx+3] = (byte) (val >> 24);
6273                                         }
6274                                 } else if (underlying_type == TypeManager.uint32_type) {
6275                                         if (!(v is Expression)){
6276                                                 uint val = (uint) v;
6277
6278                                                 data [idx]   = (byte) (val & 0xff);
6279                                                 data [idx+1] = (byte) ((val >> 8) & 0xff);
6280                                                 data [idx+2] = (byte) ((val >> 16) & 0xff);
6281                                                 data [idx+3] = (byte) (val >> 24);
6282                                         }
6283                                 } else if (underlying_type == TypeManager.sbyte_type) {
6284                                         if (!(v is Expression)){
6285                                                 sbyte val = (sbyte) v;
6286                                                 data [idx] = (byte) val;
6287                                         }
6288                                 } else if (underlying_type == TypeManager.byte_type) {
6289                                         if (!(v is Expression)){
6290                                                 byte val = (byte) v;
6291                                                 data [idx] = (byte) val;
6292                                         }
6293                                 } else if (underlying_type == TypeManager.bool_type) {
6294                                         if (!(v is Expression)){
6295                                                 bool val = (bool) v;
6296                                                 data [idx] = (byte) (val ? 1 : 0);
6297                                         }
6298                                 } else if (underlying_type == TypeManager.decimal_type){
6299                                         if (!(v is Expression)){
6300                                                 int [] bits = Decimal.GetBits ((decimal) v);
6301                                                 int p = idx;
6302
6303                                                 // FIXME: For some reason, this doesn't work on the MS runtime.
6304                                                 int [] nbits = new int [4];
6305                                                 nbits [0] = bits [3];
6306                                                 nbits [1] = bits [2];
6307                                                 nbits [2] = bits [0];
6308                                                 nbits [3] = bits [1];
6309
6310                                                 for (int j = 0; j < 4; j++){
6311                                                         data [p++] = (byte) (nbits [j] & 0xff);
6312                                                         data [p++] = (byte) ((nbits [j] >> 8) & 0xff);
6313                                                         data [p++] = (byte) ((nbits [j] >> 16) & 0xff);
6314                                                         data [p++] = (byte) (nbits [j] >> 24);
6315                                                 }
6316                                         }
6317                                 } else
6318                                         throw new Exception ("Unrecognized type in MakeByteBlob: " + underlying_type);
6319
6320                                 idx += factor;
6321                         }
6322
6323                         return data;
6324                 }
6325
6326                 //
6327                 // Emits the initializers for the array
6328                 //
6329                 void EmitStaticInitializers (EmitContext ec)
6330                 {
6331                         //
6332                         // First, the static data
6333                         //
6334                         FieldBuilder fb;
6335                         ILGenerator ig = ec.ig;
6336
6337                         byte [] data = MakeByteBlob (array_data, underlying_type, loc);
6338
6339                         fb = RootContext.MakeStaticData (data);
6340
6341                         ig.Emit (OpCodes.Dup);
6342                         ig.Emit (OpCodes.Ldtoken, fb);
6343                         ig.Emit (OpCodes.Call,
6344                                  TypeManager.void_initializearray_array_fieldhandle);
6345                 }
6346
6347                 //
6348                 // Emits pieces of the array that can not be computed at compile
6349                 // time (variables and string locations).
6350                 //
6351                 // This always expect the top value on the stack to be the array
6352                 //
6353                 void EmitDynamicInitializers (EmitContext ec)
6354                 {
6355                         ILGenerator ig = ec.ig;
6356                         int dims = bounds.Count;
6357                         int [] current_pos = new int [dims];
6358                         int top = array_data.Count;
6359
6360                         MethodInfo set = null;
6361
6362                         if (dims != 1){
6363                                 Type [] args;
6364                                 ModuleBuilder mb = null;
6365                                 mb = CodeGen.Module.Builder;
6366                                 args = new Type [dims + 1];
6367
6368                                 int j;
6369                                 for (j = 0; j < dims; j++)
6370                                         args [j] = TypeManager.int32_type;
6371
6372                                 args [j] = array_element_type;
6373
6374                                 set = mb.GetArrayMethod (
6375                                         type, "Set",
6376                                         CallingConventions.HasThis | CallingConventions.Standard,
6377                                         TypeManager.void_type, args);
6378                         }
6379
6380                         for (int i = 0; i < top; i++){
6381
6382                                 Expression e = null;
6383
6384                                 if (array_data [i] is Expression)
6385                                         e = (Expression) array_data [i];
6386
6387                                 if (e != null) {
6388                                         //
6389                                         // Basically we do this for string literals and
6390                                         // other non-literal expressions
6391                                         //
6392                                         if (e is EnumConstant){
6393                                                 e = ((EnumConstant) e).Child;
6394                                         }
6395
6396                                         if (e is StringConstant || e is DecimalConstant || !(e is Constant) ||
6397                                             num_automatic_initializers <= max_automatic_initializers) {
6398                                                 Type etype = e.Type;
6399
6400                                                 ig.Emit (OpCodes.Dup);
6401
6402                                                 for (int idx = 0; idx < dims; idx++)
6403                                                         IntConstant.EmitInt (ig, current_pos [idx]);
6404
6405                                                 //
6406                                                 // If we are dealing with a struct, get the
6407                                                 // address of it, so we can store it.
6408                                                 //
6409                                                 if ((dims == 1) &&
6410                                                     TypeManager.IsValueType (etype) &&
6411                                                     (!TypeManager.IsBuiltinOrEnum (etype) ||
6412                                                      etype == TypeManager.decimal_type)) {
6413                                                         if (e is New){
6414                                                                 New n = (New) e;
6415
6416                                                                 //
6417                                                                 // Let new know that we are providing
6418                                                                 // the address where to store the results
6419                                                                 //
6420                                                                 n.DisableTemporaryValueType ();
6421                                                         }
6422
6423                                                         ig.Emit (OpCodes.Ldelema, etype);
6424                                                 }
6425
6426                                                 e.Emit (ec);
6427
6428                                                 if (dims == 1) {
6429                                                         bool is_stobj;
6430                                                         OpCode op = ArrayAccess.GetStoreOpcode (etype, out is_stobj);
6431                                                         if (is_stobj)
6432                                                                 ig.Emit (OpCodes.Stobj, etype);
6433                                                         else
6434                                                                 ig.Emit (op);
6435                                                 } else
6436                                                         ig.Emit (OpCodes.Call, set);
6437
6438                                         }
6439                                 }
6440
6441                                 //
6442                                 // Advance counter
6443                                 //
6444                                 for (int j = dims - 1; j >= 0; j--){
6445                                         current_pos [j]++;
6446                                         if (current_pos [j] < (int) bounds [j])
6447                                                 break;
6448                                         current_pos [j] = 0;
6449                                 }
6450                         }
6451                 }
6452
6453                 void EmitArrayArguments (EmitContext ec)
6454                 {
6455                         ILGenerator ig = ec.ig;
6456
6457                         foreach (Argument a in arguments) {
6458                                 Type atype = a.Type;
6459                                 a.Emit (ec);
6460
6461                                 if (atype == TypeManager.uint64_type)
6462                                         ig.Emit (OpCodes.Conv_Ovf_U4);
6463                                 else if (atype == TypeManager.int64_type)
6464                                         ig.Emit (OpCodes.Conv_Ovf_I4);
6465                         }
6466                 }
6467
6468                 public override void Emit (EmitContext ec)
6469                 {
6470                         ILGenerator ig = ec.ig;
6471
6472                         EmitArrayArguments (ec);
6473                         if (is_one_dimensional)
6474                                 ig.Emit (OpCodes.Newarr, array_element_type);
6475                         else {
6476                                 if (is_builtin_type)
6477                                         ig.Emit (OpCodes.Newobj, (ConstructorInfo) new_method);
6478                                 else
6479                                         ig.Emit (OpCodes.Newobj, (MethodInfo) new_method);
6480                         }
6481
6482                         if (initializers != null){
6483                                 //
6484                                 // FIXME: Set this variable correctly.
6485                                 //
6486                                 bool dynamic_initializers = true;
6487
6488                                 // This will never be true for array types that cannot be statically
6489                                 // initialized. num_automatic_initializers will always be zero.  See
6490                                 // CheckIndices.
6491                                 if (num_automatic_initializers > max_automatic_initializers)
6492                                         EmitStaticInitializers (ec);
6493
6494                                 if (dynamic_initializers)
6495                                         EmitDynamicInitializers (ec);
6496                         }
6497                 }
6498
6499                 public object EncodeAsAttribute ()
6500                 {
6501                         if (!is_one_dimensional){
6502                                 Report.Error (-211, Location, "attribute can not encode multi-dimensional arrays");
6503                                 return null;
6504                         }
6505
6506                         if (array_data == null){
6507                                 Report.Error (-212, Location, "array should be initialized when passing it to an attribute");
6508                                 return null;
6509                         }
6510
6511                         object [] ret = new object [array_data.Count];
6512                         int i = 0;
6513                         foreach (Expression e in array_data){
6514                                 object v;
6515
6516                                 if (e is NullLiteral)
6517                                         v = null;
6518                                 else {
6519                                         if (!Attribute.GetAttributeArgumentExpression (e, Location, array_element_type, out v))
6520                                                 return null;
6521                                 }
6522                                 ret [i++] = v;
6523                         }
6524                         return ret;
6525                 }
6526         }
6527
6528         /// <summary>
6529         ///   Represents the `this' construct
6530         /// </summary>
6531         public class This : Expression, IAssignMethod, IMemoryLocation, IVariable {
6532
6533                 Block block;
6534                 VariableInfo variable_info;
6535
6536                 public This (Block block, Location loc)
6537                 {
6538                         this.loc = loc;
6539                         this.block = block;
6540                 }
6541
6542                 public This (Location loc)
6543                 {
6544                         this.loc = loc;
6545                 }
6546
6547                 public VariableInfo VariableInfo {
6548                         get { return variable_info; }
6549                 }
6550
6551                 public bool VerifyFixed ()
6552                 {
6553                         return !TypeManager.IsValueType (Type);
6554                 }
6555
6556                 public bool ResolveBase (EmitContext ec)
6557                 {
6558                         eclass = ExprClass.Variable;
6559                         type = ec.ContainerType;
6560
6561                         if (ec.IsStatic) {
6562                                 Error (26, "Keyword `this' is not valid in a static property, static method, or static field initializer");
6563                                 return false;
6564                         }
6565
6566                         if (block != null && block.Toplevel.ThisVariable != null)
6567                                 variable_info = block.Toplevel.ThisVariable.VariableInfo;
6568
6569                         if (ec.CurrentAnonymousMethod != null)
6570                                 ec.CaptureThis ();
6571
6572                         return true;
6573                 }
6574
6575                 public override Expression DoResolve (EmitContext ec)
6576                 {
6577                         if (!ResolveBase (ec))
6578                                 return null;
6579
6580                         if ((variable_info != null) && !(type.IsValueType && ec.OmitStructFlowAnalysis) && !variable_info.IsAssigned (ec)) {
6581                                 Error (188, "The `this' object cannot be used before all of its fields are assigned to");
6582                                 variable_info.SetAssigned (ec);
6583                                 return this;
6584                         }
6585
6586                         if (ec.IsFieldInitializer) {
6587                                 Error (27, "Keyword `this' is not available in the current context");
6588                                 return null;
6589                         }
6590
6591                         return this;
6592                 }
6593
6594                 override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
6595                 {
6596                         if (!ResolveBase (ec))
6597                                 return null;
6598
6599                         if (variable_info != null)
6600                                 variable_info.SetAssigned (ec);
6601
6602                         if (ec.TypeContainer is Class){
6603                                 Error (1604, "Cannot assign to 'this' because it is read-only");
6604                                 return null;
6605                         }
6606
6607                         return this;
6608                 }
6609
6610                 public void Emit (EmitContext ec, bool leave_copy)
6611                 {
6612                         Emit (ec);
6613                         if (leave_copy)
6614                                 ec.ig.Emit (OpCodes.Dup);
6615                 }
6616
6617                 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
6618                 {
6619                         ILGenerator ig = ec.ig;
6620
6621                         if (ec.TypeContainer is Struct){
6622                                 ec.EmitThis ();
6623                                 source.Emit (ec);
6624                                 if (leave_copy)
6625                                         ec.ig.Emit (OpCodes.Dup);
6626                                 ig.Emit (OpCodes.Stobj, type);
6627                         } else {
6628                                 throw new Exception ("how did you get here");
6629                         }
6630                 }
6631
6632                 public override void Emit (EmitContext ec)
6633                 {
6634                         ILGenerator ig = ec.ig;
6635
6636                         ec.EmitThis ();
6637                         if (ec.TypeContainer is Struct)
6638                                 ig.Emit (OpCodes.Ldobj, type);
6639                 }
6640
6641                 public override int GetHashCode()
6642                 {
6643                         return block.GetHashCode ();
6644                 }
6645
6646                 public override bool Equals (object obj)
6647                 {
6648                         This t = obj as This;
6649                         if (t == null)
6650                                 return false;
6651
6652                         return block == t.block;
6653                 }
6654
6655                 public void AddressOf (EmitContext ec, AddressOp mode)
6656                 {
6657                         ec.EmitThis ();
6658
6659                         // FIMXE
6660                         // FIGURE OUT WHY LDARG_S does not work
6661                         //
6662                         // consider: struct X { int val; int P { set { val = value; }}}
6663                         //
6664                         // Yes, this looks very bad. Look at `NOTAS' for
6665                         // an explanation.
6666                         // ec.ig.Emit (OpCodes.Ldarga_S, (byte) 0);
6667                 }
6668         }
6669
6670         /// <summary>
6671         ///   Represents the `__arglist' construct
6672         /// </summary>
6673         public class ArglistAccess : Expression
6674         {
6675                 public ArglistAccess (Location loc)
6676                 {
6677                         this.loc = loc;
6678                 }
6679
6680                 public bool ResolveBase (EmitContext ec)
6681                 {
6682                         eclass = ExprClass.Variable;
6683                         type = TypeManager.runtime_argument_handle_type;
6684                         return true;
6685                 }
6686
6687                 public override Expression DoResolve (EmitContext ec)
6688                 {
6689                         if (!ResolveBase (ec))
6690                                 return null;
6691
6692                         if (ec.IsFieldInitializer || !ec.CurrentBlock.Toplevel.HasVarargs) {
6693                                 Error (190, "The __arglist construct is valid only within " +
6694                                        "a variable argument method.");
6695                                 return null;
6696                         }
6697
6698                         return this;
6699                 }
6700
6701                 public override void Emit (EmitContext ec)
6702                 {
6703                         ec.ig.Emit (OpCodes.Arglist);
6704                 }
6705         }
6706
6707         /// <summary>
6708         ///   Represents the `__arglist (....)' construct
6709         /// </summary>
6710         public class Arglist : Expression
6711         {
6712                 public readonly Argument[] Arguments;
6713
6714                 public Arglist (Argument[] args, Location l)
6715                 {
6716                         Arguments = args;
6717                         loc = l;
6718                 }
6719
6720                 public Type[] ArgumentTypes {
6721                         get {
6722                                 Type[] retval = new Type [Arguments.Length];
6723                                 for (int i = 0; i < Arguments.Length; i++)
6724                                         retval [i] = Arguments [i].Type;
6725                                 return retval;
6726                         }
6727                 }
6728
6729                 public override Expression DoResolve (EmitContext ec)
6730                 {
6731                         eclass = ExprClass.Variable;
6732                         type = TypeManager.runtime_argument_handle_type;
6733
6734                         foreach (Argument arg in Arguments) {
6735                                 if (!arg.Resolve (ec, loc))
6736                                         return null;
6737                         }
6738
6739                         return this;
6740                 }
6741
6742                 public override void Emit (EmitContext ec)
6743                 {
6744                         foreach (Argument arg in Arguments)
6745                                 arg.Emit (ec);
6746                 }
6747         }
6748
6749         //
6750         // This produces the value that renders an instance, used by the iterators code
6751         //
6752         public class ProxyInstance : Expression, IMemoryLocation  {
6753                 public override Expression DoResolve (EmitContext ec)
6754                 {
6755                         eclass = ExprClass.Variable;
6756                         type = ec.ContainerType;
6757                         return this;
6758                 }
6759
6760                 public override void Emit (EmitContext ec)
6761                 {
6762                         ec.ig.Emit (OpCodes.Ldarg_0);
6763
6764                 }
6765
6766                 public void AddressOf (EmitContext ec, AddressOp mode)
6767                 {
6768                         ec.ig.Emit (OpCodes.Ldarg_0);
6769                 }
6770         }
6771
6772         /// <summary>
6773         ///   Implements the typeof operator
6774         /// </summary>
6775         public class TypeOf : Expression {
6776                 public Expression QueriedType;
6777                 protected Type typearg;
6778
6779                 public TypeOf (Expression queried_type, Location l)
6780                 {
6781                         QueriedType = queried_type;
6782                         loc = l;
6783                 }
6784
6785                 public override Expression DoResolve (EmitContext ec)
6786                 {
6787                         TypeExpr texpr = QueriedType.ResolveAsTypeTerminal (ec, false);
6788                         if (texpr == null)
6789                                 return null;
6790
6791                         typearg = texpr.ResolveType (ec);
6792
6793                         if (typearg == TypeManager.void_type) {
6794                                 Error (673, "System.Void cannot be used from C#. Use typeof (void) to get the void type object");
6795                                 return null;
6796                         }
6797
6798                         if (typearg.IsPointer && !ec.InUnsafe){
6799                                 UnsafeError (loc);
6800                                 return null;
6801                         }
6802
6803                         type = TypeManager.type_type;
6804                         // Even though what is returned is a type object, it's treated as a value by the compiler.
6805                         // In particular, 'typeof (Foo).X' is something totally different from 'Foo.X'.
6806                         eclass = ExprClass.Value;
6807                         return this;
6808                 }
6809
6810                 public override void Emit (EmitContext ec)
6811                 {
6812                         ec.ig.Emit (OpCodes.Ldtoken, typearg);
6813                         ec.ig.Emit (OpCodes.Call, TypeManager.system_type_get_type_from_handle);
6814                 }
6815
6816                 public Type TypeArg {
6817                         get { return typearg; }
6818                 }
6819         }
6820
6821         /// <summary>
6822         ///   Implements the `typeof (void)' operator
6823         /// </summary>
6824         public class TypeOfVoid : TypeOf {
6825                 public TypeOfVoid (Location l) : base (null, l)
6826                 {
6827                         loc = l;
6828                 }
6829
6830                 public override Expression DoResolve (EmitContext ec)
6831                 {
6832                         type = TypeManager.type_type;
6833                         typearg = TypeManager.void_type;
6834                         // See description in TypeOf.
6835                         eclass = ExprClass.Value;
6836                         return this;
6837                 }
6838         }
6839
6840         /// <summary>
6841         ///   Implements the sizeof expression
6842         /// </summary>
6843         public class SizeOf : Expression {
6844                 public Expression QueriedType;
6845                 Type type_queried;
6846
6847                 public SizeOf (Expression queried_type, Location l)
6848                 {
6849                         this.QueriedType = queried_type;
6850                         loc = l;
6851                 }
6852
6853                 public override Expression DoResolve (EmitContext ec)
6854                 {
6855                         TypeExpr texpr = QueriedType.ResolveAsTypeTerminal (ec, false);
6856                         if (texpr == null)
6857                                 return null;
6858
6859                         type_queried = texpr.ResolveType (ec);
6860
6861                         int size_of = GetTypeSize (type_queried);
6862                         if (size_of > 0) {
6863                                 return new IntConstant (size_of, loc);
6864                         }
6865
6866                         if (!ec.InUnsafe) {
6867                                 Report.Error (233, loc, "`{0}' does not have a predefined size, therefore sizeof can only be used in an unsafe context (consider using System.Runtime.InteropServices.Marshal.SizeOf)",
6868                                          TypeManager.CSharpName (type_queried));
6869                                 return null;
6870                         }
6871
6872                         if (!TypeManager.VerifyUnManaged (type_queried, loc)){
6873                                 return null;
6874                         }
6875
6876                         type = TypeManager.int32_type;
6877                         eclass = ExprClass.Value;
6878                         return this;
6879                 }
6880
6881                 public override void Emit (EmitContext ec)
6882                 {
6883                         int size = GetTypeSize (type_queried);
6884
6885                         if (size == 0)
6886                                 ec.ig.Emit (OpCodes.Sizeof, type_queried);
6887                         else
6888                                 IntConstant.EmitInt (ec.ig, size);
6889                 }
6890         }
6891
6892         /// <summary>
6893         ///   Implements the qualified-alias-member (::) expression.
6894         /// </summary>
6895         public class QualifiedAliasMember : Expression
6896         {
6897                 string alias, identifier;
6898
6899                 public QualifiedAliasMember (string alias, string identifier, Location l)
6900                 {
6901                         this.alias = alias;
6902                         this.identifier = identifier;
6903                         loc = l;
6904                 }
6905
6906                 public override FullNamedExpression ResolveAsTypeStep (EmitContext ec, bool silent)
6907                 {
6908                         if (alias == "global")
6909                                 return new MemberAccess (RootNamespace.Global, identifier, loc).ResolveAsTypeStep (ec, silent);
6910
6911                         int errors = Report.Errors;
6912                         FullNamedExpression fne = ec.DeclSpace.NamespaceEntry.LookupAlias (alias);
6913                         if (fne == null) {
6914                                 if (errors == Report.Errors)
6915                                         Report.Error (432, loc, "Alias `{0}' not found", alias);
6916                                 return null;
6917                         }
6918                         if (fne.eclass != ExprClass.Namespace) {
6919                                 if (!silent)
6920                                         Report.Error (431, loc, "`{0}' cannot be used with '::' since it denotes a type", alias);
6921                                 return null;
6922                         }
6923                         return new MemberAccess (fne, identifier, loc).ResolveAsTypeStep (ec, silent);
6924                 }
6925
6926                 public override Expression DoResolve (EmitContext ec)
6927                 {
6928                         FullNamedExpression fne;
6929                         if (alias == "global") {
6930                                 fne = RootNamespace.Global;
6931                         } else {
6932                                 int errors = Report.Errors;
6933                                 fne = ec.DeclSpace.NamespaceEntry.LookupAlias (alias);
6934                                 if (fne == null) {
6935                                         if (errors == Report.Errors)
6936                                                 Report.Error (432, loc, "Alias `{0}' not found", alias);
6937                                         return null;
6938                                 }
6939                         }
6940
6941                         Expression retval = new MemberAccess (fne, identifier, loc).DoResolve (ec);
6942                         if (retval == null)
6943                                 return null;
6944
6945                         if (!(retval is FullNamedExpression)) {
6946                                 Report.Error (687, loc, "The expression `{0}::{1}' did not resolve to a namespace or a type", alias, identifier);
6947                                 return null;
6948                         }
6949
6950                         // We defer this check till the end to match the behaviour of CSC
6951                         if (fne.eclass != ExprClass.Namespace) {
6952                                 Report.Error (431, loc, "`{0}' cannot be used with '::' since it denotes a type", alias);
6953                                 return null;
6954                         }
6955                         return retval;
6956                 }
6957
6958                 public override void Emit (EmitContext ec)
6959                 {
6960                         throw new InternalErrorException ("QualifiedAliasMember found in resolved tree");
6961                 }
6962
6963
6964                 public override string ToString ()
6965                 {
6966                         return alias + "::" + identifier;
6967                 }
6968
6969                 public override string GetSignatureForError ()
6970                 {
6971                         return ToString ();
6972                 }
6973         }
6974
6975         /// <summary>
6976         ///   Implements the member access expression
6977         /// </summary>
6978         public class MemberAccess : Expression {
6979                 public readonly string Identifier;
6980                 Expression expr;
6981
6982                 // TODO: Location can be removed
6983                 public MemberAccess (Expression expr, string id, Location l)
6984                 {
6985                         this.expr = expr;
6986                         Identifier = id;
6987                         loc = expr.Location;
6988                 }
6989
6990                 public Expression Expr {
6991                         get { return expr; }
6992                 }
6993
6994                 // TODO: this method has very poor performace for Enum fields and
6995                 // probably for other constants as well
6996                 Expression DoResolve (EmitContext ec, Expression right_side)
6997                 {
6998                         if (type != null)
6999                                 throw new Exception ();
7000
7001                         //
7002                         // Resolve the expression with flow analysis turned off, we'll do the definite
7003                         // assignment checks later.  This is because we don't know yet what the expression
7004                         // will resolve to - it may resolve to a FieldExpr and in this case we must do the
7005                         // definite assignment check on the actual field and not on the whole struct.
7006                         //
7007
7008                         SimpleName original = expr as SimpleName;
7009                         Expression new_expr = expr.Resolve (ec,
7010                                 ResolveFlags.VariableOrValue | ResolveFlags.Type |
7011                                 ResolveFlags.Intermediate | ResolveFlags.DisableStructFlowAnalysis);
7012
7013                         if (new_expr == null)
7014                                 return null;
7015
7016                         if (new_expr is Namespace) {
7017                                 Namespace ns = (Namespace) new_expr;
7018                                 FullNamedExpression retval = ns.Lookup (ec.DeclSpace, Identifier, loc);
7019                                 if (retval == null)
7020                                         Report.Error (234, loc, "The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
7021                                                 Identifier, ns.FullName);
7022                                 return retval;
7023                         }
7024
7025                         Type expr_type = new_expr.Type;
7026                         if (expr_type.IsPointer){
7027                                 Error (23, "The `.' operator can not be applied to pointer operands (" +
7028                                        TypeManager.CSharpName (expr_type) + ")");
7029                                 return null;
7030                         }
7031
7032                         Expression member_lookup;
7033                         member_lookup = MemberLookupFinal (ec, expr_type, expr_type, Identifier, loc);
7034                         if (member_lookup == null)
7035                                 return null;
7036
7037                         if (member_lookup is TypeExpr) {
7038                                 if (!(new_expr is TypeExpr) &&
7039                                     (original == null || !original.IdenticalNameAndTypeName (ec, new_expr, loc))) {
7040                                         Report.Error (572, loc, "`{0}': cannot reference a type through an expression; try `{1}' instead",
7041                                                 Identifier, member_lookup.GetSignatureForError ());
7042                                         return null;
7043                                 }
7044
7045                                 return member_lookup;
7046                         }
7047
7048                         MemberExpr me = (MemberExpr) member_lookup;
7049                         member_lookup = me.ResolveMemberAccess (ec, new_expr, loc, original);
7050                         if (member_lookup == null)
7051                                 return null;
7052
7053                         if (original != null && !TypeManager.IsValueType (expr_type)) {
7054                                 me = member_lookup as MemberExpr;
7055                                 if (me != null && me.IsInstance) {
7056                                         LocalVariableReference var = new_expr as LocalVariableReference;
7057                                         if (var != null && !var.VerifyAssigned (ec))
7058                                                 return null;
7059                                 }
7060                         }
7061
7062                         // The following DoResolve/DoResolveLValue will do the definite assignment
7063                         // check.
7064
7065                         if (right_side != null)
7066                                 return member_lookup.DoResolveLValue (ec, right_side);
7067                         else
7068                                 return member_lookup.DoResolve (ec);
7069                 }
7070
7071                 public override Expression DoResolve (EmitContext ec)
7072                 {
7073                         return DoResolve (ec, null);
7074                 }
7075
7076                 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
7077                 {
7078                         return DoResolve (ec, right_side);
7079                 }
7080
7081                 public override FullNamedExpression ResolveAsTypeStep (EmitContext ec, bool silent)
7082                 {
7083                         return ResolveNamespaceOrType (ec, silent);
7084                 }
7085
7086                 public FullNamedExpression ResolveNamespaceOrType (EmitContext ec, bool silent)
7087                 {
7088                         FullNamedExpression new_expr = expr.ResolveAsTypeStep (ec, silent);
7089
7090                         if (new_expr == null)
7091                                 return null;
7092
7093                         if (new_expr is Namespace) {
7094                                 Namespace ns = (Namespace) new_expr;
7095                                 FullNamedExpression retval = ns.Lookup (ec.DeclSpace, Identifier, loc);
7096                                 if (!silent && retval == null)
7097                                         Report.Error (234, loc, "The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
7098                                                 Identifier, ns.FullName);
7099                                 return retval;
7100                         }
7101
7102                         Type expr_type = new_expr.Type;
7103
7104                         if (expr_type.IsPointer){
7105                                 Error (23, "The `.' operator can not be applied to pointer operands (" +
7106                                        TypeManager.CSharpName (expr_type) + ")");
7107                                 return null;
7108                         }
7109
7110                         Expression member_lookup = MemberLookup (ec, expr_type, expr_type, Identifier, loc);
7111                         if (member_lookup == null) {
7112                                 int errors = Report.Errors;
7113                                 MemberLookupFailed (ec, expr_type, expr_type, Identifier, null, false, loc);
7114
7115                                 if (!silent && errors == Report.Errors) {
7116                                         Report.Error (426, loc, "The nested type `{0}' does not exist in the type `{1}'",
7117                                                 Identifier, new_expr.GetSignatureForError ());
7118                                 }
7119                                 return null;
7120                         }
7121
7122                         if (!(member_lookup is TypeExpr)) {
7123                                 new_expr.Error_UnexpectedKind (ec, "type", loc);
7124                                 return null;
7125                         }
7126
7127                         member_lookup = member_lookup.Resolve (ec, ResolveFlags.Type);
7128                         return (member_lookup as TypeExpr);
7129                 }
7130
7131                 public override void Emit (EmitContext ec)
7132                 {
7133                         throw new Exception ("Should not happen");
7134                 }
7135
7136                 public override string ToString ()
7137                 {
7138                         return expr + "." + Identifier;
7139                 }
7140
7141                 public override string GetSignatureForError ()
7142                 {
7143                         return expr.GetSignatureForError () + "." + Identifier;
7144                 }
7145         }
7146
7147         /// <summary>
7148         ///   Implements checked expressions
7149         /// </summary>
7150         public class CheckedExpr : Expression {
7151
7152                 public Expression Expr;
7153
7154                 public CheckedExpr (Expression e, Location l)
7155                 {
7156                         Expr = e;
7157                         loc = l;
7158                 }
7159
7160                 public override Expression DoResolve (EmitContext ec)
7161                 {
7162                         bool last_check = ec.CheckState;
7163                         bool last_const_check = ec.ConstantCheckState;
7164
7165                         ec.CheckState = true;
7166                         ec.ConstantCheckState = true;
7167                         Expr = Expr.Resolve (ec);
7168                         ec.CheckState = last_check;
7169                         ec.ConstantCheckState = last_const_check;
7170
7171                         if (Expr == null)
7172                                 return null;
7173
7174                         if (Expr is Constant)
7175                                 return Expr;
7176
7177                         eclass = Expr.eclass;
7178                         type = Expr.Type;
7179                         return this;
7180                 }
7181
7182                 public override void Emit (EmitContext ec)
7183                 {
7184                         bool last_check = ec.CheckState;
7185                         bool last_const_check = ec.ConstantCheckState;
7186
7187                         ec.CheckState = true;
7188                         ec.ConstantCheckState = true;
7189                         Expr.Emit (ec);
7190                         ec.CheckState = last_check;
7191                         ec.ConstantCheckState = last_const_check;
7192                 }
7193
7194         }
7195
7196         /// <summary>
7197         ///   Implements the unchecked expression
7198         /// </summary>
7199         public class UnCheckedExpr : Expression {
7200
7201                 public Expression Expr;
7202
7203                 public UnCheckedExpr (Expression e, Location l)
7204                 {
7205                         Expr = e;
7206                         loc = l;
7207                 }
7208
7209                 public override Expression DoResolve (EmitContext ec)
7210                 {
7211                         bool last_check = ec.CheckState;
7212                         bool last_const_check = ec.ConstantCheckState;
7213
7214                         ec.CheckState = false;
7215                         ec.ConstantCheckState = false;
7216                         Expr = Expr.Resolve (ec);
7217                         ec.CheckState = last_check;
7218                         ec.ConstantCheckState = last_const_check;
7219
7220                         if (Expr == null)
7221                                 return null;
7222
7223                         if (Expr is Constant)
7224                                 return Expr;
7225
7226                         eclass = Expr.eclass;
7227                         type = Expr.Type;
7228                         return this;
7229                 }
7230
7231                 public override void Emit (EmitContext ec)
7232                 {
7233                         bool last_check = ec.CheckState;
7234                         bool last_const_check = ec.ConstantCheckState;
7235
7236                         ec.CheckState = false;
7237                         ec.ConstantCheckState = false;
7238                         Expr.Emit (ec);
7239                         ec.CheckState = last_check;
7240                         ec.ConstantCheckState = last_const_check;
7241                 }
7242
7243         }
7244
7245         /// <summary>
7246         ///   An Element Access expression.
7247         ///
7248         ///   During semantic analysis these are transformed into
7249         ///   IndexerAccess, ArrayAccess or a PointerArithmetic.
7250         /// </summary>
7251         public class ElementAccess : Expression {
7252                 public ArrayList  Arguments;
7253                 public Expression Expr;
7254
7255                 public ElementAccess (Expression e, ArrayList e_list)
7256                 {
7257                         Expr = e;
7258
7259                         loc  = e.Location;
7260
7261                         if (e_list == null)
7262                                 return;
7263
7264                         Arguments = new ArrayList ();
7265                         foreach (Expression tmp in e_list)
7266                                 Arguments.Add (new Argument (tmp, Argument.AType.Expression));
7267
7268                 }
7269
7270                 bool CommonResolve (EmitContext ec)
7271                 {
7272                         Expr = Expr.Resolve (ec);
7273
7274                         if (Expr == null)
7275                                 return false;
7276
7277                         if (Arguments == null)
7278                                 return false;
7279
7280                         foreach (Argument a in Arguments){
7281                                 if (!a.Resolve (ec, loc))
7282                                         return false;
7283                         }
7284
7285                         return true;
7286                 }
7287
7288                 Expression MakePointerAccess (EmitContext ec, Type t)
7289                 {
7290                         if (t == TypeManager.void_ptr_type){
7291                                 Error (242, "The array index operation is not valid on void pointers");
7292                                 return null;
7293                         }
7294                         if (Arguments.Count != 1){
7295                                 Error (196, "A pointer must be indexed by only one value");
7296                                 return null;
7297                         }
7298                         Expression p;
7299
7300                         p = new PointerArithmetic (true, Expr, ((Argument)Arguments [0]).Expr, t, loc).Resolve (ec);
7301                         if (p == null)
7302                                 return null;
7303                         return new Indirection (p, loc).Resolve (ec);
7304                 }
7305
7306                 public override Expression DoResolve (EmitContext ec)
7307                 {
7308                         if (!CommonResolve (ec))
7309                                 return null;
7310
7311                         //
7312                         // We perform some simple tests, and then to "split" the emit and store
7313                         // code we create an instance of a different class, and return that.
7314                         //
7315                         // I am experimenting with this pattern.
7316                         //
7317                         Type t = Expr.Type;
7318
7319                         if (t == TypeManager.array_type){
7320                                 Report.Error (21, loc, "Cannot apply indexing with [] to an expression of type `System.Array'");
7321                                 return null;
7322                         }
7323
7324                         if (t.IsArray)
7325                                 return (new ArrayAccess (this, loc)).Resolve (ec);
7326                         if (t.IsPointer)
7327                                 return MakePointerAccess (ec, Expr.Type);
7328
7329                         FieldExpr fe = Expr as FieldExpr;
7330                         if (fe != null) {
7331                                 IFixedBuffer ff = AttributeTester.GetFixedBuffer (fe.FieldInfo);
7332                                 if (ff != null) {
7333                                         return MakePointerAccess (ec, ff.ElementType);
7334                                 }
7335                         }
7336                         return (new IndexerAccess (this, loc)).Resolve (ec);
7337                 }
7338
7339                 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
7340                 {
7341                         if (!CommonResolve (ec))
7342                                 return null;
7343
7344                         Type t = Expr.Type;
7345                         if (t.IsArray)
7346                                 return (new ArrayAccess (this, loc)).DoResolveLValue (ec, right_side);
7347
7348                         if (t.IsPointer)
7349                                 return MakePointerAccess (ec, Expr.Type);
7350
7351                         FieldExpr fe = Expr as FieldExpr;
7352                         if (fe != null) {
7353                                 IFixedBuffer ff = AttributeTester.GetFixedBuffer (fe.FieldInfo);
7354                                 if (ff != null) {
7355                                         if (!(fe.InstanceExpression is LocalVariableReference) &&
7356                                                 !(fe.InstanceExpression is This)) {
7357                                                 Report.Error (1708, loc, "Fixed size buffers can only be accessed through locals or fields");
7358                                                 return null;
7359                                         }
7360                                         if (!ec.InFixedInitializer && ec.ContainerType.IsValueType) {
7361                                                 Error (1666, "You cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement");
7362                                                 return null;
7363                                         }
7364                                         return MakePointerAccess (ec, ff.ElementType);
7365                                 }
7366                         }
7367                         return (new IndexerAccess (this, loc)).DoResolveLValue (ec, right_side);
7368                 }
7369
7370                 public override void Emit (EmitContext ec)
7371                 {
7372                         throw new Exception ("Should never be reached");
7373                 }
7374         }
7375
7376         /// <summary>
7377         ///   Implements array access
7378         /// </summary>
7379         public class ArrayAccess : Expression, IAssignMethod, IMemoryLocation {
7380                 //
7381                 // Points to our "data" repository
7382                 //
7383                 ElementAccess ea;
7384
7385                 LocalTemporary temp;
7386                 bool prepared;
7387
7388                 public ArrayAccess (ElementAccess ea_data, Location l)
7389                 {
7390                         ea = ea_data;
7391                         eclass = ExprClass.Variable;
7392                         loc = l;
7393                 }
7394
7395                 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
7396                 {
7397                         return DoResolve (ec);
7398                 }
7399
7400                 public override Expression DoResolve (EmitContext ec)
7401                 {
7402 #if false
7403                         ExprClass eclass = ea.Expr.eclass;
7404
7405                         // As long as the type is valid
7406                         if (!(eclass == ExprClass.Variable || eclass == ExprClass.PropertyAccess ||
7407                               eclass == ExprClass.Value)) {
7408                                 ea.Expr.Error_UnexpectedKind ("variable or value");
7409                                 return null;
7410                         }
7411 #endif
7412
7413                         Type t = ea.Expr.Type;
7414                         if (t.GetArrayRank () != ea.Arguments.Count){
7415                                 Report.Error (22, ea.Location, "Wrong number of indexes `{0}' inside [], expected `{1}'",
7416                                           ea.Arguments.Count.ToString (), t.GetArrayRank ().ToString ());
7417                                 return null;
7418                         }
7419
7420                         type = TypeManager.GetElementType (t);
7421                         if (type.IsPointer && !ec.InUnsafe){
7422                                 UnsafeError (ea.Location);
7423                                 return null;
7424                         }
7425
7426                         foreach (Argument a in ea.Arguments){
7427                                 Type argtype = a.Type;
7428
7429                                 if (argtype == TypeManager.int32_type ||
7430                                     argtype == TypeManager.uint32_type ||
7431                                     argtype == TypeManager.int64_type ||
7432                                     argtype == TypeManager.uint64_type) {
7433                                         Constant c = a.Expr as Constant;
7434                                         if (c != null && c.IsNegative) {
7435                                                 Report.Warning (251, 2, ea.Location, "Indexing an array with a negative index (array indices always start at zero)");
7436                                         }
7437                                         continue;
7438                                 }
7439
7440                                 //
7441                                 // Mhm.  This is strage, because the Argument.Type is not the same as
7442                                 // Argument.Expr.Type: the value changes depending on the ref/out setting.
7443                                 //
7444                                 // Wonder if I will run into trouble for this.
7445                                 //
7446                                 a.Expr = ExpressionToArrayArgument (ec, a.Expr, ea.Location);
7447                                 if (a.Expr == null)
7448                                         return null;
7449                         }
7450
7451                         eclass = ExprClass.Variable;
7452
7453                         return this;
7454                 }
7455
7456                 /// <summary>
7457                 ///    Emits the right opcode to load an object of Type `t'
7458                 ///    from an array of T
7459                 /// </summary>
7460                 static public void EmitLoadOpcode (ILGenerator ig, Type type)
7461                 {
7462                         if (type == TypeManager.byte_type || type == TypeManager.bool_type)
7463                                 ig.Emit (OpCodes.Ldelem_U1);
7464                         else if (type == TypeManager.sbyte_type)
7465                                 ig.Emit (OpCodes.Ldelem_I1);
7466                         else if (type == TypeManager.short_type)
7467                                 ig.Emit (OpCodes.Ldelem_I2);
7468                         else if (type == TypeManager.ushort_type || type == TypeManager.char_type)
7469                                 ig.Emit (OpCodes.Ldelem_U2);
7470                         else if (type == TypeManager.int32_type)
7471                                 ig.Emit (OpCodes.Ldelem_I4);
7472                         else if (type == TypeManager.uint32_type)
7473                                 ig.Emit (OpCodes.Ldelem_U4);
7474                         else if (type == TypeManager.uint64_type)
7475                                 ig.Emit (OpCodes.Ldelem_I8);
7476                         else if (type == TypeManager.int64_type)
7477                                 ig.Emit (OpCodes.Ldelem_I8);
7478                         else if (type == TypeManager.float_type)
7479                                 ig.Emit (OpCodes.Ldelem_R4);
7480                         else if (type == TypeManager.double_type)
7481                                 ig.Emit (OpCodes.Ldelem_R8);
7482                         else if (type == TypeManager.intptr_type)
7483                                 ig.Emit (OpCodes.Ldelem_I);
7484                         else if (TypeManager.IsEnumType (type)){
7485                                 EmitLoadOpcode (ig, TypeManager.EnumToUnderlying (type));
7486                         } else if (type.IsValueType){
7487                                 ig.Emit (OpCodes.Ldelema, type);
7488                                 ig.Emit (OpCodes.Ldobj, type);
7489                         } else if (type.IsPointer)
7490                                 ig.Emit (OpCodes.Ldelem_I);
7491                         else
7492                                 ig.Emit (OpCodes.Ldelem_Ref);
7493                 }
7494
7495                 /// <summary>
7496                 ///    Returns the right opcode to store an object of Type `t'
7497                 ///    from an array of T.
7498                 /// </summary>
7499                 static public OpCode GetStoreOpcode (Type t, out bool is_stobj)
7500                 {
7501                         //Console.WriteLine (new System.Diagnostics.StackTrace ());
7502                         is_stobj = false;
7503                         t = TypeManager.TypeToCoreType (t);
7504                         if (TypeManager.IsEnumType (t))
7505                                 t = TypeManager.EnumToUnderlying (t);
7506                         if (t == TypeManager.byte_type || t == TypeManager.sbyte_type ||
7507                             t == TypeManager.bool_type)
7508                                 return OpCodes.Stelem_I1;
7509                         else if (t == TypeManager.short_type || t == TypeManager.ushort_type ||
7510                                  t == TypeManager.char_type)
7511                                 return OpCodes.Stelem_I2;
7512                         else if (t == TypeManager.int32_type || t == TypeManager.uint32_type)
7513                                 return OpCodes.Stelem_I4;
7514                         else if (t == TypeManager.int64_type || t == TypeManager.uint64_type)
7515                                 return OpCodes.Stelem_I8;
7516                         else if (t == TypeManager.float_type)
7517                                 return OpCodes.Stelem_R4;
7518                         else if (t == TypeManager.double_type)
7519                                 return OpCodes.Stelem_R8;
7520                         else if (t == TypeManager.intptr_type) {
7521                                 is_stobj = true;
7522                                 return OpCodes.Stobj;
7523                         } else if (t.IsValueType) {
7524                                 is_stobj = true;
7525                                 return OpCodes.Stobj;
7526                         } else if (t.IsPointer)
7527                                 return OpCodes.Stelem_I;
7528                         else
7529                                 return OpCodes.Stelem_Ref;
7530                 }
7531
7532                 MethodInfo FetchGetMethod ()
7533                 {
7534                         ModuleBuilder mb = CodeGen.Module.Builder;
7535                         int arg_count = ea.Arguments.Count;
7536                         Type [] args = new Type [arg_count];
7537                         MethodInfo get;
7538
7539                         for (int i = 0; i < arg_count; i++){
7540                                 //args [i++] = a.Type;
7541                                 args [i] = TypeManager.int32_type;
7542                         }
7543
7544                         get = mb.GetArrayMethod (
7545                                 ea.Expr.Type, "Get",
7546                                 CallingConventions.HasThis |
7547                                 CallingConventions.Standard,
7548                                 type, args);
7549                         return get;
7550                 }
7551
7552
7553                 MethodInfo FetchAddressMethod ()
7554                 {
7555                         ModuleBuilder mb = CodeGen.Module.Builder;
7556                         int arg_count = ea.Arguments.Count;
7557                         Type [] args = new Type [arg_count];
7558                         MethodInfo address;
7559                         Type ret_type;
7560
7561                         ret_type = TypeManager.GetReferenceType (type);
7562
7563                         for (int i = 0; i < arg_count; i++){
7564                                 //args [i++] = a.Type;
7565                                 args [i] = TypeManager.int32_type;
7566                         }
7567
7568                         address = mb.GetArrayMethod (
7569                                 ea.Expr.Type, "Address",
7570                                 CallingConventions.HasThis |
7571                                 CallingConventions.Standard,
7572                                 ret_type, args);
7573
7574                         return address;
7575                 }
7576
7577                 //
7578                 // Load the array arguments into the stack.
7579                 //
7580                 // If we have been requested to cache the values (cached_locations array
7581                 // initialized), then load the arguments the first time and store them
7582                 // in locals.  otherwise load from local variables.
7583                 //
7584                 void LoadArrayAndArguments (EmitContext ec)
7585                 {
7586                         ILGenerator ig = ec.ig;
7587
7588                         ea.Expr.Emit (ec);
7589                         foreach (Argument a in ea.Arguments){
7590                                 Type argtype = a.Expr.Type;
7591
7592                                 a.Expr.Emit (ec);
7593
7594                                 if (argtype == TypeManager.int64_type)
7595                                         ig.Emit (OpCodes.Conv_Ovf_I);
7596                                 else if (argtype == TypeManager.uint64_type)
7597                                         ig.Emit (OpCodes.Conv_Ovf_I_Un);
7598                         }
7599                 }
7600
7601                 public void Emit (EmitContext ec, bool leave_copy)
7602                 {
7603                         int rank = ea.Expr.Type.GetArrayRank ();
7604                         ILGenerator ig = ec.ig;
7605
7606                         if (!prepared) {
7607                                 LoadArrayAndArguments (ec);
7608
7609                                 if (rank == 1)
7610                                         EmitLoadOpcode (ig, type);
7611                                 else {
7612                                         MethodInfo method;
7613
7614                                         method = FetchGetMethod ();
7615                                         ig.Emit (OpCodes.Call, method);
7616                                 }
7617                         } else
7618                                 LoadFromPtr (ec.ig, this.type);
7619
7620                         if (leave_copy) {
7621                                 ec.ig.Emit (OpCodes.Dup);
7622                                 temp = new LocalTemporary (ec, this.type);
7623                                 temp.Store (ec);
7624                         }
7625                 }
7626
7627                 public override void Emit (EmitContext ec)
7628                 {
7629                         Emit (ec, false);
7630                 }
7631
7632                 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
7633                 {
7634                         int rank = ea.Expr.Type.GetArrayRank ();
7635                         ILGenerator ig = ec.ig;
7636                         Type t = source.Type;
7637                         prepared = prepare_for_load;
7638
7639                         if (prepare_for_load) {
7640                                 AddressOf (ec, AddressOp.LoadStore);
7641                                 ec.ig.Emit (OpCodes.Dup);
7642                                 source.Emit (ec);
7643                                 if (leave_copy) {
7644                                         ec.ig.Emit (OpCodes.Dup);
7645                                         temp = new LocalTemporary (ec, this.type);
7646                                         temp.Store (ec);
7647                                 }
7648                                 StoreFromPtr (ec.ig, t);
7649
7650                                 if (temp != null)
7651                                         temp.Emit (ec);
7652
7653                                 return;
7654                         }
7655
7656                         LoadArrayAndArguments (ec);
7657
7658                         if (rank == 1) {
7659                                 bool is_stobj;
7660                                 OpCode op = GetStoreOpcode (t, out is_stobj);
7661                                 //
7662                                 // The stobj opcode used by value types will need
7663                                 // an address on the stack, not really an array/array
7664                                 // pair
7665                                 //
7666                                 if (is_stobj)
7667                                         ig.Emit (OpCodes.Ldelema, t);
7668
7669                                 source.Emit (ec);
7670                                 if (leave_copy) {
7671                                         ec.ig.Emit (OpCodes.Dup);
7672                                         temp = new LocalTemporary (ec, this.type);
7673                                         temp.Store (ec);
7674                                 }
7675
7676                                 if (is_stobj)
7677                                         ig.Emit (OpCodes.Stobj, t);
7678                                 else
7679                                         ig.Emit (op);
7680                         } else {
7681                                 ModuleBuilder mb = CodeGen.Module.Builder;
7682                                 int arg_count = ea.Arguments.Count;
7683                                 Type [] args = new Type [arg_count + 1];
7684                                 MethodInfo set;
7685
7686                                 source.Emit (ec);
7687                                 if (leave_copy) {
7688                                         ec.ig.Emit (OpCodes.Dup);
7689                                         temp = new LocalTemporary (ec, this.type);
7690                                         temp.Store (ec);
7691                                 }
7692
7693                                 for (int i = 0; i < arg_count; i++){
7694                                         //args [i++] = a.Type;
7695                                         args [i] = TypeManager.int32_type;
7696                                 }
7697
7698                                 args [arg_count] = type;
7699
7700                                 set = mb.GetArrayMethod (
7701                                         ea.Expr.Type, "Set",
7702                                         CallingConventions.HasThis |
7703                                         CallingConventions.Standard,
7704                                         TypeManager.void_type, args);
7705
7706                                 ig.Emit (OpCodes.Call, set);
7707                         }
7708
7709                         if (temp != null)
7710                                 temp.Emit (ec);
7711                 }
7712
7713                 public void AddressOf (EmitContext ec, AddressOp mode)
7714                 {
7715                         int rank = ea.Expr.Type.GetArrayRank ();
7716                         ILGenerator ig = ec.ig;
7717
7718                         LoadArrayAndArguments (ec);
7719
7720                         if (rank == 1){
7721                                 ig.Emit (OpCodes.Ldelema, type);
7722                         } else {
7723                                 MethodInfo address = FetchAddressMethod ();
7724                                 ig.Emit (OpCodes.Call, address);
7725                         }
7726                 }
7727
7728                 public void EmitGetLength (EmitContext ec, int dim)
7729                 {
7730                         int rank = ea.Expr.Type.GetArrayRank ();
7731                         ILGenerator ig = ec.ig;
7732
7733                         ea.Expr.Emit (ec);
7734                         if (rank == 1) {
7735                                 ig.Emit (OpCodes.Ldlen);
7736                                 ig.Emit (OpCodes.Conv_I4);
7737                         } else {
7738                                 IntLiteral.EmitInt (ig, dim);
7739                                 ig.Emit (OpCodes.Callvirt, TypeManager.int_getlength_int);
7740                         }
7741                 }
7742         }
7743
7744         class Indexers {
7745                 // note that the ArrayList itself in mutable.  We just can't assign to 'Properties' again.
7746                 public readonly ArrayList Properties;
7747                 static Indexers empty;
7748
7749                 public struct Indexer {
7750                         public readonly PropertyInfo PropertyInfo;
7751                         public readonly MethodInfo Getter, Setter;
7752
7753                         public Indexer (PropertyInfo property_info, MethodInfo get, MethodInfo set)
7754                         {
7755                                 this.PropertyInfo = property_info;
7756                                 this.Getter = get;
7757                                 this.Setter = set;
7758                         }
7759                 }
7760
7761                 static Indexers ()
7762                 {
7763                         empty = new Indexers (null);
7764                 }
7765
7766                 Indexers (ArrayList array)
7767                 {
7768                         Properties = array;
7769                 }
7770
7771                 static void Append (ref Indexers ix, Type caller_type, MemberInfo [] mi)
7772                 {
7773                         bool dummy;
7774                         if (mi == null)
7775                                 return;
7776                         foreach (PropertyInfo property in mi){
7777                                 MethodInfo get, set;
7778
7779                                 get = property.GetGetMethod (true);
7780                                 set = property.GetSetMethod (true);
7781                                 if (get != null && !Expression.IsAccessorAccessible (caller_type, get, out dummy))
7782                                         get = null;
7783                                 if (set != null && !Expression.IsAccessorAccessible (caller_type, set, out dummy))
7784                                         set = null;
7785                                 if (get != null || set != null) {
7786                                         if (ix == empty)
7787                                                 ix = new Indexers (new ArrayList ());
7788                                         ix.Properties.Add (new Indexer (property, get, set));
7789                                 }
7790                         }
7791                 }
7792
7793                 static private MemberInfo [] GetIndexersForTypeOrInterface (Type caller_type, Type lookup_type)
7794                 {
7795                         string p_name = TypeManager.IndexerPropertyName (lookup_type);
7796
7797                         return TypeManager.MemberLookup (
7798                                 caller_type, caller_type, lookup_type, MemberTypes.Property,
7799                                 BindingFlags.Public | BindingFlags.Instance |
7800                                 BindingFlags.DeclaredOnly, p_name, null);
7801                 }
7802
7803                 static public Indexers GetIndexersForType (Type caller_type, Type lookup_type, Location loc)
7804                 {
7805                         Indexers ix = empty;
7806
7807                         Type copy = lookup_type;
7808                         while (copy != TypeManager.object_type && copy != null){
7809                                 Append (ref ix, caller_type, GetIndexersForTypeOrInterface (caller_type, copy));
7810                                 copy = copy.BaseType;
7811                         }
7812
7813                         if (lookup_type.IsInterface) {
7814                                 Type [] ifaces = TypeManager.GetInterfaces (lookup_type);
7815                                 if (ifaces != null) {
7816                                         foreach (Type itype in ifaces)
7817                                                 Append (ref ix, caller_type, GetIndexersForTypeOrInterface (caller_type, itype));
7818                                 }
7819                         }
7820
7821                         return ix;
7822                 }
7823         }
7824
7825         /// <summary>
7826         ///   Expressions that represent an indexer call.
7827         /// </summary>
7828         public class IndexerAccess : Expression, IAssignMethod {
7829                 //
7830                 // Points to our "data" repository
7831                 //
7832                 MethodInfo get, set;
7833                 ArrayList set_arguments;
7834                 bool is_base_indexer;
7835
7836                 protected Type indexer_type;
7837                 protected Type current_type;
7838                 protected Expression instance_expr;
7839                 protected ArrayList arguments;
7840
7841                 public IndexerAccess (ElementAccess ea, Location loc)
7842                         : this (ea.Expr, false, loc)
7843                 {
7844                         this.arguments = ea.Arguments;
7845                 }
7846
7847                 protected IndexerAccess (Expression instance_expr, bool is_base_indexer,
7848                                          Location loc)
7849                 {
7850                         this.instance_expr = instance_expr;
7851                         this.is_base_indexer = is_base_indexer;
7852                         this.eclass = ExprClass.Value;
7853                         this.loc = loc;
7854                 }
7855
7856                 protected virtual bool CommonResolve (EmitContext ec)
7857                 {
7858                         indexer_type = instance_expr.Type;
7859                         current_type = ec.ContainerType;
7860
7861                         return true;
7862                 }
7863
7864                 public override Expression DoResolve (EmitContext ec)
7865                 {
7866                         ArrayList AllGetters = new ArrayList();
7867                         if (!CommonResolve (ec))
7868                                 return null;
7869
7870                         //
7871                         // Step 1: Query for all `Item' *properties*.  Notice
7872                         // that the actual methods are pointed from here.
7873                         //
7874                         // This is a group of properties, piles of them.
7875
7876                         bool found_any = false, found_any_getters = false;
7877                         Type lookup_type = indexer_type;
7878
7879                         Indexers ilist = Indexers.GetIndexersForType (current_type, lookup_type, loc);
7880                         if (ilist.Properties != null) {
7881                                 found_any = true;
7882                                 foreach (Indexers.Indexer ix in ilist.Properties) {
7883                                         if (ix.Getter != null)
7884                                                 AllGetters.Add (ix.Getter);
7885                                 }
7886                         }
7887
7888                         if (AllGetters.Count > 0) {
7889                                 found_any_getters = true;
7890                                 get = (MethodInfo) Invocation.OverloadResolve (
7891                                         ec, new MethodGroupExpr (AllGetters, loc),
7892                                         arguments, false, loc);
7893                         }
7894
7895                         if (!found_any) {
7896                                 Report.Error (21, loc, "Cannot apply indexing with [] to an expression of type `{0}'",
7897                                               TypeManager.CSharpName (indexer_type));
7898                                 return null;
7899                         }
7900
7901                         if (!found_any_getters) {
7902                                 Report.Error (154, loc, "The property or indexer `{0}' cannot be used in this context because it lacks the `get' accessor",
7903                                        "XXXXXXXX");
7904                                 return null;
7905                         }
7906
7907                         if (get == null) {
7908                                 Invocation.Error_WrongNumArguments (loc, "this", arguments.Count);
7909                                 return null;
7910                         }
7911
7912                         //
7913                         // Only base will allow this invocation to happen.
7914                         //
7915                         if (get.IsAbstract && this is BaseIndexerAccess){
7916                                 Error_CannotCallAbstractBase (TypeManager.CSharpSignature (get));
7917                                 return null;
7918                         }
7919
7920                         type = get.ReturnType;
7921                         if (type.IsPointer && !ec.InUnsafe){
7922                                 UnsafeError (loc);
7923                                 return null;
7924                         }
7925
7926                         instance_expr.CheckMarshallByRefAccess (ec.ContainerType);
7927
7928                         eclass = ExprClass.IndexerAccess;
7929                         return this;
7930                 }
7931
7932                 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
7933                 {
7934                         ArrayList AllSetters = new ArrayList();
7935                         if (!CommonResolve (ec))
7936                                 return null;
7937
7938                         bool found_any = false, found_any_setters = false;
7939
7940                         Indexers ilist = Indexers.GetIndexersForType (current_type, indexer_type, loc);
7941                         if (ilist.Properties != null) {
7942                                 found_any = true;
7943                                 foreach (Indexers.Indexer ix in ilist.Properties) {
7944                                         if (ix.Setter != null)
7945                                                 AllSetters.Add (ix.Setter);
7946                                 }
7947                         }
7948                         if (AllSetters.Count > 0) {
7949                                 found_any_setters = true;
7950                                 set_arguments = (ArrayList) arguments.Clone ();
7951                                 set_arguments.Add (new Argument (right_side, Argument.AType.Expression));
7952                                 set = (MethodInfo) Invocation.OverloadResolve (
7953                                         ec, new MethodGroupExpr (AllSetters, loc),
7954                                         set_arguments, false, loc);
7955                         }
7956
7957                         if (!found_any) {
7958                                 Report.Error (21, loc, "Cannot apply indexing with [] to an expression of type `{0}'",
7959                                               TypeManager.CSharpName (indexer_type));
7960                                 return null;
7961                         }
7962
7963                         if (!found_any_setters) {
7964                                 Error (154, "indexer can not be used in this context, because " +
7965                                        "it lacks a `set' accessor");
7966                                 return null;
7967                         }
7968
7969                         if (set == null) {
7970                                 Invocation.Error_WrongNumArguments (loc, "this", arguments.Count);
7971                                 return null;
7972                         }
7973
7974                         //
7975                         // Only base will allow this invocation to happen.
7976                         //
7977                         if (set.IsAbstract && this is BaseIndexerAccess){
7978                                 Error_CannotCallAbstractBase (TypeManager.CSharpSignature (set));
7979                                 return null;
7980                         }
7981
7982                         //
7983                         // Now look for the actual match in the list of indexers to set our "return" type
7984                         //
7985                         type = TypeManager.void_type;   // default value
7986                         foreach (Indexers.Indexer ix in ilist.Properties){
7987                                 if (ix.Setter == set){
7988                                         type = ix.PropertyInfo.PropertyType;
7989                                         break;
7990                                 }
7991                         }
7992
7993                         instance_expr.CheckMarshallByRefAccess (ec.ContainerType);
7994
7995                         eclass = ExprClass.IndexerAccess;
7996                         return this;
7997                 }
7998
7999                 bool prepared = false;
8000                 LocalTemporary temp;
8001
8002                 public void Emit (EmitContext ec, bool leave_copy)
8003                 {
8004                         Invocation.EmitCall (ec, is_base_indexer, false, instance_expr, get, arguments, loc, prepared, false);
8005                         if (leave_copy) {
8006                                 ec.ig.Emit (OpCodes.Dup);
8007                                 temp = new LocalTemporary (ec, Type);
8008                                 temp.Store (ec);
8009                         }
8010                 }
8011
8012                 //
8013                 // source is ignored, because we already have a copy of it from the
8014                 // LValue resolution and we have already constructed a pre-cached
8015                 // version of the arguments (ea.set_arguments);
8016                 //
8017                 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
8018                 {
8019                         prepared = prepare_for_load;
8020                         Argument a = (Argument) set_arguments [set_arguments.Count - 1];
8021
8022                         if (prepared) {
8023                                 source.Emit (ec);
8024                                 if (leave_copy) {
8025                                         ec.ig.Emit (OpCodes.Dup);
8026                                         temp = new LocalTemporary (ec, Type);
8027                                         temp.Store (ec);
8028                                 }
8029                         } else if (leave_copy) {
8030                                 temp = new LocalTemporary (ec, Type);
8031                                 source.Emit (ec);
8032                                 temp.Store (ec);
8033                                 a.Expr = temp;
8034                         }
8035
8036                         Invocation.EmitCall (ec, is_base_indexer, false, instance_expr, set, set_arguments, loc, false, prepared);
8037
8038                         if (temp != null)
8039                                 temp.Emit (ec);
8040                 }
8041
8042
8043                 public override void Emit (EmitContext ec)
8044                 {
8045                         Emit (ec, false);
8046                 }
8047         }
8048
8049         /// <summary>
8050         ///   The base operator for method names
8051         /// </summary>
8052         public class BaseAccess : Expression {
8053                 string member;
8054
8055                 public BaseAccess (string member, Location l)
8056                 {
8057                         this.member = member;
8058                         loc = l;
8059                 }
8060
8061                 public override Expression DoResolve (EmitContext ec)
8062                 {
8063                         Expression c = CommonResolve (ec);
8064
8065                         if (c == null)
8066                                 return null;
8067
8068                         //
8069                         // MethodGroups use this opportunity to flag an error on lacking ()
8070                         //
8071                         if (!(c is MethodGroupExpr))
8072                                 return c.Resolve (ec);
8073                         return c;
8074                 }
8075
8076                 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
8077                 {
8078                         Expression c = CommonResolve (ec);
8079
8080                         if (c == null)
8081                                 return null;
8082
8083                         //
8084                         // MethodGroups use this opportunity to flag an error on lacking ()
8085                         //
8086                         if (! (c is MethodGroupExpr))
8087                                 return c.DoResolveLValue (ec, right_side);
8088
8089                         return c;
8090                 }
8091
8092                 Expression CommonResolve (EmitContext ec)
8093                 {
8094                         Expression member_lookup;
8095                         Type current_type = ec.ContainerType;
8096                         Type base_type = current_type.BaseType;
8097
8098                         if (ec.IsStatic){
8099                                 Error (1511, "Keyword `base' is not available in a static method");
8100                                 return null;
8101                         }
8102
8103                         if (ec.IsFieldInitializer){
8104                                 Error (1512, "Keyword `base' is not available in the current context");
8105                                 return null;
8106                         }
8107
8108                         member_lookup = MemberLookup (ec, ec.ContainerType, null, base_type, member,
8109                                                       AllMemberTypes, AllBindingFlags, loc);
8110                         if (member_lookup == null) {
8111                                 MemberLookupFailed (ec, base_type, base_type, member, null, true, loc);
8112                                 return null;
8113                         }
8114
8115                         Expression left;
8116
8117                         if (ec.IsStatic)
8118                                 left = new TypeExpression (base_type, loc);
8119                         else
8120                                 left = ec.GetThis (loc);
8121
8122                         MemberExpr me = (MemberExpr) member_lookup;
8123
8124                         Expression e = me.ResolveMemberAccess (ec, left, loc, null);
8125
8126                         if (e is PropertyExpr) {
8127                                 PropertyExpr pe = (PropertyExpr) e;
8128
8129                                 pe.IsBase = true;
8130                         }
8131
8132                         if (e is MethodGroupExpr)
8133                                 ((MethodGroupExpr) e).IsBase = true;
8134
8135                         return e;
8136                 }
8137
8138                 public override void Emit (EmitContext ec)
8139                 {
8140                         throw new Exception ("Should never be called");
8141                 }
8142         }
8143
8144         /// <summary>
8145         ///   The base indexer operator
8146         /// </summary>
8147         public class BaseIndexerAccess : IndexerAccess {
8148                 public BaseIndexerAccess (ArrayList args, Location loc)
8149                         : base (null, true, loc)
8150                 {
8151                         arguments = new ArrayList ();
8152                         foreach (Expression tmp in args)
8153                                 arguments.Add (new Argument (tmp, Argument.AType.Expression));
8154                 }
8155
8156                 protected override bool CommonResolve (EmitContext ec)
8157                 {
8158                         instance_expr = ec.GetThis (loc);
8159
8160                         current_type = ec.ContainerType.BaseType;
8161                         indexer_type = current_type;
8162
8163                         foreach (Argument a in arguments){
8164                                 if (!a.Resolve (ec, loc))
8165                                         return false;
8166                         }
8167
8168                         return true;
8169                 }
8170         }
8171
8172         /// <summary>
8173         ///   This class exists solely to pass the Type around and to be a dummy
8174         ///   that can be passed to the conversion functions (this is used by
8175         ///   foreach implementation to typecast the object return value from
8176         ///   get_Current into the proper type.  All code has been generated and
8177         ///   we only care about the side effect conversions to be performed
8178         ///
8179         ///   This is also now used as a placeholder where a no-action expression
8180         ///   is needed (the `New' class).
8181         /// </summary>
8182         public class EmptyExpression : Expression {
8183                 public static readonly EmptyExpression Null = new EmptyExpression ();
8184
8185                 static EmptyExpression temp = new EmptyExpression ();
8186                 public static EmptyExpression Grab ()
8187                 {
8188                         if (temp == null)
8189                                 throw new InternalErrorException ("Nested Grab");
8190                         EmptyExpression retval = temp;
8191                         temp = null;
8192                         return retval;
8193                 }
8194
8195                 public static void Release (EmptyExpression e)
8196                 {
8197                         if (temp != null)
8198                                 throw new InternalErrorException ("Already released");
8199                         temp = e;
8200                 }
8201
8202                 // TODO: should be protected
8203                 public EmptyExpression ()
8204                 {
8205                         type = TypeManager.object_type;
8206                         eclass = ExprClass.Value;
8207                         loc = Location.Null;
8208                 }
8209
8210                 public EmptyExpression (Type t)
8211                 {
8212                         type = t;
8213                         eclass = ExprClass.Value;
8214                         loc = Location.Null;
8215                 }
8216
8217                 public override Expression DoResolve (EmitContext ec)
8218                 {
8219                         return this;
8220                 }
8221
8222                 public override void Emit (EmitContext ec)
8223                 {
8224                         // nothing, as we only exist to not do anything.
8225                 }
8226
8227                 //
8228                 // This is just because we might want to reuse this bad boy
8229                 // instead of creating gazillions of EmptyExpressions.
8230                 // (CanImplicitConversion uses it)
8231                 //
8232                 public void SetType (Type t)
8233                 {
8234                         type = t;
8235                 }
8236         }
8237
8238         public class UserCast : Expression {
8239                 MethodBase method;
8240                 Expression source;
8241
8242                 public UserCast (MethodInfo method, Expression source, Location l)
8243                 {
8244                         this.method = method;
8245                         this.source = source;
8246                         type = method.ReturnType;
8247                         eclass = ExprClass.Value;
8248                         loc = l;
8249                 }
8250
8251                 public Expression Source {
8252                         get {
8253                                 return source;
8254                         }
8255                 }
8256
8257                 public override Expression DoResolve (EmitContext ec)
8258                 {
8259                         //
8260                         // We are born fully resolved
8261                         //
8262                         return this;
8263                 }
8264
8265                 public override void Emit (EmitContext ec)
8266                 {
8267                         ILGenerator ig = ec.ig;
8268
8269                         source.Emit (ec);
8270
8271                         if (method is MethodInfo)
8272                                 ig.Emit (OpCodes.Call, (MethodInfo) method);
8273                         else
8274                                 ig.Emit (OpCodes.Call, (ConstructorInfo) method);
8275
8276                 }
8277         }
8278
8279         // <summary>
8280         //   This class is used to "construct" the type during a typecast
8281         //   operation.  Since the Type.GetType class in .NET can parse
8282         //   the type specification, we just use this to construct the type
8283         //   one bit at a time.
8284         // </summary>
8285         public class ComposedCast : TypeExpr {
8286                 Expression left;
8287                 string dim;
8288
8289                 public ComposedCast (Expression left, string dim)
8290                         : this (left, dim, left.Location)
8291                 {
8292                 }
8293
8294                 public ComposedCast (Expression left, string dim, Location l)
8295                 {
8296                         this.left = left;
8297                         this.dim = dim;
8298                         loc = l;
8299                 }
8300
8301                 public override TypeExpr DoResolveAsTypeStep (EmitContext ec)
8302                 {
8303                         TypeExpr lexpr = left.ResolveAsTypeTerminal (ec, false);
8304                         if (lexpr == null)
8305                                 return null;
8306
8307                         bool old = ec.TestObsoleteMethodUsage;
8308                         ec.TestObsoleteMethodUsage = false;
8309                         Type ltype = lexpr.ResolveType (ec);
8310                         ec.TestObsoleteMethodUsage = old;
8311
8312                         if ((ltype == TypeManager.void_type) && (dim != "*")) {
8313                                 Report.Error (1547, Location,
8314                                               "Keyword 'void' cannot be used in this context");
8315                                 return null;
8316                         }
8317
8318                         if (dim == "*" && !TypeManager.VerifyUnManaged (ltype, loc)) {
8319                                 return null;
8320                         }
8321
8322                         type = TypeManager.GetConstructedType (ltype, dim);
8323                         if (type == null) {
8324                                 throw new InternalErrorException ("Couldn't create computed type " + ltype + dim);
8325                         }
8326
8327                         if (!ec.InUnsafe && type.IsPointer){
8328                                 UnsafeError (loc);
8329                                 return null;
8330                         }
8331
8332                         if (type.IsArray && (type.GetElementType () == TypeManager.arg_iterator_type ||
8333                                 type.GetElementType () == TypeManager.typed_reference_type)) {
8334                                 Report.Error (611, loc, "Array elements cannot be of type `{0}'", TypeManager.CSharpName (type.GetElementType ()));
8335                                 return null;
8336                         }
8337
8338                         eclass = ExprClass.Type;
8339                         return this;
8340                 }
8341
8342                 public override string Name {
8343                         get { return left + dim; }
8344                 }
8345
8346                 public override string FullName {
8347                         get { return type.FullName; }
8348                 }
8349
8350                 public override string GetSignatureForError ()
8351                 {
8352                         return left.GetSignatureForError () + dim;
8353                 }
8354         }
8355
8356         public class FixedBufferPtr : Expression {
8357                 Expression array;
8358
8359                 public FixedBufferPtr (Expression array, Type array_type, Location l)
8360                 {
8361                         this.array = array;
8362                         this.loc = l;
8363
8364                         type = TypeManager.GetPointerType (array_type);
8365                         eclass = ExprClass.Value;
8366                 }
8367
8368                 public override void Emit(EmitContext ec)
8369                 {
8370                         array.Emit (ec);
8371                 }
8372
8373                 public override Expression DoResolve (EmitContext ec)
8374                 {
8375                         //
8376                         // We are born fully resolved
8377                         //
8378                         return this;
8379                 }
8380         }
8381
8382
8383         //
8384         // This class is used to represent the address of an array, used
8385         // only by the Fixed statement, this generates "&a [0]" construct
8386         // for fixed (char *pa = a)
8387         //
8388         public class ArrayPtr : FixedBufferPtr {
8389                 Type array_type;
8390
8391                 public ArrayPtr (Expression array, Type array_type, Location l):
8392                         base (array, array_type, l)
8393                 {
8394                         this.array_type = array_type;
8395                 }
8396
8397                 public override void Emit (EmitContext ec)
8398                 {
8399                         base.Emit (ec);
8400
8401                         ILGenerator ig = ec.ig;
8402                         IntLiteral.EmitInt (ig, 0);
8403                         ig.Emit (OpCodes.Ldelema, array_type);
8404                 }
8405         }
8406
8407         //
8408         // Used by the fixed statement
8409         //
8410         public class StringPtr : Expression {
8411                 LocalBuilder b;
8412
8413                 public StringPtr (LocalBuilder b, Location l)
8414                 {
8415                         this.b = b;
8416                         eclass = ExprClass.Value;
8417                         type = TypeManager.char_ptr_type;
8418                         loc = l;
8419                 }
8420
8421                 public override Expression DoResolve (EmitContext ec)
8422                 {
8423                         // This should never be invoked, we are born in fully
8424                         // initialized state.
8425
8426                         return this;
8427                 }
8428
8429                 public override void Emit (EmitContext ec)
8430                 {
8431                         ILGenerator ig = ec.ig;
8432
8433                         ig.Emit (OpCodes.Ldloc, b);
8434                         ig.Emit (OpCodes.Conv_I);
8435                         ig.Emit (OpCodes.Call, TypeManager.int_get_offset_to_string_data);
8436                         ig.Emit (OpCodes.Add);
8437                 }
8438         }
8439
8440         //
8441         // Implements the `stackalloc' keyword
8442         //
8443         public class StackAlloc : Expression {
8444                 Type otype;
8445                 Expression t;
8446                 Expression count;
8447
8448                 public StackAlloc (Expression type, Expression count, Location l)
8449                 {
8450                         t = type;
8451                         this.count = count;
8452                         loc = l;
8453                 }
8454
8455                 public override Expression DoResolve (EmitContext ec)
8456                 {
8457                         count = count.Resolve (ec);
8458                         if (count == null)
8459                                 return null;
8460
8461                         if (count.Type != TypeManager.int32_type){
8462                                 count = Convert.ImplicitConversionRequired (ec, count, TypeManager.int32_type, loc);
8463                                 if (count == null)
8464                                         return null;
8465                         }
8466
8467                         Constant c = count as Constant;
8468                         if (c != null && c.IsNegative) {
8469                                 Report.Error (247, loc, "Cannot use a negative size with stackalloc");
8470                                 return null;
8471                         }
8472
8473                         if (ec.InCatch || ec.InFinally) {
8474                                 Error (255, "Cannot use stackalloc in finally or catch");
8475                                 return null;
8476                         }
8477
8478                         TypeExpr texpr = t.ResolveAsTypeTerminal (ec, false);
8479                         if (texpr == null)
8480                                 return null;
8481
8482                         otype = texpr.ResolveType (ec);
8483
8484                         if (!TypeManager.VerifyUnManaged (otype, loc))
8485                                 return null;
8486
8487                         type = TypeManager.GetPointerType (otype);
8488                         eclass = ExprClass.Value;
8489
8490                         return this;
8491                 }
8492
8493                 public override void Emit (EmitContext ec)
8494                 {
8495                         int size = GetTypeSize (otype);
8496                         ILGenerator ig = ec.ig;
8497
8498                         if (size == 0)
8499                                 ig.Emit (OpCodes.Sizeof, otype);
8500                         else
8501                                 IntConstant.EmitInt (ig, size);
8502                         count.Emit (ec);
8503                         ig.Emit (OpCodes.Mul);
8504                         ig.Emit (OpCodes.Localloc);
8505                 }
8506         }
8507 }