dart2js cps: Fix codegen for instanceof checks.

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 387 matching lines @@
 
   @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_);
+  bool tryRegisterInstanceofCheck(ClassElement class_) {
+    if (glue.classWorld.isInstantiated(class_)) {
+      // Ensure the class remains instantiated during backend tree-shaking.
+      // TODO(asgerf): We could have a more precise hook to inform the emitter
+      // that the JS constructor function is needed, without the class being
+      // instantiated.
+      registry.registerInstantiatedClass(class_);
+      return true;
+    }
+    // Will throw if the JS constructor is not emitted, so do not allow the
+    // instanceof check.  This should only happen when certain optimization
+    // passes are disabled, as the type check itself is trivial.
+    return false;
   }
 
   @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));
       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);
+                 glue.mayGenerateInstanceofCheck(type) &&
+                 tryRegisterInstanceofCheck(clazz)) {

[Siggi Cherem (dart-lang), 2016/01/16 00:50:40]

what would the code below generate when this is false?

[asgerf, 2016/01/16 01:05:13]

A call to a static checkSubtype method. That method is pretty slow but that case
really should not happen in practice anyway.

         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:
       //
@@ skipping 775 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);
     });
   }
 }