dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/cps_ir/mutable_ssa.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.cps_ir.mutable_ssa;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Determines which mutable variables should be rewritten to phi assignments
@@ skipping 21 matching lines @@
     ++currentDepth;
     pushAction(() => --currentDepth);
     return node.body;
   }
 
   void processLetMutable(LetMutable node) {
     variableDepth[node.variable] = currentDepth;
   }
 
   void processSetMutable(SetMutable node) {
-    MutableVariable variable = node.variable.definition;
+    MutableVariable variable = node.variable;
     if (currentDepth > variableDepth[variable]) {
       hasAssignmentInTry.add(variable);
     }
   }
 
   /// True if there are no mutable variables or they are all assigned inside
   /// a try block. In this case, there is nothing to do and the pass should
   /// be skipped.
   bool get allMutablesAreAssignedInTryBlocks {
     return hasAssignmentInTry.length == variableDepth.length;
@@ skipping 82 matching lines @@
                     Map<MutableVariable, Primitive> environment) {
     Expression next = node.next;
     for (; node is! TailExpression; node = next, next = node.next) {
       if (node is LetMutable && shouldRewrite(node.variable)) {
         // Put the new mutable variable on the stack while processing the body,
         // and pop it off again when done with the body.
         mutableVariables.add(node.variable);
         stack.add(new VariableItem());
 
         // Put the initial value into the environment.
-        Primitive value = node.value.definition;
+        Primitive value = node.value;
         environment[node.variable] = value;
 
         // Preserve variable names.
         mergeHints(node.variable, value);
 
         // Remove the mutable variable binding.
-        node.value.unlink();
+        node.valueRef.unlink();
         node.remove();
       } else if (node is LetPrim && node.primitive is SetMutable) {
         SetMutable setter = node.primitive;
-        MutableVariable variable = setter.variable.definition;
+        MutableVariable variable = setter.variable;
         if (shouldRewrite(variable)) {
           // As above, update the environment, preserve variables and remove
           // the mutable variable assignment.
-          environment[variable] = setter.value.definition;
-          mergeHints(variable, setter.value.definition);
-          setter.value.unlink();
+          environment[variable] = setter.value;
+          mergeHints(variable, setter.value);
+          setter.valueRef.unlink();
           node.remove();
         }
       } else if (node is LetPrim && node.primitive is GetMutable) {
         GetMutable getter = node.primitive;
-        MutableVariable variable = getter.variable.definition;
+        MutableVariable variable = getter.variable;
         if (shouldRewrite(variable)) {
           // Replace with the reaching definition from the environment.
           Primitive value = environment[variable];
           getter.replaceUsesWith(value);
           mergeHints(variable, value);
           node.remove();
         }
       } else if (node is LetCont) {
         // Create phi parameters for each join continuation bound here, and put
         // them on the stack for later processing.
@@ skipping 21 matching lines @@
         // The current environment bindings cannot change inside the try block
         // because we exclude all variables assigned inside a try block.
         // The environment might be extended with more bindings before we
         // analyze the catch block, but that's ok.
         stack.add(new ContinuationItem(node.handler, environment));
       }
     }
 
     // Analyze the terminal node.
     if (node is InvokeContinuation) {
-      Continuation cont = node.continuation.definition;
+      Continuation cont = node.continuation;
       if (cont.isReturnContinuation) return;
       // This is a call to a join continuation. Add arguments for the phi
       // parameters that were added to this continuation.
       int phiCount = continuationPhiCount[cont];
       for (int i = 0; i < phiCount; ++i) {
         Primitive value = environment[mutableVariables[i]];
         Reference<Primitive> arg = new Reference<Primitive>(value);
-        node.arguments.add(arg);
+        node.argumentRefs.add(arg);
         arg.parent = node;
       }
     } else if (node is Branch) {
       // Enqueue both branches with the current environment.
       // Clone the environments once so the processing of one branch does not
       // mutate the environment needed to process the other branch.
       stack.add(new ContinuationItem(
-          node.trueContinuation.definition,
+          node.trueContinuation,
           new Map<MutableVariable, Primitive>.from(environment)));
       stack.add(new ContinuationItem(
-          node.falseContinuation.definition,
+          node.falseContinuation,
           environment));
     } else {
       assert(node is Throw || node is Unreachable);
     }
   }
 }
 
 abstract class StackItem {}
 
 /// Represents a mutable variable that is in scope.
 ///
 /// The topmost mutable variable falls out of scope when this item is
 /// taken off the stack.
 class VariableItem extends StackItem {}
 
 /// Represents a yet unprocessed continuation together with the
 /// environment in which to process it.
 class ContinuationItem extends StackItem {
   final Continuation continuation;
   final Map<MutableVariable, Primitive> environment;
 
   ContinuationItem(this.continuation, this.environment);
 }