mcs/mcs/assign.cs

   1 //
   2 // assign.cs: Assignments.
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //   Martin Baulig (martin@gnome.org)
   7 //
   8 // (C) 2001, 2002, 2003 Ximian, Inc.
   9 //
  10 using System;
  11 using System.Reflection;
  12 using System.Reflection.Emit;
  13
  14 namespace Mono.CSharp {
  15
  16         /// <summary>
  17         ///   This interface is implemented by expressions that can be assigned to.
  18         /// </summary>
  19         /// <remarks>
  20         ///   This interface is implemented by Expressions whose values can not
  21         ///   store the result on the top of the stack.
  22         ///
  23         ///   Expressions implementing this (Properties, Indexers and Arrays) would
  24         ///   perform an assignment of the Expression "source" into its final
  25         ///   location.
  26         ///
  27         ///   No values on the top of the stack are expected to be left by
  28         ///   invoking this method.
  29         /// </remarks>
  30         public interface IAssignMethod {
  31                 //
  32                 // This method will emit the code for the actual assignment
  33                 //
  34                 void EmitAssign (EmitContext ec, Expression source);
  35
  36                 //
  37                 // This method is invoked before any code generation takes
  38                 // place, and it is a mechanism to inform that the expression
  39                 // will be invoked more than once, and that the method should
  40                 // use temporary values to avoid having side effects
  41                 //
  42                 // Example: a [ g () ] ++
  43                 //
  44                 void CacheTemporaries (EmitContext ec);
  45         }
  46
  47         /// <summary>
  48         ///   An Expression to hold a temporary value.
  49         /// </summary>
  50         /// <remarks>
  51         ///   The LocalTemporary class is used to hold temporary values of a given
  52         ///   type to "simulate" the expression semantics on property and indexer
  53         ///   access whose return values are void.
  54         ///
  55         ///   The local temporary is used to alter the normal flow of code generation
  56         ///   basically it creates a local variable, and its emit instruction generates
  57         ///   code to access this value, return its address or save its value.
  58         /// </remarks>
  59         public class LocalTemporary : Expression, IMemoryLocation {
  60                 LocalBuilder builder;
  61
  62                 public LocalTemporary (EmitContext ec, Type t)
  63                 {
  64                         type = t;
  65                         eclass = ExprClass.Value;
  66                         loc = Location.Null;
  67                         builder = ec.GetTemporaryStorage (t);
  68                 }
  69
  70                 public void Release (EmitContext ec)
  71                 {
  72                         ec.FreeTemporaryStorage (builder);
  73                         builder = null;
  74                 }
  75
  76                 public LocalTemporary (LocalBuilder b, Type t)
  77                 {
  78                         type = t;
  79                         eclass = ExprClass.Value;
  80                         loc = Location.Null;
  81                         builder = b;
  82                 }
  83
  84                 public override Expression DoResolve (EmitContext ec)
  85                 {
  86                         return this;
  87                 }
  88
  89                 public override void Emit (EmitContext ec)
  90                 {
  91                         ec.ig.Emit (OpCodes.Ldloc, builder);
  92                 }
  93
  94                 public void Store (EmitContext ec)
  95                 {
  96                         ec.ig.Emit (OpCodes.Stloc, builder);
  97                 }
  98
  99                 public void AddressOf (EmitContext ec, AddressOp mode)
 100                 {
 101                         ec.ig.Emit (OpCodes.Ldloca, builder);
 102                 }
 103         }
 104
 105         /// <summary>
 106         ///   The Assign node takes care of assigning the value of source into
 107         ///   the expression represented by target.
 108         /// </summary>
 109         public class Assign : ExpressionStatement {
 110                 protected Expression target, source, real_source;
 111                 protected LocalTemporary temp = null, real_temp = null;
 112                 protected Assign embedded = null;
 113                 protected bool is_embedded = false;
 114                 protected bool must_free_temp = false;
 115
 116                 public Assign (Expression target, Expression source, Location l)
 117                 {
 118                         this.target = target;
 119                         this.source = this.real_source = source;
 120                         this.loc = l;
 121                 }
 122
 123                 protected Assign (Assign embedded, Location l)
 124                         : this (embedded.target, embedded.source, l)
 125                 {
 126                         this.is_embedded = true;
 127                 }
 128
 129                 protected virtual Assign GetEmbeddedAssign (Location loc)
 130                 {
 131                         return new Assign (this, loc);
 132                 }
 133
 134                 public Expression Target {
 135                         get {
 136                                 return target;
 137                         }
 138
 139                         set {
 140                                 target = value;
 141                         }
 142                 }
 143
 144                 public Expression Source {
 145                         get {
 146                                 return source;
 147                         }
 148
 149                         set {
 150                                 source = value;
 151                         }
 152                 }
 153
 154                 public static void error70 (EventInfo ei, Location l)
 155                 {
 156                         Report.Error (70, l, "The event '" + ei.Name +
 157                                       "' can only appear on the left-side of a += or -= (except when" +
 158                                       " used from within the type '" + ei.DeclaringType + "')");
 159                 }
 160
 161                 //
 162                 // Will return either `this' or an instance of `New'.
 163                 //
 164                 public override Expression DoResolve (EmitContext ec)
 165                 {
 166                         // Create an embedded assignment if our source is an assignment.
 167                         if (source is Assign)
 168                                 source = embedded = ((Assign) source).GetEmbeddedAssign (loc);
 169
 170                         real_source = source = source.Resolve (ec);
 171                         if (source == null)
 172                                 return null;
 173
 174                         //
 175                         // This is used in an embedded assignment.
 176                         // As an example, consider the statement "A = X = Y = Z".
 177                         //
 178                         if (is_embedded && !(source is Constant)) {
 179                                 // If this is the innermost assignment (the "Y = Z" in our example),
 180                                 // create a new temporary local, otherwise inherit that variable
 181                                 // from our child (the "X = (Y = Z)" inherits the local from the
 182                                 // "Y = Z" assignment).
 183
 184                                 if (embedded == null) {
 185                                         if (this is CompoundAssign)
 186                                                 real_temp = temp = new LocalTemporary (ec, target.Type);
 187                                         else
 188                                                 real_temp = temp = new LocalTemporary (ec, source.Type);
 189                                 } else
 190                                         temp = embedded.temp;
 191
 192                                 // Set the source to the new temporary variable.
 193                                 // This means that the following target.ResolveLValue () will tell
 194                                 // the target to read it's source value from that variable.
 195                                 source = temp;
 196                         }
 197
 198                         // If we have an embedded assignment, use the embedded assignment's temporary
 199                         // local variable as source.
 200                         if (embedded != null)
 201                                 source = (embedded.temp != null) ? embedded.temp : embedded.source;
 202
 203                         target = target.ResolveLValue (ec, source);
 204
 205                         if (target == null)
 206                                 return null;
 207
 208                         Type target_type = target.Type;
 209                         Type source_type = real_source.Type;
 210
 211                         // If we're an embedded assignment, our parent will reuse our source as its
 212                         // source, it won't read from our target.
 213                         if (is_embedded)
 214                                 type = source_type;
 215                         else
 216                                 type = target_type;
 217                         eclass = ExprClass.Value;
 218
 219                         //
 220                         // If we are doing a property assignment, then
 221                         // set the `value' field on the property, and Resolve
 222                         // it.
 223                         //
 224                         if (target is PropertyExpr){
 225                                 PropertyExpr property_assign = (PropertyExpr) target;
 226
 227                                 if (source_type != target_type){
 228                                         source = Convert.ImplicitConversionRequired (ec, source, target_type, loc);
 229                                         if (source == null)
 230                                                 return null;
 231                                 }
 232
 233                                 //
 234                                 // FIXME: Maybe handle this in the LValueResolve
 235                                 //
 236                                 if (!property_assign.VerifyAssignable ())
 237                                         return null;
 238
 239                                 return this;
 240                         }
 241
 242                         if (target is IndexerAccess) {
 243                                 return this;
 244                         }
 245
 246                         if (target is EventExpr) {
 247                                 EventInfo ei = ((EventExpr) target).EventInfo;
 248
 249                                 Expression ml = MemberLookup (
 250                                         ec, ec.ContainerType, ei.Name,
 251                                         MemberTypes.Event, AllBindingFlags | BindingFlags.DeclaredOnly, loc);
 252
 253                                 if (ml == null) {
 254                                         //
 255                                         // If this is the case, then the Event does not belong
 256                                         // to this Type and so, according to the spec
 257                                         // is allowed to only appear on the left hand of
 258                                         // the += and -= operators
 259                                         //
 260                                         // Note that target will not appear as an EventExpr
 261                                         // in the case it is being referenced within the same type container;
 262                                         // it will appear as a FieldExpr in that case.
 263                                         //
 264
 265                                         if (!(source is Binary)) {
 266                                                 error70 (ei, loc);
 267                                                 return null;
 268                                         } else {
 269                                                 Binary tmp = ((Binary) source);
 270                                                 if (tmp.Oper != Binary.Operator.Addition &&
 271                                                     tmp.Oper != Binary.Operator.Subtraction) {
 272                                                         error70 (ei, loc);
 273                                                         return null;
 274                                                 }
 275                                         }
 276                                 }
 277                         }
 278
 279                         if (source is New && target_type.IsValueType){
 280                                 New n = (New) source;
 281
 282                                 if (n.SetValueTypeVariable (target))
 283                                         return n;
 284                                 else
 285                                         return null;
 286                         }
 287
 288                         if (target.eclass != ExprClass.Variable && target.eclass != ExprClass.EventAccess){
 289                                 Report.Error (131, loc,
 290                                               "Left hand of an assignment must be a variable, " +
 291                                               "a property or an indexer");
 292                                 return null;
 293                         }
 294
 295                         if ((source.eclass == ExprClass.Type) && (source is TypeExpr)) {
 296                                 source.Error_UnexpectedKind ("variable or value");
 297                                 return null;
 298                         } else if (source is MethodGroupExpr){
 299                                 ((MethodGroupExpr) source).ReportUsageError ();
 300                                 return null;
 301                         }
 302
 303                         if (target_type == source_type)
 304                                 return this;
 305
 306                         //
 307                         // If this assignemnt/operator was part of a compound binary
 308                         // operator, then we allow an explicit conversion, as detailed
 309                         // in the spec.
 310                         //
 311
 312                         if (this is CompoundAssign){
 313                                 CompoundAssign a = (CompoundAssign) this;
 314
 315                                 Binary b = source as Binary;
 316                                 if (b != null && b.IsBuiltinOperator){
 317                                         //
 318                                         // 1. if the source is explicitly convertible to the
 319                                         //    target_type
 320                                         //
 321
 322                                         source = Convert.ExplicitConversion (ec, source, target_type, loc);
 323                                         if (source == null){
 324                                                 Convert.Error_CannotImplicitConversion (loc, source_type, target_type);
 325                                                 return null;
 326                                         }
 327
 328                                         //
 329                                         // 2. and the original right side is implicitly convertible to
 330                                         // the type of target_type.
 331                                         //
 332                                         if (Convert.ImplicitStandardConversionExists (a.original_source, target_type))
 333                                                 return this;
 334
 335                                         Convert.Error_CannotImplicitConversion (loc, a.original_source.Type, target_type);
 336                                         return null;
 337                                 }
 338                         }
 339
 340                         source = Convert.ImplicitConversionRequired (ec, source, target_type, loc);
 341                         if (source == null)
 342                                 return null;
 343
 344                         // If we're an embedded assignment, we need to create a new temporary variable
 345                         // for the converted value.  Our parent will use this new variable as its source.
 346                         // The same applies when we have an embedded assignment - in this case, we need
 347                         // to convert our embedded assignment's temporary local variable to the correct
 348                         // type and store it in a new temporary local.
 349                         if (is_embedded || embedded != null) {
 350                                 type = target_type;
 351                                 temp = new LocalTemporary (ec, type);
 352                                 must_free_temp = true;
 353                         }
 354
 355                         return this;
 356                 }
 357
 358                 Expression EmitEmbedded (EmitContext ec)
 359                 {
 360                         // Emit an embedded assignment.
 361
 362                         if (real_temp != null) {
 363                                 // If we're the innermost assignment, `real_source' is the right-hand
 364                                 // expression which gets assigned to all the variables left of it.
 365                                 // Emit this expression and store its result in real_temp.
 366                                 real_source.Emit (ec);
 367                                 real_temp.Store (ec);
 368                         }
 369
 370                         if (embedded != null)
 371                                 embedded.EmitEmbedded (ec);
 372
 373                         // This happens when we've done a type conversion, in this case source will be
 374                         // the expression which does the type conversion from real_temp.
 375                         // So emit it and store the result in temp; this is the var which will be read
 376                         // by our parent.
 377                         if (temp != real_temp) {
 378                                 source.Emit (ec);
 379                                 temp.Store (ec);
 380                         }
 381
 382                         Expression temp_source = (temp != null) ? temp : source;
 383                         ((IAssignMethod) target).EmitAssign (ec, temp_source);
 384                         return temp_source;
 385                 }
 386
 387                 void ReleaseEmbedded (EmitContext ec)
 388                 {
 389                         if (embedded != null)
 390                                 embedded.ReleaseEmbedded (ec);
 391
 392                         if (real_temp != null)
 393                                 real_temp.Release (ec);
 394
 395                         if (must_free_temp)
 396                                 temp.Release (ec);
 397                 }
 398
 399                 void Emit (EmitContext ec, bool is_statement)
 400                 {
 401                         if (target is EventExpr) {
 402                                 ((EventExpr) target).EmitAddOrRemove (ec, source);
 403                                 return;
 404                         }
 405
 406                         bool use_temporaries = false;
 407
 408                         //
 409                         // FIXME! We need a way to "probe" if the process can
 410                         // just use `dup' to propagate the result
 411                         //
 412                         IAssignMethod am = (IAssignMethod) target;
 413
 414                         if (this is CompoundAssign){
 415                                 am.CacheTemporaries (ec);
 416                                 use_temporaries = true;
 417                         }
 418
 419                         if (!is_statement)
 420                                 use_temporaries = true;
 421
 422                         Expression temp_source;
 423                         if (embedded != null) {
 424                                 temp_source = embedded.EmitEmbedded (ec);
 425
 426                                 if (temp != null) {
 427                                         source.Emit (ec);
 428                                         temp.Store (ec);
 429                                         temp_source = temp;
 430                                 }
 431                         } else
 432                                 temp_source = source;
 433
 434                         if (use_temporaries){
 435                                 //
 436                                 // Doing this for every path is too expensive
 437                                 // I wonder if we can work around this and have a less
 438                                 // expensive path
 439                                 //
 440                                 LocalTemporary tempo;
 441
 442                                 tempo = new LocalTemporary (ec, source.Type);
 443
 444                                 temp_source.Emit (ec);
 445                                 tempo.Store (ec);
 446                                 am.EmitAssign (ec, tempo);
 447                                 if (!is_statement)
 448                                         tempo.Emit (ec);
 449
 450                                 tempo.Release (ec);
 451                         } else {
 452                                 am.EmitAssign (ec, temp_source);
 453                         }
 454
 455                         if (embedded != null) {
 456                                 if (temp != null)
 457                                         temp.Release (ec);
 458                                 embedded.ReleaseEmbedded (ec);
 459                         }
 460                 }
 461
 462                 public override void Emit (EmitContext ec)
 463                 {
 464                         Emit (ec, false);
 465                 }
 466
 467                 public override void EmitStatement (EmitContext ec)
 468                 {
 469                         Emit (ec, true);
 470                 }
 471         }
 472
 473
 474         //
 475         // This class is used for compound assignments.
 476         //
 477         class CompoundAssign : Assign {
 478                 Binary.Operator op;
 479                 public Expression original_source;
 480
 481                 public CompoundAssign (Binary.Operator op, Expression target, Expression source, Location l)
 482                         : base (target, source, l)
 483                 {
 484                         original_source = source;
 485                         this.op = op;
 486                 }
 487
 488                 protected CompoundAssign (CompoundAssign embedded, Location l)
 489                         : this (embedded.op, embedded.target, embedded.source, l)
 490                 {
 491                         this.is_embedded = true;
 492                 }
 493
 494                 protected override Assign GetEmbeddedAssign (Location loc)
 495                 {
 496                         return new CompoundAssign (this, loc);
 497                 }
 498
 499                 public Expression ResolveSource (EmitContext ec)
 500                 {
 501                         return original_source.Resolve (ec);
 502                 }
 503
 504                 public override Expression DoResolve (EmitContext ec)
 505                 {
 506                         original_source = original_source.Resolve (ec);
 507                         if (original_source == null)
 508                                 return null;
 509
 510                         target = target.Resolve (ec);
 511                         if (target == null)
 512                                 return null;
 513
 514                         //
 515                         // Only now we can decouple the original source/target
 516                         // into a tree, to guarantee that we do not have side
 517                         // effects.
 518                         //
 519                         source = new Binary (op, target, original_source, loc);
 520                         return base.DoResolve (ec);
 521                 }
 522         }
 523 }
 524
 525
 526
 527