dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/cps_ir/use_field_initializers.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.use_field_initializers;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 import '../elements/elements.dart';
 import '../js_backend/js_backend.dart';
 
@@ skipping 76 matching lines @@
     endBasicBlock();
   }
   void visitThrow(Throw node) {
     endBasicBlock();
   }
   void visitUnreachable(Unreachable node) {
     endBasicBlock();
   }
 
   void visitLetMutable(LetMutable node) {
-    escape(node.value);
+    escape(node.valueRef);
   }
 
   void visitLetCont(LetCont node) {
     if (unescaped.isNotEmpty) {
       // Ensure we do not lift a LetCont if there is a sink target set above
       // the current node.
       sinkLetConts();
       letConts.add(node);
     }
   }
@@ skipping 10 matching lines @@
   void endBasicBlock() {
     sinkLetConts();
     letConts.clear();
     unescaped.clear();
   }
 
   void visitLetPrim(LetPrim node) {
     Primitive prim = node.primitive;
     if (prim is CreateInstance) {
       unescaped.add(prim);
-      prim.arguments.forEach(escape);
+      prim.argumentRefs.forEach(escape);
       return;
     }
     if (unescaped.isEmpty) return;
     if (prim is SetField) {
-      escape(prim.value);
-      Primitive object = prim.object.definition;
+      escape(prim.valueRef);
+      Primitive object = prim.object;
       if (object is CreateInstance && unescaped.contains(object)) {
         int index = getFieldIndex(object.classElement, prim.field);
         if (index == -1) {
           // This field is not initialized at creation time, so we cannot pull
           // set SetField into the CreateInstance instruction.  We have to
           // leave the instruction here, and this counts as a use of the object.
-          escape(prim.object);
+          escape(prim.objectRef);
         } else {
           // Replace the field initializer with the new value. There are no uses
           // of the object before this, so the old value cannot have been seen.
-          object.arguments[index].changeTo(prim.value.definition);
+          object.argumentRefs[index].changeTo(prim.value);
           prim.destroy();
           // The right-hand side might not be in scope at the CreateInstance.
           // Sink the creation down to this point.
           rebindCreateInstanceAt(object, node);
           letContSinkTarget = node;
         }
       }
       return;
     }
     if (prim is GetField) {
       // When reading the field of a newly created object, just use the initial
       // value and destroy the GetField. This can unblock the other optimization
       // since we remove a use of the object.
-      Primitive object = prim.object.definition;
+      Primitive object = prim.object;
       if (object is CreateInstance && unescaped.contains(object)) {
         int index = getFieldIndex(object.classElement, prim.field);
         if (index == -1) {
-          escape(prim.object);
+          escape(prim.objectRef);
         } else {
-          prim.replaceUsesWith(object.arguments[index].definition);
+          prim.replaceUsesWith(object.argument(index));
           prim.destroy();
           node.remove();
         }
       }
       return;
     }
     escapeVisitor.visit(node.primitive);
   }
 
   void rebindCreateInstanceAt(CreateInstance prim, LetPrim newBinding) {
@@ skipping 27 matching lines @@
 }
 
 class EscapeVisitor extends DeepRecursiveVisitor {
   final UseFieldInitializers main;
   EscapeVisitor(this.main);
 
   processReference(Reference ref) {
     main.escape(ref);
   }
 }