All strong mode cleaning of dart2js.

pkg/compiler/lib/src/universe/world_builder.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 world_builder;
 
 import 'dart:collection';
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 39 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(MemberElement element, Selector selector, World world);
+  bool canHit(MemberEntity element, Selector selector, covariant World world);
 
   /// Returns whether this [TypeMask] applied to [selector] can hit a
   /// [noSuchMethod].
-  bool needsNoSuchMethodHandling(Selector selector, World world);
+  bool needsNoSuchMethodHandling(Selector selector, covariant World world);
 }
 
 /// The combined constraints on receivers all the dynamic call sites of the same
 /// selector.
 ///
 /// For instance for these calls
 ///
 ///     class A {
 ///        foo(a, b) {}
 ///     }
@@ skipping 17 matching lines @@
   ///     class A {
   ///        foo(a, b) {}
   ///     }
   ///     class B {
   ///        foo(a, b) {}
   ///     }
   ///     new A().foo(a, b);
   ///
   /// Ideally the selector constraints for calls `foo` with two positional
   /// arguments apply to `A.foo` but `B.foo`.
-  bool applies(MemberEntity element, Selector selector, World world);
+  bool applies(MemberEntity element, Selector selector, covariant World world);
 
   /// Returns `true` if at least one of the receivers matching these constraints
   /// in the closed [world] have no implementation matching [selector].
   ///
   /// For instance for this code snippet
   ///
   ///     class A {}
   ///     class B { foo() {} }
   ///     m(b) => (b ? new A() : new B()).foo();
   ///
   /// the potential receiver `new A()` has no implementation of `foo` and thus
   /// needs to handle the call through its `noSuchMethod` handler.
-  bool needsNoSuchMethodHandling(Selector selector, World world);
+  bool needsNoSuchMethodHandling(Selector selector, covariant World world);
 }
 
 /// A mutable [SelectorConstraints] used in [WorldBuilder].
 abstract class UniverseSelectorConstraints extends SelectorConstraints {
   /// Adds [constraint] to these selector constraints. Return `true` if the set
   /// of potential receivers expanded due to the new constraint.
-  bool addReceiverConstraint(ReceiverConstraint constraint);
+  bool addReceiverConstraint(covariant ReceiverConstraint constraint);
 }
 
 /// Strategy for computing the constraints on potential receivers of dynamic
 /// call sites.
 abstract class SelectorConstraintsStrategy {
   /// Create a [UniverseSelectorConstraints] to represent the global receiver
   /// constraints for dynamic call sites with [selector].
   UniverseSelectorConstraints createSelectorConstraints(Selector selector);
 }
 
@@ skipping 46 matching lines @@
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<InterfaceType> get instantiatedTypes;
 
   /// Registers that [type] is checked in this world builder. The unaliased type
   /// is returned.
   void registerIsCheck(DartType type);
 }