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 //
  14 using System;
  15 using System.Reflection;
  16 using System.Reflection.Emit;
  17 using System.Collections;
  18
  19 namespace Mono.CSharp {
  20
  21         /// <summary>
  22         ///   This interface is implemented by expressions that can be assigned to.
  23         /// </summary>
  24         /// <remarks>
  25         ///   This interface is implemented by Expressions whose values can not
  26         ///   store the result on the top of the stack.
  27         ///
  28         ///   Expressions implementing this (Properties, Indexers and Arrays) would
  29         ///   perform an assignment of the Expression "source" into its final
  30         ///   location.
  31         ///
  32         ///   No values on the top of the stack are expected to be left by
  33         ///   invoking this method.
  34         /// </remarks>
  35         public interface IAssignMethod {
  36                 //
  37                 // This is an extra version of Emit. If leave_copy is `true'
  38                 // A copy of the expression will be left on the stack at the
  39                 // end of the code generated for EmitAssign
  40                 //
  41                 void Emit (EmitContext ec, bool leave_copy);
  42
  43                 //
  44                 // This method does the assignment
  45                 // `source' will be stored into the location specified by `this'
  46                 // if `leave_copy' is true, a copy of `source' will be left on the stack
  47                 // if `prepare_for_load' is true, when `source' is emitted, there will
  48                 // be data on the stack that it can use to compuatate its value. This is
  49                 // for expressions like a [f ()] ++, where you can't call `f ()' twice.
  50                 //
  51                 void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load);
  52
  53                 /*
  54                 For simple assignments, this interface is very simple, EmitAssign is called with source
  55                 as the source expression and leave_copy and prepare_for_load false.
  56
  57                 For compound assignments it gets complicated.
  58
  59                 EmitAssign will be called as before, however, prepare_for_load will be
  60                 true. The @source expression will contain an expression
  61                 which calls Emit. So, the calls look like:
  62
  63                 this.EmitAssign (ec, source, false, true) ->
  64                         source.Emit (ec); ->
  65                                 [...] ->
  66                                         this.Emit (ec, false); ->
  67                                         end this.Emit (ec, false); ->
  68                                 end [...]
  69                         end source.Emit (ec);
  70                 end this.EmitAssign (ec, source, false, true)
  71
  72
  73                 When prepare_for_load is true, EmitAssign emits a `token' on the stack that
  74                 Emit will use for its state.
  75
  76                 Let's take FieldExpr as an example. assume we are emitting f ().y += 1;
  77
  78                 Here is the call tree again. This time, each call is annotated with the IL
  79                 it produces:
  80
  81                 this.EmitAssign (ec, source, false, true)
  82                         call f
  83                         dup
  84
  85                         Binary.Emit ()
  86                                 this.Emit (ec, false);
  87                                 ldfld y
  88                                 end this.Emit (ec, false);
  89
  90                                 IntConstant.Emit ()
  91                                 ldc.i4.1
  92                                 end IntConstant.Emit
  93
  94                                 add
  95                         end Binary.Emit ()
  96
  97                         stfld
  98                 end this.EmitAssign (ec, source, false, true)
  99
 100                 Observe two things:
 101                         1) EmitAssign left a token on the stack. It was the result of f ().
 102                         2) This token was used by Emit
 103
 104                 leave_copy (in both EmitAssign and Emit) tells the compiler to leave a copy
 105                 of the expression at that point in evaluation. This is used for pre/post inc/dec
 106                 and for a = x += y. Let's do the above example with leave_copy true in EmitAssign
 107
 108                 this.EmitAssign (ec, source, true, true)
 109                         call f
 110                         dup
 111
 112                         Binary.Emit ()
 113                                 this.Emit (ec, false);
 114                                 ldfld y
 115                                 end this.Emit (ec, false);
 116
 117                                 IntConstant.Emit ()
 118                                 ldc.i4.1
 119                                 end IntConstant.Emit
 120
 121                                 add
 122                         end Binary.Emit ()
 123
 124                         dup
 125                         stloc temp
 126                         stfld
 127                         ldloc temp
 128                 end this.EmitAssign (ec, source, true, true)
 129
 130                 And with it true in Emit
 131
 132                 this.EmitAssign (ec, source, false, true)
 133                         call f
 134                         dup
 135
 136                         Binary.Emit ()
 137                                 this.Emit (ec, true);
 138                                 ldfld y
 139                                 dup
 140                                 stloc temp
 141                                 end this.Emit (ec, true);
 142
 143                                 IntConstant.Emit ()
 144                                 ldc.i4.1
 145                                 end IntConstant.Emit
 146
 147                                 add
 148                         end Binary.Emit ()
 149
 150                         stfld
 151                         ldloc temp
 152                 end this.EmitAssign (ec, source, false, true)
 153
 154                 Note that these two examples are what happens for ++x and x++, respectively.
 155                 */
 156         }
 157
 158         /// <summary>
 159         ///   An Expression to hold a temporary value.
 160         /// </summary>
 161         /// <remarks>
 162         ///   The LocalTemporary class is used to hold temporary values of a given
 163         ///   type to "simulate" the expression semantics on property and indexer
 164         ///   access whose return values are void.
 165         ///
 166         ///   The local temporary is used to alter the normal flow of code generation
 167         ///   basically it creates a local variable, and its emit instruction generates
 168         ///   code to access this value, return its address or save its value.
 169         ///
 170         ///   If `is_address' is true, then the value that we store is the address to the
 171         ///   real value, and not the value itself.
 172         ///
 173         ///   This is needed for a value type, because otherwise you just end up making a
 174         ///   copy of the value on the stack and modifying it. You really need a pointer
 175         ///   to the origional value so that you can modify it in that location. This
 176         ///   Does not happen with a class because a class is a pointer -- so you always
 177         ///   get the indirection.
 178         ///
 179         ///   The `is_address' stuff is really just a hack. We need to come up with a better
 180         ///   way to handle it.
 181         /// </remarks>
 182         public class LocalTemporary : Expression, IMemoryLocation, IAssignMethod {
 183                 LocalBuilder builder;
 184                 bool is_address;
 185
 186                 public LocalTemporary (Type t) : this (t, false) {}
 187
 188                 public LocalTemporary (Type t, bool is_address)
 189                 {
 190                         type = t;
 191                         eclass = ExprClass.Value;
 192                         this.is_address = is_address;
 193                 }
 194
 195                 public LocalTemporary (LocalBuilder b, Type t)
 196                 {
 197                         type = t;
 198                         eclass = ExprClass.Value;
 199                         loc = Location.Null;
 200                         builder = b;
 201                 }
 202
 203                 public void Release (EmitContext ec)
 204                 {
 205                         ec.FreeTemporaryLocal (builder, type);
 206                         builder = null;
 207                 }
 208
 209                 public override Expression CreateExpressionTree (EmitContext ec)
 210                 {
 211                         Arguments args = new Arguments (1);
 212                         args.Add (new Argument (this));
 213                         return CreateExpressionFactoryCall ("Constant", args);
 214                 }
 215
 216                 public override Expression DoResolve (EmitContext ec)
 217                 {
 218                         return this;
 219                 }
 220
 221                 public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
 222                 {
 223                         return this;
 224                 }
 225
 226                 public override void Emit (EmitContext ec)
 227                 {
 228                         ILGenerator ig = ec.ig;
 229
 230                         if (builder == null)
 231                                 throw new InternalErrorException ("Emit without Store, or after Release");
 232
 233                         ig.Emit (OpCodes.Ldloc, builder);
 234                         // we need to copy from the pointer
 235                         if (is_address)
 236                                 LoadFromPtr (ig, type);
 237                 }
 238
 239                 #region IAssignMethod Members
 240
 241                 public void Emit (EmitContext ec, bool leave_copy)
 242                 {
 243                         Emit (ec);
 244
 245                         if (leave_copy)
 246                                 Emit (ec);
 247                 }
 248
 249                 public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
 250                 {
 251                         if (prepare_for_load)
 252                                 throw new NotImplementedException ();
 253
 254                         source.Emit (ec);
 255
 256                         Store (ec);
 257
 258                         if (leave_copy)
 259                                 Emit (ec);
 260                 }
 261
 262                 #endregion
 263
 264                 public LocalBuilder Builder {
 265                         get { return builder; }
 266                 }
 267
 268                 // NB: if you have `is_address' on the stack there must
 269                 // be a managed pointer. Otherwise, it is the type from
 270                 // the ctor.
 271                 public void Store (EmitContext ec)
 272                 {
 273                         ILGenerator ig = ec.ig;
 274                         if (builder == null)
 275                                 builder = ec.GetTemporaryLocal (is_address ? TypeManager.GetReferenceType (type): type);
 276
 277                         ig.Emit (OpCodes.Stloc, builder);
 278                 }
 279
 280                 public void AddressOf (EmitContext ec, AddressOp mode)
 281                 {
 282                         if (builder == null)
 283                                 builder = ec.GetTemporaryLocal (is_address ? TypeManager.GetReferenceType (type): type);
 284
 285                         // if is_address, than this is just the address anyways,
 286                         // so we just return this.
 287                         ILGenerator ig = ec.ig;
 288
 289                         if (is_address)
 290                                 ig.Emit (OpCodes.Ldloc, builder);
 291                         else
 292                                 ig.Emit (OpCodes.Ldloca, builder);
 293                 }
 294
 295                 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
 296                 {
 297                         type = storey.MutateType (type);
 298                 }
 299
 300                 public bool PointsToAddress {
 301                         get {
 302                                 return is_address;
 303                         }
 304                 }
 305         }
 306
 307         /// <summary>
 308         ///   The Assign node takes care of assigning the value of source into
 309         ///   the expression represented by target.
 310         /// </summary>
 311         public class Assign : ExpressionStatement {
 312                 protected Expression target, source;
 313
 314                 protected Assign (Expression target, Expression source, Location loc)
 315                 {
 316                         this.target = target;
 317                         this.source = source;
 318                         this.loc = loc;
 319                 }
 320
 321                 public override Expression CreateExpressionTree (EmitContext ec)
 322                 {
 323                         Report.Error (832, loc, "An expression tree cannot contain an assignment operator");
 324                         return null;
 325                 }
 326
 327                 public Expression Target {
 328                         get { return target; }
 329                 }
 330
 331                 public Expression Source {
 332                         get { return source; }
 333                 }
 334
 335                 public override Expression DoResolve (EmitContext ec)
 336                 {
 337                         bool ok = true;
 338                         source = source.Resolve (ec);
 339
 340                         if (source == null) {
 341                                 ok = false;
 342                                 source = EmptyExpression.Null;
 343                         }
 344
 345                         target = target.ResolveLValue (ec, source);
 346
 347                         if (target == null || !ok)
 348                                 return null;
 349
 350                         Type target_type = target.Type;
 351                         Type source_type = source.Type;
 352
 353                         eclass = ExprClass.Value;
 354                         type = target_type;
 355
 356                         if (!(target is IAssignMethod)) {
 357                                 Error_ValueAssignment (loc);
 358                                 return null;
 359                         }
 360
 361                         if ((RootContext.Version == LanguageVersion.ISO_1) &&
 362                                    (source is MethodGroupExpr)){
 363                                 ((MethodGroupExpr) source).ReportUsageError ();
 364                                 return null;
 365                         }
 366
 367                         if (!TypeManager.IsEqual (target_type, source_type)) {
 368                                 if (TypeManager.IsDynamicType (source_type)) {
 369                                         Arguments args = new Arguments (1);
 370                                         args.Add (new Argument (source));
 371                                         return new DynamicConversion (target_type, false, args, loc).Resolve (ec);
 372                                 }
 373
 374                                 Expression resolved = ResolveConversions (ec);
 375
 376                                 if (resolved != this)
 377                                         return resolved;
 378                         }
 379
 380                         return this;
 381                 }
 382
 383                 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
 384                 {
 385                         source.MutateHoistedGenericType (storey);
 386                         target.MutateHoistedGenericType (storey);
 387                         type = storey.MutateType (type);
 388                 }
 389
 390                 protected virtual Expression ResolveConversions (EmitContext ec)
 391                 {
 392                         source = Convert.ImplicitConversionRequired (ec, source, target.Type, loc);
 393                         if (source == null)
 394                                 return null;
 395
 396                         return this;
 397                 }
 398
 399                 void Emit (EmitContext ec, bool is_statement)
 400                 {
 401                         IAssignMethod t = (IAssignMethod) target;
 402                         t.EmitAssign (ec, source, !is_statement, this is CompoundAssign);
 403                 }
 404
 405                 public override void Emit (EmitContext ec)
 406                 {
 407                         Emit (ec, false);
 408                 }
 409
 410                 public override void EmitStatement (EmitContext ec)
 411                 {
 412                         Emit (ec, true);
 413                 }
 414
 415                 protected override void CloneTo (CloneContext clonectx, Expression t)
 416                 {
 417                         Assign _target = (Assign) t;
 418
 419                         _target.target = target.Clone (clonectx);
 420                         _target.source = source.Clone (clonectx);
 421                 }
 422         }
 423
 424         class SimpleAssign : Assign {
 425                 public SimpleAssign (Expression target, Expression source)
 426                         : this (target, source, target.Location)
 427                 {
 428                 }
 429
 430                 public SimpleAssign (Expression target, Expression source, Location loc)
 431                         : base (target, source, loc)
 432                 {
 433                 }
 434
 435                 bool CheckEqualAssign (Expression t)
 436                 {
 437                         if (source is Assign) {
 438                                 Assign a = (Assign) source;
 439                                 if (t.Equals (a.Target))
 440                                         return true;
 441                                 return a is SimpleAssign && ((SimpleAssign) a).CheckEqualAssign (t);
 442                         }
 443                         return t.Equals (source);
 444                 }
 445
 446                 public override Expression DoResolve (EmitContext ec)
 447                 {
 448                         Expression e = base.DoResolve (ec);
 449                         if (e == null || e != this)
 450                                 return e;
 451
 452                         if (CheckEqualAssign (target))
 453                                 Report.Warning (1717, 3, loc, "Assignment made to same variable; did you mean to assign something else?");
 454
 455                         return this;
 456                 }
 457         }
 458
 459         // This class implements fields and events class initializers
 460         public class FieldInitializer : Assign
 461         {
 462                 //
 463                 // Keep resolved value because field initializers have their own rules
 464                 //
 465                 ExpressionStatement resolved;
 466                 IResolveContext rc;
 467
 468                 public FieldInitializer (FieldBuilder field, Expression expression, IResolveContext rc)
 469                         : base (new FieldExpr (field, expression.Location), expression, expression.Location)
 470                 {
 471                         this.rc = rc;
 472                         if (!field.IsStatic)
 473                                 ((FieldExpr)target).InstanceExpression = CompilerGeneratedThis.Instance;
 474                 }
 475
 476                 public override Expression DoResolve (EmitContext ec)
 477                 {
 478                         // Field initializer can be resolved (fail) many times
 479                         if (source == null)
 480                                 return null;
 481
 482                         if (resolved == null) {
 483                                 //
 484                                 // Field initializers are tricky for partial classes. They have to
 485                                 // share same costructor (block) but they have they own resolve scope.
 486                                 //
 487
 488                                 // TODO: Use ResolveContext only
 489                                 EmitContext f_ec = new EmitContext (rc, rc.GenericDeclContainer, null, TypeManager.void_type, 0, true);
 490                                 f_ec.IsStatic = ec.IsStatic;
 491                                 f_ec.CurrentBlock = ec.CurrentBlock;
 492
 493                                 EmitContext.Flags flags = EmitContext.Flags.InFieldInitializer;
 494                                 if (ec.IsInUnsafeScope)
 495                                         flags |= EmitContext.Flags.InUnsafe;
 496
 497                                 f_ec.Set (flags);
 498
 499                                 resolved = base.DoResolve (f_ec) as ExpressionStatement;
 500                         }
 501
 502                         return resolved;
 503                 }
 504
 505                 public override void EmitStatement (EmitContext ec)
 506                 {
 507                         if (resolved == null)
 508                                 return;
 509
 510                         if (resolved != this)
 511                                 resolved.EmitStatement (ec);
 512                         else
 513                                 base.EmitStatement (ec);
 514                 }
 515
 516                 public bool IsComplexInitializer {
 517                         get { return !(source is Constant); }
 518                 }
 519
 520                 public bool IsDefaultInitializer {
 521                         get {
 522                                 Constant c = source as Constant;
 523                                 if (c == null)
 524                                         return false;
 525
 526                                 FieldExpr fe = (FieldExpr)target;
 527                                 return c.IsDefaultInitializer (fe.Type);
 528                         }
 529                 }
 530         }
 531
 532         class EventAddOrRemove : ExpressionStatement {
 533                 EventExpr target;
 534                 Binary.Operator op;
 535                 Expression source;
 536
 537                 public EventAddOrRemove (Expression target, Binary.Operator op, Expression source, Location loc)
 538                 {
 539                         this.target = target as EventExpr;
 540                         this.op = op;
 541                         this.source = source;
 542                         this.loc = loc;
 543                 }
 544
 545                 public override Expression CreateExpressionTree (EmitContext ec)
 546                 {
 547                         return new SimpleAssign (target, source).CreateExpressionTree (ec);
 548                 }
 549
 550                 public override Expression DoResolve (EmitContext ec)
 551                 {
 552                         if (op != Binary.Operator.Addition && op != Binary.Operator.Subtraction)
 553                                 target.Error_AssignmentEventOnly ();
 554
 555                         source = source.Resolve (ec);
 556                         if (source == null)
 557                                 return null;
 558
 559                         source = Convert.ImplicitConversionRequired (ec, source, target.Type, loc);
 560                         if (source == null)
 561                                 return null;
 562
 563                         eclass = ExprClass.Value;
 564                         type = TypeManager.void_type;
 565                         return this;
 566                 }
 567
 568                 public override void Emit (EmitContext ec)
 569                 {
 570                         if (RootContext.EvalMode)
 571                                 EmitStatement (ec);
 572                         else
 573                                 throw new InternalErrorException ("don't know what to emit");
 574                 }
 575
 576                 public override void EmitStatement (EmitContext ec)
 577                 {
 578                         target.EmitAddOrRemove (ec, op == Binary.Operator.Addition, source);
 579                 }
 580         }
 581
 582         //
 583         // This class is used for compound assignments.
 584         //
 585         class CompoundAssign : Assign {
 586                 Binary.Operator op;
 587                 Expression original_source;
 588
 589                 public CompoundAssign (Binary.Operator op, Expression target, Expression source)
 590                         : base (target, source, target.Location)
 591                 {
 592                         original_source = source;
 593                         this.op = op;
 594                 }
 595
 596                 public sealed class TargetExpression : Expression {
 597                         Expression child;
 598                         public TargetExpression (Expression child)
 599                         {
 600                                 this.child = child;
 601                                 this.loc = child.Location;
 602                         }
 603
 604                         public override Expression CreateExpressionTree (EmitContext ec)
 605                         {
 606                                 throw new NotSupportedException ("ET");
 607                         }
 608
 609                         public override Expression DoResolve (EmitContext ec)
 610                         {
 611                                 child = child.Resolve (ec);
 612                                 if (child == null)
 613                                         return null;
 614                                 type = child.Type;
 615                                 eclass = ExprClass.Value;
 616                                 return this;
 617                         }
 618
 619                         public override void Emit (EmitContext ec)
 620                         {
 621                                 child.Emit (ec);
 622                         }
 623                 }
 624
 625                 public override Expression DoResolve (EmitContext ec)
 626                 {
 627                         original_source = original_source.Resolve (ec);
 628                         if (original_source == null)
 629                                 return null;
 630
 631                         MemberAccess ma = target as MemberAccess;
 632                         using (ec.Set (EmitContext.Flags.InCompoundAssignment)) {
 633                                 target = target.Resolve (ec);
 634                         }
 635
 636                         if (target == null)
 637                                 return null;
 638
 639                         if (target is MethodGroupExpr){
 640                                 Error_CannotAssign (((MethodGroupExpr)target).Name, target.ExprClassName);
 641                                 return null;
 642                         }
 643
 644                         if (target is EventExpr)
 645                                 return new EventAddOrRemove (target, op, original_source, loc).DoResolve (ec);
 646
 647                         //
 648                         // Only now we can decouple the original source/target
 649                         // into a tree, to guarantee that we do not have side
 650                         // effects.
 651                         //
 652                         source = new Binary (op, new TargetExpression (target), original_source, true);
 653
 654                         // TODO: TargetExpression breaks MemberAccess composition
 655                         if (target is DynamicMemberBinder) {
 656                                 Arguments targs = ((DynamicMemberBinder) target).Arguments;
 657                                 source = source.Resolve (ec);
 658
 659                                 Arguments args = new Arguments (2);
 660                                 args.AddRange (targs);
 661                                 args.Add (new Argument (source));
 662                                 source = new DynamicMemberBinder (true, ma.Name, args, loc).Resolve (ec);
 663
 664                                 // Handles possible event addition/subtraction
 665                                 if (op == Binary.Operator.Addition || op == Binary.Operator.Subtraction) {
 666                                         args = new Arguments (2);
 667                                         args.AddRange (targs);
 668                                         args.Add (new Argument (original_source));
 669                                         string method_prefix = op == Binary.Operator.Addition ?
 670                                                 Event.AEventAccessor.AddPrefix : Event.AEventAccessor.RemovePrefix;
 671
 672                                         Expression invoke = new DynamicInvocation (
 673                                                 new MemberAccess (original_source, method_prefix + ma.Name, loc), args, loc).Resolve (ec);
 674
 675                                         args = new Arguments (1);
 676                                         args.AddRange (targs);
 677                                         source = new DynamicEventCompoundAssign (ma.Name, args,
 678                                                 (ExpressionStatement) source, (ExpressionStatement) invoke, loc).Resolve (ec);
 679                                 }
 680
 681                                 return source;
 682                         }
 683
 684                         return base.DoResolve (ec);
 685                 }
 686
 687                 protected override Expression ResolveConversions (EmitContext ec)
 688                 {
 689                         Type target_type = target.Type;
 690
 691                         //
 692                         // 1. the return type is implicitly convertible to the type of target
 693                         //
 694                         if (Convert.ImplicitConversionExists (ec, source, target_type)) {
 695                                 source = Convert.ImplicitConversion (ec, source, target_type, loc);
 696                                 return this;
 697                         }
 698
 699                         //
 700                         // Otherwise, if the selected operator is a predefined operator
 701                         //
 702                         Binary b = source as Binary;
 703                         if (b != null) {
 704                                 //
 705                                 // 2a. the operator is a shift operator
 706                                 //
 707                                 // 2b. the return type is explicitly convertible to the type of x, and
 708                                 // y is implicitly convertible to the type of x
 709                                 //
 710                                 if ((b.Oper & Binary.Operator.ShiftMask) != 0 ||
 711                                         Convert.ImplicitConversionExists (ec, original_source, target_type)) {
 712                                         source = Convert.ExplicitConversion (ec, source, target_type, loc);
 713                                         return this;
 714                                 }
 715                         }
 716
 717                         original_source.Error_ValueCannotBeConverted (ec, loc, target_type, false);
 718                         return null;
 719                 }
 720
 721                 protected override void CloneTo (CloneContext clonectx, Expression t)
 722                 {
 723                         CompoundAssign ctarget = (CompoundAssign) t;
 724
 725                         ctarget.original_source = ctarget.source = source.Clone (clonectx);
 726                         ctarget.target = target.Clone (clonectx);
 727                 }
 728         }
 729 }