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

pkg/compiler/lib/src/js_backend/codegen/codegen.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 code_generator;
 
 import 'glue.dart';
 
 import '../../closure.dart' show
     ClosureClassElement;
@@ skipping 263 matching lines @@
 
     registry.registerInstantiation(node.type);
     FunctionElement target = node.target;
     List<js.Expression> arguments = visitExpressionList(node.arguments);
     return buildStaticInvoke(
         target,
         arguments,
         sourceInformation: node.sourceInformation);
   }
 
-  void registerMethodInvoke(tree_ir.InvokeMethod node) {
-    Selector selector = node.selector;
-    TypeMask mask = node.mask;
-    mask = glue.extendMaskIfReachesAll(selector, mask);
-    if (selector.isGetter) {
-      registry.registerDynamicUse(new DynamicUse(selector, mask));
-    } else if (selector.isSetter) {
-      registry.registerDynamicUse(new DynamicUse(selector, mask));
-    } else {
-      assert(invariant(CURRENT_ELEMENT_SPANNABLE,
-          selector.isCall || selector.isOperator ||
-          selector.isIndex || selector.isIndexSet,
-          message: 'unexpected kind ${selector.kind}'));
+  void registerMethodInvoke(Selector selector, TypeMask receiverType) {
+    registry.registerDynamicUse(new DynamicUse(selector, receiverType));
+    if (!selector.isGetter && !selector.isSetter) {
       // TODO(sigurdm): We should find a better place to register the call.
       Selector call = new Selector.callClosureFrom(selector);
       registry.registerDynamicUse(new DynamicUse(call, null));
-      registry.registerDynamicUse(new DynamicUse(selector, mask));
     }
   }
 
   @override
   js.Expression visitInvokeMethod(tree_ir.InvokeMethod node) {
-    registerMethodInvoke(node);
+    TypeMask mask = glue.extendMaskIfReachesAll(node.selector, node.mask);
+    registerMethodInvoke(node.selector, mask);
     return js.propertyCall(visitExpression(node.receiver),
                            glue.invocationName(node.selector),
                            visitExpressionList(node.arguments))
         .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitInvokeStatic(tree_ir.InvokeStatic node) {
     FunctionElement target = node.target;
     List<js.Expression> arguments = visitExpressionList(node.arguments);
@@ skipping 31 matching lines @@
             new CallStructure.unnamed(node.arguments.length)));
     return js.js('#.#.call(#, #)',
         [glue.prototypeAccess(node.target.enclosingClass),
          glue.invocationName(node.selector),
          visitExpression(node.receiver),
          visitExpressionList(node.arguments)])
         .withSourceInformation(node.sourceInformation);
   }
 
   @override
+  js.Expression visitOneShotInterceptor(tree_ir.OneShotInterceptor node) {
+    registerMethodInvoke(node.selector, node.mask);
+    registry.registerUseInterceptor();
+    return js.js('#.#(#)',
+        [glue.getInterceptorLibrary(),
+         glue.registerOneShotInterceptor(node.selector),
+         visitExpressionList(node.arguments)])
+        .withSourceInformation(node.sourceInformation);
+  }
+
+  @override
   js.Expression visitLiteralList(tree_ir.LiteralList node) {
     registry.registerInstantiatedClass(glue.listClass);
     List<js.Expression> entries = visitExpressionList(node.values);
     return new js.ArrayInitializer(entries);
   }
 
   @override
   js.Expression visitLiteralMap(tree_ir.LiteralMap node) {
     ConstructorElement constructor;
     if (node.entries.isEmpty) {
@@ skipping 24 matching lines @@
   @override
   js.Expression visitNot(tree_ir.Not node) {
     return new js.Prefix("!", visitExpression(node.operand));
   }
 
   @override
   js.Expression visitThis(tree_ir.This node) {
     return new js.This();
   }
 
+  /// Ensure that 'instanceof' checks may be performed against [class_].
+  ///
+  /// Even if the class is never instantiated, a JS constructor must be emitted
+  /// so the 'instanceof' expression does not throw an exception at runtime.
+  ///
+  /// It does not help to ask the class world if the class is instantiated,
+  /// because it could still get tree-shaken if it is unused after optimization.
+  void registerInstanceofCheck(ClassElement class_) {
+    // TODO(asgerf): This is the only hook we have to ensure the JS constructor
+    //   gets emitted, but it is very imprecise. We should do better.
+    registry.registerInstantiatedClass(class_);
+  }
+
   @override
   js.Expression visitTypeOperator(tree_ir.TypeOperator node) {
     js.Expression value = visitExpression(node.value);
     List<js.Expression> typeArguments = visitExpressionList(node.typeArguments);
     DartType type = node.type;
     if (type is InterfaceType) {
       registry.registerTypeUse(new TypeUse.isCheck(type));
-      //glue.registerIsCheck(type, registry);
       ClassElement clazz = type.element;
 
       if (glue.isStringClass(clazz)) {
         if (node.isTypeTest) {
           return js.js(r'typeof # === "string"', <js.Expression>[value]);
         }
         // TODO(sra): Implement fast cast via calling 'stringTypeCast'.
       } else if (glue.isBoolClass(clazz)) {
         if (node.isTypeTest) {
           return js.js(r'typeof # === "boolean"', <js.Expression>[value]);
         }
         // TODO(sra): Implement fast cast via calling 'boolTypeCast'.
+      } else if (node.isTypeTest &&
+                 node.typeArguments.isEmpty &&
+                 glue.mayGenerateInstanceofCheck(type)) {
+        registerInstanceofCheck(clazz);
+        return js.js('# instanceof #', [value, glue.constructorAccess(clazz)]);
       }
 
       // The helper we use needs the JSArray class to exist, but for some
       // reason the helper does not cause this dependency to be registered.
       // TODO(asgerf): Most programs need List anyway, but we should fix this.
       registry.registerInstantiatedClass(glue.listClass);
 
       // We use one of the two helpers:
       //
       //     checkSubtype(value, $isT, typeArgs, $asT)
@@ skipping 708 matching lines @@
   void registerDefaultParameterValues(ExecutableElement element) {
     if (element is! FunctionElement) return;
     FunctionElement function = element;
     if (function.isStatic) return; // Defaults are inlined at call sites.
     function.functionSignature.forEachOptionalParameter((param) {
       ConstantValue constant = glue.getDefaultParameterValue(param);
       registry.registerCompileTimeConstant(constant);
     });
   }
 }