dart2js cps: Keep interceptors in a separate field.

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

 // Copyright (c) 2014, 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.type_propagation;
 
 import 'optimizers.dart';
 
 import '../closure.dart' show
     ClosureClassElement;
 import '../common.dart';
@@ skipping 1142 matching lines @@
     return compiler.world.allFunctions.filter(selector, receiverType);
   }
 
   /************************* CALL EXPRESSIONS *************************/
 
   /// Replaces [node] with a more specialized instruction, if possible.
   ///
   /// Returns `true` if the node was replaced.
   specializeOperatorCall(InvokeMethod node) {
     if (!backend.isInterceptedSelector(node.selector)) return null;
-    if (node.dartArgumentsLength > 1) return null;
+    if (node.argumentRefs.length > 1) return null;
     if (node.callingConvention == CallingConvention.OneShotIntercepted) {
       return null;
     }
 
     bool trustPrimitives = compiler.trustPrimitives;
 
     /// Check that the receiver and argument satisfy the given type checks, and
     /// throw a [NoSuchMethodError] or [ArgumentError] if the check fails.
     CpsFragment makeGuard(TypeCheckOperator receiverGuard,
                           [TypeCheckOperator argumentGuard]) {
       CpsFragment cps = new CpsFragment(node.sourceInformation);
 
       // Make no guards if trusting primitives.
       if (trustPrimitives) return cps;
 
       // Determine which guards are needed.
       ChecksNeeded receiverChecks =
-          receiverGuard.getChecksNeeded(node.dartReceiver, classWorld);
+          receiverGuard.getChecksNeeded(node.receiver, classWorld);
       bool needReceiverGuard = receiverChecks != ChecksNeeded.None;
       bool needArgumentGuard =
           argumentGuard != null &&
-          argumentGuard.needsCheck(node.dartArgument(0), classWorld);
+          argumentGuard.needsCheck(node.argument(0), classWorld);
 
       if (!needReceiverGuard && !needArgumentGuard) return cps;
 
       // If we only need the receiver check, emit the specialized receiver
       // check instruction. Examples:
       //
       //   if (typeof receiver !== "number") return receiver.$lt;
       //   if (typeof receiver !== "number") return receiver.$lt();
       //
       if (!needArgumentGuard) {
-        Primitive condition = receiverGuard.makeCheck(cps, node.dartReceiver);
+        Primitive condition = receiverGuard.makeCheck(cps, node.receiver);
         cps.letPrim(new ReceiverCheck(
-            node.dartReceiver,
+            node.receiver,
             node.selector,
             node.sourceInformation,
             condition: condition,
             useSelector: true,
             isNullCheck: receiverChecks == ChecksNeeded.Null
         ));
         return cps;
       }
 
       // TODO(asgerf): We should consider specialized instructions for
       //   argument checks and receiver+argument checks, to avoid breaking up
       //   basic blocks.
 
       // Emit as `H.iae(x)` if only the argument check may fail. For example:
       //
       //   if (typeof argument !== "number") return H.iae(argument);
       //
       if (!needReceiverGuard) {
-        cps.ifTruthy(argumentGuard.makeCheck(cps, node.dartArgument(0)))
+        cps.ifTruthy(argumentGuard.makeCheck(cps, node.argument(0)))
            .invokeStaticThrower(helpers.throwIllegalArgumentException,
-              [node.dartArgument(0)]);
+              [node.argument(0)]);
         return cps;
       }
 
       // Both receiver and argument check is needed. Emit as a combined check
       // using a one-shot interceptor to produce the exact error message in
       // the error case.  For example:
       //
       //   if (typeof receiver !== "number" || typeof argument !== "number")
       //       return J.$lt(receiver, argument);
       //
       Continuation fail = cps.letCont();
-      cps.ifTruthy(receiverGuard.makeCheck(cps, node.dartReceiver))
+      cps.ifTruthy(receiverGuard.makeCheck(cps, node.receiver))
          .invokeContinuation(fail);
-      cps.ifTruthy(argumentGuard.makeCheck(cps, node.dartArgument(0)))
+      cps.ifTruthy(argumentGuard.makeCheck(cps, node.argument(0)))
          .invokeContinuation(fail);
 
       cps.insideContinuation(fail)
-         ..invokeMethod(node.dartReceiver, node.selector, node.mask,
-             [node.dartArgument(0)], CallingConvention.OneShotIntercepted)
+         ..invokeMethod(node.receiver, node.selector, node.mask,
+             [node.argument(0)],
+             callingConvention: CallingConvention.OneShotIntercepted)
          ..put(new Unreachable());
 
       return cps;
     }
 
     /// Replaces the call with [operator], using the receiver and first argument
     /// as operands (in that order).
     ///
     /// If [guard] is given, the receiver and argument are both checked using
     /// that operator.
     CpsFragment makeBinary(BuiltinOperator operator,
                            {TypeCheckOperator guard: TypeCheckOperator.none}) {
       CpsFragment cps = makeGuard(guard, guard);
-      Primitive left = guard.makeRefinement(cps, node.dartReceiver, classWorld);
+      Primitive left = guard.makeRefinement(cps, node.receiver, classWorld);
       Primitive right =
-          guard.makeRefinement(cps, node.dartArgument(0), classWorld);
+          guard.makeRefinement(cps, node.argument(0), classWorld);
       Primitive result = cps.applyBuiltin(operator, [left, right]);
       result.hint = node.hint;
       node.replaceUsesWith(result);
       return cps;
     }
 
     /// Like [makeBinary] but for unary operators with the receiver as the
     /// argument.
     CpsFragment makeUnary(BuiltinOperator operator,
                           {TypeCheckOperator guard: TypeCheckOperator.none}) {
       CpsFragment cps = makeGuard(guard);
       Primitive argument =
-          guard.makeRefinement(cps, node.dartReceiver, classWorld);
+          guard.makeRefinement(cps, node.receiver, classWorld);
       Primitive result = cps.applyBuiltin(operator, [argument]);
       result.hint = node.hint;
       node.replaceUsesWith(result);
       return cps;
     }
 
     Selector renameToOptimizedSelector(String name) {
       return new Selector.call(
           new Name(name, backend.helpers.interceptorsLibrary),
           node.selector.callStructure);
     }
 
     /// Replaces the call with a call to [name] with the same inputs.
     InvokeMethod makeRenamedInvoke(String name) {
       return new InvokeMethod(node.receiver,
           renameToOptimizedSelector(name),
           node.mask,
           node.arguments.toList(),
           sourceInformation: node.sourceInformation,
-          callingConvention: node.callingConvention);
+          callingConvention: node.callingConvention,
+          interceptor: node.interceptor);
     }
 
     TypeMask successType =
-        typeSystem.receiverTypeFor(node.selector, node.dartReceiver.type);
+        typeSystem.receiverTypeFor(node.selector, node.receiver.type);
 
-    if (node.selector.isOperator && node.dartArgumentsLength == 1) {
-      Primitive leftArg = node.dartReceiver;
-      Primitive rightArg = node.dartArgument(0);
+    if (node.selector.isOperator && node.argumentRefs.length == 1) {
+      Primitive leftArg = node.receiver;
+      Primitive rightArg = node.argument(0);
       AbstractConstantValue left = getValue(leftArg);
       AbstractConstantValue right = getValue(rightArg);
 
       String opname = node.selector.name;
       if (opname == '==') {
         // Equality is special due to its treatment of null values and the
         // fact that Dart-null corresponds to both JS-null and JS-undefined.
         // Please see documentation for IsFalsy, StrictEq, and LooseEq.
         if (left.isNullConstant || right.isNullConstant) {
           return makeBinary(BuiltinOperator.Identical);
@@ skipping 70 matching lines @@
           }
         }
         if (lattice.isDefinitelyString(left, allowNull: trustPrimitives) &&
             lattice.isDefinitelyString(right, allowNull: trustPrimitives) &&
             opname == '+') {
           // TODO(asgerf): Add IsString builtin so we can use a guard here.
           return makeBinary(BuiltinOperator.StringConcatenate);
         }
       }
     }
-    if (node.selector.isOperator && node.dartArgumentsLength == 0) {
+    if (node.selector.isOperator && node.argumentRefs.length == 0) {
       if (typeSystem.isDefinitelyNum(successType)) {
         String opname = node.selector.name;
         if (opname == '~') {
           return makeUnary(BuiltinOperator.NumBitNot, guard: checkIsNumber);
         }
         if (opname == 'unary-') {
           return makeUnary(BuiltinOperator.NumNegate, guard: checkIsNumber);
         }
       }
     }
     if (node.selector.isCall) {
       String name = node.selector.name;
-      Primitive receiver = node.dartReceiver;
+      Primitive receiver = node.receiver;
       AbstractConstantValue receiverValue = getValue(receiver);
       if (name == 'remainder') {
-        if (node.dartArgumentsLength == 1) {
-          Primitive arg = node.dartArgument(0);
+        if (node.argumentRefs.length == 1) {
+          Primitive arg = node.argument(0);
           AbstractConstantValue argValue = getValue(arg);
           if (lattice.isDefinitelyInt(receiverValue, allowNull: true) &&
               lattice.isDefinitelyInt(argValue) &&
               isIntNotZero(argValue)) {
             return makeBinary(BuiltinOperator.NumRemainder,
                 guard: checkIsNumber);
           }
         }
       } else if (name == 'codeUnitAt') {
-        if (node.dartArgumentsLength == 1) {
-          Primitive index = node.dartArgument(0);
+        if (node.argumentRefs.length == 1) {
+          Primitive index = node.argument(0);
           if (lattice.isDefinitelyString(receiverValue) &&
               lattice.isDefinitelyInt(getValue(index))) {
             CpsFragment cps = new CpsFragment(node.sourceInformation);
             receiver = makeBoundsCheck(cps, receiver, index);
             ApplyBuiltinOperator get =
                 cps.applyBuiltin(BuiltinOperator.CharCodeAt,
                                  <Primitive>[receiver, index]);
             node.replaceUsesWith(get);
             get.hint = node.hint;
             return cps;
@@ skipping 13 matching lines @@
   bool isInterceptedSelector(Selector selector) {
     return backend.isInterceptedSelector(selector);
   }
 
   /// If [node] is a getter or setter invocation, tries to replace the
   /// invocation with a direct access to a field.
   ///
   /// Returns `true` if the node was replaced.
   Primitive specializeFieldAccess(InvokeMethod node) {
     if (!node.selector.isGetter && !node.selector.isSetter) return null;
-    AbstractConstantValue receiver = getValue(node.dartReceiver);
+    AbstractConstantValue receiver = getValue(node.receiver);
     Element target =
         typeSystem.locateSingleElement(receiver.type, node.selector);
     if (target is! FieldElement) return null;
     // TODO(asgerf): Inlining native fields will make some tests pass for the
     // wrong reason, so for testing reasons avoid inlining them.
     if (backend.isNative(target) || backend.isJsInterop(target)) {
       return null;
     }
     if (node.selector.isGetter) {
-      return new GetField(node.dartReceiver, target);
+      return new GetField(node.receiver, target);
     } else {
       if (target.isFinal) return null;
       assert(node.hasNoUses);
-      return new SetField(node.dartReceiver,
+      return new SetField(node.receiver,
                           target,
-                          node.dartArgument(0));
+                          node.argument(0));
     }
   }
 
   /// Create a check that throws if [index] is not a valid index on [list].
   ///
   /// This function assumes that [index] is an integer.
   ///
   /// Returns a CPS fragment whose context is the branch where no error
   /// was thrown.
   Primitive makeBoundsCheck(CpsFragment cps,
@@ skipping 33 matching lines @@
     cps.ifTruthy(lengthChanged).invokeStaticThrower(
         helpers.throwConcurrentModificationError,
         <Primitive>[list]);
     return cps;
   }
 
   /// Tries to replace [node] with a direct `length` or index access.
   ///
   /// Returns `true` if the node was replaced.
   specializeIndexableAccess(InvokeMethod node) {
-    Primitive receiver = node.dartReceiver;
+    Primitive receiver = node.receiver;
     AbstractConstantValue receiverValue = getValue(receiver);
     if (!typeSystem.isDefinitelyIndexable(receiverValue.type,
             allowNull: true)) {
       return null;
     }
     switch (node.selector.name) {
       case 'length':
         if (node.selector.isGetter) {
           return new GetLength(receiver);
         }
         if (node.selector.isSetter) {
           if (!typeSystem.isDefinitelyExtendableArray(receiver.type,
                 allowNull: true)) {
             return null;
           }
           CpsFragment cps = new CpsFragment(node.sourceInformation);
-          Primitive newLength = node.dartArgument(0);
+          Primitive newLength = node.argument(0);
           if (!typeSystem.isDefinitelyUint(newLength.type)) {
             // TODO(asgerf): We could let the SetLength instruction throw for
             // negative right-hand sides (see length setter in js_array.dart).
             if (compiler.trustPrimitives) {
               newLength = cps.refine(newLength, typeSystem.uint32Type);
               newLength.type = typeSystem.uint32Type;
             } else {
               return null;
             }
           }
           cps.letPrim(new ApplyBuiltinMethod(
               BuiltinMethod.SetLength,
               receiver,
               [newLength],
               node.sourceInformation));
           if (!typeSystem.isDefinitelyUint32(newLength.type)) {
             // If the setter succeeded, the length must have been a uint32.
             cps.refine(newLength, typeSystem.uint32Type);
           }
           return cps;
         }
         return null;
 
       case '[]':
-        Primitive index = node.dartArgument(0);
+        Primitive index = node.argument(0);
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         receiver = makeBoundsCheck(cps, receiver, index);
         GetIndex get = cps.letPrim(new GetIndex(receiver, index));
         node.replaceUsesWith(get);
         // TODO(asgerf): Make replaceUsesWith set the hint?
         get.hint = node.hint;
         return cps;
 
       case '[]=':
         if (!typeSystem.isDefinitelyMutableIndexable(receiverValue.type,
                 allowNull: true)) {
           return null;
         }
-        Primitive index = node.dartArgument(0);
-        Primitive value = node.dartArgument(1);
+        Primitive index = node.argument(0);
+        Primitive value = node.argument(1);
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         receiver = makeBoundsCheck(cps, receiver, index);
         cps.letPrim(new SetIndex(receiver, index, value));
         assert(node.hasNoUses);
         return cps;
 
       case 'isEmpty':
         if (!node.selector.isGetter) return null;
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         Primitive length = cps.letPrim(new GetLength(receiver));
@@ skipping 17 matching lines @@
 
       default:
         return null;
     }
   }
 
   /// Tries to replace [node] with one or more direct array access operations.
   ///
   /// Returns `true` if the node was replaced.
   CpsFragment specializeArrayAccess(InvokeMethod node) {
-    Primitive list = node.dartReceiver;
+    Primitive list = node.receiver;
     AbstractConstantValue listValue = getValue(list);
     // Ensure that the object is a native list or null.
     if (!lattice.isDefinitelyArray(listValue, allowNull: true)) {
       return null;
     }
     bool isFixedLength =
         lattice.isDefinitelyFixedArray(listValue, allowNull: true);
     bool isExtendable =
         lattice.isDefinitelyExtendableArray(listValue, allowNull: true);
     SourceInformation sourceInfo = node.sourceInformation;
     switch (node.selector.name) {
       case 'add':
         if (!node.selector.isCall ||
             node.selector.positionalArgumentCount != 1 ||
             node.selector.namedArgumentCount != 0) {
           return null;
         }
         if (!isExtendable) return null;
-        Primitive addedItem = node.dartArgument(0);
+        Primitive addedItem = node.argument(0);
         CpsFragment cps = new CpsFragment(sourceInfo);
         cps.invokeBuiltin(BuiltinMethod.Push,
             list,
             <Primitive>[addedItem]);
         if (node.hasAtLeastOneUse) {
           node.replaceUsesWith(cps.makeNull());
         }
         return cps;
 
       case 'removeLast':
@@ skipping 11 matching lines @@
         removedItem.hint = node.hint;
         node.replaceUsesWith(removedItem);
         return cps;
 
       case 'addAll':
         if (!node.selector.isCall ||
             node.selector.argumentCount != 1) {
           return null;
         }
         if (!isExtendable) return null;
-        Primitive addedList = node.dartArgument(0);
+        Primitive addedList = node.argument(0);
         // Rewrite addAll([x1, ..., xN]) to push(x1), ..., push(xN).
         // Ensure that the list is not mutated between creation and use.
         // We aim for the common case where this is the only use of the list,
         // which also guarantees that this list is not mutated before use.
         if (addedList is! LiteralList || !addedList.hasExactlyOneUse) {
           return null;
         }
         LiteralList addedLiteral = addedList;
         CpsFragment cps = new CpsFragment(sourceInfo);
         for (Reference value in addedLiteral.valueRefs) {
           cps.invokeBuiltin(BuiltinMethod.Push,
               list,
               <Primitive>[value.definition]);
         }
         if (node.hasAtLeastOneUse) {
           node.replaceUsesWith(cps.makeNull());
         }
         return cps;
 
       case 'elementAt':
         if (!node.selector.isCall ||
             node.selector.positionalArgumentCount != 1 ||
             node.selector.namedArgumentCount != 0) {
           return null;
         }
         if (listValue.isNullable) return null;
-        Primitive index = node.dartArgument(0);
+        Primitive index = node.argument(0);
         if (!lattice.isDefinitelyInt(getValue(index))) return null;
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         list = makeBoundsCheck(cps, list, index);
         GetIndex get = cps.letPrim(new GetIndex(list, index));
         get.hint = node.hint;
         node.replaceUsesWith(get);
         return cps;
 
       case 'forEach':
         Element element =
             compiler.world.locateSingleElement(node.selector, listValue.type);
         if (element == null ||
             !element.isFunction ||
             !node.selector.isCall) return null;
         assert(node.selector.positionalArgumentCount == 1);
         assert(node.selector.namedArgumentCount == 0);
         FunctionDefinition target = functionCompiler.compileToCpsIr(element);
 
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         Primitive result = cps.inlineFunction(target,
             node.receiver,
             node.arguments.toList(),
+            interceptor: node.interceptor,
             hint: node.hint);
         node.replaceUsesWith(result);
         return cps;
 
       case 'iterator':
         // TODO(asgerf): This should be done differently.
         //               The types are recomputed in a very error-prone manner.
         if (!node.selector.isGetter) return null;
         Primitive iterator = node;
         LetPrim iteratorBinding = node.parent;
@@ skipping 167 matching lines @@
   ///       =>
   ///     obj.foo$<n>(<args>)
   ///
   Primitive specializeClosureCall(InvokeMethod node) {
     Selector call = node.selector;
     if (!call.isClosureCall) return null;
 
     assert(!isInterceptedSelector(call));
     assert(call.argumentCount == node.argumentRefs.length);
 
-    Primitive tearOff = node.dartReceiver.effectiveDefinition;
+    Primitive tearOff = node.receiver.effectiveDefinition;
     // Note: We don't know if [tearOff] is actually a tear-off.
     // We name variables based on the pattern we are trying to match.
 
     if (tearOff is GetStatic && tearOff.element.isFunction) {
       FunctionElement target = tearOff.element;
       FunctionSignature signature = target.functionSignature;
 
       // If the selector does not apply, don't bother (will throw at runtime).
       if (!call.signatureApplies(target)) return null;
 
@@ skipping 109 matching lines @@
     // engines typically do poor optimization of the entire function containing
     // the 'try'.
     if (functionElement.resolvedAst.elements.containsTryStatement) return null;
 
     FunctionDefinition target =
         functionCompiler.compileToCpsIr(functionElement);
 
     // Accesses to closed-over values are field access primitives.  We we don't
     // inline if there are other uses of 'this' since that could be an escape or
     // a recursive call.
-    for (Reference ref = target.thisParameter.firstRef;
+    for (Reference ref = target.receiverParameter.firstRef;
          ref != null;
          ref = ref.next) {
       Node use = ref.parent;
       if (use is GetField) continue;
       // Closures do not currently have writable fields, but closure conversion
       // could esily be changed to allocate some cells in a closure object.
       if (use is SetField && ref == use.objectRef) continue;
       return null;
     }
 
@@ skipping 25 matching lines @@
   }
 
   visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     Element target = node.target;
     if (target is ConstructorBodyElement) {
       ConstructorBodyElement constructorBody = target;
       target = constructorBody.constructor;
     }
     node.effects =
         Effects.from(compiler.world.getSideEffectsOfElement(target));
-    TypeMask receiverType = node.dartReceiver.type;
+    TypeMask receiverType = node.receiver.type;
     if (node.callingConvention == CallingConvention.Intercepted &&
         typeSystem.areDisjoint(receiverType, typeSystem.interceptorType)) {
       // Some direct calls take an interceptor because the target class is
       // mixed into a native class.  If it is known at the call site that the
       // receiver is non-intercepted, get rid of the interceptor.
-      node.receiverRef.changeTo(node.dartReceiver);
+      node.interceptorRef.changeTo(node.receiver);
     }
   }
 
   visitInvokeMethod(InvokeMethod node) {
     var specialized =
         specializeOperatorCall(node) ??
         specializeFieldAccess(node) ??
         specializeIndexableAccess(node) ??
         specializeArrayAccess(node) ??
         specializeSingleUseClosureCall(node) ??
         specializeClosureCall(node);
     if (specialized != null) return specialized;
 
-    TypeMask receiverType = node.dartReceiver.type;
+    TypeMask receiverType = node.receiver.type;
     node.mask = typeSystem.intersection(node.mask, receiverType);
 
     node.effects = Effects.from(
         compiler.world.getSideEffectsOfSelector(node.selector, node.mask));
 
     bool canBeNonThrowingCallOnNull =
         selectorsOnNull.contains(node.selector) &&
         receiverType.isNullable;
 
     if (node.callingConvention == CallingConvention.Intercepted &&
         !canBeNonThrowingCallOnNull &&
         typeSystem.areDisjoint(receiverType, typeSystem.interceptorType)) {
       // Use the Dart receiver as the JS receiver. This changes the wording of
       // the error message when the receiver is null, but we accept this.
-      node.receiverRef.changeTo(node.dartReceiver);
+      node.interceptorRef.changeTo(node.receiver);
 
       // Replace the extra receiver argument with a dummy value if the
       // target definitely does not use it.
       if (typeSystem.targetIgnoresReceiverArgument(receiverType,
             node.selector)) {
-        Constant dummy = makeConstantPrimitive(new IntConstantValue(0));
-        new LetPrim(dummy).insertAbove(node.parent);
-        node.argumentRefs[0].changeTo(dummy);
-        node.callingConvention = CallingConvention.DummyIntercepted;
+        node.makeDummyIntercepted();
       }
     }
   }
 
   CpsFragment visitTypeCast(TypeCast node) {
     AbstractConstantValue value = getValue(node.value);
     switch (lattice.isSubtypeOf(value, node.dartType, allowNull: true)) {
       case AbstractBool.Maybe:
       case AbstractBool.Nothing:
         return null;
@@ skipping 16 matching lines @@
       Primitive argument = node.argument(0);
       AbstractConstantValue value = getValue(argument);
       if (lattice.isDefinitelyString(value)) {
         node.replaceUsesWith(argument);
         return new CpsFragment();
       } else if (typeSystem.isDefinitelySelfInterceptor(value.type)) {
         TypeMask toStringReturn = typeSystem.getInvokeReturnType(
             Selectors.toString_, value.type);
         if (typeSystem.isDefinitelyString(toStringReturn)) {
           CpsFragment cps = new CpsFragment(node.sourceInformation);
-          Primitive invoke = cps.invokeMethod(argument,
+          Primitive invoke = cps.invokeMethod(
+              argument,
               Selectors.toString_,
               value.type,
-              [cps.makeZero()],
-              CallingConvention.DummyIntercepted);
+              [],
+              callingConvention: CallingConvention.DummyIntercepted);
           node.replaceUsesWith(invoke);
           return cps;
         }
       }
     } else if (node.target == compiler.identicalFunction) {
       if (node.argumentRefs.length == 2) {
         return new ApplyBuiltinOperator(BuiltinOperator.Identical,
             [node.argument(0), node.argument(1)],
             node.sourceInformation);
       }
@@ skipping 500 matching lines @@
   }
 
   bool isInterceptedSelector(Selector selector) {
     return backend.isInterceptedSelector(selector);
   }
 
   // -------------------------- Visitor overrides ------------------------------
   void visit(Node node) { node.accept(this); }
 
   void visitFunctionDefinition(FunctionDefinition node) {
-    bool isIntercepted = backend.isInterceptedMethod(node.element);
-
+    if (node.interceptorParameter != null) {
+      setValue(node.interceptorParameter, nonConstant(typeSystem.nonNullType));
+    }
     // If the abstract value of the function parameters is Nothing, use the
     // inferred parameter type.  Otherwise (e.g., when inlining) do not
     // change the abstract value.
-    if (node.thisParameter != null && getValue(node.thisParameter).isNothing) {
-      if (isIntercepted &&
-          !typeSystem.methodIgnoresReceiverArgument(node.element)) {
-        setValue(node.thisParameter, nonConstant(typeSystem.nonNullType));
-      } else {
-        setValue(node.thisParameter,
-            nonConstant(typeSystem.getReceiverType(node.element)));
-      }
-    }
-    if (isIntercepted && getValue(node.parameters[0]).isNothing) {
-      if (typeSystem.methodIgnoresReceiverArgument(node.element)) {
-        setValue(node.parameters[0], nonConstant());
-      } else {
-        setValue(node.parameters[0],
-            nonConstant(typeSystem.getReceiverType(node.element)));
-      }
+    if (node.receiverParameter != null &&
+        getValue(node.receiverParameter).isNothing) {
+      setValue(node.receiverParameter,
+          nonConstant(typeSystem.getReceiverType(node.element)));
     }
     bool hasParameterWithoutValue = false;
-    for (Parameter param in node.parameters.skip(isIntercepted ? 1 : 0)) {
+    for (Parameter param in node.parameters) {
       if (getValue(param).isNothing) {
         TypeMask type = param.hint is ParameterElement
             ? typeSystem.getParameterType(param.hint)
             : typeSystem.dynamicType;
         setValue(param, lattice.fromMask(type));
         if (type.isEmpty) hasParameterWithoutValue = true;
       }
     }
     if (!hasParameterWithoutValue) { // Don't analyze unreachable code.
       push(node.body);
@@ skipping 49 matching lines @@
     // Forward the constant status of all continuation invokes to the
     // continuation. Note that this is effectively a phi node in SSA terms.
     for (int i = 0; i < node.argumentRefs.length; i++) {
       Primitive def = node.argument(i);
       AbstractConstantValue cell = getValue(def);
       setValue(cont.parameters[i], cell);
     }
   }
 
   void visitInvokeMethod(InvokeMethod node) {
-    AbstractConstantValue receiver = getValue(node.dartReceiver);
+    AbstractConstantValue receiver = getValue(node.receiver);
     if (receiver.isNothing) {
       return setResult(node, lattice.nothing);
     }
 
     void finish(AbstractConstantValue result, {bool canReplace: false}) {
       if (result == null) {
         canReplace = false;
         result = lattice.getInvokeReturnType(node.selector, receiver);
       }
       setResult(node, result, canReplace: canReplace);
     }
 
     if (node.selector.isGetter) {
       // Constant fold known length of containers.
       if (node.selector == Selectors.length) {
         if (typeSystem.isDefinitelyIndexable(receiver.type, allowNull: true)) {
           AbstractConstantValue length = lattice.lengthSpecial(receiver);
           return finish(length, canReplace: !receiver.isNullable);
         }
       }
       return finish(null);
     }
 
     if (node.selector.isCall) {
       if (node.selector == Selectors.codeUnitAt) {
-        AbstractConstantValue right = getValue(node.dartArgument(0));
+        AbstractConstantValue right = getValue(node.argument(0));
         AbstractConstantValue result =
             lattice.codeUnitAtSpecial(receiver, right);
         return finish(result, canReplace: !receiver.isNullable);
       }
       return finish(null);
     }
 
     if (node.selector == Selectors.index) {
-      AbstractConstantValue right = getValue(node.dartArgument(0));
+      AbstractConstantValue right = getValue(node.argument(0));
       AbstractConstantValue result = lattice.indexSpecial(receiver, right);
       return finish(result, canReplace: !receiver.isNullable);
     }
 
     if (!node.selector.isOperator) {
       return finish(null);
     }
 
     // Calculate the resulting constant if possible.
     String opname = node.selector.name;
-    if (node.dartArgumentsLength == 0) {
+    if (node.argumentRefs.length == 0) {
       // Unary operator.
       if (opname == "unary-") {
         opname = "-";
       }
       UnaryOperator operator = UnaryOperator.parse(opname);
       AbstractConstantValue result = lattice.unaryOp(operator, receiver);
       return finish(result, canReplace: !receiver.isNullable);
-    } else if (node.dartArgumentsLength == 1) {
+    } else if (node.argumentRefs.length == 1) {
       // Binary operator.
-      AbstractConstantValue right = getValue(node.dartArgument(0));
+      AbstractConstantValue right = getValue(node.argument(0));
       BinaryOperator operator = BinaryOperator.parse(opname);
       AbstractConstantValue result =
           lattice.binaryOp(operator, receiver, right);
       return finish(result, canReplace: !receiver.isNullable);
     }
     return finish(null);
   }
 
   void visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
 
@@ skipping 714 matching lines @@
   }
 
   Primitive makeCheck(CpsFragment cps, Primitive value) {
     return cps.applyBuiltin(negatedOperator, [value]);
   }
 
   Primitive makeRefinement(CpsFragment cps, Primitive value, World world) {
     return cps.refine(value, new TypeMask.nonNullSubclass(classElement, world));
   }
 }