All strong mode cleaning of dart2js.

pkg/compiler/lib/src/world.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 dart2js.world;
 
 import 'closure.dart' show ClosureClassElement, SynthesizedCallMethodElementX;
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements, ElementEnvironment;
@@ skipping 235 matching lines @@
   /// If we're calling bar on an object of type D, we don't need the handler
   /// either because all objects of type D implement bar through inheritance.
   ///
   /// If we're calling bar on an object of type A we do need the handler because
   /// we may have to call B.noSuchMethod since B does not implement bar.
   bool needsNoSuchMethod(ClassEntity cls, Selector selector, ClassQuery query);
 
   /// Returns whether [element] will be the one used at runtime when being
   /// invoked on an instance of [cls]. [selector] is used to ensure library
   /// privacy is taken into account.
-  bool hasElementIn(ClassEntity cls, Selector selector, Entity element);
+  bool hasElementIn(
+      covariant ClassEntity cls, Selector selector, covariant Entity element);
 
   /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
   /// of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClosedWorld].
   ClassHierarchyNode getClassHierarchyNode(ClassEntity cls);
 
   /// Returns [ClassSet] for [cls] used to model the extends and implements
   /// relations of known classes.
@@ skipping 91 matching lines @@
 
   /// Registers that [element] is called in a loop.
   // TODO(johnniwinther): Is this 'potentially called' or 'known to be called'?
   void addFunctionCalledInLoop(Entity element);
 
   /// Registers that [element] is guaranteed not to throw an exception.
   void registerCannotThrow(Entity element);
 
   /// Adds the closure class [cls] to the inference world. The class is
   /// considered directly instantiated.
-  void registerClosureClass(ClassElement cls);
+  void registerClosureClass(covariant ClassElement cls);
 }
 
 abstract class OpenWorld implements World {
   /// Called to add [cls] to the set of known classes.
   ///
   /// This ensures that class hierarchy queries can be performed on [cls] and
   /// classes that extend or implement it.
-  void registerClass(ClassEntity cls);
+  void registerClass(covariant ClassEntity cls);
 
   void registerUsedElement(MemberEntity element);
   void registerTypedef(TypedefElement typedef);
 
   ClosedWorld closeWorld();
 
   /// Returns an iterable over all mixin applications that mixin [cls].
   Iterable<ClassEntity> allMixinUsesOf(ClassEntity cls);
 }
 
@@ skipping 90 matching lines @@
   CommonMasks get commonMasks {
     return _commonMasks;
   }
 
   TypeMask getCachedMask(ClassEntity base, int flags, TypeMask createMask()) {
     Map<ClassEntity, TypeMask> cachedMasks =
         _canonicalizedTypeMasks[flags] ??= <ClassEntity, TypeMask>{};
     return cachedMasks.putIfAbsent(base, createMask);
   }
 
-  bool checkEntity(Entity element);
+  bool checkEntity(covariant Entity element);
 
-  bool checkClass(ClassEntity cls);
+  bool checkClass(covariant ClassEntity cls);
 
-  bool checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true});
+  bool checkInvariants(covariant ClassEntity cls,
+      {bool mustBeInstantiated: true});
 
-  OrderedTypeSet getOrderedTypeSet(ClassEntity cls);
+  OrderedTypeSet getOrderedTypeSet(covariant ClassEntity cls);
 
-  int getHierarchyDepth(ClassEntity cls);
+  int getHierarchyDepth(covariant ClassEntity cls);
 
-  ClassEntity getSuperClass(ClassEntity cls);
+  ClassEntity getSuperClass(covariant ClassEntity cls);
 
-  Iterable<ClassEntity> getInterfaces(ClassEntity cls);
+  Iterable<ClassEntity> getInterfaces(covariant ClassEntity cls);
 
-  ClassEntity getAppliedMixin(ClassEntity cls);
+  ClassEntity getAppliedMixin(covariant ClassEntity cls);
 
-  bool isNamedMixinApplication(ClassEntity cls);
+  bool isNamedMixinApplication(covariant ClassEntity cls);
 
   @override
   bool isInstantiated(ClassEntity cls) {
     assert(checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isInstantiated;
   }
 
   @override
   bool isDirectlyInstantiated(ClassEntity cls) {
@@ skipping 280 matching lines @@
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassEntity superclass, ClassEntity type) {
     assert(checkClass(superclass));
     Set<ClassEntity> subclasses = _typesImplementedBySubclasses[superclass];
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
   /// Returns whether a [selector] call on an instance of [cls]
   /// will hit a method at runtime, and not go through [noSuchMethod].
-  bool hasConcreteMatch(ClassEntity cls, Selector selector,
-      {ClassEntity stopAtSuperclass});
+  bool hasConcreteMatch(covariant ClassEntity cls, Selector selector,
+      {covariant ClassEntity stopAtSuperclass});
 
   @override
   bool needsNoSuchMethod(
       ClassEntity base, Selector selector, ClassQuery query) {
     /// Returns `true` if subclasses in the [rootNode] tree needs noSuchMethod
     /// handling.
     bool subclassesNeedNoSuchMethod(ClassHierarchyNode rootNode) {
       if (!rootNode.isInstantiated) {
         // No subclass needs noSuchMethod handling since they are all
         // uninstantiated.
@@ skipping 252 matching lines @@
           sideEffects.setAllSideEffects();
           sideEffects.setDependsOnSomething();
         }
       } else {
         sideEffects.add(getSideEffectsOfElement(e));
       }
     }
     return sideEffects;
   }
 
-  SideEffects getSideEffectsOfElement(Entity element) {
+  SideEffects getSideEffectsOfElement(covariant Entity element) {
     assert(checkEntity(element));
     return _sideEffects.putIfAbsent(element, _makeSideEffects);
   }
 
-  static _makeSideEffects() => new SideEffects();
+  static SideEffects _makeSideEffects() => new SideEffects();
 
   @override
   SideEffects getCurrentlyKnownSideEffects(Entity element) {
     return getSideEffectsOfElement(element);
   }
 
   void registerSideEffects(Entity element, SideEffects effects) {
     assert(checkEntity(element));
     if (_sideEffectsFreeElements.contains(element)) return;
     _sideEffects[element] = effects;
@@ skipping 203 matching lines @@
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
     // contain the side effects of the initializers.
     assert(!element.isGenerativeConstructorBody);
     assert(!element.isField);
     return super.getSideEffectsOfElement(element);
   }
 }