All strong mode cleaning of dart2js.

pkg/compiler/lib/src/elements/types.dart

 // Copyright (c) 2016, 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 '../common_elements.dart';
 import '../util/util.dart' show equalElements;
 import 'entities.dart';
 
 /// Hierarchy to describe types in Dart.
 ///
@@ skipping 107 matching lines @@
   }
 
   bool get treatAsRaw {
     for (DartType type in typeArguments) {
       if (!type.treatAsDynamic) return false;
     }
     return true;
   }
 
   @override
-  R accept<R, A>(DartTypeVisitor visitor, A argument) =>
+  R accept<R, A>(DartTypeVisitor<R, A> visitor, A argument) =>
       visitor.visitInterfaceType(this, argument);
 
   int get hashCode {
     int hash = element.hashCode;
     for (DartType argument in typeArguments) {
       int argumentHash = argument != null ? argument.hashCode : 0;
       hash = 17 * hash + 3 * argumentHash;
     }
     return hash;
   }
@@ skipping 44 matching lines @@
     }
     int index = parameters.indexOf(this);
     if (index != -1) {
       return arguments[index];
     }
     // The type variable was not substituted.
     return this;
   }
 
   @override
-  R accept<R, A>(DartTypeVisitor visitor, A argument) =>
+  R accept<R, A>(DartTypeVisitor<R, A> visitor, A argument) =>
       visitor.visitTypeVariableType(this, argument);
 
   int get hashCode => 17 * element.hashCode;
 
   bool operator ==(other) {
     if (other is! TypeVariableType) return false;
     return identical(other.element, element);
   }
 
   String toString() => '${element.typeDeclaration.name}.${element.name}';
 }
 
 class VoidType extends DartType {
   const VoidType();
 
   bool get isVoid => true;
 
   DartType subst(List<DartType> arguments, List<DartType> parameters) {
     // `void` cannot be substituted.
     return this;
   }
 
   @override
-  R accept<R, A>(DartTypeVisitor visitor, A argument) =>
+  R accept<R, A>(DartTypeVisitor<R, A> visitor, A argument) =>
       visitor.visitVoidType(this, argument);
 
   int get hashCode => 6007;
 
   String toString() => 'void';
 }
 
 class DynamicType extends DartType {
   const DynamicType();
 
   @override
   bool get isDynamic => true;
 
   @override
   bool get treatAsDynamic => true;
 
   DartType subst(List<DartType> arguments, List<DartType> parameters) {
     // `dynamic` cannot be substituted.
     return this;
   }
 
   @override
-  R accept<R, A>(DartTypeVisitor visitor, A argument) =>
+  R accept<R, A>(DartTypeVisitor<R, A> visitor, A argument) =>
       visitor.visitDynamicType(this, argument);
 
   int get hashCode => 91;
 
   String toString() => 'dynamic';
 }
 
 class FunctionType extends DartType {
   final DartType returnType;
   final List<DartType> parameterTypes;
@@ skipping 51 matching lines @@
     }
     if (changed) {
       // Create a new type only if necessary.
       return new FunctionType(newReturnType, newParameterTypes,
           newOptionalParameterTypes, namedParameters, newNamedParameterTypes);
     }
     return this;
   }
 
   @override
-  R accept<R, A>(DartTypeVisitor visitor, A argument) =>
+  R accept<R, A>(DartTypeVisitor<R, A> visitor, A argument) =>
       visitor.visitFunctionType(this, argument);
 
   int get hashCode {
     int hash = 3 * returnType.hashCode;
     for (DartType parameter in parameterTypes) {
       hash = 17 * hash + 5 * parameter.hashCode;
     }
     for (DartType parameter in optionalParameterTypes) {
       hash = 19 * hash + 7 * parameter.hashCode;
     }
@@ skipping 80 matching lines @@
     }
     return argument;
   });
   // Use the new List only if necessary.
   return changed ? result : types;
 }
 
 abstract class DartTypeVisitor<R, A> {
   const DartTypeVisitor();
 
-  R visit(DartType type, A argument) => type.accept(this, argument);
+  R visit(covariant DartType type, A argument) => type.accept(this, argument);
 
-  R visitVoidType(VoidType type, A argument) => null;
+  R visitVoidType(covariant VoidType type, A argument) => null;
 
-  R visitTypeVariableType(TypeVariableType type, A argument) => null;
+  R visitTypeVariableType(covariant TypeVariableType type, A argument) => null;
 
-  R visitFunctionType(FunctionType type, A argument) => null;
+  R visitFunctionType(covariant FunctionType type, A argument) => null;
 
-  R visitInterfaceType(InterfaceType type, A argument) => null;
+  R visitInterfaceType(covariant InterfaceType type, A argument) => null;
 
-  R visitDynamicType(DynamicType type, A argument) => null;
+  R visitDynamicType(covariant DynamicType type, A argument) => null;
 }
 
 abstract class BaseDartTypeVisitor<R, A> extends DartTypeVisitor<R, A> {
   const BaseDartTypeVisitor();
 
-  R visitType(DartType type, A argument);
+  R visitType(covariant DartType type, A argument);
 
   @override
-  R visitVoidType(VoidType type, A argument) => visitType(type, argument);
-
-  @override
-  R visitTypeVariableType(TypeVariableType type, A argument) =>
+  R visitVoidType(covariant VoidType type, A argument) =>
       visitType(type, argument);
 
   @override
-  R visitFunctionType(FunctionType type, A argument) =>
+  R visitTypeVariableType(covariant TypeVariableType type, A argument) =>
       visitType(type, argument);
 
   @override
-  R visitInterfaceType(InterfaceType type, A argument) =>
+  R visitFunctionType(covariant FunctionType type, A argument) =>
       visitType(type, argument);
 
   @override
-  R visitDynamicType(DynamicType type, A argument) => visitType(type, argument);
+  R visitInterfaceType(covariant InterfaceType type, A argument) =>
+      visitType(type, argument);
+
+  @override
+  R visitDynamicType(covariant DynamicType type, A argument) =>
+      visitType(type, argument);
 }
 
 /// Abstract visitor for determining relations between types.
-abstract class AbstractTypeRelation
-    extends BaseDartTypeVisitor<bool, DartType> {
+abstract class AbstractTypeRelation<T extends DartType>
+    extends BaseDartTypeVisitor<bool, T> {
   CommonElements get commonElements;
 
   /// Ensures that the super hierarchy of [type] is computed.
   void ensureResolved(InterfaceType type) {}
 
   /// Returns the unaliased version of [type].
-  DartType getUnaliased(DartType type) => type.unaliased;
+  T getUnaliased(T type) => type.unaliased;
 
   /// Returns [type] as an instance of [cls], or `null` if [type] is not subtype
   /// if [cls].
   InterfaceType asInstanceOf(InterfaceType type, ClassEntity cls);
 
   /// Returns the type of the `call` method on [type], or `null` if the class
   /// of [type] does not have a `call` method.
   FunctionType getCallType(InterfaceType type);
 
   /// Returns the declared bound of [element].
   DartType getTypeVariableBound(TypeVariableEntity element);
 
-  bool visitType(DartType t, DartType s) {
+  bool visitType(T t, T s) {
     throw 'internal error: unknown type ${t}';
   }
 
-  bool visitVoidType(VoidType t, DartType s) {
+  bool visitVoidType(VoidType t, T s) {
     assert(s is! VoidType);
     return false;
   }
 
-  bool invalidTypeArguments(DartType t, DartType s);
+  bool invalidTypeArguments(T t, T s);
 
-  bool invalidFunctionReturnTypes(DartType t, DartType s);
+  bool invalidFunctionReturnTypes(T t, T s);
 
-  bool invalidFunctionParameterTypes(DartType t, DartType s);
+  bool invalidFunctionParameterTypes(T t, T s);
 
-  bool invalidTypeVariableBounds(DartType bound, DartType s);
+  bool invalidTypeVariableBounds(T bound, T s);
 
-  bool invalidCallableType(DartType callType, DartType s);
+  bool invalidCallableType(covariant DartType callType, covariant DartType s);
 
-  bool visitInterfaceType(InterfaceType t, DartType s) {
+  bool visitInterfaceType(InterfaceType t, covariant DartType s) {
     ensureResolved(t);
 
     bool checkTypeArguments(InterfaceType instance, InterfaceType other) {
-      List<DartType> tTypeArgs = instance.typeArguments;
-      List<DartType> sTypeArgs = other.typeArguments;
+      List<T> tTypeArgs = instance.typeArguments;
+      List<T> sTypeArgs = other.typeArguments;
       assert(tTypeArgs.length == sTypeArgs.length);
       for (int i = 0; i < tTypeArgs.length; i++) {
         if (invalidTypeArguments(tTypeArgs[i], sTypeArgs[i])) {
           return false;
         }
       }
       return true;
     }
 
     if (s is InterfaceType) {
@@ skipping 25 matching lines @@
     }
 
     // TODO(johnniwinther): Rewrite the function subtyping to be more readable
     // but still as efficient.
 
     // For the comments we use the following abbreviations:
     //  x.p     : parameterTypes on [:x:],
     //  x.o     : optionalParameterTypes on [:x:], and
     //  len(xs) : length of list [:xs:].
 
-    Iterator<DartType> tps = tf.parameterTypes.iterator;
-    Iterator<DartType> sps = sf.parameterTypes.iterator;
+    Iterator<T> tps = tf.parameterTypes.iterator;
+    Iterator<T> sps = sf.parameterTypes.iterator;
     bool sNotEmpty = sps.moveNext();
     bool tNotEmpty = tps.moveNext();
     tNext() => (tNotEmpty = tps.moveNext());
     sNext() => (sNotEmpty = sps.moveNext());
 
     bool incompatibleParameters() {
       while (tNotEmpty && sNotEmpty) {
         if (invalidFunctionParameterTypes(tps.current, sps.current)) {
           return true;
         }
@@ skipping 10 matching lines @@
     }
     if (!sf.namedParameters.isEmpty) {
       // We must have [: len(t.p) == len(s.p) :].
       if (sNotEmpty) {
         return false;
       }
       // Since named parameters are globally ordered we can determine the
       // subset relation with a linear search for [:sf.namedParameters:]
       // within [:tf.namedParameters:].
       List<String> tNames = tf.namedParameters;
-      List<DartType> tTypes = tf.namedParameterTypes;
+      List<T> tTypes = tf.namedParameterTypes;
       List<String> sNames = sf.namedParameters;
-      List<DartType> sTypes = sf.namedParameterTypes;
+      List<T> sTypes = sf.namedParameterTypes;
       int tIndex = 0;
       int sIndex = 0;
       while (tIndex < tNames.length && sIndex < sNames.length) {
         if (tNames[tIndex] == sNames[sIndex]) {
           if (invalidFunctionParameterTypes(tTypes[tIndex], sTypes[sIndex])) {
             return false;
           }
           sIndex++;
         }
         tIndex++;
@@ skipping 24 matching lines @@
       } else {
         if (sNotEmpty) {
           // We must have [: len(t.p) + len(t.o) >= len(s.p) :].
           return false;
         }
       }
     }
     return true;
   }
 
-  bool visitTypeVariableType(TypeVariableType t, DartType s) {
+  bool visitTypeVariableType(TypeVariableType t, T s) {
     // Identity check is handled in [isSubtype].
     DartType bound = getTypeVariableBound(t.element);
     if (bound.isTypeVariable) {
       // The bound is potentially cyclic so we need to be extra careful.
       Set<TypeVariableEntity> seenTypeVariables = new Set<TypeVariableEntity>();
       seenTypeVariables.add(t.element);
       while (bound.isTypeVariable) {
         TypeVariableType typeVariable = bound;
         if (bound == s) {
           // [t] extends [s].
           return true;
         }
         if (seenTypeVariables.contains(typeVariable.element)) {
           // We have a cycle and have already checked all bounds in the cycle
           // against [s] and can therefore conclude that [t] is not a subtype
           // of [s].
           return false;
         }
         seenTypeVariables.add(typeVariable.element);
         bound = getTypeVariableBound(typeVariable.element);
       }
     }
     if (invalidTypeVariableBounds(bound, s)) return false;
     return true;
   }
 }
 
-abstract class MoreSpecificVisitor extends AbstractTypeRelation {
-  bool isMoreSpecific(DartType t, DartType s) {
+abstract class MoreSpecificVisitor<T extends DartType>
+    extends AbstractTypeRelation<T> {
+  bool isMoreSpecific(T t, T s) {
     if (identical(t, s) || s.treatAsDynamic || t == commonElements.nullType) {
       return true;
     }
     if (t.isVoid || s.isVoid) {
       return false;
     }
     if (t.treatAsDynamic) {
       return false;
     }
     if (s == commonElements.objectType) {
       return true;
     }
     t = getUnaliased(t);
     s = getUnaliased(s);
 
     return t.accept(this, s);
   }
 
-  bool invalidTypeArguments(DartType t, DartType s) {
+  bool invalidTypeArguments(T t, T s) {
     return !isMoreSpecific(t, s);
   }
 
-  bool invalidFunctionReturnTypes(DartType t, DartType s) {
+  bool invalidFunctionReturnTypes(T t, T s) {
     if (s.treatAsDynamic && t.isVoid) return true;
     return !s.isVoid && !isMoreSpecific(t, s);
   }
 
-  bool invalidFunctionParameterTypes(DartType t, DartType s) {
+  bool invalidFunctionParameterTypes(T t, T s) {
     return !isMoreSpecific(t, s);
   }
 
-  bool invalidTypeVariableBounds(DartType bound, DartType s) {
+  bool invalidTypeVariableBounds(T bound, T s) {
     return !isMoreSpecific(bound, s);
   }
 
-  bool invalidCallableType(DartType callType, DartType s) {
+  bool invalidCallableType(covariant DartType callType, covariant DartType s) {
     return !isMoreSpecific(callType, s);
   }
 }
 
 /// Type visitor that determines the subtype relation two types.
-abstract class SubtypeVisitor extends MoreSpecificVisitor {
-  bool isSubtype(DartType t, DartType s) {
+abstract class SubtypeVisitor<T extends DartType>
+    extends MoreSpecificVisitor<T> {
+  bool isSubtype(T t, T s) {
     return t.treatAsDynamic || isMoreSpecific(t, s);
   }
 
-  bool isAssignable(DartType t, DartType s) {
+  bool isAssignable(T t, T s) {
     return isSubtype(t, s) || isSubtype(s, t);
   }
 
-  bool invalidTypeArguments(DartType t, DartType s) {
+  bool invalidTypeArguments(T t, T s) {
     return !isSubtype(t, s);
   }
 
-  bool invalidFunctionReturnTypes(DartType t, DartType s) {
+  bool invalidFunctionReturnTypes(T t, T s) {
     return !s.isVoid && !isAssignable(t, s);
   }
 
-  bool invalidFunctionParameterTypes(DartType t, DartType s) {
+  bool invalidFunctionParameterTypes(T t, T s) {
     return !isAssignable(t, s);
   }
 
-  bool invalidTypeVariableBounds(DartType bound, DartType s) {
+  bool invalidTypeVariableBounds(T bound, T s) {
     return !isSubtype(bound, s);
   }
 
-  bool invalidCallableType(DartType callType, DartType s) {
+  bool invalidCallableType(covariant DartType callType, covariant DartType s) {
     return !isSubtype(callType, s);
   }
 }
 
 /// Type visitor that determines one type could a subtype of another given the
 /// right type variable substitution. The computation is approximate and returns
 /// `false` only if we are sure no such substitution exists.
-abstract class PotentialSubtypeVisitor extends SubtypeVisitor {
-  bool isSubtype(DartType t, DartType s) {
+abstract class PotentialSubtypeVisitor<T extends DartType>
+    extends SubtypeVisitor<T> {
+  bool isSubtype(T t, T s) {
     if (t is TypeVariableType || s is TypeVariableType) {
       return true;
     }
     return super.isSubtype(t, s);
   }
 }
 
 /// Basic interface for the Dart type system.
 abstract class DartTypes {
   /// The types defined in 'dart:core'.
@@ skipping 71 matching lines @@
     // include a runtime value for method type variables this must be updated.
     // For full support the global assumption that all type variables are
     // declared by the same enclosing class will not hold: Both an enclosing
     // method and an enclosing class may define type variables, so the return
     // type cannot be [ClassElement] and the caller must be prepared to look in
     // two locations, not one. Currently we ignore method type variables by
     // returning in the next statement.
     return contextClass;
   }
 }