All strong mode cleaning of dart2js.

pkg/compiler/lib/src/native/resolver.dart

 // Copyright (c) 2014, 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.
 
 import 'package:front_end/src/fasta/scanner.dart' show StringToken, Token;
 import 'package:front_end/src/fasta/scanner.dart' as Tokens show EOF_TOKEN;
 import 'package:front_end/src/scanner/token.dart' show BeginToken;
 
 import '../common.dart';
 import '../common_elements.dart' show CommonElements, ElementEnvironment;
@@ skipping 62 matching lines @@
 }
 
 abstract class NativeMemberResolverBase implements NativeMemberResolver {
   static final RegExp _identifier = new RegExp(r'^[a-zA-Z_$][a-zA-Z0-9_$]*$');
 
   ElementEnvironment get elementEnvironment;
   CommonElements get commonElements;
   NativeBasicData get nativeBasicData;
   NativeDataBuilder get nativeDataBuilder;
 
-  bool isJsInteropMember(MemberEntity element);
-  bool isNativeMethod(FunctionEntity element);
+  bool isJsInteropMember(covariant MemberEntity element);
+  bool isNativeMethod(covariant FunctionEntity element);
 
-  NativeBehavior computeNativeMethodBehavior(FunctionEntity function,
+  NativeBehavior computeNativeMethodBehavior(covariant FunctionEntity function,
       {bool isJsInterop});
-  NativeBehavior computeNativeFieldLoadBehavior(FieldEntity field,
+  NativeBehavior computeNativeFieldLoadBehavior(covariant FieldEntity field,
       {bool isJsInterop});
-  NativeBehavior computeNativeFieldStoreBehavior(FieldEntity field);
+  NativeBehavior computeNativeFieldStoreBehavior(covariant FieldEntity field);
 
   @override
   void resolveNativeMember(MemberEntity element, [NativeRegistry registry]) {
     bool isJsInterop = isJsInteropMember(element);
     if (element.isFunction ||
         element.isConstructor ||
         element.isGetter ||
         element.isSetter) {
       FunctionEntity method = element;
       bool isNative = _processMethodAnnotations(method);
@@ skipping 20 matching lines @@
         // only get one look at each member and there might be a load or store
         // we have not seen yet.
         registry?.registerNativeData(fieldLoadBehavior);
         registry?.registerNativeData(fieldStoreBehavior);
       }
     }
   }
 
   /// Process the potentially native [field]. Adds information from metadata
   /// attributes. Returns `true` of [method] is native.
-  bool _processFieldAnnotations(FieldEntity element) {
+  bool _processFieldAnnotations(covariant FieldEntity element) {
     if (element.isInstanceMember &&
         nativeBasicData.isNativeClass(element.enclosingClass)) {
       // Exclude non-instance (static) fields - they are not really native and
       // are compiled as isolate globals.  Access of a property of a constructor
       // function or a non-method property in the prototype chain, must be coded
       // using a JS-call.
       _setNativeName(element);
       return true;
     }
     return false;
   }
 
   /// Process the potentially native [method]. Adds information from metadata
   /// attributes. Returns `true` of [method] is native.
-  bool _processMethodAnnotations(FunctionEntity method) {
+  bool _processMethodAnnotations(covariant FunctionEntity method) {
     if (isNativeMethod(method)) {
       if (method.isStatic) {
         _setNativeNameForStaticMethod(method);
       } else {
         _setNativeName(method);
       }
       return true;
     }
     return false;
   }
@@ skipping 271 matching lines @@
       LibraryEntity library, Set<ClassEntity> nativeClasses) {
     _elementEnvironment.forEachClass(library, (ClassEntity cls) {
       if (_nativeBasicData.isNativeClass(cls)) {
         _processNativeClass(cls, nativeClasses);
       }
     });
   }
 
   /// Adds [cls] to [nativeClasses] and performs further processing of [cls],
   /// if necessary.
-  void _processNativeClass(ClassEntity cls, Set<ClassEntity> nativeClasses) {
+  void _processNativeClass(
+      covariant ClassEntity cls, Set<ClassEntity> nativeClasses) {
     nativeClasses.add(cls);
     // Js Interop interfaces do not have tags.
     if (_nativeBasicData.isJsInteropClass(cls)) return;
     // Since we map from dispatch tags to classes, a dispatch tag must be used
     // on only one native class.
     for (String tag in _nativeBasicData.getNativeTagsOfClass(cls)) {
       ClassEntity owner = _tagOwner[tag];
       if (owner != null) {
         if (owner != cls) {
           throw new SpannableAssertionFailure(
               cls, "Tag '$tag' already in use by '${owner.name}'");
         }
       } else {
         _tagOwner[tag] = cls;
       }
     }
   }
 
   /// Returns the name of the super class of [cls] or `null` of [cls] has
   /// no explicit superclass.
-  String _findExtendsNameOfClass(ClassEntity cls) {
+  String _findExtendsNameOfClass(covariant ClassEntity cls) {
     return _elementEnvironment
         .getSuperClass(cls, skipUnnamedMixinApplications: true)
         ?.name;
   }
 
   /// Adds all subclasses of [nativeClasses] found in [libraries] to
   /// [nativeClasses].
   void _processSubclassesOfNativeClasses(
       Iterable<LibraryEntity> libraries, Set<ClassEntity> nativeClasses) {
     Set<ClassEntity> nativeClassesAndSubclasses = new Set<ClassEntity>();
@@ skipping 147 matching lines @@
 
   Iterable<ConstantValue> fields = constructedObject.fields.values;
   // TODO(sra): Better validation of the constant.
   if (fields.length != 1 || fields.single is! StringConstantValue) {
     throw new SpannableAssertionFailure(
         spannable, 'Annotations needs one string: ${value.toStructuredText()}');
   }
   StringConstantValue specStringConstant = fields.single;
   return specStringConstant.primitiveValue;
 }