dart2js cps: Keep interceptors in a separate field.

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 93 matching lines @@
   }
 
   /// Refine the type of each argument on [node] according to the provided
   /// type masks.
   void _refineArguments(
       InvocationPrimitive node, List<TypeMask> argumentSuccessTypes) {
     if (argumentSuccessTypes == null) return;
 
     // Note: node.dartArgumentsLength is shorter when the call doesn't include
     // some optional arguments.
-    int length = min(argumentSuccessTypes.length, node.dartArgumentsLength);
+    int length = min(argumentSuccessTypes.length, node.argumentRefs.length);
     for (int i = 0; i < length; i++) {
       TypeMask argSuccessType = argumentSuccessTypes[i];
 
       // Skip arguments that provide no refinement.
       if (argSuccessType == types.dynamicType) continue;
 
       applyRefinement(node.parent,
-          new Refinement(node.dartArgument(i), argSuccessType));
+          new Refinement(node.argument(i), argSuccessType));
     }
   }
 
   void visitInvokeStatic(InvokeStatic node) {
     node.argumentRefs.forEach(processReference);
     _refineArguments(node,
         _getSuccessTypesForStaticMethod(types, node.target));
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     // Update references to their current refined values.
     processReference(node.receiverRef);
     node.argumentRefs.forEach(processReference);
 
     // If the call is intercepted, we want to refine the actual receiver,
     // not the interceptor.
-    Primitive receiver = node.dartReceiver;
+    Primitive receiver = 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);
@@ skipping 76 matching lines @@
         Refinement refinedFalse = new Refinement(second, types.nonNullType);
         pushRefinement(trueCont, refinedTrue);
         pushRefinement(falseCont, refinedFalse);
       } else {
         push(trueCont);
         push(falseCont);
       }
     }
 
     if (condition is InvokeMethod && condition.selector == Selectors.equals) {
-      refineEquality(condition.dartReceiver,
-                     condition.dartArgument(0),
+      refineEquality(condition.receiver,
+                     condition.argument(0),
                      trueCont,
                      falseCont);
       return;
     }
 
     if (condition is ApplyBuiltinOperator &&
         condition.operator == BuiltinOperator.Identical) {
       refineEquality(condition.argument(0),
                      condition.argument(1),
                      trueCont,
@@ skipping 174 matching lines @@
       case 'exp':
       case 'log':
         return [types.numType];
       case 'pow':
         return [types.numType, types.numType];
     }
   }
 
   return null;
 }