dart2js cps: Use definitions by default, not references.

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

 library dart2js.cps_ir.loop_invariant_branch;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 import 'loop_hierarchy.dart';
 import 'cps_fragment.dart';
 import 'redundant_join.dart' show AlphaRenamer;
 
 /// Hoists branches out of loops, where:
 /// - the branch is at the entry point of a loop
@@ skipping 103 matching lines @@
   ///     let inner(y, x1, x2, x3) = BODY
   ///     let outer(x1, x2, x3) =
   ///       [ .. inner(y', x1, x2, x3) .. ]
   ///
   void appendParameters(Continuation cont, List<Parameter> parameters) {
     cont.parameters.addAll(parameters);
     for (Reference ref = cont.firstRef; ref != null; ref = ref.next) {
       Node use = ref.parent;
       if (use is InvokeContinuation) {
         for (Parameter loopParam in parameters) {
-          use.arguments.add(new Reference<Primitive>(loopParam)..parent = use);
+          use.argumentRefs.add(new Reference<Primitive>(loopParam)..parent = use);
         }
       }
     }
   }
 
   bool tryHoistEntryCheck(Continuation loop) {
     // Check if this is a loop starting with a branch.
     Expression body = getEffectiveBody(loop.body);
     if (body is! Branch) return false;
     Branch branch = body;
 
     // Is the condition loop invariant?
-    Primitive condition = branch.condition.definition;
+    Primitive condition = branch.condition;
     if (loopHeaderFor[condition] == loop) return false;
 
-    Continuation trueCont = branch.trueContinuation.definition;
-    Continuation falseCont = branch.falseContinuation.definition;
+    Continuation trueCont = branch.trueContinuation;
+    Continuation falseCont = branch.falseContinuation;
     Continuation hoistedCase; // The branch to hoist.
     Continuation loopCase; // The branch that is part of the loop.
 
     // Check that one branch is part of the loop, and the other is an exit.
     if (loopHierarchy.getLoopHeader(trueCont) != loop &&
         loopHierarchy.getLoopHeader(falseCont) == loop) {
       hoistedCase = trueCont;
       loopCase = falseCont;
     } else if (loopHierarchy.getLoopHeader(falseCont) != loop &&
                loopHierarchy.getLoopHeader(trueCont) == loop) {
@@ skipping 53 matching lines @@
     //
     //     let newTrue() = hoistCase(i)
     //     let newFalse() =
     //       let loop(x) =
     //         let loopCase() = LOOP
     //         branch b hoistCase loopCase
     //     branch b newTrue newFalse
     //
     InvokeContinuation loopEntry = loopBinding.body;
     List<Primitive> loopArgs =
-        loopEntry.arguments.map((ref) => ref.definition).toList();
+        loopEntry.arguments.toList();
     CpsFragment cps = new CpsFragment();
     cps.branch(condition,
           strict: branch.isStrictCheck,
           negate: hoistedCase == falseCont)
        .invokeContinuation(hoistedCase, loopArgs);
 
     // The continuations created in the fragment need to have their loop header
     // set so the loop hierarchy remains intact
     loopHierarchy.update(cps,
         exitLoop: loopHierarchy.getEnclosingLoop(loop),
@@ skipping 17 matching lines @@
     //   in loop(i)
     //
     destroyAndReplace(branch, new InvokeContinuation(loopCase, []));
 
     // Record that at least one branch was hoisted to trigger alpha renaming.
     wasHoisted = true;
 
     return true;
   }
 }