dart2js cps: Use definitions by default, not references.

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

 // Copyright (c) 2016, 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.path_based_optimizer;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 import 'cps_fragment.dart';
 import '../js_backend/js_backend.dart';
 import '../constants/values.dart';
@@ skipping 99 matching lines @@
   Expression traverseContinuation(Continuation cont) {
     valueOf = valuesAt[cont];
     if (valueOf == null) {
       // Do not go into unreachable code.
       destroyAndReplace(cont.body, new Unreachable());
     }
     return cont.body;
   }
 
   void visitInvokeContinuation(InvokeContinuation node) {
-    Continuation cont = node.continuation.definition;
+    Continuation cont = node.continuation;
     if (cont.isReturnContinuation) return;
     if (node.isRecursive) return;
     Map<Primitive, int> target = valuesAt[cont];
     if (target == null) {
       valuesAt[cont] = valueOf;
     } else {
       for (Primitive prim in target.keys) {
         target[prim] |= valueOf[prim] ?? ANY;
       }
     }
   }
 
   visitBranch(Branch node) {
-    Primitive condition = node.condition.definition.effectiveDefinition;
-    Continuation trueCont = node.trueContinuation.definition;
-    Continuation falseCont = node.falseContinuation.definition;
+    Primitive condition = node.condition.effectiveDefinition;
+    Continuation trueCont = node.trueContinuation;
+    Continuation falseCont = node.falseContinuation;
     if (condition.hasExactlyOneUse) {
       // Handle common case specially. Do not add [condition] to the map if
       // there are no other uses.
       valuesAt[trueCont] = copy(valueOf);
       valuesAt[falseCont] = valueOf;
       return;
     }
     int values = valueOf[condition] ?? ANY;
     int positiveValues = node.isStrictCheck ? TRUE : TRUTHY;
     int negativeValues = (~positiveValues) & ANY;
@@ skipping 13 matching lines @@
     int receiverValue = valueOf[node.dartReceiver] ?? ANY;
     if (!backend.isInterceptedSelector(node.selector)) {
       // Only self-interceptors can respond to a non-intercepted selector.
       valueOf[node.dartReceiver] = receiverValue & SELF_INTERCEPTOR;
     } else if (receiverValue & ~SELF_INTERCEPTOR == 0 &&
                node.callingConvention == CallingConvention.Intercepted) {
       // This is an intercepted call whose receiver is definitely a
       // self-interceptor.
       // TODO(25646): If TypeMasks could represent "any self-interceptor" this
       //   optimization should be subsumed by type propagation.
-      node.receiver.changeTo(node.dartReceiver);
+      node.receiverRef.changeTo(node.dartReceiver);
 
       // Replace the extra receiver argument with a dummy value if the
       // target definitely does not use it.
       if (typeSystem.targetIgnoresReceiverArgument(node.dartReceiver.type,
             node.selector)) {
         Constant dummy = new Constant(new IntConstantValue(0))
             ..type = typeSystem.intType;
         new LetPrim(dummy).insertAbove(node.parent);
-        node.arguments[0].changeTo(dummy);
+        node.argumentRefs[0].changeTo(dummy);
         node.callingConvention = CallingConvention.DummyIntercepted;
       }
     }
   }
 }