mcs/gmcs/assign.cs

   1 //
   2 // assign.cs: Assignments.
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //   Martin Baulig (martin@ximian.com)
   7 //
   8 // (C) 2001, 2002, 2003 Ximian, Inc.
   9 // (C) 2004 Novell, Inc
  10 //
  11 using System;
  12 using System.Reflection;
  13 using System.Reflection.Emit;
  14
  15 namespace Mono.CSharp {
  16
  17         /// <summary>
  18         ///   This interface is implemented by expressions that can be assigned to.
  19         /// </summary>
  20         /// <remarks>
  21         ///   This interface is implemented by Expressions whose values can not
  22         ///   store the result on the top of the stack.
  23         ///
  24         ///   Expressions implementing this (Properties, Indexers and Arrays) would
  25         ///   perform an assignment of the Expression "source" into its final
  26         ///   location.
  27         ///
  28         ///   No values on the top of the stack are expected to be left by
  29         ///   invoking this method.
  30         /// </remarks>
  31         public interface IAssignMethod {
  32                 //
  33                 // This is an extra version of Emit. If leave_copy is `true'
  34                 // A copy of the expression will be left on the stack at the
  35                 // end of the code generated for EmitAssign
  36                 //
  37                 void Emit (EmitContext ec, bool leave_copy);
  38
  39                 //
  40                 // This method does the assignment
  41                 // `source' will be stored into the location specified by `this'
  42                 // if `leave_copy' is true, a copy of `source' will be left on the stack
  43                 // if `prepare_for_load' is true, when `source' is emitted, there will
  44                 // be data on the stack that it can use to compuatate its value. This is
  45                 // for expressions like a [f ()] ++, where you can't call `f ()' twice.
  46                 //
  47                 void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load);
  48
  49                 /*
  50                 For simple assignments, this interface is very simple, EmitAssign is called with source
  51                 as the source expression and leave_copy and prepare_for_load false.
  52
  53                 For compound assignments it gets complicated.
  54
  55                 EmitAssign will be called as before, however, prepare_for_load will be
  56                 true. The @source expression will contain an expression
  57                 which calls Emit. So, the calls look like:
  58
  59                 this.EmitAssign (ec, source, false, true) ->
  60                         source.Emit (ec); ->
  61                                 [...] ->
  62                                         this.Emit (ec, false); ->
  63                                         end this.Emit (ec, false); ->
  64                                 end [...]
  65                         end source.Emit (ec);
  66                 end this.EmitAssign (ec, source, false, true)
  67
  68
  69                 When prepare_for_load is true, EmitAssign emits a `token' on the stack that
  70                 Emit will use for its state.
  71
  72                 Let's take FieldExpr as an example. assume we are emitting f ().y += 1;
  73
  74                 Here is the call tree again. This time, each call is annotated with the IL
  75                 it produces:
  76
  77                 this.EmitAssign (ec, source, false, true)
  78                         call f
  79                         dup
  80
  81                         Binary.Emit ()
  82                                 this.Emit (ec, false);
  83                                 ldfld y
  84                                 end this.Emit (ec, false);
  85
  86                                 IntConstant.Emit ()
  87                                 ldc.i4.1
  88                                 end IntConstant.Emit
  89
  90                                 add
  91                         end Binary.Emit ()
  92
  93                         stfld
  94                 end this.EmitAssign (ec, source, false, true)
  95
  96                 Observe two things:
  97                         1) EmitAssign left a token on the stack. It was the result of f ().
  98                         2) This token was used by Emit
  99
 100                 leave_copy (in both EmitAssign and Emit) tells the compiler to leave a copy
 101                 of the expression at that point in evaluation. This is used for pre/post inc/dec
 102                 and for a = x += y. Let's do the above example with leave_copy true in EmitAssign
 103
 104                 this.EmitAssign (ec, source, true, true)
 105                         call f
 106                         dup
 107
 108                         Binary.Emit ()
 109                                 this.Emit (ec, false);
 110                                 ldfld y
 111                                 end this.Emit (ec, false);
 112
 113                                 IntConstant.Emit ()
 114                                 ldc.i4.1
 115                                 end IntConstant.Emit
 116
 117                                 add
 118                         end Binary.Emit ()
 119
 120                         dup
 121                         stloc temp
 122                         stfld
 123                         ldloc temp
 124                 end this.EmitAssign (ec, source, true, true)
 125
 126                 And with it true in Emit
 127
 128                 this.EmitAssign (ec, source, false, true)
 129                         call f
 130                         dup
 131
 132                         Binary.Emit ()
 133                                 this.Emit (ec, true);
 134                                 ldfld y
 135                                 dup
 136                                 stloc temp
 137                                 end this.Emit (ec, true);
 138
 139                                 IntConstant.Emit ()
 140                                 ldc.i4.1
 141                                 end IntConstant.Emit
 142
 143                                 add
 144                         end Binary.Emit ()
 145
 146                         stfld
 147                         ldloc temp
 148                 end this.EmitAssign (ec, source, false, true)
 149
 150                 Note that these two examples are what happens for ++x and x++, respectively.
 151                 */
 152         }
 153
 154         /// <summary>
 155         ///   An Expression to hold a temporary value.
 156         /// </summary>
 157         /// <remarks>
 158         ///   The LocalTemporary class is used to hold temporary values of a given
 159         ///   type to "simulate" the expression semantics on property and indexer
 160         ///   access whose return values are void.
 161         ///
 162         ///   The local temporary is used to alter the normal flow of code generation
 163         ///   basically it creates a local variable, and its emit instruction generates
 164         ///   code to access this value, return its address or save its value.
 165         ///
 166         ///   If `is_address' is true, then the value that we store is the address to the
 167         ///   real value, and not the value itself.
 168         ///
 169         ///   This is needed for a value type, because otherwise you just end up making a
 170         ///   copy of the value on the stack and modifying it. You really need a pointer
 171         ///   to the origional value so that you can modify it in that location. This
 172         ///   Does not happen with a class because a class is a pointer -- so you always
 173         ///   get the indirection.
 174         ///
 175         ///   The `is_address' stuff is really just a hack. We need to come up with a better
 176         ///   way to handle it.
 177         /// </remarks>
 178         public class LocalTemporary : Expression, IMemoryLocation {
 179                 LocalBuilder builder;
 180                 bool is_address;
 181
 182                 public LocalTemporary (EmitContext ec, Type t) : this (ec, t, false) {}
 183
 184                 public LocalTemporary (EmitContext ec, Type t, bool is_address)
 185                 {
 186                         type = t;
 187                         eclass = ExprClass.Value;
 188                         loc = Location.Null;
 189                         builder = ec.GetTemporaryLocal (is_address ? TypeManager.GetReferenceType (t): t);
 190                         this.is_address = is_address;
 191                 }
 192
 193                 public LocalTemporary (LocalBuilder b, Type t)
 194                 {
 195                         type = t;
 196                         eclass = ExprClass.Value;
 197                         loc = Location.Null;
 198                         builder = b;
 199                 }
 200
 201                 public void Release (EmitContext ec)
 202                 {
 203                         ec.FreeTemporaryLocal (builder, type);
 204                         builder = null;
 205                 }
 206
 207                 public override Expression DoResolve (EmitContext ec)
 208                 {
 209                         return this;
 210                 }
 211
 212                 public override void Emit (EmitContext ec)
 213                 {
 214                         ILGenerator ig = ec.ig;
 215
 216                         ig.Emit (OpCodes.Ldloc, builder);
 217                         // we need to copy from the pointer
 218                         if (is_address)
 219                                 LoadFromPtr (ig, type);
 220                 }
 221
 222                 // NB: if you have `is_address' on the stack there must
 223                 // be a managed pointer. Otherwise, it is the type from
 224                 // the ctor.
 225                 public void Store (EmitContext ec)
 226                 {
 227                         ILGenerator ig = ec.ig;
 228                         ig.Emit (OpCodes.Stloc, builder);
 229                 }
 230
 231                 public void AddressOf (EmitContext ec, AddressOp mode)
 232                 {
 233                         // if is_address, than this is just the address anyways,
 234                         // so we just return this.
 235                         ILGenerator ig = ec.ig;
 236
 237                         if (is_address)
 238                                 ig.Emit (OpCodes.Ldloc, builder);
 239                         else
 240                                 ig.Emit (OpCodes.Ldloca, builder);
 241                 }
 242
 243                 public bool PointsToAddress {
 244                         get {
 245                                 return is_address;
 246                         }
 247                 }
 248         }
 249
 250         /// <summary>
 251         ///   The Assign node takes care of assigning the value of source into
 252         ///   the expression represented by target.
 253         /// </summary>
 254         public class Assign : ExpressionStatement {
 255                 protected Expression target, source, real_source;
 256                 protected LocalTemporary temp = null, real_temp = null;
 257                 protected Assign embedded = null;
 258                 protected bool is_embedded = false;
 259                 protected bool must_free_temp = false;
 260
 261                 public Assign (Expression target, Expression source, Location l)
 262                 {
 263                         this.target = target;
 264                         this.source = this.real_source = source;
 265                         this.loc = l;
 266                 }
 267
 268                 protected Assign (Assign embedded, Location l)
 269                         : this (embedded.target, embedded.source, l)
 270                 {
 271                         this.is_embedded = true;
 272                 }
 273
 274                 protected virtual Assign GetEmbeddedAssign (Location loc)
 275                 {
 276                         return new Assign (this, loc);
 277                 }
 278
 279                 public Expression Target {
 280                         get {
 281                                 return target;
 282                         }
 283
 284                         set {
 285                                 target = value;
 286                         }
 287                 }
 288
 289                 public Expression Source {
 290                         get {
 291                                 return source;
 292                         }
 293
 294                         set {
 295                                 source = value;
 296                         }
 297                 }
 298
 299                 public static void error70 (EventInfo ei, Location l)
 300                 {
 301                         Report.Error (70, l, "The event '" + ei.Name +
 302                                       "' can only appear on the left-side of a += or -= (except when" +
 303                                       " used from within the type '" + ei.DeclaringType + "')");
 304                 }
 305
 306                 //
 307                 // Will return either `this' or an instance of `New'.
 308                 //
 309                 public override Expression DoResolve (EmitContext ec)
 310                 {
 311                         // Create an embedded assignment if our source is an assignment.
 312                         if (source is Assign)
 313                                 source = embedded = ((Assign) source).GetEmbeddedAssign (loc);
 314
 315                         real_source = source = source.Resolve (ec);
 316                         if (source == null) {
 317                                 // Ensure that we don't propagate the error as spurious "uninitialized variable" errors.
 318                                 target = target.ResolveLValue (ec, EmptyExpression.Null, Location);
 319                                 return null;
 320                         }
 321
 322                         //
 323                         // This is used in an embedded assignment.
 324                         // As an example, consider the statement "A = X = Y = Z".
 325                         //
 326                         if (is_embedded && !(source is Constant)) {
 327                                 // If this is the innermost assignment (the "Y = Z" in our example),
 328                                 // create a new temporary local, otherwise inherit that variable
 329                                 // from our child (the "X = (Y = Z)" inherits the local from the
 330                                 // "Y = Z" assignment).
 331
 332                                 if (embedded == null) {
 333                                         if (this is CompoundAssign)
 334                                                 real_temp = temp = new LocalTemporary (ec, target.Type);
 335                                         else
 336                                                 real_temp = temp = new LocalTemporary (ec, source.Type);
 337                                 } else
 338                                         temp = embedded.temp;
 339
 340                                 // Set the source to the new temporary variable.
 341                                 // This means that the following target.ResolveLValue () will tell
 342                                 // the target to read it's source value from that variable.
 343                                 source = temp;
 344                         }
 345
 346                         // If we have an embedded assignment, use the embedded assignment's temporary
 347                         // local variable as source.
 348                         if (embedded != null)
 349                                 source = (embedded.temp != null) ? embedded.temp : embedded.source;
 350
 351                         target = target.ResolveLValue (ec, source, Location);
 352
 353                         if (target == null)
 354                                 return null;
 355
 356                         if (source.Equals (target)) {
 357                                 Report.Warning (1717, 3, loc, "Assignment made to same variable; did you mean to assign something else?");
 358                         }
 359
 360                         Type target_type = target.Type;
 361                         Type source_type = real_source.Type;
 362
 363                         // If we're an embedded assignment, our parent will reuse our source as its
 364                         // source, it won't read from our target.
 365                         if (is_embedded)
 366                                 type = source_type;
 367                         else
 368                                 type = target_type;
 369                         eclass = ExprClass.Value;
 370
 371                         if (target is EventExpr) {
 372                                 EventInfo ei = ((EventExpr) target).EventInfo;
 373
 374                                 Expression ml = MemberLookup (
 375                                         ec, ec.ContainerType, ei.Name,
 376                                         MemberTypes.Event, AllBindingFlags | BindingFlags.DeclaredOnly, loc);
 377
 378                                 if (ml == null) {
 379                                         //
 380                                         // If this is the case, then the Event does not belong
 381                                         // to this Type and so, according to the spec
 382                                         // is allowed to only appear on the left hand of
 383                                         // the += and -= operators
 384                                         //
 385                                         // Note that target will not appear as an EventExpr
 386                                         // in the case it is being referenced within the same type container;
 387                                         // it will appear as a FieldExpr in that case.
 388                                         //
 389
 390                                         if (!(source is BinaryDelegate)) {
 391                                                 error70 (ei, loc);
 392                                                 return null;
 393                                         }
 394                                 }
 395                         }
 396
 397                         FieldExpr field_exp = target as FieldExpr;
 398                         if (field_exp != null && field_exp.DeclaringType.IsValueType && !ec.IsConstructor && !ec.IsFieldInitializer) {
 399                                 field_exp = field_exp.InstanceExpression as FieldExpr;
 400                                 if (field_exp != null && field_exp.FieldInfo.IsInitOnly) {
 401                                         if (field_exp.IsStatic) {
 402                                                 Report.Error (1650, loc, "Members of static readonly field '{0}' cannot be assigned to " +
 403                                                         "(except in a static constructor or a variable initializer)", TypeManager.GetFullNameSignature (field_exp.FieldInfo));
 404                                         } else {
 405                                                 Report.Error (1648, loc, "Members of readonly field '{0}' cannot be assigned to " +
 406                                                         "(except in a constructor or a variable initializer)", TypeManager.GetFullNameSignature (field_exp.FieldInfo));
 407                                         }
 408                                         return null;
 409                                 }
 410                         }
 411
 412                         if (!(target is IAssignMethod) && (target.eclass != ExprClass.EventAccess)) {
 413                                 Report.Error (131, loc,
 414                                               "Left hand of an assignment must be a variable, " +
 415                                               "a property or an indexer");
 416                                 return null;
 417                         }
 418
 419                         if ((source.eclass == ExprClass.Type) && (source is TypeExpr)) {
 420                                 source.Error_UnexpectedKind ("variable or value", loc);
 421                                 return null;
 422                         } else if ((RootContext.Version == LanguageVersion.ISO_1) &&
 423                                    (source is MethodGroupExpr)){
 424                                 ((MethodGroupExpr) source).ReportUsageError ();
 425                                 return null;
 426
 427                         }
 428
 429                         if (target_type == source_type){
 430                         if (source is New && target_type.IsValueType &&
 431                             (target.eclass != ExprClass.IndexerAccess) && (target.eclass != ExprClass.PropertyAccess)){
 432                                 New n = (New) source;
 433
 434                                 if (n.SetValueTypeVariable (target))
 435                                         return n;
 436                                 else
 437                                         return null;
 438                         }
 439
 440                                 return this;
 441                         }
 442
 443                         //
 444                         // If this assignemnt/operator was part of a compound binary
 445                         // operator, then we allow an explicit conversion, as detailed
 446                         // in the spec.
 447                         //
 448
 449                         if (this is CompoundAssign){
 450                                 CompoundAssign a = (CompoundAssign) this;
 451
 452                                 Binary b = source as Binary;
 453                                 if (b != null){
 454                                         //
 455                                         // 1. if the source is explicitly convertible to the
 456                                         //    target_type
 457                                         //
 458
 459                                         source = Convert.ExplicitConversion (ec, source, target_type, loc);
 460                                         if (source == null){
 461                                                 Convert.Error_CannotImplicitConversion (loc, source_type, target_type);
 462                                                 return null;
 463                                         }
 464
 465                                         //
 466                                         // 2. and the original right side is implicitly convertible to
 467                                         // the type of target
 468                                         //
 469                                         if (Convert.ImplicitStandardConversionExists (ec, a.original_source, target_type))
 470                                                 return this;
 471
 472                                         //
 473                                         // In the spec 2.4 they added: or if type of the target is int
 474                                         // and the operator is a shift operator...
 475                                         //
 476                                         if (source_type == TypeManager.int32_type &&
 477                                             (b.Oper == Binary.Operator.LeftShift || b.Oper == Binary.Operator.RightShift))
 478                                                 return this;
 479
 480                                         Convert.Error_CannotImplicitConversion (loc, a.original_source.Type, target_type);
 481                                         return null;
 482                                 }
 483                         }
 484
 485                         source = Convert.ImplicitConversionRequired (ec, source, target_type, loc);
 486                         if (source == null)
 487                                 return null;
 488
 489                         // If we're an embedded assignment, we need to create a new temporary variable
 490                         // for the converted value.  Our parent will use this new variable as its source.
 491                         // The same applies when we have an embedded assignment - in this case, we need
 492                         // to convert our embedded assignment's temporary local variable to the correct
 493                         // type and store it in a new temporary local.
 494                         if (is_embedded || embedded != null) {
 495                                 type = target_type;
 496                                 temp = new LocalTemporary (ec, type);
 497                                 must_free_temp = true;
 498                         }
 499
 500                         return this;
 501                 }
 502
 503                 Expression EmitEmbedded (EmitContext ec)
 504                 {
 505                         // Emit an embedded assignment.
 506
 507                         if (real_temp != null) {
 508                                 // If we're the innermost assignment, `real_source' is the right-hand
 509                                 // expression which gets assigned to all the variables left of it.
 510                                 // Emit this expression and store its result in real_temp.
 511                                 real_source.Emit (ec);
 512                                 real_temp.Store (ec);
 513                         }
 514
 515                         if (embedded != null)
 516                                 embedded.EmitEmbedded (ec);
 517
 518                         // This happens when we've done a type conversion, in this case source will be
 519                         // the expression which does the type conversion from real_temp.
 520                         // So emit it and store the result in temp; this is the var which will be read
 521                         // by our parent.
 522                         if (temp != real_temp) {
 523                                 source.Emit (ec);
 524                                 temp.Store (ec);
 525                         }
 526
 527                         Expression temp_source = (temp != null) ? temp : source;
 528                         ((IAssignMethod) target).EmitAssign (ec, temp_source, false, false);
 529                         return temp_source;
 530                 }
 531
 532                 void ReleaseEmbedded (EmitContext ec)
 533                 {
 534                         if (embedded != null)
 535                                 embedded.ReleaseEmbedded (ec);
 536
 537                         if (real_temp != null)
 538                                 real_temp.Release (ec);
 539
 540                         if (must_free_temp)
 541                                 temp.Release (ec);
 542                 }
 543
 544                 void Emit (EmitContext ec, bool is_statement)
 545                 {
 546                         if (target is EventExpr) {
 547                                 ((EventExpr) target).EmitAddOrRemove (ec, source);
 548                                 return;
 549                         }
 550
 551                         IAssignMethod am = (IAssignMethod) target;
 552
 553                         Expression temp_source;
 554                         if (embedded != null) {
 555                                 temp_source = embedded.EmitEmbedded (ec);
 556
 557                                 if (temp != null) {
 558                                         source.Emit (ec);
 559                                         temp.Store (ec);
 560                                         temp_source = temp;
 561                                 }
 562                         } else
 563                                 temp_source = source;
 564
 565                         am.EmitAssign (ec, temp_source, !is_statement, this is CompoundAssign);
 566
 567                         if (embedded != null) {
 568                                 if (temp != null)
 569                                         temp.Release (ec);
 570                                 embedded.ReleaseEmbedded (ec);
 571                         }
 572                 }
 573
 574                 public override void Emit (EmitContext ec)
 575                 {
 576                         Emit (ec, false);
 577                 }
 578
 579                 public override void EmitStatement (EmitContext ec)
 580                 {
 581                         Emit (ec, true);
 582                 }
 583         }
 584
 585
 586         //
 587         // This class is used for compound assignments.
 588         //
 589         class CompoundAssign : Assign {
 590                 Binary.Operator op;
 591                 public Expression original_source;
 592
 593                 public CompoundAssign (Binary.Operator op, Expression target, Expression source, Location l)
 594                         : base (target, source, l)
 595                 {
 596                         original_source = source;
 597                         this.op = op;
 598                 }
 599
 600                 protected CompoundAssign (CompoundAssign embedded, Location l)
 601                         : this (embedded.op, embedded.target, embedded.source, l)
 602                 {
 603                         this.is_embedded = true;
 604                 }
 605
 606                 protected override Assign GetEmbeddedAssign (Location loc)
 607                 {
 608                         return new CompoundAssign (this, loc);
 609                 }
 610
 611                 public Expression ResolveSource (EmitContext ec)
 612                 {
 613                         return original_source.Resolve (ec);
 614                 }
 615
 616                 public override Expression DoResolve (EmitContext ec)
 617                 {
 618                         original_source = original_source.Resolve (ec);
 619                         if (original_source == null)
 620                                 return null;
 621
 622                         target = target.Resolve (ec);
 623                         if (target == null)
 624                                 return null;
 625
 626                         //
 627                         // Only now we can decouple the original source/target
 628                         // into a tree, to guarantee that we do not have side
 629                         // effects.
 630                         //
 631                         source = new Binary (op, target, original_source, loc);
 632                         return base.DoResolve (ec);
 633                 }
 634         }
 635 }
 636
 637
 638
 639