dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/cps_ir/optimize_interceptors.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 dart2js.cps_ir.optimize_interceptors;
 
 import 'optimizers.dart';
 import 'cps_ir_nodes.dart';
 import 'loop_hierarchy.dart';
 import 'cps_fragment.dart';
@@ skipping 119 matching lines @@
 
   /// True if [node] may return [JSNumber] instead of [JSInt] or [JSDouble].
   bool jsNumberClassSuffices(Interceptor node) {
     // No methods on JSNumber call 'down' to methods on JSInt or JSDouble.  If
     // all uses of the interceptor are for methods is defined only on JSNumber
     // then JSNumber will suffice in place of choosing between JSInt or
     // JSDouble.
     for (Reference ref = node.firstRef; ref != null; ref = ref.next) {
       if (ref.parent is InvokeMethod) {
         InvokeMethod invoke = ref.parent;
-        if (invoke.receiver != ref) return false;
+        if (invoke.receiverRef != ref) return false;
         var interceptedClasses =
             backend.getInterceptedClassesOn(invoke.selector.name);
         if (interceptedClasses.contains(helpers.jsDoubleClass)) return false;
         if (interceptedClasses.contains(helpers.jsIntClass)) return false;
         continue;
       }
       // Other uses need full distinction.
       return false;
     }
     return true;
@@ skipping 15 matching lines @@
     }
     return false;
   }
 
   /// Returns the only interceptor class that may be returned by [node], or
   /// `null` if no such class could be found.
   ClassElement getSingleInterceptorClass(Interceptor node) {
     // TODO(asgerf): This could be more precise if we used the use-site type,
     // since the interceptor may have been hoisted out of a loop, where a less
     // precise type is known.
-    Primitive input = node.input.definition;
+    Primitive input = node.input;
     TypeMask type = input.type;
     if (canInterceptNull(node)) return null;
     type = type.nonNullable();
     if (typeSystem.isDefinitelyArray(type)) {
       return backend.helpers.jsArrayClass;
     }
     if (typeSystem.isDefinitelyInt(type)) {
       return backend.helpers.jsIntClass;
     }
     if (typeSystem.isDefinitelyNum(type) && jsNumberClassSuffices(node)) {
       return backend.helpers.jsNumberClass;
     }
     ClassElement singleClass = type.singleClass(classWorld);
     if (singleClass != null &&
         singleClass.isSubclassOf(backend.helpers.jsInterceptorClass)) {
       return singleClass;
     }
     return null;
   }
 
   /// Try to replace [interceptor] with a constant, and return `true` if
   /// successful.
   bool constifyInterceptor(Interceptor interceptor) {
     LetPrim let = interceptor.parent;
-    Primitive input = interceptor.input.definition;
+    Primitive input = interceptor.input;
     ClassElement classElement = getSingleInterceptorClass(interceptor);
 
     if (classElement == null) return false;
     ConstantValue constant = new InterceptorConstantValue(classElement.rawType);
 
     if (!input.type.isNullable) {
       Primitive constantPrim = makeConstantFor(constant,
           useSite: let,
           type: interceptor.type,
           sourceInformation: interceptor.sourceInformation);
@@ skipping 42 matching lines @@
     if (node.hasExactlyOneUse) {
       // Set the loop header on single-use interceptors so [visitInvokeMethod]
       // can determine if it should become a one-shot interceptor.
       loopHeaderFor[node] = currentLoopHeader;
     }
   }
 
   @override
   void visitInvokeMethod(InvokeMethod node) {
     if (node.callingConvention != CallingConvention.Intercepted) return;
-    Primitive interceptor = node.receiver.definition;
+    Primitive interceptor = node.receiver;
     if (interceptor is! Interceptor ||
         interceptor.hasMultipleUses ||
         loopHeaderFor[interceptor] != currentLoopHeader) {
       return;
     }
     // TODO(asgerf): Consider heuristics for when to use one-shot interceptors.
     //   E.g. using only one-shot interceptors with a fast path.
     node.callingConvention = CallingConvention.OneShotIntercepted;
-    node..receiver.unlink()..receiver = node.arguments.removeAt(0);
+    node..receiverRef.unlink()..receiverRef = node.argumentRefs.removeAt(0);
   }
 
   @override
   void visitTypeTestViaFlag(TypeTestViaFlag node) {
-    Primitive interceptor = node.interceptor.definition;
+    Primitive interceptor = node.interceptor;
     if (interceptor is! Interceptor ||
         interceptor.hasMultipleUses ||
         loopHeaderFor[interceptor] != currentLoopHeader ||
         !backend.mayGenerateInstanceofCheck(node.dartType)) {
       return;
     }
     Interceptor inter = interceptor;
-    Primitive value = inter.input.definition;
+    Primitive value = inter.input;
     node.replaceWith(new TypeTest(value, node.dartType, [])..type = node.type);
   }
 }
 
 /// Shares interceptor constants when one is in scope of another.
 ///
 /// Interceptor optimization runs after GVN, hence this clean-up step is needed.
 ///
 /// TODO(asgerf): Handle in separate constant optimization pass? With some other
 ///   constant-related optimizations, like cloning small constants at use-site.
@@ skipping 17 matching lines @@
         sharedConstantFor.remove(prim.value);
       });
     }
     return next;
   }
 
   bool shouldShareConstant(Constant constant) {
     return constant.value.isInterceptor;
   }
 }