Instruction selection before removing HTypeKnown

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));
-    // If there is an instruction that dominates all others, we can
-    // use only the selector of that instruction.
-    if (dominator != null) {
+    HInstruction dominator = findDominator(node.usedBy);
+    // If there is a call that dominates all other uses, we can use just the
+    // selector of that instruction.
+    if (dominator is HInvokeDynamic &&
+        dominator.isCallOnInterceptor(compiler) &&
+        node == dominator.receiver) {
       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);
           }
         }
       }
     } else {
       interceptedClasses = new Set<ClassElement>();
       for (HInstruction user in node.usedBy) {
-        if (user is HIs) {
-          // Is-checks can be performed on any intercepted class.
+        if (user is HInvokeDynamic &&
+            user.isCallOnInterceptor(compiler) &&
+            node == user.receiver) {
+          interceptedClasses.addAll(
+              backend.getInterceptedClassesOn(user.selector.name));
+        } else {
+          // Use a most general interceptor for other instructions, example,
+          // is-checks and escaping interceptors.
           interceptedClasses.addAll(backend.interceptedClasses);
           break;
         }
-        if (user is! HInvoke) continue;
-        // We don't handle escaping interceptors yet.
-        interceptedClasses.addAll(
-            backend.getInterceptedClassesOn(user.selector.name));
       }
     }
 
     HInstruction receiver = node.receiver;
     if (canUseSelfForInterceptor(receiver, interceptedClasses)) {
       return rewriteToUseSelfAsInterceptor(node, receiver);
     }
 
     // Try computing a constant interceptor.
     HInstruction constantInterceptor =
@@ skipping 105 matching lines @@
       instruction = new HInvokeDynamicMethod(
           selector, inputs, node.instructionType, true);
     }
 
     HBasicBlock block = node.block;
     block.addAfter(node, instruction);
     block.rewrite(node, instruction);
     return true;
   }
 }