All strong mode cleaning of dart2js.

pkg/compiler/lib/src/js_backend/runtime_types.dart

 // Copyright (c) 2013, 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 js_backend.runtime_types;
 
 import '../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../elements/elements.dart' show ClassElement;
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart'
@@ skipping 219 matching lines @@
   final Set<ClassEntity> classesUsingTypeVariableExpression;
 
   _RuntimeTypesNeed(
       this._elementEnvironment,
       this._backendUsage,
       this.classesNeedingRti,
       this.methodsNeedingRti,
       this.localFunctionsNeedingRti,
       this.classesUsingTypeVariableExpression);
 
-  bool checkClass(ClassEntity cls) => true;
+  bool checkClass(covariant ClassEntity cls) => true;
 
   bool classNeedsRti(ClassEntity cls) {
     assert(checkClass(cls));
     if (_backendUsage.isRuntimeTypeUsed) return true;
     return classesNeedingRti.contains(cls);
   }
 
   bool classNeedsRtiField(ClassEntity cls) {
     assert(checkClass(cls));
     if (!_elementEnvironment.isGenericClass(cls)) return false;
@@ skipping 42 matching lines @@
 
   final Map<ClassEntity, Set<ClassEntity>> rtiDependencies =
       <ClassEntity, Set<ClassEntity>>{};
 
   final Set<ClassEntity> classesUsingTypeVariableExpression =
       new Set<ClassEntity>();
 
   RuntimeTypesNeedBuilderImpl(this._elementEnvironment, DartTypes types)
       : super(types);
 
-  bool checkClass(ClassEntity cls) => true;
+  bool checkClass(covariant ClassEntity cls) => true;
 
   @override
   void registerClassUsingTypeVariableExpression(ClassEntity cls) {
     classesUsingTypeVariableExpression.add(cls);
   }
 
   @override
   void registerRtiDependency(ClassEntity element, ClassEntity dependency) {
     // We're not dealing with typedef for now.
     assert(element != null);
@@ skipping 524 matching lines @@
     jsAst.Expression encoding =
         getTypeRepresentation(emitter, type, onVariable);
     if (contextClass == null && !alwaysGenerateFunction) {
       return encoding;
     } else {
       List<String> parameters = const <String>[];
       if (contextClass != null) {
         parameters = _elementEnvironment
             .getThisType(contextClass)
             .typeArguments
-            .map((TypeVariableType type) {
+            .map((DartType _type) {
+          TypeVariableType type = _type;
           return type.element.name;
         }).toList();
       }
       return js('function(#) { return # }', [parameters, encoding]);
     }
   }
 
   @override
   jsAst.Expression getSignatureEncoding(
       Emitter emitter, DartType type, jsAst.Expression this_) {
@@ skipping 85 matching lines @@
     // TODO(sra): Since the result string is used only in constructing constant
     // names, it would result in more readable names if the final string was a
     // legal JavaScript identifer.
     if (interface.typeArguments.isEmpty) return name;
     String arguments =
         new List.filled(interface.typeArguments.length, 'dynamic').join(', ');
     return '$name<$arguments>';
   }
 }
 
-class TypeRepresentationGenerator implements ResolutionDartTypeVisitor {
+class TypeRepresentationGenerator
+    implements ResolutionDartTypeVisitor<dynamic, Emitter> {
   final Namer namer;
   OnVariableCallback onVariable;
   ShouldEncodeTypedefCallback shouldEncodeTypedef;
   Map<TypeVariableType, jsAst.Expression> typedefBindings;
 
   TypeRepresentationGenerator(this.namer);
 
   /**
    * Creates a type representation for [type]. [onVariable] is called to provide
    * the type representation for type variables.
@@ skipping 207 matching lines @@
     StringBuffer sb = new StringBuffer();
     for (ClassEntity holder in classes) {
       for (ClassEntity check in [holder]) {
         sb.write('${holder.name}.' '${check.name}, ');
       }
     }
     return '[$sb]';
   }
 }
 
-class ArgumentCollector extends ResolutionDartTypeVisitor {
+class ArgumentCollector extends ResolutionDartTypeVisitor<dynamic, bool> {
   final Set<ClassEntity> classes = new Set<ClassEntity>();
 
   collect(DartType type, {bool isTypeArgument: false}) {
     visit(type, isTypeArgument);
   }
 
   /// Collect all types in the list as if they were arguments of an
   /// InterfaceType.
   collectAll(List<DartType> types, {bool isTypeArgument: false}) {
     for (DartType type in types) {
@@ skipping 11 matching lines @@
   }
 
   visitFunctionType(FunctionType type, _) {
     collect(type.returnType, isTypeArgument: true);
     collectAll(type.parameterTypes, isTypeArgument: true);
     collectAll(type.optionalParameterTypes, isTypeArgument: true);
     collectAll(type.namedParameterTypes, isTypeArgument: true);
   }
 }
 
-class FunctionArgumentCollector extends ResolutionDartTypeVisitor {
+class FunctionArgumentCollector
+    extends ResolutionDartTypeVisitor<dynamic, bool> {
   final Set<ClassEntity> classes = new Set<ClassEntity>();
 
   FunctionArgumentCollector();
 
   collect(DartType type, {bool inFunctionType: false}) {
     visit(type, inFunctionType);
   }
 
   collectAll(List<DartType> types, {bool inFunctionType: false}) {
     for (DartType type in types) {
@@ skipping 47 matching lines @@
  * substition for this check.
  */
 class TypeCheck {
   final ClassEntity cls;
   final Substitution substitution;
   final int hashCode = _nextHash = (_nextHash + 100003).toUnsigned(30);
   static int _nextHash = 0;
 
   TypeCheck(this.cls, this.substitution);
 }