All strong mode cleaning of dart2js.

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 738 matching lines @@
   ResolutionImpact computeWorldImpact(KMember member) {
     return _memberList[member.memberIndex].getWorldImpact(this);
   }
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return member;
   }
 
   @override
-  ir.Member getMemberNode(KMember member) {
+  ir.Member getMemberNode(covariant KMember member) {
     return _memberList[member.memberIndex].node;
   }
 
   /// Returns the kernel IR node that defines the [cls].
   ir.Class getClassNode(KClass cls) {
     return _classEnvs[cls.classIndex].cls;
   }
 }
 
 /// Environment for fast lookup of program libraries.
@@ skipping 413 matching lines @@
   InterfaceType getRawType(ClassEntity cls) {
     return elementMap._getRawType(cls);
   }
 
   @override
   bool isGenericClass(ClassEntity cls) {
     return getThisType(cls).typeArguments.isNotEmpty;
   }
 
   @override
-  bool isMixinApplication(KClass cls) {
+  bool isMixinApplication(covariant KClass cls) {
     return elementMap._isMixinApplication(cls);
   }
 
   @override
-  bool isUnnamedMixinApplication(KClass cls) {
+  bool isUnnamedMixinApplication(covariant KClass cls) {
     return elementMap._isUnnamedMixinApplication(cls);
   }
 
   @override
   ClassEntity getEffectiveMixinClass(ClassEntity cls) {
     if (!isMixinApplication(cls)) return null;
     do {
       cls = elementMap._getAppliedMixin(cls);
     } while (isMixinApplication(cls));
     return cls;
   }
 
   @override
   DartType getTypeVariableBound(TypeVariableEntity typeVariable) {
     throw new UnimplementedError(
         'KernelElementEnvironment.getTypeVariableBound');
   }
 
   @override
   InterfaceType createInterfaceType(
       ClassEntity cls, List<DartType> typeArguments) {
     return new InterfaceType(cls, typeArguments);
   }
 
   @override
-  FunctionType getFunctionType(KFunction function) {
+  FunctionType getFunctionType(covariant KFunction function) {
     return elementMap._getFunctionType(function);
   }
 
   @override
-  FunctionType getLocalFunctionType(KLocalFunction function) {
+  FunctionType getLocalFunctionType(covariant KLocalFunction function) {
     return function.functionType;
   }
 
   @override
   DartType getUnaliasedType(DartType type) => type;
 
   @override
   ConstructorEntity lookupConstructor(ClassEntity cls, String name,
       {bool required: false}) {
     ConstructorEntity constructor = elementMap.lookupConstructor(cls, name);
@@ skipping 76 matching lines @@
       {bool required: false}) {
     ClassEntity cls = elementMap.lookupClass(library, name);
     if (cls == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The class '$name'  was not found in library '${library.name}'.");
     }
     return cls;
   }
 
   @override
-  void forEachClass(KLibrary library, void f(ClassEntity cls)) {
+  void forEachClass(covariant KLibrary library, void f(ClassEntity cls)) {
     elementMap._forEachClass(library, f);
   }
 
   @override
   LibraryEntity lookupLibrary(Uri uri, {bool required: false}) {
     LibraryEntity library = elementMap.lookupLibrary(uri);
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           CURRENT_ELEMENT_SPANNABLE, "The library '$uri' was not found.");
     }
     return library;
   }
 
   @override
-  bool isDeferredLoadLibraryGetter(KMember member) {
+  bool isDeferredLoadLibraryGetter(covariant KMember member) {
     // TODO(johnniwinther): Support these.
     return false;
   }
 
   @override
-  Iterable<ConstantValue> getMemberMetadata(KMember member) {
+  Iterable<ConstantValue> getMemberMetadata(covariant KMember member) {
     _MemberData memberData = elementMap._memberList[member.memberIndex];
     return memberData.getMetadata(elementMap);
   }
 }
 
 /// Visitor that converts kernel dart types into [DartType].
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
   final KernelToElementMapImpl elementAdapter;
   bool topLevel = true;
 
@@ skipping 343 matching lines @@
   KernelNativeMemberResolver(
       this.elementMap, this.nativeBasicData, this.nativeDataBuilder);
 
   @override
   ElementEnvironment get elementEnvironment => elementMap.elementEnvironment;
 
   @override
   CommonElements get commonElements => elementMap.commonElements;
 
   @override
-  native.NativeBehavior computeNativeFieldStoreBehavior(KField field) {
+  native.NativeBehavior computeNativeFieldStoreBehavior(
+      covariant KField field) {
     ir.Field node = elementMap._memberList[field.memberIndex].node;
     return elementMap.getNativeBehaviorForFieldStore(node);
   }
 
   @override
-  native.NativeBehavior computeNativeFieldLoadBehavior(KField field,
+  native.NativeBehavior computeNativeFieldLoadBehavior(covariant KField field,
       {bool isJsInterop}) {
     ir.Field node = elementMap._memberList[field.memberIndex].node;
     return elementMap.getNativeBehaviorForFieldLoad(node,
         isJsInterop: isJsInterop);
   }
 
   @override
-  native.NativeBehavior computeNativeMethodBehavior(KFunction function,
+  native.NativeBehavior computeNativeMethodBehavior(
+      covariant KFunction function,
       {bool isJsInterop}) {
     ir.Member node = elementMap._memberList[function.memberIndex].node;
     return elementMap.getNativeBehaviorForMethod(node,
         isJsInterop: isJsInterop);
   }
 
   @override
-  bool isNativeMethod(KFunction function) {
+  bool isNativeMethod(covariant KFunction function) {
     if (!native.maybeEnableNative(function.library.canonicalUri)) return false;
     ir.Member node = elementMap._memberList[function.memberIndex].node;
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(johnniwinther): Compute this.
     return false;
@@ skipping 119 matching lines @@
   @override
   DiagnosticReporter get reporter {
     return _elementMap.reporter;
   }
 
   @override
   ConstantValue getFieldConstantValue(ir.Field field) {
     throw new UnsupportedError("JsKernelToElementMap.getFieldConstantValue");
   }
 }