dart2js: use WorldImpact for dump_info

pkg/compiler/lib/src/universe/universe.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.
 
 library universe;
 
 import 'dart:collection';
 
 import '../common.dart';
 import '../compiler.dart' show
@@ skipping 21 matching lines @@
 ///     class Bar {
 ///        void foo() {}
 ///     }
 ///     main() => new Bar().foo();
 ///
 abstract class ReceiverConstraint {
   /// Returns whether [element] is a potential target when being
   /// invoked on a receiver with this constraint. [selector] is used to ensure
   /// library privacy is taken into account.
   bool canHit(Element element, Selector selector, ClassWorld classWorld);
+
+  /// Returns whether this [TypeMask] applied to [selector] can hit a
+  /// [noSuchMethod].
+  bool needsNoSuchMethodHandling(Selector selector, ClassWorld classWorld);
 }
 
 /// The combined constraints on receivers all the dynamic call sites of the same
 /// selector.
 ///
 /// For instance for these calls
 ///
 ///     class A {
 ///        foo(a, b) {}
 ///     }
 ///     class B {
 ///        foo(a, b) {}
 ///     }
 ///     class C {
 ///        foo(a, b) {}
 ///     }
 ///     new A().foo(a, b);
 ///     new B().foo(0, 42);
 ///
-/// the selector constaints for dynamic calls to 'foo' with two positional
+/// the selector constraints for dynamic calls to 'foo' with two positional
 /// arguments could be 'receiver of exact instance `A` or `B`'.
 abstract class SelectorConstraints {
   /// Returns `true` if [selector] applies to [element] under these constraints
   /// given the closed [world].
   ///
   /// Consider for instance in this world:
   ///
   ///     class A {
   ///        foo(a, b) {}
   ///     }
@@ skipping 322 matching lines @@
   // TODO(ahe): Replace this method with something that is O(1), for example,
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
           return closure.executableContext == element;
         }));
   }
 }