dart2js cps: Use oneshot interceptors and 'instanceof' expressions.

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

 // Copyright (c) 2013, 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.ir_nodes;
 
 import 'dart:collection';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 495 matching lines @@
 
   /// JS receiver is an interceptor, the first argument is the Dart receiver.
   ///
   /// For example: `getInterceptor(foo).bar$1(foo, x)`
   Intercepted,
 
   /// JS receiver is the Dart receiver, the first argument is a dummy value.
   ///
   /// For example: `foo.bar$1(0, x)`
   DummyIntercepted,
+
+  /// JS receiver is the Dart receiver, there are no extra arguments.
+  ///
+  /// Compiles to a one-shot interceptor, e.g: `J.bar$1(foo, x)`
+  OneShotIntercepted,
 }
 
 /// Invoke a method on an object.
 ///
 /// This includes getters, setters, operators, and index getter/setters.
 ///
 /// Tearing off a method is treated like a getter invocation (getters and
 /// tear-offs cannot be distinguished at compile-time).
 ///
 /// The [selector] records the names of named arguments. The value of named
 /// arguments occur at the end of the [arguments] list, in normalized order.
 class InvokeMethod extends UnsafePrimitive {
   Reference<Primitive> receiver;
   Selector selector;
   TypeMask mask;
   final List<Reference<Primitive>> arguments;
   final SourceInformation sourceInformation;
 
   CallingConvention callingConvention = CallingConvention.Normal;
 
   Reference<Primitive> get dartReceiverReference {
     return callingConvention == CallingConvention.Intercepted
         ? arguments[0]
         : receiver;
   }
 
   Primitive get dartReceiver => dartReceiverReference.definition;
 
   Reference<Primitive> dartArgumentReference(int n) {
-    return callingConvention == CallingConvention.Normal
-        ? arguments[n]
-        : arguments[n + 1];
+    switch (callingConvention) {
+      case CallingConvention.Normal:
+      case CallingConvention.OneShotIntercepted:
+        return arguments[n];
+
+      case CallingConvention.Intercepted:
+      case CallingConvention.DummyIntercepted:
+        return arguments[n + 1];
+    }
   }
 
   Primitive dartArgument(int n) => dartArgumentReference(n).definition;
 
   /// If true, it is known that the receiver cannot be `null`.
   bool receiverIsNotNull = false;
 
   InvokeMethod(Primitive receiver,
                this.selector,
                this.mask,
@@ skipping 296 matching lines @@
     if (condition != null) {
       condition.parent = this;
     }
   }
 
   Primitive get effectiveDefinition => value.definition.effectiveDefinition;
 }
 
 /// An "is" type test.
 ///
-/// Returns `true` if [value] is an instance of [type].
+/// Returns `true` if [value] is an instance of [dartType].
 ///
 /// [type] must not be the [Object], `dynamic` or [Null] types (though it might
 /// be a type variable containing one of these types). This design is chosen
 /// to simplify code generation for type tests.
 class TypeTest extends Primitive {
   Reference<Primitive> value;
   final DartType dartType;
 
   /// If [dartType] is an [InterfaceType], this holds the internal
   /// representation of the type arguments to [dartType]. Since these may
@@ skipping 1499 matching lines @@
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends TrampolineRecursiveVisitor {
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (new RemovalVisitor()).visit(node);
   }
 }