Take is checks into account when deriving interceptor classes.

sdk/lib/_internal/compiler/implementation/ssa/interceptor_simplifier.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.
 
 part of ssa;
 
 /**
  * This phase simplifies interceptors in multiple ways:
  *
  * 1) If the interceptor is for an object whose type is known, it
@@ skipping 155 matching lines @@
     return result;
   }
 
   bool visitInterceptor(HInterceptor node) {
     if (node.isConstant()) return false;
 
     // If the interceptor is used by multiple instructions, specialize
     // it with a set of classes it intercepts.
     Set<ClassElement> interceptedClasses;
     JavaScriptBackend backend = compiler.backend;
-    HInstruction dominator =
-        findDominator(node.usedBy.where((i) => i is HInvokeDynamic));
+    HInstruction dominator = findDominator(node.usedBy.where((i) {
+        return i is HInvokeDynamic || i is HIs;

[floitsch, 2014/03/11 17:07:06]

Indent by two and the next line by 0.

+      }));
     // If there is an instruction that dominates all others, we can
     // use only the selector of that instruction.
     if (dominator != null) {
-      interceptedClasses =
-            backend.getInterceptedClassesOn(dominator.selector.name);
+      if (dominator is HIs) {
+        // Is checks do not constrain the set of intercepted classes.
+        interceptedClasses = backend.interceptedClasses;
+      } else {
+        interceptedClasses =
+              backend.getInterceptedClassesOn(dominator.selector.name);
 
-      // If we found that we need number, we must still go through all
-      // uses to check if they require int, or double.
-      if (interceptedClasses.contains(backend.jsNumberClass)
-          && !(interceptedClasses.contains(backend.jsDoubleClass)
-               || interceptedClasses.contains(backend.jsIntClass))) {
-        for (HInstruction user in node.usedBy) {
-          if (user is! HInvoke) continue;
-          Set<ClassElement> intercepted =
-              backend.getInterceptedClassesOn(user.selector.name);
-          if (intercepted.contains(backend.jsIntClass)) {
-            interceptedClasses.add(backend.jsIntClass);
-          }
-          if (intercepted.contains(backend.jsDoubleClass)) {
-            interceptedClasses.add(backend.jsDoubleClass);
+        // If we found that we need number, we must still go through all
+        // uses to check if they require int, or double.
+        if (interceptedClasses.contains(backend.jsNumberClass)
+            && !(interceptedClasses.contains(backend.jsDoubleClass)
+                 || interceptedClasses.contains(backend.jsIntClass))) {
+          for (HInstruction user in node.usedBy) {
+            if (user is! HInvoke) continue;
+            Set<ClassElement> intercepted =
+                backend.getInterceptedClassesOn(user.selector.name);
+            if (intercepted.contains(backend.jsIntClass)) {
+              interceptedClasses.add(backend.jsIntClass);
+            }
+            if (intercepted.contains(backend.jsDoubleClass)) {
+              interceptedClasses.add(backend.jsDoubleClass);
+            }
           }
         }
       }
     } else {
       interceptedClasses = new Set<ClassElement>();
       for (HInstruction user in node.usedBy) {
         if (user is HIs) {
           // Is-checks can be performed on any intercepted class.
           interceptedClasses.addAll(backend.interceptedClasses);
           break;
@@ skipping 120 matching lines @@
       instruction = new HInvokeDynamicMethod(
           selector, inputs, node.instructionType, true);
     }
 
     HBasicBlock block = node.block;
     block.addAfter(node, instruction);
     block.rewrite(node, instruction);
     return true;
   }
 }