mcs/mcs/expression.cs

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