All strong mode cleaning of dart2js.

pkg/compiler/lib/src/js_model/elements.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.js_model.elements;
 
 import '../common_elements.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart';
@@ skipping 40 matching lines @@
 
   LibraryEntity toBackendLibrary(LibraryEntity library) {
     return _toBackendLibrary.putIfAbsent(library, () {
       JLibrary newLibrary = new JLibrary(
           _toBackendLibrary.length, library.name, library.canonicalUri);
       _frontendLibraryList.add(library);
       return newLibrary;
     });
   }
 
-  LibraryEntity toFrontendLibrary(JLibrary library) =>
+  LibraryEntity toFrontendLibrary(covariant JLibrary library) =>
       _frontendLibraryList[library.libraryIndex];
 
   final Map<ClassEntity, ClassEntity> _toBackendClass =
       <ClassEntity, ClassEntity>{};
   final List<ClassEntity> _frontendClassList = <ClassEntity>[];
 
   ClassEntity toBackendClass(ClassEntity cls) {
     return _toBackendClass.putIfAbsent(cls, () {
       LibraryEntity library = toBackendLibrary(cls.library);
       JClass newClass = new JClass(library, _toBackendClass.length, cls.name,
           isAbstract: cls.isAbstract);
       _frontendClassList.add(cls);
       return newClass;
     });
   }
 
-  ClassEntity toFrontendClass(JClass cls) => _frontendClassList[cls.classIndex];
+  ClassEntity toFrontendClass(covariant JClass cls) =>
+      _frontendClassList[cls.classIndex];
 
   final Map<MemberEntity, MemberEntity> _toBackendMember =
       <MemberEntity, MemberEntity>{};
   final List<MemberEntity> _frontendMemberList = <MemberEntity>[];
 
   MemberEntity toBackendMember(MemberEntity member) {
     return _toBackendMember.putIfAbsent(member, () {
       LibraryEntity library = toBackendLibrary(member.library);
       ClassEntity cls;
       if (member.enclosingClass != null) {
@@ skipping 45 matching lines @@
             memberName, function.parameterStructure, function.asyncMarker,
             isStatic: function.isStatic,
             isExternal: function.isExternal,
             isAbstract: function.isAbstract);
       }
       _frontendMemberList.add(member);
       return newMember;
     });
   }
 
-  MemberEntity toFrontendMember(JMember member) =>
+  MemberEntity toFrontendMember(covariant JMember member) =>
       _frontendMemberList[member.memberIndex];
 
   DartType toBackendType(DartType type) =>
       const TypeConverter().visit(type, _toBackendEntity);
   DartType toFrontendType(DartType type) =>
       const TypeConverter().visit(type, _toFrontendEntity);
 
   Entity _toBackendEntity(Entity entity) {
     if (entity is ClassEntity) return toBackendClass(entity);
     assert(entity is TypeVariableEntity);
@@ skipping 527 matching lines @@
         .isFunctionUsedByBackend(_map.toFrontendMember(element));
   }
 
   @override
   bool isFieldUsedByBackend(FieldEntity element) {
     return _backendUsage.isFieldUsedByBackend(_map.toFrontendMember(element));
   }
 
   @override
   Iterable<FunctionEntity> get globalFunctionDependencies {
-    return _backendUsage.globalFunctionDependencies
-        .map((FunctionEntity e) => _map.toBackendMember(e));
+    FunctionEntity f(FunctionEntity e) => _map.toBackendMember(e);
+    return _backendUsage.globalFunctionDependencies.map(f);
   }
 
   @override
   Iterable<ClassEntity> get globalClassDependencies {
     return _backendUsage.globalClassDependencies.map(_map.toBackendClass);
   }
 
   @override
   bool get requiresPreamble => _backendUsage.requiresPreamble;
 
@@ skipping 1151 matching lines @@
   @override
   ClassEntity get numClass => _map.toBackendClass(_commonElements.numClass);
 
   @override
   ClassEntity get boolClass => _map.toBackendClass(_commonElements.boolClass);
 
   @override
   FunctionEntity get throwUnsupportedError =>
       _map.toBackendMember(_commonElements.throwUnsupportedError);
 }