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 //
   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 (Type t) : this (t, false) {}
 183
 184                 public LocalTemporary (Type t, bool is_address)
 185                 {
 186                         type = t;
 187                         eclass = ExprClass.Value;
 188                         this.is_address = is_address;
 189                 }
 190
 191                 public LocalTemporary (LocalBuilder b, Type t)
 192                 {
 193                         type = t;
 194                         eclass = ExprClass.Value;
 195                         loc = Location.Null;
 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 Expression DoResolve (EmitContext ec)
 206                 {
 207                         return this;
 208                 }
 209
 210                 public override void Emit (EmitContext ec)
 211                 {
 212                         ILGenerator ig = ec.ig;
 213
 214                         if (builder == null)
 215                                 throw new InternalErrorException ("Emit without Store, or after Release");
 216
 217                         ig.Emit (OpCodes.Ldloc, builder);
 218                         // we need to copy from the pointer
 219                         if (is_address)
 220                                 LoadFromPtr (ig, type);
 221                 }
 222
 223                 // NB: if you have `is_address' on the stack there must
 224                 // be a managed pointer. Otherwise, it is the type from
 225                 // the ctor.
 226                 public void Store (EmitContext ec)
 227                 {
 228                         ILGenerator ig = ec.ig;
 229                         if (builder == null)
 230                                 builder = ec.GetTemporaryLocal (is_address ? TypeManager.GetReferenceType (type): type);
 231
 232                         ig.Emit (OpCodes.Stloc, builder);
 233                 }
 234
 235                 public void AddressOf (EmitContext ec, AddressOp mode)
 236                 {
 237                         if (builder == null)
 238                                 builder = ec.GetTemporaryLocal (is_address ? TypeManager.GetReferenceType (type): type);
 239
 240                         // if is_address, than this is just the address anyways,
 241                         // so we just return this.
 242                         ILGenerator ig = ec.ig;
 243
 244                         if (is_address)
 245                                 ig.Emit (OpCodes.Ldloc, builder);
 246                         else
 247                                 ig.Emit (OpCodes.Ldloca, builder);
 248                 }
 249
 250                 public bool PointsToAddress {
 251                         get {
 252                                 return is_address;
 253                         }
 254                 }
 255         }
 256
 257         /// <summary>
 258         ///   The Assign node takes care of assigning the value of source into
 259         ///   the expression represented by target.
 260         /// </summary>
 261         public class Assign : ExpressionStatement {
 262                 protected Expression target, source, real_source;
 263                 protected LocalTemporary temp = null, real_temp = null;
 264                 protected Assign embedded = null;
 265                 protected bool is_embedded = false;
 266                 protected bool must_free_temp = false;
 267
 268                 public Assign (Expression target, Expression source)
 269                         : this (target, source, target.Location)
 270                 {
 271                 }
 272
 273                 public Assign (Expression target, Expression source, Location l)
 274                 {
 275                         this.target = target;
 276                         this.source = this.real_source = source;
 277                         this.loc = l;
 278                 }
 279
 280                 protected Assign (Assign embedded, Location l)
 281                         : this (embedded.target, embedded.source, l)
 282                 {
 283                         this.is_embedded = true;
 284                 }
 285
 286                 public override Expression CreateExpressionTree (EmitContext ec)
 287                 {
 288                         Report.Error (832, loc, "An expression tree cannot contain an assignment operator");
 289                         return null;
 290                 }
 291
 292                 protected virtual Assign GetEmbeddedAssign (Location loc)
 293                 {
 294                         return new Assign (this, loc);
 295                 }
 296
 297                 public Expression Target {
 298                         get {
 299                                 return target;
 300                         }
 301
 302                         set {
 303                                 target = value;
 304                         }
 305                 }
 306
 307                 public Expression Source {
 308                         get {
 309                                 return source;
 310                         }
 311
 312                         set {
 313                                 source = value;
 314                         }
 315                 }
 316
 317                 public static void error70 (EventInfo ei, Location l)
 318                 {
 319                         Report.Error (70, l, "The event `" + TypeManager.CSharpSignature (ei) +
 320                                       "' can only appear on the left hand side of += or -= (except when" +
 321                                       " used from within the type `" + ei.DeclaringType + "')");
 322                 }
 323
 324                 //
 325                 // Will return either `this' or an instance of `New'.
 326                 //
 327                 public override Expression DoResolve (EmitContext ec)
 328                 {
 329                         // Create an embedded assignment if our source is an assignment.
 330                         if (source is Assign)
 331                                 source = embedded = ((Assign) source).GetEmbeddedAssign (loc);
 332
 333                         real_source = source = source.Resolve (ec);
 334
 335                         if (source == null) {
 336                                 // Ensure that we don't propagate the error as spurious "uninitialized variable" errors.
 337                                 target = target.ResolveLValue (ec, EmptyExpression.Null, Location);
 338                                 return null;
 339                         }
 340
 341                         //
 342                         // This is used in an embedded assignment.
 343                         // As an example, consider the statement "A = X = Y = Z".
 344                         //
 345                         if (is_embedded && !(source is Constant)) {
 346                                 // If this is the innermost assignment (the "Y = Z" in our example),
 347                                 // create a new temporary local, otherwise inherit that variable
 348                                 // from our child (the "X = (Y = Z)" inherits the local from the
 349                                 // "Y = Z" assignment).
 350
 351                                 if (embedded == null) {
 352                                         if (this is CompoundAssign)
 353                                                 real_temp = temp = new LocalTemporary (target.Type);
 354                                         else
 355                                                 real_temp = temp = new LocalTemporary (source.Type);
 356                                 } else
 357                                         temp = embedded.temp;
 358
 359                                 // Set the source to the new temporary variable.
 360                                 // This means that the following target.ResolveLValue () will tell
 361                                 // the target to read it's source value from that variable.
 362                                 source = temp;
 363                         }
 364
 365                         // If we have an embedded assignment, use the embedded assignment's temporary
 366                         // local variable as source.
 367                         if (embedded != null)
 368                                 source = (embedded.temp != null) ? embedded.temp : embedded.source;
 369
 370                         target = target.ResolveLValue (ec, source, Location);
 371
 372                         if (target == null)
 373                                 return null;
 374
 375                         bool same_assignment = (embedded != null) ? embedded.Target.Equals(target) : source.Equals (target);
 376                         if (same_assignment) {
 377                                 Report.Warning (1717, 3, loc, "Assignment made to same variable; did you mean to assign something else?");
 378                         }
 379
 380                         Type target_type = target.Type;
 381                         Type source_type = real_source.Type;
 382
 383                         // If we're an embedded assignment, our parent will reuse our source as its
 384                         // source, it won't read from our target.
 385                         if (is_embedded)
 386                                 type = source_type;
 387                         else
 388                                 type = target_type;
 389                         eclass = ExprClass.Value;
 390
 391                         if (target is EventExpr) {
 392                                 EventInfo ei = ((EventExpr) target).EventInfo;
 393
 394                                 Expression ml = MemberLookup (
 395                                         ec.ContainerType, ec.ContainerType, ei.Name,
 396                                         MemberTypes.Event, AllBindingFlags | BindingFlags.DeclaredOnly, loc);
 397
 398                                 if (ml == null) {
 399                                         //
 400                                         // If this is the case, then the Event does not belong
 401                                         // to this Type and so, according to the spec
 402                                         // is allowed to only appear on the left hand of
 403                                         // the += and -= operators
 404                                         //
 405                                         // Note that target will not appear as an EventExpr
 406                                         // in the case it is being referenced within the same type container;
 407                                         // it will appear as a FieldExpr in that case.
 408                                         //
 409
 410                                         if (!(source is BinaryDelegate)) {
 411                                                 error70 (ei, loc);
 412                                                 return null;
 413                                         }
 414                                 }
 415                         }
 416
 417                         if (!(target is IAssignMethod) && (target.eclass != ExprClass.EventAccess)) {
 418                                 Error_ValueAssignment (loc);
 419                                 return null;
 420                         }
 421
 422                         if ((source.eclass == ExprClass.Type) && (source is TypeExpr)) {
 423                                 source.Error_UnexpectedKind (ec.DeclContainer, "variable or value", loc);
 424                                 return null;
 425                         } else if ((RootContext.Version == LanguageVersion.ISO_1) &&
 426                                    (source is MethodGroupExpr)){
 427                                 ((MethodGroupExpr) source).ReportUsageError ();
 428                                 return null;
 429
 430                         }
 431
 432                         if (target_type == source_type) {
 433                                 if (target.eclass == ExprClass.Variable) {
 434                                         New n = source as New;
 435                                         if (n == null)
 436                                                 return this;
 437
 438                                         if (n.HasInitializer) {
 439                                                 n.SetTargetVariable (target);
 440                                         } else if (target_type.IsValueType) {
 441                                                 n.SetTargetVariable (target);
 442                                                 return n;
 443                                         }
 444                                 }
 445
 446                                 return this;
 447                         }
 448
 449                         //
 450                         // If this assignment/operator was part of a compound binary
 451                         // operator, then we allow an explicit conversion, as detailed
 452                         // in the spec.
 453                         //
 454
 455                         if (this is CompoundAssign){
 456                                 CompoundAssign a = (CompoundAssign) this;
 457
 458                                 Binary b = source as Binary;
 459                                 if (b != null){
 460                                         //
 461                                         // 1. if the source is explicitly convertible to the
 462                                         //    target_type
 463                                         //
 464
 465                                         source = Convert.ExplicitConversion (ec, source, target_type, loc);
 466                                         if (source == null){
 467                                                 a.original_source.Error_ValueCannotBeConverted (ec, loc, target_type, true);
 468                                                 return null;
 469                                         }
 470
 471                                         //
 472                                         // 2. and the original right side is implicitly convertible to
 473                                         // the type of target
 474                                         //
 475                                         if (Convert.ImplicitConversionExists (ec, a.original_source, target_type))
 476                                                 return this;
 477
 478                                         //
 479                                         // In the spec 2.4 they added: or if type of the target is int
 480                                         // and the operator is a shift operator...
 481                                         //
 482                                         if (source_type == TypeManager.int32_type &&
 483                                             (b.Oper == Binary.Operator.LeftShift || b.Oper == Binary.Operator.RightShift))
 484                                                 return this;
 485
 486                                         a.original_source.Error_ValueCannotBeConverted (ec, loc, target_type, false);
 487                                         return null;
 488                                 }
 489                         }
 490
 491                         if (source.eclass == ExprClass.MethodGroup && !TypeManager.IsDelegateType (target_type)) {
 492                                 Report.Error (428, source.Location, "Cannot convert method group `{0}' to non-delegate type `{1}'. Did you intend to invoke the method?",
 493                                         ((MethodGroupExpr)source).Name, target.GetSignatureForError ());
 494                                 return null;
 495                         }
 496
 497                         source = Convert.ImplicitConversionRequired (ec, source, target_type, loc);
 498                         if (source == null)
 499                                 return null;
 500
 501                         // If we're an embedded assignment, we need to create a new temporary variable
 502                         // for the converted value.  Our parent will use this new variable as its source.
 503                         // The same applies when we have an embedded assignment - in this case, we need
 504                         // to convert our embedded assignment's temporary local variable to the correct
 505                         // type and store it in a new temporary local.
 506                         if (is_embedded || embedded != null) {
 507                                 type = target_type;
 508                                 temp = new LocalTemporary (type);
 509                                 must_free_temp = true;
 510                         }
 511
 512                         return this;
 513                 }
 514
 515                 Expression EmitEmbedded (EmitContext ec)
 516                 {
 517                         // Emit an embedded assignment.
 518
 519                         if (real_temp != null) {
 520                                 // If we're the innermost assignment, `real_source' is the right-hand
 521                                 // expression which gets assigned to all the variables left of it.
 522                                 // Emit this expression and store its result in real_temp.
 523                                 real_source.Emit (ec);
 524                                 real_temp.Store (ec);
 525                         }
 526
 527                         if (embedded != null)
 528                                 embedded.EmitEmbedded (ec);
 529
 530                         // This happens when we've done a type conversion, in this case source will be
 531                         // the expression which does the type conversion from real_temp.
 532                         // So emit it and store the result in temp; this is the var which will be read
 533                         // by our parent.
 534                         if (temp != real_temp) {
 535                                 source.Emit (ec);
 536                                 temp.Store (ec);
 537                         }
 538
 539                         Expression temp_source = (temp != null) ? temp : source;
 540                         ((IAssignMethod) target).EmitAssign (ec, temp_source, false, false);
 541                         return temp_source;
 542                 }
 543
 544                 void ReleaseEmbedded (EmitContext ec)
 545                 {
 546                         if (embedded != null)
 547                                 embedded.ReleaseEmbedded (ec);
 548
 549                         if (real_temp != null)
 550                                 real_temp.Release (ec);
 551
 552                         if (must_free_temp)
 553                                 temp.Release (ec);
 554                 }
 555
 556                 void Emit (EmitContext ec, bool is_statement)
 557                 {
 558                         if (target is EventExpr) {
 559                                 ((EventExpr) target).EmitAddOrRemove (ec, source);
 560                                 return;
 561                         }
 562
 563                         IAssignMethod am = (IAssignMethod) target;
 564
 565                         Expression temp_source;
 566                         if (embedded != null) {
 567                                 temp_source = embedded.EmitEmbedded (ec);
 568
 569                                 if (temp != null) {
 570                                         source.Emit (ec);
 571                                         temp.Store (ec);
 572                                         temp_source = temp;
 573                                 }
 574                         } else
 575                                 temp_source = source;
 576
 577                         am.EmitAssign (ec, temp_source, !is_statement, this is CompoundAssign);
 578
 579                         if (embedded != null) {
 580                                 if (temp != null)
 581                                         temp.Release (ec);
 582                                 embedded.ReleaseEmbedded (ec);
 583                         }
 584                 }
 585
 586                 public override void Emit (EmitContext ec)
 587                 {
 588                         Emit (ec, false);
 589                 }
 590
 591                 public override void EmitStatement (EmitContext ec)
 592                 {
 593                         Emit (ec, true);
 594                 }
 595
 596                 protected override void CloneTo (CloneContext clonectx, Expression t)
 597                 {
 598                         Assign _target = (Assign) t;
 599
 600                         _target.target = target.Clone (clonectx);
 601                         _target.source = source.Clone (clonectx);
 602                 }
 603         }
 604
 605
 606         // This class implements fields and events class initializers
 607         public class FieldInitializer : Assign
 608         {
 609                 //
 610                 // Keep resolved value because field initializers have their own rules
 611                 //
 612                 ExpressionStatement resolved;
 613
 614                 public FieldInitializer (FieldBuilder field, Expression expression)
 615                         : base (new FieldExpr (field, expression.Location, true), expression)
 616                 {
 617                         if (!field.IsStatic)
 618                                 ((FieldExpr)target).InstanceExpression = CompilerGeneratedThis.Instance;
 619                 }
 620
 621                 public override Expression DoResolve (EmitContext ec)
 622                 {
 623                         // Field initializer can be resolved (fail) many times
 624                         if (Source == null)
 625                                 return null;
 626
 627                         if (resolved == null)
 628                                 resolved = base.DoResolve (ec) as ExpressionStatement;
 629
 630                         return resolved;
 631                 }
 632
 633                 public override void EmitStatement (EmitContext ec)
 634                 {
 635                         if (resolved == null)
 636                                 return;
 637
 638                         if (resolved != this)
 639                                 resolved.EmitStatement (ec);
 640                         else
 641                                 base.EmitStatement (ec);
 642                 }
 643
 644                 public bool IsComplexInitializer {
 645                         get {
 646                                 if (embedded != null)
 647                                         return true;
 648
 649                                 return !(source is Constant);
 650                         }
 651                 }
 652
 653                 public bool IsDefaultInitializer {
 654                         get {
 655                                 Constant c = source as Constant;
 656                                 if (c == null)
 657                                         return false;
 658
 659                                 FieldExpr fe = (FieldExpr)target;
 660                                 return c.IsDefaultInitializer (fe.Type);
 661                         }
 662                 }
 663         }
 664
 665
 666         //
 667         // This class is used for compound assignments.
 668         //
 669         class CompoundAssign : Assign {
 670                 Binary.Operator op;
 671                 public Expression original_source;
 672
 673                 public CompoundAssign (Binary.Operator op, Expression target, Expression source)
 674                         : base (target, source, target.Location)
 675                 {
 676                         original_source = source;
 677                         this.op = op;
 678                 }
 679
 680                 protected CompoundAssign (CompoundAssign embedded, Location l)
 681                         : this (embedded.op, embedded.target, embedded.source)
 682                 {
 683                         this.is_embedded = true;
 684                 }
 685
 686                 protected override Assign GetEmbeddedAssign (Location loc)
 687                 {
 688                         return new CompoundAssign (this, loc);
 689                 }
 690
 691                 public override Expression DoResolve (EmitContext ec)
 692                 {
 693                         original_source = original_source.Resolve (ec);
 694                         if (original_source == null)
 695                                 return null;
 696
 697                         using (ec.Set (EmitContext.Flags.InCompoundAssignment)) {
 698                                 target = target.Resolve (ec);
 699                         }
 700
 701                         if (target == null)
 702                                 return null;
 703
 704                         if (target is MethodGroupExpr){
 705                                 Error_CannotAssign (((MethodGroupExpr)target).Name, target.ExprClassName);
 706                                 return null;
 707                         }
 708                         //
 709                         // Only now we can decouple the original source/target
 710                         // into a tree, to guarantee that we do not have side
 711                         // effects.
 712                         //
 713                         source = new Binary (op, target, original_source, true);
 714                         return base.DoResolve (ec);
 715                 }
 716
 717                 protected override void CloneTo (CloneContext clonectx, Expression t)
 718                 {
 719                         CompoundAssign target = (CompoundAssign) t;
 720
 721                         target.original_source = original_source.Clone (clonectx);
 722                 }
 723         }
 724 }