dart2js cps: Keep interceptors in a separate field.

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 86 matching lines @@
     }
     return prim;
   }
 
   void computeInterceptedClasses(Interceptor interceptor) {
     Set<ClassElement> intercepted = interceptor.interceptedClasses;
     intercepted.clear();
     for (Reference ref = interceptor.firstRef; ref != null; ref = ref.next) {
       Node use = ref.parent;
       if (use is InvokeMethod) {
-        TypeMask type = use.dartReceiver.type;
+        TypeMask type = use.receiver.type;
         bool canOccurAsReceiver(ClassElement elem) {
           return classWorld.isInstantiated(elem) &&
               !typeSystem.areDisjoint(type,
                   typeSystem.getInterceptorSubtypes(elem));
         }
         Iterable<ClassElement> classes =
             backend.getInterceptedClassesOn(use.selector.name);
         intercepted.addAll(classes.where(canOccurAsReceiver));
       } else {
         intercepted.clear();
@@ skipping 12 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.receiverRef != ref) return false;
+        if (invoke.interceptorRef != 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;
   }
 
   /// True if [node] can intercept a `null` value and return the [JSNull]
   /// interceptor.
   bool canInterceptNull(Interceptor node) {
     for (Reference ref = node.firstRef; ref != null; ref = ref.next) {
       Node use = ref.parent;
       if (use is InvokeMethod) {
         if (selectorsOnNull.contains(use.selector) &&
-            use.dartReceiver.type.isNullable) {
+            use.receiver.type.isNullable) {
           return true;
         }
       } else {
         return true;
       }
     }
     return false;
   }
 
   /// Returns the only interceptor class that may be returned by [node], or
@@ skipping 83 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;
+    Primitive interceptor = node.interceptor;
     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..receiverRef.unlink()..receiverRef = node.argumentRefs.removeAt(0);
+    node.makeOneShotIntercepted();
   }
 
   @override
   void visitTypeTestViaFlag(TypeTestViaFlag node) {
     Primitive interceptor = node.interceptor;
     if (interceptor is! Interceptor ||
         interceptor.hasMultipleUses ||
         loopHeaderFor[interceptor] != currentLoopHeader ||
         !backend.mayGenerateInstanceofCheck(node.dartType)) {
       return;
@@ skipping 30 matching lines @@
         sharedConstantFor.remove(prim.value);
       });
     }
     return next;
   }
 
   bool shouldShareConstant(Constant constant) {
     return constant.value.isInterceptor;
   }
 }