Split TypedSelector into Selector and TypeMask.

pkg/compiler/lib/src/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 766 matching lines @@
 
   bool isInterceptedSelector(Selector selector) {
     return interceptedElements[selector.name] != null;
   }
 
   /**
    * Returns `true` iff [selector] matches an element defined in a class mixed
    * into an intercepted class.  These selectors are not eligible for the 'dummy
    * explicit receiver' optimization.
    */
-  bool isInterceptedMixinSelector(Selector selector) {
+  bool isInterceptedMixinSelector(Selector selector, TypeMask mask) {
     Set<Element> elements = interceptedMixinElements.putIfAbsent(
         selector.name,
         () {
           Set<Element> elements = interceptedElements[selector.name];
           if (elements == null) return null;
           return elements
               .where((element) =>
                   classesMixedIntoInterceptedClasses.contains(
                       element.enclosingClass))
               .toSet();
         });
 
     if (elements == null) return false;
     if (elements.isEmpty) return false;
-    return elements.any((element) => selector.applies(element, compiler.world));
+    return elements.any((element) {
+      return selector.applies(element, compiler.world) &&
+             (mask == null || mask.canHit(element, selector, compiler.world));
+    });
   }
 
   final Map<String, Set<ClassElement>> interceptedClassesCache =
       new Map<String, Set<ClassElement>>();
 
   /**
    * Returns a set of interceptor classes that contain a member named
    * [name]. Returns [:null:] if there is no class.
    */
   Set<ClassElement> getInterceptedClassesOn(String name) {
@@ skipping 450 matching lines @@
     // Also register the types of the arguments passed to this method.
     enqueueClass(compiler.enqueuer.resolution, compiler.stringClass, registry);
   }
 
   void registerNoSuchMethod(FunctionElement noSuchMethod) {
     noSuchMethodRegistry.registerNoSuchMethod(noSuchMethod);
   }
 
   void enableNoSuchMethod(Enqueuer world) {
     enqueue(world, getCreateInvocationMirror(), compiler.globalDependencies);
-    world.registerInvocation(compiler.noSuchMethodSelector);
+    world.registerInvocation(
+        new UniverseSelector(compiler.noSuchMethodSelector, null));
   }
 
   void enableIsolateSupport(Enqueuer enqueuer) {
     // TODO(floitsch): We should also ensure that the class IsolateMessage is
     // instantiated. Currently, just enabling isolate support works.
     if (compiler.mainFunction != null) {
       // The JavaScript backend implements [Isolate.spawn] by looking up
       // top-level functions by name. So all top-level function tear-off
       // closures have a private name field.
       //
@@ skipping 1691 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }