Optimize is-check to instanceof when it eliminates an interceptor

pkg/compiler/lib/src/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 2286 matching lines @@
     use(input);
 
     js.PropertyAccess field =
         new js.PropertyAccess.field(pop(), backend.namer.operatorIsType(type));
     // We always negate at least once so that the result is boolified.
     push(new js.Prefix('!', field));
     // If the result is not negated, put another '!' in front.
     if (!negative) push(new js.Prefix('!', pop()));
   }
 
+  void checkTypeViaInstanceof(
+      HInstruction input, DartType type, bool negative) {
+    registry.registerIsCheck(type);
+
+    use(input);
+
+    js.Expression jsClassReference =
+        backend.emitter.constructorAccess(type.element);

[floitsch, 2015/01/16 14:14:33]

Please confirm that `constructorAccess` is correct. (I believe it is, but a
second opinion is helpful).
In the new emitter the constructor-access might return the stub (at least until
there really was a construction).
Normally the test should simply fail in these cases (which makes sense, since no
instantiated object exists yet).

Later the rhs might change (probably leading to a deopt), but at that point we
are obviously safe.

[sra1, 2015/01/20 20:07:27]

Verified.
Good points.
Many instances are in methods of the class, e.g.  Duration.== has the check
"other is Duration".  These cases can only be reached after construction.

I think the risks are low since we are using 'instanceof' only if we can
eliminate a getInterceptor call.

I wonder if instanceof might be better than a property test for
self-intercepting classes where we 'know' that the property test will be
megamorphic?

+    push(js.js('# instanceof #', [pop(), jsClassReference]));
+    if (negative) push(new js.Prefix('!', pop()));
+  }
+
   void handleNumberOrStringSupertypeCheck(HInstruction input,
                                           HInstruction interceptor,
                                           DartType type,
                                           { bool negative: false }) {
     assert(!identical(type.element, compiler.listClass)
            && !Elements.isListSupertype(type.element, compiler)
            && !Elements.isStringOnlySupertype(type.element, compiler));
     String relation = negative ? '!==' : '===';
     checkNum(input, relation);
     js.Expression numberTest = pop();
@@ skipping 97 matching lines @@
         checkBool(input, relation);
         attachLocationToLast(node);
       } else if (element == compiler.intClass) {
         // The is check in the code tells us that it might not be an
         // int. So we do a typeof first to avoid possible
         // deoptimizations on the JS engine due to the Math.floor check.
         checkNum(input, relation);
         js.Expression numTest = pop();
         checkBigInt(input, relation);
         push(new js.Binary(negative ? '||' : '&&', numTest, pop()), node);
+      } else if (node.useInstanceOf) {
+        assert(interceptor == null);
+        checkTypeViaInstanceof(input, type, negative);
+        attachLocationToLast(node);
       } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
         handleNumberOrStringSupertypeCheck(
             input, interceptor, type, negative: negative);
         attachLocationToLast(node);
       } else if (Elements.isStringOnlySupertype(element, compiler)) {
         handleStringSupertypeCheck(
             input, interceptor, type, negative: negative);
         attachLocationToLast(node);
       } else if (identical(element, compiler.listClass)
                  || Elements.isListSupertype(element, compiler)) {
@@ skipping 218 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = backend.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.emitter.staticFunctionAccess(helper);
   }
 }