dart2js cps: Use definitions by default, not references.

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

 // Copyright (c) 2015, 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 cps_ir.optimization.insert_refinements;
 
 import 'dart:math' show min;
 import 'optimizers.dart' show Pass;
 import 'cps_ir_nodes.dart';
 import '../elements/elements.dart';
@@ skipping 56 matching lines @@
       // Create a new LetCont binding only this continuation.
       let.continuations.remove(cont);
       let = new LetCont(cont, null);
     } else {
       let.remove(); // Reuse the existing LetCont.
     }
     let.insertAbove(use);
   }
 
   Primitive unfoldInterceptor(Primitive prim) {
-    return prim is Interceptor ? prim.input.definition : prim;
+    return prim is Interceptor ? prim.input : prim;
   }
 
   /// Sets [refined] to be the current refinement for its value, and pushes an
   /// action that will restore the original scope again.
   ///
   /// The refinement is inserted as the child of [insertionParent] if it has
   /// at least one use after its scope has been processed.
   void applyRefinement(InteriorNode insertionParent, Refinement refined) {
     Primitive value = refined.effectiveDefinition;
     Primitive currentRefinement = refinementFor[value];
@@ skipping 33 matching lines @@
 
       // Skip arguments that provide no refinement.
       if (argSuccessType == types.dynamicType) continue;
 
       applyRefinement(node.parent,
           new Refinement(node.dartArgument(i), argSuccessType));
     }
   }
 
   void visitInvokeStatic(InvokeStatic node) {
-    node.arguments.forEach(processReference);
+    node.argumentRefs.forEach(processReference);
     _refineArguments(node,
         _getSuccessTypesForStaticMethod(types, node.target));
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     // Update references to their current refined values.
-    processReference(node.receiver);
-    node.arguments.forEach(processReference);
+    processReference(node.receiverRef);
+    node.argumentRefs.forEach(processReference);
 
     // If the call is intercepted, we want to refine the actual receiver,
     // not the interceptor.
-    Primitive receiver = unfoldInterceptor(node.receiver.definition);
+    Primitive receiver = unfoldInterceptor(node.receiver);
 
     // Do not try to refine the receiver of closure calls; the class world
     // does not know about closure classes.
     Selector selector = node.selector;
     if (!selector.isClosureCall) {
       // Filter away receivers that throw on this selector.
       TypeMask type = types.receiverTypeFor(selector, node.mask);
       Refinement refinement = new Refinement(receiver, type);
       LetPrim letPrim = node.parent;
       applyRefinement(letPrim, refinement);
 
       // Refine arguments of methods on numbers which we know will throw on
       // invalid argument values.
       _refineArguments(node,
           _getSuccessTypesForInstanceMethod(types, type, selector));
     }
   }
 
   void visitTypeCast(TypeCast node) {
-    Primitive value = node.value.definition;
+    Primitive value = node.value;
 
-    processReference(node.value);
-    node.typeArguments.forEach(processReference);
+    processReference(node.valueRef);
+    node.typeArgumentRefs.forEach(processReference);
 
     // Refine the type of the input.
     TypeMask type = types.subtypesOf(node.dartType).nullable();
     Refinement refinement = new Refinement(value, type);
     LetPrim letPrim = node.parent;
     applyRefinement(letPrim, refinement);
   }
 
   void visitRefinement(Refinement node) {
     // We found a pre-existing refinement node. These are generated by the
     // IR builder to hold information from --trust-type-annotations.
     // Update its input to use our own current refinement, then update the
     // environment to use this refinement.
     processReference(node.value);
     Primitive value = node.value.definition.effectiveDefinition;
     Primitive oldRefinement = refinementFor[value];
     refinementFor[value] = node;
     pushAction(() {
       refinementFor[value] = oldRefinement;
     });
   }
 
   bool isTrue(Primitive prim) {
     return prim is Constant && prim.value.isTrue;
   }
 
   void visitBranch(Branch node) {
-    processReference(node.condition);
-    Primitive condition = node.condition.definition;
+    processReference(node.conditionRef);
+    Primitive condition = node.condition;
 
-    Continuation trueCont = node.trueContinuation.definition;
-    Continuation falseCont = node.falseContinuation.definition;
+    Continuation trueCont = node.trueContinuation;
+    Continuation falseCont = node.falseContinuation;
 
     // Sink both continuations to the Branch to ensure everything in scope
     // here is also in scope inside the continuations.
     sinkContinuationToUse(trueCont, node);
     sinkContinuationToUse(falseCont, node);
 
     // If the condition is an 'is' check, promote the checked value.
     if (condition is TypeTest) {
-      Primitive value = condition.value.definition;
+      Primitive value = condition.value;
       TypeMask type = types.subtypesOf(condition.dartType);
       Primitive refinedValue = new Refinement(value, type);
       pushRefinement(trueCont, refinedValue);
       push(falseCont);
       return;
     }
 
     // If the condition is comparison with a constant, promote the other value.
     // This can happen either for calls to `==` or `identical` calls, such
     // as the ones inserted by the unsugaring pass.
@@ skipping 21 matching lines @@
     if (condition is InvokeMethod && condition.selector == Selectors.equals) {
       refineEquality(condition.dartReceiver,
                      condition.dartArgument(0),
                      trueCont,
                      falseCont);
       return;
     }
 
     if (condition is ApplyBuiltinOperator &&
         condition.operator == BuiltinOperator.Identical) {
-      refineEquality(condition.arguments[0].definition,
-                     condition.arguments[1].definition,
+      refineEquality(condition.argument(0),
+                     condition.argument(1),
                      trueCont,
                      falseCont);
       return;
     }
 
     push(trueCont);
     push(falseCont);
   }
 
   @override
@@ skipping 165 matching lines @@
       case 'exp':
       case 'log':
         return [types.numType];
       case 'pow':
         return [types.numType, types.numType];
     }
   }
 
   return null;
 }