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

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';
 import '../constants/values.dart';
 import '../elements/elements.dart';
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../types/types.dart' show TypeMask;
 import '../io/source_information.dart' show SourceInformation;
+import '../universe/selector.dart';
 
 /// Replaces `getInterceptor` calls with interceptor constants when possible,
 /// or with "almost constant" expressions like "x && CONST" when the input
 /// is either null or has a known interceptor.
 //
 //  TODO(asgerf): Compute intercepted classes in this pass.
 class OptimizeInterceptors extends TrampolineRecursiveVisitor implements Pass {
   String get passName => 'Optimize interceptors';
 
   JavaScriptBackend backend;
   LoopHierarchy loopHierarchy;
   Continuation currentLoopHeader;
 
   OptimizeInterceptors(this.backend);
 
   BackendHelpers get helpers => backend.helpers;
 
+  Map<Interceptor, Continuation> loopHeaderFor = <Interceptor, Continuation>{};
+
   void rewrite(FunctionDefinition node) {
     // TODO(asgerf): Computing the LoopHierarchy here may be overkill when all
     //               we want is to hoist constants out of loops.
     loopHierarchy = new LoopHierarchy(node);
     visit(node.body);
     new ShareConstants().visit(node);
   }
 
   @override
   Expression traverseContinuation(Continuation cont) {
@@ skipping 50 matching lines @@
     Continuation loop = getCurrentOuterLoop();
     if (loop != null) {
       LetCont loopBinding = loop.parent;
       letPrim.insertAbove(loopBinding);
     } else {
       letPrim.insertAbove(useSite);
     }
     return prim;
   }
 
-  void constifyInterceptor(Interceptor interceptor) {
+  bool constifyInterceptor(Interceptor interceptor) {
     LetPrim let = interceptor.parent;
     InterceptorConstantValue constant = getInterceptorConstant(interceptor);
 
-    if (constant == null) return;
+    if (constant == null) return false;
 
     if (interceptor.isAlwaysIntercepted) {
       Primitive constantPrim = makeConstantFor(constant,
           useSite: let,
           type: interceptor.type,
           sourceInformation: interceptor.sourceInformation);
       constantPrim.useElementAsHint(interceptor.hint);
       interceptor..replaceUsesWith(constantPrim)..destroy();
       let.remove();
     } else if (interceptor.isAlwaysNullOrIntercepted) {
@@ skipping 15 matching lines @@
             BuiltinOperator.LooseEq,
             [input, cps.makeNull()]);
         cps.ifTruthy(condition).invokeContinuation(cont, [input]);
       }
       cps.invokeContinuation(cont, [constantPrim]);
       cps.context = cont;
       cps.insertAbove(let);
       interceptor..replaceUsesWith(param)..destroy();
       let.remove();
     }
+    return true;
   }
 
   @override
   Expression traverseLetPrim(LetPrim node) {
     Expression next = node.body;
-    if (node.primitive is Interceptor) {
-      constifyInterceptor(node.primitive);
+    visit(node.primitive);
+    return next;
+  }
+
+  @override
+  void visitInterceptor(Interceptor node) {
+    if (constifyInterceptor(node)) return;
+    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;
     }
-    return next;
+  }
+
+  @override
+  void visitInvokeMethod(InvokeMethod node) {
+    if (node.callingConvention != CallingConvention.Intercepted) return;
+    Primitive interceptor = node.receiver.definition;
+    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);
+  }
+
+  @override
+  void visitTypeTestViaFlag(TypeTestViaFlag node) {
+    Primitive interceptor = node.interceptor.definition;
+    if (interceptor is! Interceptor ||
+        interceptor.hasMultipleUses ||
+        loopHeaderFor[interceptor] != currentLoopHeader ||
+        !backend.mayGenerateInstanceofCheck(node.dartType)) {
+      return;
+    }
+    Interceptor inter = interceptor;
+    Primitive value = inter.input.definition;
+    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.
 class ShareConstants extends TrampolineRecursiveVisitor {
@@ skipping 16 matching lines @@
         sharedConstantFor.remove(prim.value);
       });
     }
     return next;
   }
 
   bool shouldShareConstant(Constant constant) {
     return constant.value.isInterceptor;
   }
 }