All strong mode cleaning of dart2js.

pkg/compiler/lib/src/resolution/resolution_strategy.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.resolution_strategy;
 
 import 'package:front_end/src/fasta/scanner.dart' show Token;
 
 import '../common.dart';
 import '../common_elements.dart';
@@ skipping 124 matching lines @@
   }
 
   WorkItemBuilder createResolutionWorkItemBuilder(
       NativeBasicData nativeBasicData,
       NativeDataBuilder nativeDataBuilder,
       ImpactTransformer impactTransformer) {
     return new ResolutionWorkItemBuilder(_compiler.resolution);
   }
 
   FunctionEntity computeMain(
-      LibraryElement mainApp, WorldImpactBuilder impactBuilder) {
+      covariant LibraryElement mainApp, WorldImpactBuilder impactBuilder) {
     _elementEnvironment._mainLibrary = mainApp;
     if (mainApp == null) return null;
     MethodElement mainFunction;
     Element main = mainApp.findExported(Identifiers.main);
     ErroneousElement errorElement = null;
     if (main == null) {
       if (_compiler.options.analyzeOnly) {
         if (!_compiler.analyzeAll) {
           errorElement = new ErroneousElementX(MessageKind.CONSIDER_ANALYZE_ALL,
               {'main': Identifiers.main}, Identifiers.main, mainApp);
@@ skipping 231 matching lines @@
   @override
   LibraryEntity get mainLibrary => _mainLibrary;
 
   @override
   FunctionEntity get mainFunction => _mainFunction;
 
   @override
   Iterable<LibraryEntity> get libraries => _compiler.libraryLoader.libraries;
 
   @override
-  String getLibraryName(LibraryElement library) => library.libraryName;
+  String getLibraryName(covariant LibraryElement library) =>
+      library.libraryName;
 
   @override
-  ResolutionInterfaceType getThisType(ClassElement cls) {
+  ResolutionInterfaceType getThisType(covariant ClassElement cls) {
     cls.ensureResolved(_resolution);
     return cls.thisType;
   }
 
   @override
-  ResolutionInterfaceType getRawType(ClassElement cls) {
+  ResolutionInterfaceType getRawType(covariant ClassElement cls) {
     cls.ensureResolved(_resolution);
     return cls.rawType;
   }
 
   @override
   bool isGenericClass(ClassEntity cls) {
     return getThisType(cls).typeArguments.isNotEmpty;
   }
 
   @override
-  bool isMixinApplication(ClassElement cls) {
+  bool isMixinApplication(covariant ClassElement cls) {
     return cls.isMixinApplication;
   }
 
   @override
-  bool isUnnamedMixinApplication(ClassElement cls) {
+  bool isUnnamedMixinApplication(covariant ClassElement cls) {
     return cls.isUnnamedMixinApplication;
   }
 
   @override
-  ClassEntity getEffectiveMixinClass(ClassElement cls) {
+  ClassEntity getEffectiveMixinClass(covariant ClassElement cls) {
     if (!cls.isMixinApplication) return null;
     do {
       MixinApplicationElement mixinApplication = cls;
       cls = mixinApplication.mixin;
     } while (cls.isMixinApplication);
     return cls;
   }
 
   @override
-  ResolutionDartType getTypeVariableBound(TypeVariableElement typeVariable) {
+  ResolutionDartType getTypeVariableBound(
+      covariant TypeVariableElement typeVariable) {
     return typeVariable.bound;
   }
 
   @override
-  ResolutionInterfaceType createInterfaceType(
-      ClassElement cls, List<ResolutionDartType> typeArguments) {
+  ResolutionInterfaceType createInterfaceType(covariant ClassElement cls,
+      covariant List<ResolutionDartType> typeArguments) {
     cls.ensureResolved(_resolution);
     return cls.thisType.createInstantiation(typeArguments);
   }
 
   @override
-  MemberElement lookupClassMember(ClassElement cls, String name,
+  MemberElement lookupClassMember(covariant ClassElement cls, String name,
       {bool setter: false, bool required: false}) {
     cls.ensureResolved(_resolution);
     Element member = cls.implementation.lookupLocalMember(name);
     if (member != null && member.isAbstractField) {
       AbstractFieldElement abstractField = member;
       if (setter) {
         member = abstractField.setter;
       } else {
         member = abstractField.getter;
       }
       if (member == null && required) {
         throw new SpannableAssertionFailure(
             cls,
             "The class '${cls.name}' does not contain required "
             "${setter ? 'setter' : 'getter'}: '$name'.");
       }
     }
     if (member == null && required) {
       throw new SpannableAssertionFailure(
           cls,
           "The class '${cls.name}' does not "
           "contain required member: '$name'.");
     }
     return member?.declaration;
   }
 
   @override
-  ConstructorElement lookupConstructor(ClassElement cls, String name,
+  ConstructorElement lookupConstructor(covariant ClassElement cls, String name,
       {bool required: false}) {
     cls.ensureResolved(_resolution);
     ConstructorElement constructor = cls.implementation.lookupConstructor(name);
     // TODO(johnniwinther): Skip redirecting factories.
     if (constructor == null && required) {
       throw new SpannableAssertionFailure(
           cls,
           "The class '${cls.name}' does not contain "
           "required constructor: '$name'.");
     }
     return constructor?.declaration;
   }
 
   @override
-  void forEachClassMember(
-      ClassElement cls, void f(ClassElement declarer, MemberElement member)) {
+  void forEachClassMember(covariant ClassElement cls,
+      void f(ClassElement declarer, MemberElement member)) {
     cls.ensureResolved(_resolution);
     cls.forEachMember((ClassElement declarer, _member) {
       MemberElement member = _member;
       if (member.isSynthesized) return;
       if (member.isMalformed) return;
       if (member.isConstructor) return;
       f(declarer, member);
     }, includeSuperAndInjectedMembers: true);
   }
 
   @override
   void forEachConstructor(
-      ClassElement cls, void f(ConstructorEntity constructor)) {
+      covariant ClassElement cls, void f(ConstructorEntity constructor)) {
     cls.ensureResolved(_resolution);
     for (ConstructorElement constructor in cls.implementation.constructors) {
       _resolution.ensureResolved(constructor.declaration);
       if (constructor.isRedirectingFactory) continue;
       f(constructor);
     }
   }
 
   @override
-  ClassEntity getSuperClass(ClassElement cls,
+  ClassEntity getSuperClass(covariant ClassElement cls,
       {bool skipUnnamedMixinApplications: false}) {
     cls.ensureResolved(_resolution);
     ClassElement superclass = cls.superclass;
     if (skipUnnamedMixinApplications) {
       while (superclass != null && superclass.isUnnamedMixinApplication) {
         superclass = superclass.superclass;
       }
     }
     return superclass;
   }
 
   @override
   void forEachSupertype(
-      ClassElement cls, void f(ResolutionInterfaceType supertype)) {
-    cls.allSupertypes
-        .forEach((ResolutionInterfaceType supertype) => f(supertype));
+      covariant ClassElement cls, void f(ResolutionInterfaceType supertype)) {
+    cls.allSupertypes.forEach((InterfaceType supertype) => f(supertype));
   }
 
   @override
-  void forEachMixin(ClassElement cls, void f(ClassElement mixin)) {
+  void forEachMixin(covariant ClassElement cls, void f(ClassElement mixin)) {
     for (; cls != null; cls = cls.superclass) {
       if (cls.isMixinApplication) {
         MixinApplicationElement mixinApplication = cls;
         f(mixinApplication.mixin);
       }
     }
   }
 
   @override
-  MemberElement lookupLibraryMember(LibraryElement library, String name,
+  MemberElement lookupLibraryMember(
+      covariant LibraryElement library, String name,
       {bool setter: false, bool required: false}) {
     Element member = library.implementation.findLocal(name);
     if (member != null && member.isAbstractField) {
       AbstractFieldElement abstractField = member;
       if (setter) {
         member = abstractField.setter;
       } else {
         member = abstractField.getter;
       }
       if (member == null && required) {
         throw new SpannableAssertionFailure(
             library,
             "The library '${library.canonicalUri}' does not contain required "
             "${setter ? 'setter' : 'getter'}: '$name'.");
       }
     }
     if (member == null && required) {
       throw new SpannableAssertionFailure(
           member,
           "The library '${library.libraryName}' does not "
           "contain required member: '$name'.");
     }
     return member?.declaration;
   }
 
   @override
   void forEachLibraryMember(
-      LibraryElement library, void f(MemberEntity member)) {
+      covariant LibraryElement library, void f(MemberEntity member)) {
     library.implementation.forEachLocalMember((Element element) {
       if (!element.isClass && !element.isTypedef) {
         MemberElement member = element;
         f(member);
       }
     });
   }
 
   @override
-  ClassElement lookupClass(LibraryElement library, String name,
+  ClassElement lookupClass(covariant LibraryElement library, String name,
       {bool required: false}) {
     ClassElement cls = library.implementation.findLocal(name);
     if (cls == null && required) {
       throw new SpannableAssertionFailure(
           library,
           "The library '${library.libraryName}' does not "
           "contain required class: '$name'.");
     }
     return cls?.declaration;
   }
 
   @override
-  void forEachClass(LibraryElement library, void f(ClassElement cls)) {
-    library.implementation.forEachLocalMember((member) {
+  void forEachClass(covariant LibraryElement library, void f(ClassEntity cls)) {
+    library.implementation.forEachLocalMember((dynamic member) {
       if (member.isClass) {
-        f(member);
+        ClassElement cls = member;
+        f(cls);
       }
     });
   }
 
   @override
   LibraryElement lookupLibrary(Uri uri, {bool required: false}) {
     LibraryElement library = _libraryProvider.lookupLibrary(uri);
     // If the script of the library is synthesized, the library does not exist
     // and we do not try to load the helpers.
     //
     // This could for example happen if dart:async is disabled, then loading it
     // should not try to find the given element.
     if (library != null && library.isSynthesized) {
       return null;
     }
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           NO_LOCATION_SPANNABLE, "The library '${uri}' was not found.");
     }
     return library;
   }
 
   @override
-  bool isDeferredLoadLibraryGetter(MemberElement member) {
+  bool isDeferredLoadLibraryGetter(covariant MemberElement member) {
     return member.isDeferredLoaderGetter;
   }
 
   @override
-  ResolutionFunctionType getFunctionType(MethodElement method) {
+  ResolutionFunctionType getFunctionType(covariant MethodElement method) {
     if (method is ConstructorBodyElement) {
       return method.constructor.type;
     }
     method.computeType(_resolution);
     return method.type;
   }
 
   @override
-  ResolutionFunctionType getLocalFunctionType(LocalFunctionElement function) {
+  ResolutionFunctionType getLocalFunctionType(
+      covariant LocalFunctionElement function) {
     return function.type;
   }
 
   @override
-  ResolutionDartType getUnaliasedType(ResolutionDartType type) {
+  ResolutionDartType getUnaliasedType(covariant ResolutionDartType type) {
     type.computeUnaliased(_resolution);
     return type.unaliased;
   }
 
   @override
-  Iterable<ConstantValue> getMemberMetadata(MemberElement element) {
+  Iterable<ConstantValue> getMemberMetadata(covariant MemberElement element) {
     List<ConstantValue> values = <ConstantValue>[];
     _compiler.reporter.withCurrentElement(element, () {
       for (MetadataAnnotation metadata in element.implementation.metadata) {
         metadata.ensureResolved(_compiler.resolution);
         assert(metadata.constant != null,
             failedAt(metadata, "Unevaluated metadata constant."));
         ConstantValue value =
             _compiler.constants.getConstantValue(metadata.constant);
         values.add(value);
       }
@@ skipping 10 matching lines @@
 /// annotations correspond to the correct element.
 class _ElementAnnotationProcessor implements AnnotationProcessor {
   Compiler _compiler;
 
   _ElementAnnotationProcessor(this._compiler);
 
   CommonElements get _commonElements => _compiler.resolution.commonElements;
 
   /// Check whether [cls] has a `@Native(...)` annotation, and if so, set its
   /// native name from the annotation.
-  void extractNativeAnnotations(
-      LibraryElement library, NativeBasicDataBuilder nativeBasicDataBuilder) {
+  void extractNativeAnnotations(covariant LibraryElement library,
+      NativeBasicDataBuilder nativeBasicDataBuilder) {
     library.forEachLocalMember((Element element) {
       if (element.isClass) {
         EagerAnnotationHandler.checkAnnotation(_compiler, element,
             new NativeAnnotationHandler(nativeBasicDataBuilder));
       }
     });
   }
 
-  void extractJsInteropAnnotations(
-      LibraryElement library, NativeBasicDataBuilder nativeBasicDataBuilder) {
+  void extractJsInteropAnnotations(covariant LibraryElement library,
+      NativeBasicDataBuilder nativeBasicDataBuilder) {
     bool checkJsInteropAnnotation(Element element) {
       return EagerAnnotationHandler.checkAnnotation(
           _compiler, element, const JsInteropAnnotationHandler());
     }
 
     if (checkJsInteropAnnotation(library)) {
       nativeBasicDataBuilder.markAsJsInteropLibrary(library);
     }
     library.forEachLocalMember((Element element) {
       if (element.isClass) {
@@ skipping 141 matching lines @@
               });
             } else {
               checkFunctionParameters(fn);
             }
           }
         });
       });
     }
 
     _compiler.libraryLoader.libraries
-        .forEach(processJsInteropAnnotationsInLibrary);
+        .forEach((LibraryEntity l) => processJsInteropAnnotationsInLibrary(l));
   }
 }
 
 /// Builder that creates work item necessary for the resolution of a
 /// [MemberElement].
 class ResolutionWorkItemBuilder extends WorkItemBuilder {
   final Resolution _resolution;
 
   ResolutionWorkItemBuilder(this._resolution);
 
   @override
   WorkItem createWorkItem(MemberElement element) {
     assert(element.isDeclaration, failedAt(element));
     if (element.isMalformed) return null;
 
     assert(element is AnalyzableElement,
         failedAt(element, 'Element $element is not analyzable.'));
     return _resolution.createWorkItem(element);
   }
 }