dart2js cps: Use definitions by default, not references.

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

 // Copyright (c) 2014, 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.redundant_phi_elimination;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Eliminate redundant phis from the given [FunctionDefinition].
@@ skipping 29 matching lines @@
 
   /// Called for each continuation on the work set. Modifies the IR graph if
   /// [cont] is a candidate for redundant phi elimination.
   void _processContinuation(Continuation cont) {
     // Generate the list of all cont invocations. If cont is used in any other
     // context (i.e. as a continuation of InvokeMethod), it is not possible to
     // optimize.
     List<InvokeContinuation> invokes = <InvokeContinuation>[];
     for (Reference ref = cont.firstRef; ref != null; ref = ref.next) {
       Node parent = ref.parent;
-      if (parent is InvokeContinuation && ref == parent.continuation) {
+      if (parent is InvokeContinuation && ref == parent.continuationRef) {
         invokes.add(parent);
       } else {
         return; // Can't optimize.
       }
     }
 
     if (invokes.isEmpty) {
       return; // Continuation is never invoked, can't optimize.
     }
 
     /// Returns the unique definition of parameter i if it exists and null
     /// otherwise. A definition is unique if it is the only value used to
     /// invoke the continuation, excluding feedback.
     Primitive uniqueDefinitionOf(int i) {
       Primitive value = null;
       for (InvokeContinuation invoke in invokes) {
-        Primitive def = invoke.arguments[i].definition.effectiveDefinition;
+        Primitive def = invoke.argument(i).effectiveDefinition;
 
         if (cont.parameters[i] == def) {
           // Invocation param == param in LetCont (i.e. a recursive call).
           continue;
         } else if (value == null) {
           value = def; // Set initial comparison value.
         } else if (value != def) {
           return null; // Differing invocation arguments.
         }
       }
@@ skipping 25 matching lines @@
     // to index `dst`.
     int dst = 0;
     for (int src = 0; src < cont.parameters.length; src++) {
       // Is the current phi redundant?
       Primitive uniqueDefinition = uniqueDefinitionOf(src);
       if (uniqueDefinition == null || !safeForHandlers(uniqueDefinition)) {
         // Reorganize parameters and arguments in case of deletions.
         if (src != dst) {
           cont.parameters[dst] = cont.parameters[src];
           for (InvokeContinuation invoke in invokes) {
-            invoke.arguments[dst] = invoke.arguments[src];
+            invoke.argumentRefs[dst] = invoke.argumentRefs[src];
           }
         }
         dst++;
         continue;
       }
 
       Primitive oldDefinition = cont.parameters[src];
 
       // Add continuations of about-to-be modified invokes to worklist since
       // we might introduce new optimization opportunities.
       for (Reference ref = oldDefinition.firstRef;
            ref != null;
            ref = ref.next) {
         Node parent = ref.parent;
         if (parent is InvokeContinuation) {
-          Continuation thatCont = parent.continuation.definition;
+          Continuation thatCont = parent.continuation;
           if (thatCont != cont) {
             workSet.add(thatCont);
           }
         }
       }
 
       // Replace individual parameters:
       // * In the continuation body, replace occurrence of param with value,
       // * and implicitly remove param from continuation signature and
       //   invocations by not incrementing `dst`. References of removed
       //   arguments are unlinked to keep definition usages up to date.
       oldDefinition.replaceUsesWith(uniqueDefinition);
       for (InvokeContinuation invoke in invokes) {
-        invoke.arguments[src].unlink();
+        invoke.argumentRefs[src].unlink();
       }
 
       // Finally, if the substituted definition is not in scope of the affected
       // continuation, move the continuation binding. This is safe to do since
       // the continuation is referenced only as the target in continuation
       // invokes, and all such invokes must be within the scope of
       // [uniqueDefinition]. Note that this is linear in the depth of
       // the binding of [uniqueDefinition].
       letCont = _makeUniqueBinding(cont);
       _moveIntoScopeOf(letCont, uniqueDefinition);
     }
 
     // Remove trailing items from parameter and argument lists.
     cont.parameters.length = dst;
     for (InvokeContinuation invoke in invokes) {
-      invoke.arguments.length = dst;
+      invoke.argumentRefs.length = dst;
     }
   }
 
   void processLetCont(LetCont node) {
     node.continuations.forEach(workSet.add);
   }
 }
 
 /// Returns true, iff [letCont] is not scope of [definition].
 /// Linear in the depth of definition within the IR graph.
@@ skipping 25 matching lines @@
 /// Returns the LetCont that now binds [continuation].
 LetCont _makeUniqueBinding(Continuation continuation) {
   LetCont letCont = continuation.parent;
   if (letCont.continuations.length == 1) return letCont;
   letCont.continuations.remove(continuation);
   LetCont newBinding = new LetCont(continuation, null);
   continuation.parent = newBinding;
   newBinding.insertBelow(letCont);
   return newBinding;
 }