fix #25578, implement @covariant parameter overrides

pkg/analyzer/lib/src/task/strong_mode.dart

 // Copyright (c) 2015, 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.task.strong_mode;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 103 matching lines @@
    * At the moment, this method will only return a type other than 'dynamic' if
    * the types of all of the parameters are the same. In the future we might
    * want to be smarter about it, such as by returning the least upper bound of
    * the parameter types.
    */
   DartType _computeParameterType(ParameterElement parameter, int index,
       List<FunctionType> overriddenTypes) {
     DartType parameterType = null;
     int length = overriddenTypes.length;
     for (int i = 0; i < length; i++) {
-      DartType type = _getTypeOfCorrespondingParameter(
+      ParameterElement matchingParam = _getCorrespondingParameter(
           parameter, index, overriddenTypes[i].parameters);
+      var type = matchingParam?.type ?? typeProvider.dynamicType;
       if (parameterType == null) {
         parameterType = type;
       } else if (parameterType != type) {
         return typeProvider.dynamicType;
       }
     }
     return parameterType ?? typeProvider.dynamicType;
   }
 
   /**
@@ skipping 13 matching lines @@
       if (returnType == null) {
         returnType = type;
       } else if (returnType != type) {
         return typeProvider.dynamicType;
       }
     }
     return returnType ?? typeProvider.dynamicType;
   }
 
   /**
-   * Given a method, return the type of the parameter in the method that
-   * corresponds to the given [parameter]. If the parameter is positional, then
+   * Given a method, return the parameter in the method that corresponds to the
+   * given [parameter]. If the parameter is positional, then
    * it appears at the given [index] in its enclosing element's list of
    * parameters.
    */
-  DartType _getTypeOfCorrespondingParameter(ParameterElement parameter,
+  ParameterElement _getCorrespondingParameter(ParameterElement parameter,
       int index, List<ParameterElement> methodParameters) {
     //
     // Find the corresponding parameter.
     //
-    ParameterElement matchingParameter = null;
     if (parameter.parameterKind == ParameterKind.NAMED) {
       //
       // If we're looking for a named parameter, only a named parameter with
       // the same name will be matched.
       //
-      matchingParameter = methodParameters.lastWhere(
+      return methodParameters.lastWhere(
           (ParameterElement methodParameter) =>
               methodParameter.parameterKind == ParameterKind.NAMED &&
               methodParameter.name == parameter.name,
           orElse: () => null);
-    } else {
-      //
-      // If we're looking for a positional parameter we ignore the difference
-      // between required and optional parameters.
-      //
-      if (index < methodParameters.length) {
-        matchingParameter = methodParameters[index];
-        if (matchingParameter.parameterKind == ParameterKind.NAMED) {
-          matchingParameter = null;
-        }
+    }
+    //
+    // If we're looking for a positional parameter we ignore the difference
+    // between required and optional parameters.
+    //
+    if (index < methodParameters.length) {
+      var matchingParameter = methodParameters[index];
+      if (matchingParameter.parameterKind != ParameterKind.NAMED) {
+        return matchingParameter;
       }
     }
-    //
-    // Then return the type of the parameter.
-    //
-    return matchingParameter == null
-        ? typeProvider.dynamicType
-        : matchingParameter.type;
+    return null;
   }
 
   /**
    * Infer type information for all of the instance members in the given
    * [classElement].
    */
   void _inferClass(ClassElement classElement) {
     if (classElement is ClassElementImpl) {
       if (classElement.hasBeenInferred) {
         return;
@@ skipping 96 matching lines @@
         _updateSyntheticVariableType(element);
       }
     }
     //
     // Infer the parameter types.
     //
     List<ParameterElement> parameters = element.parameters;
     int length = parameters.length;
     for (int i = 0; i < length; ++i) {
       ParameterElement parameter = parameters[i];
-      if (parameter is ParameterElementImpl && parameter.hasImplicitType) {
-        parameter.type = _computeParameterType(parameter, i, overriddenTypes);
-        if (element is PropertyAccessorElement) {
-          _updateSyntheticVariableType(element);
+      if (parameter is ParameterElementImpl) {
+        // If a parameter is covariant, any parameters that override it are too.
+        parameter.inheritsCovariant = overriddenTypes.any((f) {
+          var param = _getCorrespondingParameter(parameter, i, f.parameters);
+          return param != null && param.isCovariant;
+        });
+
+        if (parameter.hasImplicitType) {
+          parameter.type = _computeParameterType(parameter, i, overriddenTypes);
+          if (element is PropertyAccessorElement) {
+            _updateSyntheticVariableType(element);
+          }
         }
       }
     }
   }
 
   /**
    * If the given [fieldElement] represents a non-synthetic instance field for
    * which no type was provided, infer the type of the field.
    */
   void _inferField(FieldElement fieldElement) {
@@ skipping 150 matching lines @@
         results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}