Take noSuchMethod into account when computing the potential targets of a call.

sdk/lib/_internal/compiler/implementation/universe/function_set.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 universe;
 
 // TODO(kasperl): This actually holds getters and setters just fine
 // too and stricly they aren't functions. Maybe this needs a better
 // name -- something like ElementSet seems a bit too generic.
 class FunctionSet {
@@ skipping 33 matching lines @@
         : false;
   }
 
   /**
    * Returns an object that allows iterating over all the functions
    * that may be invoked with the given [selector].
    */
   Iterable<Element> filter(Selector selector) {
     SourceString name = selector.name;
     FunctionSetNode node = nodes[name];
-    return (node != null)
-        ? node.query(selector, compiler).functions
-        : const <Element>[];
+    FunctionSetNode noSuchMethods = nodes[Compiler.NO_SUCH_METHOD];
+    if (node != null) {
+      return node.query(selector, compiler, noSuchMethods).functions;
+    }
+    // If there is no method that matches [selector] we know we can
+    // only hit [:noSuchMethod:].
+    if (noSuchMethods == null) return const <Element>[];
+    selector = (selector.mask == null)
+        ? compiler.noSuchMethodSelector
+        : new TypedSelector(selector.mask, compiler.noSuchMethodSelector);
+
+    return noSuchMethods.query(selector, compiler, null).functions;
   }
 
   void forEach(Function action) {
     nodes.forEach((SourceString name, FunctionSetNode node) {
       node.forEach(action);
     });
   }
 }
 
 
@@ skipping 50 matching lines @@
 
   bool contains(Element element) {
     assert(element.name == name);
     return elements.contains(element);
   }
 
   void forEach(Function action) {
     elements.forEach(action);
   }
 
-  FunctionSetQuery query(Selector selector, Compiler compiler) {
+  TypeMask getNonNullTypeMaskOfSelector(Selector selector, Compiler compiler) {
+    // TODO(ngeoffray): We should probably change untyped selector
+    // to always be a subclass of Object.
+    return selector.mask != null
+        ? selector.mask
+        : new TypeMask.subclass(compiler.objectClass.rawType);
+    }
+
+  FunctionSetQuery query(Selector selector,
+                         Compiler compiler,
+                         FunctionSetNode noSuchMethods) {
     assert(selector.name == name);
     FunctionSetQuery result = cache[selector];
     if (result != null) return result;
     List<Element> functions;
     for (Element element in elements) {
       if (selector.appliesUnnamed(element, compiler)) {
         if (functions == null) {
           // Defer the allocation of the functions list until we are
           // sure we need it. This allows us to return immutable empty
           // lists when the filtering produced no results.
           functions = <Element>[];
         }
         functions.add(element);
       }
     }
+
+    TypeMask mask = getNonNullTypeMaskOfSelector(selector, compiler);
+    // If we cannot ensure a method will be found at runtime, we also
+    // add [noSuchMethod] implementations that apply to [mask] as
+    // potential targets.
+    if (noSuchMethods != null && !mask.willHit(selector, compiler)) {
+      FunctionSetQuery noSuchMethodQuery = noSuchMethods.query(
+          new TypedSelector(mask, compiler.noSuchMethodSelector),
+          compiler,
+          null);
+      if (!noSuchMethodQuery.functions.isEmpty) {
+        if (functions == null) {
+          functions = new List<Element>.from(noSuchMethodQuery.functions);
+        } else {
+          functions.addAll(noSuchMethodQuery.functions);
+        }
+      }
+    }
     cache[selector] = result = (functions != null)
         ? newQuery(functions, selector, compiler)
         : const FunctionSetQuery(const <Element>[]);
     return result;
   }
 
   FunctionSetQuery newQuery(List<Element> functions,
                             Selector selector,
                             Compiler compiler) {
     return new FunctionSetQuery(functions);
   }
 }
 
 class FunctionSetQuery {
   final List<Element> functions;
   const FunctionSetQuery(this.functions);
 }