mcs/mcs/assign.cs

   1 //
   2 // assign.cs: Assignments.
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //   Martin Baulig (martin@ximian.com)
   7 //   Marek Safar (marek.safar@gmail.com)
   8 //
   9 // Dual licensed under the terms of the MIT X11 or GNU GPL
  10 //
  11 // Copyright 2001, 2002, 2003 Ximian, Inc.
  12 // Copyright 2004-2008 Novell, Inc
  13 // Copyright 2011 Xamarin Inc
  14 //
  15 using System;
  16
  17 #if STATIC
  18 using IKVM.Reflection.Emit;
  19 #else
  20 using System.Reflection.Emit;
  21 #endif
  22
  23 namespace Mono.CSharp {
  24
  25         /// <summary>
  26         ///   This interface is implemented by expressions that can be assigned to.
  27         /// </summary>
  28         /// <remarks>
  29         ///   This interface is implemented by Expressions whose values can not
  30         ///   store the result on the top of the stack.
  31         ///
  32         ///   Expressions implementing this (Properties, Indexers and Arrays) would
  33         ///   perform an assignment of the Expression "source" into its final
  34         ///   location.
  35         ///
  36         ///   No values on the top of the stack are expected to be left by
  37         ///   invoking this method.
  38         /// </remarks>
  39         public interface IAssignMethod {
  40                 //
  41                 // This is an extra version of Emit. If leave_copy is `true'
  42                 // A copy of the expression will be left on the stack at the
  43                 // end of the code generated for EmitAssign
  44                 //
  45                 void Emit (EmitContext ec, bool leave_copy);
  46
  47                 //
  48                 // This method does the assignment
  49                 // `source' will be stored into the location specified by `this'
  50                 // if `leave_copy' is true, a copy of `source' will be left on the stack
  51                 // if `prepare_for_load' is true, when `source' is emitted, there will
  52                 // be data on the stack that it can use to compuatate its value. This is
  53                 // for expressions like a [f ()] ++, where you can't call `f ()' twice.
  54                 //
  55                 void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool isCompound);
  56
  57                 /*
  58                 For simple assignments, this interface is very simple, EmitAssign is called with source
  59                 as the source expression and leave_copy and prepare_for_load false.
  60
  61                 For compound assignments it gets complicated.
  62
  63                 EmitAssign will be called as before, however, prepare_for_load will be
  64                 true. The @source expression will contain an expression
  65                 which calls Emit. So, the calls look like:
  66
  67                 this.EmitAssign (ec, source, false, true) ->
  68                         source.Emit (ec); ->
  69                                 [...] ->
  70                                         this.Emit (ec, false); ->
  71                                         end this.Emit (ec, false); ->
  72                                 end [...]
  73                         end source.Emit (ec);
  74                 end this.EmitAssign (ec, source, false, true)
  75
  76
  77                 When prepare_for_load is true, EmitAssign emits a `token' on the stack that
  78                 Emit will use for its state.
  79
  80                 Let's take FieldExpr as an example. assume we are emitting f ().y += 1;
  81
  82                 Here is the call tree again. This time, each call is annotated with the IL
  83                 it produces:
  84
  85                 this.EmitAssign (ec, source, false, true)
  86                         call f
  87                         dup
  88
  89                         Binary.Emit ()
  90                                 this.Emit (ec, false);
  91                                 ldfld y
  92                                 end this.Emit (ec, false);
  93
  94                                 IntConstant.Emit ()
  95                                 ldc.i4.1
  96                                 end IntConstant.Emit
  97
  98                                 add
  99                         end Binary.Emit ()
 100
 101                         stfld
 102                 end this.EmitAssign (ec, source, false, true)
 103
 104                 Observe two things:
 105                         1) EmitAssign left a token on the stack. It was the result of f ().
 106                         2) This token was used by Emit
 107
 108                 leave_copy (in both EmitAssign and Emit) tells the compiler to leave a copy
 109                 of the expression at that point in evaluation. This is used for pre/post inc/dec
 110                 and for a = x += y. Let's do the above example with leave_copy true in EmitAssign
 111
 112                 this.EmitAssign (ec, source, true, true)
 113                         call f
 114                         dup
 115
 116                         Binary.Emit ()
 117                                 this.Emit (ec, false);
 118                                 ldfld y
 119                                 end this.Emit (ec, false);
 120
 121                                 IntConstant.Emit ()
 122                                 ldc.i4.1
 123                                 end IntConstant.Emit
 124
 125                                 add
 126                         end Binary.Emit ()
 127
 128                         dup
 129                         stloc temp
 130                         stfld
 131                         ldloc temp
 132                 end this.EmitAssign (ec, source, true, true)
 133
 134                 And with it true in Emit
 135
 136                 this.EmitAssign (ec, source, false, true)
 137                         call f
 138                         dup
 139
 140                         Binary.Emit ()
 141                                 this.Emit (ec, true);
 142                                 ldfld y
 143                                 dup
 144                                 stloc temp
 145                                 end this.Emit (ec, true);
 146
 147                                 IntConstant.Emit ()
 148                                 ldc.i4.1
 149                                 end IntConstant.Emit
 150
 151                                 add
 152                         end Binary.Emit ()
 153
 154                         stfld
 155                         ldloc temp
 156                 end this.EmitAssign (ec, source, false, true)
 157
 158                 Note that these two examples are what happens for ++x and x++, respectively.
 159                 */
 160         }
 161
 162         /// <summary>
 163         ///   An Expression to hold a temporary value.
 164         /// </summary>
 165         /// <remarks>
 166         ///   The LocalTemporary class is used to hold temporary values of a given
 167         ///   type to "simulate" the expression semantics. The local variable is
 168         ///   never captured.
 169         ///
 170         ///   The local temporary is used to alter the normal flow of code generation
 171         ///   basically it creates a local variable, and its emit instruction generates
 172         ///   code to access this value, return its address or save its value.
 173         ///
 174         ///   If `is_address' is true, then the value that we store is the address to the
 175         ///   real value, and not the value itself.
 176         ///
 177         ///   This is needed for a value type, because otherwise you just end up making a
 178         ///   copy of the value on the stack and modifying it. You really need a pointer
 179         ///   to the origional value so that you can modify it in that location. This
 180         ///   Does not happen with a class because a class is a pointer -- so you always
 181         ///   get the indirection.
 182         ///
 183         /// </remarks>
 184         public class LocalTemporary : Expression, IMemoryLocation, IAssignMethod {
 185                 LocalBuilder builder;
 186
 187                 public LocalTemporary (TypeSpec t)
 188                 {
 189                         type = t;
 190                         eclass = ExprClass.Value;
 191                 }
 192
 193                 public LocalTemporary (LocalBuilder b, TypeSpec t)
 194                         : this (t)
 195                 {
 196                         builder = b;
 197                 }
 198
 199                 public void Release (EmitContext ec)
 200                 {
 201                         ec.FreeTemporaryLocal (builder, type);
 202                         builder = null;
 203                 }
 204
 205                 public override bool ContainsEmitWithAwait ()
 206                 {
 207                         return false;
 208                 }
 209
 210                 public override Expression CreateExpressionTree (ResolveContext ec)
 211                 {
 212                         Arguments args = new Arguments (1);
 213                         args.Add (new Argument (this));
 214                         return CreateExpressionFactoryCall (ec, "Constant", args);
 215                 }
 216
 217                 protected override Expression DoResolve (ResolveContext ec)
 218                 {
 219                         return this;
 220                 }
 221
 222                 public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
 223                 {
 224                         return this;
 225                 }
 226
 227                 public override void Emit (EmitContext ec)
 228                 {
 229                         if (builder == null)
 230                                 throw new InternalErrorException ("Emit without Store, or after Release");
 231
 232                         ec.Emit (OpCodes.Ldloc, builder);
 233                 }
 234
 235                 #region IAssignMethod Members
 236
 237                 public void Emit (EmitContext ec, bool leave_copy)
 238                 {
 239                         Emit (ec);
 240
 241                         if (leave_copy)
 242                                 Emit (ec);
 243                 }
 244
 245                 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool isCompound)
 246                 {
 247                         if (isCompound)
 248                                 throw new NotImplementedException ();
 249
 250                         source.Emit (ec);
 251
 252                         Store (ec);
 253
 254                         if (leave_copy)
 255                                 Emit (ec);
 256                 }
 257
 258                 #endregion
 259
 260                 public LocalBuilder Builder {
 261                         get { return builder; }
 262                 }
 263
 264                 public void Store (EmitContext ec)
 265                 {
 266                         if (builder == null)
 267                                 builder = ec.GetTemporaryLocal (type);
 268
 269                         ec.Emit (OpCodes.Stloc, builder);
 270                 }
 271
 272                 public void AddressOf (EmitContext ec, AddressOp mode)
 273                 {
 274                         if (builder == null)
 275                                 builder = ec.GetTemporaryLocal (type);
 276
 277                         if (builder.LocalType.IsByRef) {
 278                                 //
 279                                 // if is_address, than this is just the address anyways,
 280                                 // so we just return this.
 281                                 //
 282                                 ec.Emit (OpCodes.Ldloc, builder);
 283                         } else {
 284                                 ec.Emit (OpCodes.Ldloca, builder);
 285                         }
 286                 }
 287         }
 288
 289         /// <summary>
 290         ///   The Assign node takes care of assigning the value of source into
 291         ///   the expression represented by target.
 292         /// </summary>
 293         public abstract class Assign : ExpressionStatement {
 294                 protected Expression target, source;
 295
 296                 protected Assign (Expression target, Expression source, Location loc)
 297                 {
 298                         this.target = target;
 299                         this.source = source;
 300                         this.loc = loc;
 301                 }
 302
 303                 public Expression Target {
 304                         get { return target; }
 305                 }
 306
 307                 public Expression Source {
 308                         get {
 309                                 return source;
 310                         }
 311                 }
 312
 313                 public override Location StartLocation {
 314                         get {
 315                                 return target.StartLocation;
 316                         }
 317                 }
 318
 319                 public override bool ContainsEmitWithAwait ()
 320                 {
 321                         return target.ContainsEmitWithAwait () || source.ContainsEmitWithAwait ();
 322                 }
 323
 324                 public override Expression CreateExpressionTree (ResolveContext ec)
 325                 {
 326                         ec.Report.Error (832, loc, "An expression tree cannot contain an assignment operator");
 327                         return null;
 328                 }
 329
 330                 protected override Expression DoResolve (ResolveContext ec)
 331                 {
 332                         bool ok = true;
 333                         source = source.Resolve (ec);
 334
 335                         if (source == null) {
 336                                 ok = false;
 337                                 source = ErrorExpression.Instance;
 338                         }
 339
 340                         target = target.ResolveLValue (ec, source);
 341
 342                         if (target == null || !ok)
 343                                 return null;
 344
 345                         TypeSpec target_type = target.Type;
 346                         TypeSpec source_type = source.Type;
 347
 348                         eclass = ExprClass.Value;
 349                         type = target_type;
 350
 351                         if (!(target is IAssignMethod)) {
 352                                 target.Error_ValueAssignment (ec, source);
 353                                 return null;
 354                         }
 355
 356                         if (target_type != source_type) {
 357                                 Expression resolved = ResolveConversions (ec);
 358
 359                                 if (resolved != this)
 360                                         return resolved;
 361                         }
 362
 363                         return this;
 364                 }
 365
 366                 public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
 367                 {
 368                         var tassign = target as IDynamicAssign;
 369                         if (tassign == null)
 370                                 throw new InternalErrorException (target.GetType () + " does not support dynamic assignment");
 371
 372                         var target_object = tassign.MakeAssignExpression (ctx, source);
 373
 374                         //
 375                         // Some hacking is needed as DLR does not support void type and requires
 376                         // always have object convertible return type to support caching and chaining
 377                         //
 378                         // We do this by introducing an explicit block which returns RHS value when
 379                         // available or null
 380                         //
 381                         if (target_object.NodeType == System.Linq.Expressions.ExpressionType.Block)
 382                                 return target_object;
 383
 384                         System.Linq.Expressions.UnaryExpression source_object;
 385                         if (ctx.HasSet (BuilderContext.Options.CheckedScope)) {
 386                                 source_object = System.Linq.Expressions.Expression.ConvertChecked (source.MakeExpression (ctx), target_object.Type);
 387                         } else {
 388                                 source_object = System.Linq.Expressions.Expression.Convert (source.MakeExpression (ctx), target_object.Type);
 389                         }
 390
 391                         return System.Linq.Expressions.Expression.Assign (target_object, source_object);
 392                 }
 393                 protected virtual Expression ResolveConversions (ResolveContext ec)
 394                 {
 395                         source = Convert.ImplicitConversionRequired (ec, source, target.Type, source.Location);
 396                         if (source == null)
 397                                 return null;
 398
 399                         return this;
 400                 }
 401
 402                 void Emit (EmitContext ec, bool is_statement)
 403                 {
 404                         IAssignMethod t = (IAssignMethod) target;
 405                         t.EmitAssign (ec, source, !is_statement, this is CompoundAssign);
 406                 }
 407
 408                 public override void Emit (EmitContext ec)
 409                 {
 410                         Emit (ec, false);
 411                 }
 412
 413                 public override void EmitStatement (EmitContext ec)
 414                 {
 415                         Emit (ec, true);
 416                 }
 417
 418                 public override void FlowAnalysis (FlowAnalysisContext fc)
 419                 {
 420                         source.FlowAnalysis (fc);
 421
 422                         if (target is ArrayAccess || target is IndexerExpr) {
 423                                 target.FlowAnalysis (fc);
 424                                 return;
 425                         }
 426
 427                         var pe = target as PropertyExpr;
 428                         if (pe != null && !pe.IsAutoPropertyAccess)
 429                                 target.FlowAnalysis (fc);
 430                 }
 431
 432                 protected override void CloneTo (CloneContext clonectx, Expression t)
 433                 {
 434                         Assign _target = (Assign) t;
 435
 436                         _target.target = target.Clone (clonectx);
 437                         _target.source = source.Clone (clonectx);
 438                 }
 439
 440                 public override object Accept (StructuralVisitor visitor)
 441                 {
 442                         return visitor.Visit (this);
 443                 }
 444         }
 445
 446         public class SimpleAssign : Assign
 447         {
 448                 public SimpleAssign (Expression target, Expression source)
 449                         : this (target, source, target.Location)
 450                 {
 451                 }
 452
 453                 public SimpleAssign (Expression target, Expression source, Location loc)
 454                         : base (target, source, loc)
 455                 {
 456                 }
 457
 458                 bool CheckEqualAssign (Expression t)
 459                 {
 460                         if (source is Assign) {
 461                                 Assign a = (Assign) source;
 462                                 if (t.Equals (a.Target))
 463                                         return true;
 464                                 return a is SimpleAssign && ((SimpleAssign) a).CheckEqualAssign (t);
 465                         }
 466                         return t.Equals (source);
 467                 }
 468
 469                 protected override Expression DoResolve (ResolveContext ec)
 470                 {
 471                         Expression e = base.DoResolve (ec);
 472                         if (e == null || e != this)
 473                                 return e;
 474
 475                         if (CheckEqualAssign (target))
 476                                 ec.Report.Warning (1717, 3, loc, "Assignment made to same variable; did you mean to assign something else?");
 477
 478                         return this;
 479                 }
 480
 481                 public override void FlowAnalysis (FlowAnalysisContext fc)
 482                 {
 483                         base.FlowAnalysis (fc);
 484
 485                         var vr = target as VariableReference;
 486                         if (vr != null) {
 487                                 if (vr.VariableInfo != null)
 488                                         fc.SetVariableAssigned (vr.VariableInfo);
 489
 490                                 return;
 491                         }
 492
 493                         var fe = target as FieldExpr;
 494                         if (fe != null) {
 495                                 fe.SetFieldAssigned (fc);
 496                                 return;
 497                         }
 498
 499                         var pe = target as PropertyExpr;
 500                         if (pe != null) {
 501                                 pe.SetBackingFieldAssigned (fc);
 502                                 return;
 503                         }
 504                 }
 505
 506                 public override Reachability MarkReachable (Reachability rc)
 507                 {
 508                         return source.MarkReachable (rc);
 509                 }
 510         }
 511
 512         public class RuntimeExplicitAssign : Assign
 513         {
 514                 public RuntimeExplicitAssign (Expression target, Expression source)
 515                         : base (target, source, target.Location)
 516                 {
 517                 }
 518
 519                 protected override Expression ResolveConversions (ResolveContext ec)
 520                 {
 521                         source = EmptyCast.Create (source, target.Type);
 522                         return this;
 523                 }
 524         }
 525
 526         //
 527         // Compiler generated assign
 528         //
 529         class CompilerAssign : Assign
 530         {
 531                 public CompilerAssign (Expression target, Expression source, Location loc)
 532                         : base (target, source, loc)
 533                 {
 534                         if (target.Type != null) {
 535                                 type = target.Type;
 536                                 eclass = ExprClass.Value;
 537                         }
 538                 }
 539
 540                 protected override Expression DoResolve (ResolveContext ec)
 541                 {
 542                         var expr = base.DoResolve (ec);
 543                         var vr = target as VariableReference;
 544                         if (vr != null && vr.VariableInfo != null)
 545                                 vr.VariableInfo.IsEverAssigned = false;
 546
 547                         return expr;
 548                 }
 549
 550                 public void UpdateSource (Expression source)
 551                 {
 552                         base.source = source;
 553                 }
 554         }
 555
 556         //
 557         // Implements fields and events class initializers
 558         //
 559         public class FieldInitializer : Assign
 560         {
 561                 //
 562                 // Field initializers are tricky for partial classes. They have to
 563                 // share same constructor (block) for expression trees resolve but
 564                 // they have they own resolve scope
 565                 //
 566                 sealed class FieldInitializerContext : BlockContext
 567                 {
 568                         readonly ExplicitBlock ctor_block;
 569
 570                         public FieldInitializerContext (IMemberContext mc, BlockContext constructorContext)
 571                                 : base (mc, null, constructorContext.ReturnType)
 572                         {
 573                                 flags |= Options.FieldInitializerScope | Options.ConstructorScope;
 574                                 this.ctor_block = constructorContext.CurrentBlock.Explicit;
 575
 576                                 if (ctor_block.IsCompilerGenerated)
 577                                         CurrentBlock = ctor_block;
 578                         }
 579
 580                         public override ExplicitBlock ConstructorBlock {
 581                             get {
 582                                 return ctor_block;
 583                             }
 584                         }
 585                 }
 586
 587                 //
 588                 // Keep resolved value because field initializers have their own rules
 589                 //
 590                 ExpressionStatement resolved;
 591                 FieldBase mc;
 592
 593                 public FieldInitializer (FieldBase mc, Expression expression, Location loc)
 594                         : base (new FieldExpr (mc.Spec, expression.Location), expression, loc)
 595                 {
 596                         this.mc = mc;
 597                         if (!mc.IsStatic)
 598                                 ((FieldExpr)target).InstanceExpression = new CompilerGeneratedThis (mc.CurrentType, expression.Location);
 599                 }
 600
 601                 public int AssignmentOffset { get; private set; }
 602
 603                 public FieldBase Field {
 604                         get {
 605                                 return mc;
 606                         }
 607                 }
 608
 609                 public override Location StartLocation {
 610                         get {
 611                                 return loc;
 612                         }
 613                 }
 614
 615                 protected override Expression DoResolve (ResolveContext rc)
 616                 {
 617                         // Field initializer can be resolved (fail) many times
 618                         if (source == null)
 619                                 return null;
 620
 621                         if (resolved == null) {
 622                                 var bc = (BlockContext) rc;
 623                                 var ctx = new FieldInitializerContext (mc, bc);
 624                                 resolved = base.DoResolve (ctx) as ExpressionStatement;
 625                                 AssignmentOffset = ctx.AssignmentInfoOffset - bc.AssignmentInfoOffset;
 626                         }
 627
 628                         return resolved;
 629                 }
 630
 631                 public override void EmitStatement (EmitContext ec)
 632                 {
 633                         if (resolved == null)
 634                                 return;
 635
 636                         //
 637                         // Emit sequence symbol info even if we are in compiler generated
 638                         // block to allow debugging field initializers when constructor is
 639                         // compiler generated
 640                         //
 641                         if (ec.HasSet (BuilderContext.Options.OmitDebugInfo) && ec.HasMethodSymbolBuilder) {
 642                                 using (ec.With (BuilderContext.Options.OmitDebugInfo, false)) {
 643                                         ec.Mark (loc);
 644                                 }
 645                         }
 646
 647                         if (resolved != this)
 648                                 resolved.EmitStatement (ec);
 649                         else
 650                                 base.EmitStatement (ec);
 651                 }
 652
 653                 public override void FlowAnalysis (FlowAnalysisContext fc)
 654                 {
 655                         source.FlowAnalysis (fc);
 656                         ((FieldExpr) target).SetFieldAssigned (fc);
 657                 }
 658
 659                 public bool IsDefaultInitializer {
 660                         get {
 661                                 Constant c = source as Constant;
 662                                 if (c == null)
 663                                         return false;
 664
 665                                 FieldExpr fe = (FieldExpr)target;
 666                                 return c.IsDefaultInitializer (fe.Type);
 667                         }
 668                 }
 669
 670                 public override bool IsSideEffectFree {
 671                         get {
 672                                 return source.IsSideEffectFree;
 673                         }
 674                 }
 675         }
 676
 677         class PrimaryConstructorAssign : SimpleAssign
 678         {
 679                 readonly Field field;
 680                 readonly Parameter parameter;
 681
 682                 public PrimaryConstructorAssign (Field field, Parameter parameter)
 683                         : base (null, null, parameter.Location)
 684                 {
 685                         this.field = field;
 686                         this.parameter = parameter;
 687                 }
 688
 689                 protected override Expression DoResolve (ResolveContext rc)
 690                 {
 691                         target = new FieldExpr (field, loc);
 692                         source = rc.CurrentBlock.ParametersBlock.GetParameterInfo (parameter).CreateReferenceExpression (rc, loc);
 693                         return base.DoResolve (rc);
 694                 }
 695
 696                 public override void EmitStatement (EmitContext ec)
 697                 {
 698                         using (ec.With (BuilderContext.Options.OmitDebugInfo, true)) {
 699                                 base.EmitStatement (ec);
 700                         }
 701                 }
 702         }
 703
 704         //
 705         // This class is used for compound assignments.
 706         //
 707         public class CompoundAssign : Assign
 708         {
 709                 // This is just a hack implemented for arrays only
 710                 public sealed class TargetExpression : Expression
 711                 {
 712                         readonly Expression child;
 713
 714                         public TargetExpression (Expression child)
 715                         {
 716                                 this.child = child;
 717                                 this.loc = child.Location;
 718                         }
 719
 720                         public bool RequiresEmitWithAwait { get; set; }
 721
 722                         public override bool ContainsEmitWithAwait ()
 723                         {
 724                                 return RequiresEmitWithAwait || child.ContainsEmitWithAwait ();
 725                         }
 726
 727                         public override Expression CreateExpressionTree (ResolveContext ec)
 728                         {
 729                                 throw new NotSupportedException ("ET");
 730                         }
 731
 732                         protected override Expression DoResolve (ResolveContext ec)
 733                         {
 734                                 type = child.Type;
 735                                 eclass = ExprClass.Value;
 736                                 return this;
 737                         }
 738
 739                         public override void Emit (EmitContext ec)
 740                         {
 741                                 child.Emit (ec);
 742                         }
 743
 744                         public override Expression EmitToField (EmitContext ec)
 745                         {
 746                                 return child.EmitToField (ec);
 747                         }
 748                 }
 749
 750                 // Used for underlying binary operator
 751                 readonly Binary.Operator op;
 752                 Expression right;
 753                 Expression left;
 754
 755                 public CompoundAssign (Binary.Operator op, Expression target, Expression source)
 756                         : base (target, source, target.Location)
 757                 {
 758                         right = source;
 759                         this.op = op;
 760                 }
 761
 762                 public CompoundAssign (Binary.Operator op, Expression target, Expression source, Expression left)
 763                         : this (op, target, source)
 764                 {
 765                         this.left = left;
 766                 }
 767
 768                 public Binary.Operator Operator {
 769                         get {
 770                                 return op;
 771                         }
 772                 }
 773
 774                 protected override Expression DoResolve (ResolveContext ec)
 775                 {
 776                         right = right.Resolve (ec);
 777                         if (right == null)
 778                                 return null;
 779
 780                         MemberAccess ma = target as MemberAccess;
 781                         using (ec.Set (ResolveContext.Options.CompoundAssignmentScope)) {
 782                                 target = target.Resolve (ec);
 783                         }
 784
 785                         if (target == null)
 786                                 return null;
 787
 788                         if (target is MethodGroupExpr){
 789                                 ec.Report.Error (1656, loc,
 790                                         "Cannot assign to `{0}' because it is a `{1}'",
 791                                         ((MethodGroupExpr)target).Name, target.ExprClassName);
 792                                 return null;
 793                         }
 794
 795                         var event_expr = target as EventExpr;
 796                         if (event_expr != null) {
 797                                 source = Convert.ImplicitConversionRequired (ec, right, target.Type, loc);
 798                                 if (source == null)
 799                                         return null;
 800
 801                                 Expression rside;
 802                                 if (op == Binary.Operator.Addition)
 803                                         rside = EmptyExpression.EventAddition;
 804                                 else if (op == Binary.Operator.Subtraction)
 805                                         rside = EmptyExpression.EventSubtraction;
 806                                 else
 807                                         rside = null;
 808
 809                                 target = target.ResolveLValue (ec, rside);
 810                                 if (target == null)
 811                                         return null;
 812
 813                                 eclass = ExprClass.Value;
 814                                 type = event_expr.Operator.ReturnType;
 815                                 return this;
 816                         }
 817
 818                         //
 819                         // Only now we can decouple the original source/target
 820                         // into a tree, to guarantee that we do not have side
 821                         // effects.
 822                         //
 823                         if (left == null)
 824                                 left = new TargetExpression (target);
 825
 826                         source = new Binary (op, left, right, true);
 827
 828                         if (target is DynamicMemberAssignable) {
 829                                 Arguments targs = ((DynamicMemberAssignable) target).Arguments;
 830                                 source = source.Resolve (ec);
 831
 832                                 Arguments args = new Arguments (targs.Count + 1);
 833                                 args.AddRange (targs);
 834                                 args.Add (new Argument (source));
 835
 836                                 var binder_flags = CSharpBinderFlags.ValueFromCompoundAssignment;
 837
 838                                 //
 839                                 // Compound assignment does target conversion using additional method
 840                                 // call, set checked context as the binary operation can overflow
 841                                 //
 842                                 if (ec.HasSet (ResolveContext.Options.CheckedScope))
 843                                         binder_flags |= CSharpBinderFlags.CheckedContext;
 844
 845                                 if (target is DynamicMemberBinder) {
 846                                         source = new DynamicMemberBinder (ma.Name, binder_flags, args, loc).Resolve (ec);
 847
 848                                         // Handles possible event addition/subtraction
 849                                         if (op == Binary.Operator.Addition || op == Binary.Operator.Subtraction) {
 850                                                 args = new Arguments (targs.Count + 1);
 851                                                 args.AddRange (targs);
 852                                                 args.Add (new Argument (right));
 853                                                 string method_prefix = op == Binary.Operator.Addition ?
 854                                                         Event.AEventAccessor.AddPrefix : Event.AEventAccessor.RemovePrefix;
 855
 856                                                 var invoke = DynamicInvocation.CreateSpecialNameInvoke (
 857                                                         new MemberAccess (right, method_prefix + ma.Name, loc), args, loc).Resolve (ec);
 858
 859                                                 args = new Arguments (targs.Count);
 860                                                 args.AddRange (targs);
 861                                                 source = new DynamicEventCompoundAssign (ma.Name, args,
 862                                                         (ExpressionStatement) source, (ExpressionStatement) invoke, loc).Resolve (ec);
 863                                         }
 864                                 } else {
 865                                         source = new DynamicIndexBinder (binder_flags, args, loc).Resolve (ec);
 866                                 }
 867
 868                                 return source;
 869                         }
 870
 871                         return base.DoResolve (ec);
 872                 }
 873
 874                 public override void FlowAnalysis (FlowAnalysisContext fc)
 875                 {
 876                         target.FlowAnalysis (fc);
 877                         source.FlowAnalysis (fc);
 878                 }
 879
 880                 protected override Expression ResolveConversions (ResolveContext ec)
 881                 {
 882                         //
 883                         // LAMESPEC: Under dynamic context no target conversion is happening
 884                         // This allows more natual dynamic behaviour but breaks compatibility
 885                         // with static binding
 886                         //
 887                         if (target is RuntimeValueExpression)
 888                                 return this;
 889
 890                         TypeSpec target_type = target.Type;
 891
 892                         //
 893                         // 1. the return type is implicitly convertible to the type of target
 894                         //
 895                         if (Convert.ImplicitConversionExists (ec, source, target_type)) {
 896                                 source = Convert.ImplicitConversion (ec, source, target_type, loc);
 897                                 return this;
 898                         }
 899
 900                         //
 901                         // Otherwise, if the selected operator is a predefined operator
 902                         //
 903                         Binary b = source as Binary;
 904                         if (b == null) {
 905                                 if (source is ReducedExpression)
 906                                         b = ((ReducedExpression) source).OriginalExpression as Binary;
 907                                 else if (source is ReducedExpression.ReducedConstantExpression) {
 908                                         b = ((ReducedExpression.ReducedConstantExpression) source).OriginalExpression as Binary;
 909                                 } else if (source is Nullable.LiftedBinaryOperator) {
 910                                         var po = ((Nullable.LiftedBinaryOperator) source);
 911                                         if (po.UserOperator == null)
 912                                                 b = po.Binary;
 913                                 } else if (source is TypeCast) {
 914                                         b = ((TypeCast) source).Child as Binary;
 915                                 }
 916                         }
 917
 918                         if (b != null) {
 919                                 //
 920                                 // 2a. the operator is a shift operator
 921                                 //
 922                                 // 2b. the return type is explicitly convertible to the type of x, and
 923                                 // y is implicitly convertible to the type of x
 924                                 //
 925                                 if ((b.Oper & Binary.Operator.ShiftMask) != 0 ||
 926                                         Convert.ImplicitConversionExists (ec, right, target_type)) {
 927                                         source = Convert.ExplicitConversion (ec, source, target_type, loc);
 928                                         return this;
 929                                 }
 930                         }
 931
 932                         if (source.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
 933                                 Arguments arg = new Arguments (1);
 934                                 arg.Add (new Argument (source));
 935                                 return new SimpleAssign (target, new DynamicConversion (target_type, CSharpBinderFlags.ConvertExplicit, arg, loc), loc).Resolve (ec);
 936                         }
 937
 938                         right.Error_ValueCannotBeConverted (ec, target_type, false);
 939                         return null;
 940                 }
 941
 942                 protected override void CloneTo (CloneContext clonectx, Expression t)
 943                 {
 944                         CompoundAssign ctarget = (CompoundAssign) t;
 945
 946                         ctarget.right = ctarget.source = source.Clone (clonectx);
 947                         ctarget.target = target.Clone (clonectx);
 948                 }
 949
 950                 public override object Accept (StructuralVisitor visitor)
 951                 {
 952                         return visitor.Visit (this);
 953                 }
 954         }
 955 }