fix #27259, implement covariance checking for strong mode and DDC

pkg/analyzer/lib/src/dart/element/type.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.
 
 library analyzer.src.dart.element.type;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 700 matching lines @@
   bool operator ==(Object object) {
     if (object is FunctionTypeImpl) {
       if (typeFormals.length != object.typeFormals.length) {
         return false;
       }
       // `<T>T -> T` should be equal to `<U>U -> U`
       // To test this, we instantiate both types with the same (unique) type
       // variables, and see if the result is equal.
       if (typeFormals.isNotEmpty) {
         List<DartType> freshVariables =
-            relateTypeFormals(this, object, (t, s) => t == s);
+            relateTypeFormals(this, object, (t, s, _, __) => t == s);
         if (freshVariables == null) {
           return false;
         }
         return instantiate(freshVariables) ==
             object.instantiate(freshVariables);
       }
 
       return returnType == object.returnType &&
           TypeImpl.equalArrays(
               normalParameterTypes, object.normalParameterTypes) &&
@@ skipping 156 matching lines @@
   }
 
   @override
   bool isMoreSpecificThan(DartType type,
       [bool withDynamic = false, Set<Element> visitedElements]) {
     // Note: visitedElements is only used for breaking recursion in the type
     // hierarchy; we don't use it when recursing into the function type.
     return relate(
         this,
         type,
-        (DartType t, DartType s, _, __) =>
+        (DartType t, DartType s) =>
             (t as TypeImpl).isMoreSpecificThan(s, withDynamic),
         new TypeSystemImpl(null).instantiateToBounds);
   }
 
   @override
   bool isSubtypeOf(DartType type) {
     var typeSystem = new TypeSystemImpl(null);
     return relate(
         typeSystem.instantiateToBounds(this),
         typeSystem.instantiateToBounds(type),
-        (DartType t, DartType s, _, __) => t.isAssignableTo(s),
+        (DartType t, DartType s) => t.isAssignableTo(s),
         typeSystem.instantiateToBounds);
   }
 
   @override
   FunctionTypeImpl pruned(List<FunctionTypeAliasElement> prune) {
     if (prune == null) {
       return this;
     } else if (prune.contains(element)) {
       // Circularity found.  Prune the type declaration.
       return new CircularFunctionTypeImpl();
@@ skipping 149 matching lines @@
 
   /**
    * Compares two function types [t] and [s] to see if their corresponding
    * parameter types match [parameterRelation] and their return types match
    * [returnRelation].
    *
    * Used for the various relations on function types which have the same
    * structural rules for handling optional parameters and arity, but use their
    * own relation for comparing corresponding parameters or return types.
    *
-   * If [returnRelation] is omitted, uses [parameterRelation] for both.
+   * If [parameterRelation] is omitted, uses [returnRelation] for both. This
+   * is convenient for Dart 1 type system methods.
    */
   static bool relate(
       FunctionType t,
       DartType other,
-      bool parameterRelation(
-          DartType t, DartType s, bool tIsCovariant, bool sIsCovariant),
+      bool returnRelation(DartType t, DartType s),
       DartType instantiateToBounds(DartType t),
-      {bool returnRelation(DartType t, DartType s)}) {
-    returnRelation ??= (t, s) => parameterRelation(t, s, false, false);
+      {bool parameterRelation(ParameterElement t, ParameterElement s)}) {
+    parameterRelation ??= (t, s) => returnRelation(t.type, s.type);
 
     // Trivial base cases.
     if (other == null) {
       return false;
     } else if (identical(t, other) ||
         other.isDynamic ||
         other.isDartCoreFunction ||
         other.isObject) {
       return true;
     } else if (other is! FunctionType) {
       return false;
     }
 
     // This type cast is safe, because we checked it above.
     FunctionType s = other as FunctionType;
     if (t.typeFormals.isNotEmpty) {
-      List<DartType> freshVariables = relateTypeFormals(t, s, returnRelation);
+      List<DartType> freshVariables =
+          relateTypeFormals(t, s, (s, t, _, __) => returnRelation(s, t));
       if (freshVariables == null) {
         return false;
       }
       t = t.instantiate(freshVariables);
       s = s.instantiate(freshVariables);
     } else if (s.typeFormals.isNotEmpty) {
       return false;
     }
 
     // Test the return types.
     DartType sRetType = s.returnType;
     if (!sRetType.isVoid && !returnRelation(t.returnType, sRetType)) {
       return false;
     }
 
     // Test the parameter types.
+    return relateParameters(t.parameters, s.parameters, parameterRelation);
+  }
 
+  /**
+   * Compares parameters [tParams] and [sParams] of two function types, taking
+   * corresponding parameters from the lists, and see if they match
+   * [parameterRelation].
+   *
+   * Corresponding parameters are defined as a pair `(t, s)` where `t` is a
+   * parameter from [tParams] and `s` is a parameter from [sParams], and both
+   * `t` and `s` are at the same position (for positional parameters)
+   * or have the same name (for named parameters).
+   * 
+   * Used for the various relations on function types which have the same
+   * structural rules for handling optional parameters and arity, but use their
+   * own relation for comparing the parameters.
+   */
+  static bool relateParameters(
+      List<ParameterElement> tParams,
+      List<ParameterElement> sParams,
+      bool parameterRelation(ParameterElement t, ParameterElement s)) {
     // TODO(jmesserly): this could be implemented with less allocation if we
     // wanted, by taking advantage of the fact that positional arguments must
     // appear before named ones.
     var tRequired = <ParameterElement>[];
     var tOptional = <ParameterElement>[];
     var tNamed = <String, ParameterElement>{};
-    for (var p in t.parameters) {
+    for (var p in tParams) {
       var kind = p.parameterKind;
       if (kind == ParameterKind.REQUIRED) {
         tRequired.add(p);
       } else if (kind == ParameterKind.POSITIONAL) {
         tOptional.add(p);
       } else {
         assert(kind == ParameterKind.NAMED);
         tNamed[p.name] = p;
       }
     }
 
     var sRequired = <ParameterElement>[];
     var sOptional = <ParameterElement>[];
     var sNamed = <String, ParameterElement>{};
-    for (var p in s.parameters) {
+    for (var p in sParams) {
       var kind = p.parameterKind;
       if (kind == ParameterKind.REQUIRED) {
         sRequired.add(p);
       } else if (kind == ParameterKind.POSITIONAL) {
         sOptional.add(p);
       } else {
         assert(kind == ParameterKind.NAMED);
         sNamed[p.name] = p;
       }
     }
@@ skipping 12 matching lines @@
     }
 
     // For each named parameter in s, make sure we have a corresponding one
     // that relates.
     for (String key in sNamed.keys) {
       var tParam = tNamed[key];
       if (tParam == null) {
         return false;
       }
       var sParam = sNamed[key];
-      if (!parameterRelation(
-          tParam.type, sParam.type, tParam.isCovariant, sParam.isCovariant)) {
+      if (!parameterRelation(tParam, sParam)) {
         return false;
       }
     }
 
     // Make sure all of the positional parameters (both required and optional)
     // relate to each other.
     var tPositional = tRequired;
     var sPositional = sRequired;
 
     if (tOptional.isNotEmpty) {
       tPositional = tPositional.toList()..addAll(tOptional);
     }
 
     if (sOptional.isNotEmpty) {
       sPositional = sPositional.toList()..addAll(sOptional);
     }
 
     // Check that s has enough required parameters.
     if (sRequired.length < tRequired.length) {
       return false;
     }
 
     // Check that s does not include more positional parameters than we do.
     if (tPositional.length < sPositional.length) {
       return false;
     }
 
     for (int i = 0; i < sPositional.length; i++) {
-      var tParam = tPositional[i];
-      var sParam = sPositional[i];
-      if (!parameterRelation(
-          tParam.type, sParam.type, tParam.isCovariant, sParam.isCovariant)) {
+      if (!parameterRelation(tPositional[i], sPositional[i])) {
         return false;
       }
     }
 
     return true;
   }
 
   /**
    * Given two functions [f1] and [f2] where f1 and f2 are known to be
    * generic function types (both have type formals), this checks that they
    * have the same number of formals, and that those formals have bounds
    * (e.g. `<T extends LowerBound>`) that satisfy [relation].
    *
    * The return value will be a new list of fresh type variables, that can be
    * used to instantiate both function types, allowing further comparison.
    * For example, given `<T>T -> T` and `<U>U -> U` we can instantiate them with
    * `F` to get `F -> F` and `F -> F`, which we can see are equal.
    */
   static List<DartType> relateTypeFormals(
-      FunctionType f1, FunctionType f2, bool relation(DartType t, DartType s)) {
+      FunctionType f1,
+      FunctionType f2,
+      bool relation(DartType bound2, DartType bound1,
+          TypeParameterElement formal2, TypeParameterElement formal1)) {
     List<TypeParameterElement> params1 = f1.typeFormals;
     List<TypeParameterElement> params2 = f2.typeFormals;
     int count = params1.length;
     if (params2.length != count) {
       return null;
     }
     // We build up a substitution matching up the type parameters
     // from the two types, {variablesFresh/variables1} and
     // {variablesFresh/variables2}
     List<DartType> variables1 = <DartType>[];
@@ skipping 10 matching lines @@
       DartType variableFresh = new TypeParameterTypeImpl(pFresh);
 
       variables1.add(variable1);
       variables2.add(variable2);
       variablesFresh.add(variableFresh);
       DartType bound1 = p1.bound ?? DynamicTypeImpl.instance;
       DartType bound2 = p2.bound ?? DynamicTypeImpl.instance;
       bound1 = bound1.substitute2(variablesFresh, variables1);
       bound2 = bound2.substitute2(variablesFresh, variables2);
       pFresh.bound = bound2;
-      if (!relation(bound2, bound1)) {
+      if (!relation(bound2, bound1, p2, p1)) {
         return null;
       }
     }
     return variablesFresh;
   }
 
   /**
    * Return `true` if all of the name/type pairs in the first map ([firstTypes])
    * are equal to the corresponding name/type pairs in the second map
    * ([secondTypes]). The maps are expected to iterate over their entries in the
@@ skipping 1666 matching lines @@
 
   @override
   TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
 
   @override
   VoidTypeImpl substitute2(
           List<DartType> argumentTypes, List<DartType> parameterTypes,
           [List<FunctionTypeAliasElement> prune]) =>
       this;
 }