mcs/gmcs/expression.cs

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