dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 import '../../cps_ir/optimizers.dart' show Pass;
 import '../../constants/values.dart';
 import '../../elements/elements.dart';
 import '../../js_backend/codegen/glue.dart';
 import '../../universe/selector.dart' show Selector;
 import '../../cps_ir/cps_ir_builder.dart' show ThisParameterLocal;
@@ skipping 132 matching lines @@
     if (_exceptionParameter.hasAtLeastOneUse ||
         stackTraceParameter.hasAtLeastOneUse) {
       InvokeStatic unwrapped = insertStaticCallAbove(
           _glue.getExceptionUnwrapper(),
           [new Parameter(null)], // Dummy argument, see below.
           body);
       _exceptionParameter.replaceUsesWith(unwrapped);
 
       // Replace the dummy with the exception parameter.  It must be set after
       // replacing all uses of [_exceptionParameter].
-      unwrapped.arguments[0].changeTo(_exceptionParameter);
+      unwrapped.argumentRefs[0].changeTo(_exceptionParameter);
 
       if (stackTraceParameter.hasAtLeastOneUse) {
         InvokeStatic stackTraceValue = insertStaticCallAbove(
             _glue.getTraceFromException(),
             [_exceptionParameter],
             body);
         stackTraceParameter.replaceUsesWith(stackTraceValue);
       }
     }
 
     assert(stackTraceParameter.hasNoUses);
     node.handler.parameters.removeLast();
 
     visit(node.handler);
     _exceptionParameter = previousExceptionParameter;
 
     return node.body;
   }
 
   processThrow(Throw node) {
     // The subexpression of throw is wrapped in the JavaScript output.
     Primitive wrappedException = insertStaticCallAbove(
         _glue.getWrapExceptionHelper(),
-        [node.value.definition],
+        [node.value],
         node);
-    node.value.changeTo(wrappedException);
+    node.valueRef.changeTo(wrappedException);
   }
 
   processRethrow(Rethrow node) {
     // Rethrow can only appear in a catch block.  It throws that block's
     // (wrapped) caught exception.
     Throw replacement = new Throw(_exceptionParameter);
     InteriorNode parent = node.parent;
     parent.body = replacement;
     replacement.parent = parent;
     // The original rethrow does not have any references that we need to
     // worry about unlinking.
   }
 
   bool isNullConstant(Primitive prim) {
     return prim is Constant && prim.value.isNull;
   }
 
   processInvokeMethod(InvokeMethod node) {
     Selector selector = node.selector;
     if (!_glue.isInterceptedSelector(selector)) return;
 
     // Some platform libraries will compare non-interceptable objects against
     // null using the Dart == operator.  These must be translated directly.
     if (node.selector == Selectors.equals &&
-        node.arguments.length == 1 &&
-        isNullConstant(node.arguments[0].definition)) {
+        node.argumentRefs.length == 1 &&
+        isNullConstant(node.argument(0))) {
       node.replaceWith(new ApplyBuiltinOperator(
           BuiltinOperator.Identical,
-          [node.receiver.definition, node.arguments[0].definition],
+          [node.receiver, node.argument(0)],
           node.sourceInformation));
       return;
     }
 
-    Primitive receiver = node.receiver.definition;
+    Primitive receiver = node.receiver;
     Primitive newReceiver;
 
     if (receiver == explicitReceiverParameter) {
       // If the receiver is the explicit receiver, we are calling a method in
       // the same interceptor:
       //  Change 'receiver.foo()'  to  'this.foo(receiver)'.
       newReceiver = thisParameter;
     } else {
       newReceiver = new Interceptor(receiver, node.sourceInformation);
       if (receiver.hint != null) {
         newReceiver.hint = new InterceptorEntity(receiver.hint);
       }
       new LetPrim(newReceiver).insertAbove(node.parent);
     }
-    node.arguments.insert(0, node.receiver);
-    node.receiver = new Reference<Primitive>(newReceiver)..parent = node;
+    node.argumentRefs.insert(0, node.receiverRef);
+    node.receiverRef = new Reference<Primitive>(newReceiver)..parent = node;
     node.callingConvention = CallingConvention.Intercepted;
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (!_glue.isInterceptedMethod(node.target)) return;
 
-    Primitive receiver = node.receiver.definition;
+    Primitive receiver = node.receiver;
     Primitive newReceiver;
 
     if (receiver == explicitReceiverParameter) {
       // If the receiver is the explicit receiver, we are calling a method in
       // the same interceptor:
       //  Change 'receiver.foo()'  to  'this.foo(receiver)'.
       newReceiver = thisParameter;
     } else {
       newReceiver = new Interceptor(receiver, node.sourceInformation);
       if (receiver.hint != null) {
         newReceiver.hint = new InterceptorEntity(receiver.hint);
       }
       new LetPrim(newReceiver).insertAbove(node.parent);
     }
-    node.arguments.insert(0, node.receiver);
-    node.receiver = new Reference<Primitive>(newReceiver)..parent = node;
+    node.argumentRefs.insert(0, node.receiverRef);
+    node.receiverRef = new Reference<Primitive>(newReceiver)..parent = node;
     node.callingConvention = CallingConvention.Intercepted;
   }
 }