fix #25578, implement @covariant parameter overrides

pkg/analyzer/lib/src/task/strong/checker.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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1103 matching lines @@
       reporter.onError(error);
     }
   }
 }
 
 /// Checks for overriding declarations of fields and methods. This is used to
 /// check overrides between classes and superclasses, interfaces, and mixin
 /// applications.
 class _OverrideChecker {
   final StrongTypeSystemImpl rules;
-  final TypeProvider _typeProvider;
   final CodeChecker _checker;
 
   _OverrideChecker(CodeChecker checker)
       : _checker = checker,
-        rules = checker.rules,
-        _typeProvider = checker.typeProvider;
+        rules = checker.rules;
 
   void check(ClassDeclaration node) {
     if (node.element.type.isObject) return;
     _checkSuperOverrides(node);
     _checkMixinApplicationOverrides(node);
     _checkAllInterfaceOverrides(node);
   }
 
   /// Checks that implementations correctly override all reachable interfaces.
   /// In particular, we need to check these overrides for the definitions in
@@ skipping 261 matching lines @@
         ]);
       }
     }
     FunctionType concreteSubType = subType;
     FunctionType concreteBaseType = baseType;
     if (concreteSubType.typeFormals.isNotEmpty) {
       if (concreteBaseType.typeFormals.isEmpty) {
         concreteSubType = rules.instantiateToBounds(concreteSubType);
       }
     }
-    concreteSubType =
-        rules.typeToConcreteType(_typeProvider, concreteSubType);
-    concreteBaseType =
-        rules.typeToConcreteType(_typeProvider, concreteBaseType);
 
-    if (!rules.isSubtypeOf(concreteSubType, concreteBaseType)) {
-      // See whether non-subtype cases fit one of our common patterns:
-      //
-      // Common pattern 1: Inferable return type (on getters and methods)
-      //   class A {
-      //     int get foo => ...;
-      //     String toString() { ... }
-      //   }
-      //   class B extends A {
-      //     get foo => e; // no type specified.
-      //     toString() { ... } // no return type specified.
-      //   }
-
+    if (!rules.isOverrideSubtypeOf(concreteSubType, concreteBaseType)) {
       ErrorCode errorCode;
       if (errorLocation is ExtendsClause) {
         errorCode = StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_BASE;
       } else if (errorLocation.parent is WithClause) {
         errorCode = StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_MIXIN;
       } else {
         errorCode = StrongModeCode.INVALID_METHOD_OVERRIDE;
       }
 
       _checker._recordMessage(errorLocation, errorCode, [
         element.enclosingElement.name,
         element.name,
         subType,
         type,
         baseType
       ]);
     }
-    return true;
+
+    // If we have any covariant parameters and we're comparing against a
+    // superclass, we check all superclasses instead of stopping the search.
+    bool hasCovariant = element.parameters.any((p) => p.isCovariant);
+    bool keepSearching = hasCovariant && isSubclass;
+    return !keepSearching;
   }
 
   /// Check overrides between a class and its superclasses and mixins. For
   /// example, in:
   ///
   ///      A extends B with E, F
   ///
   /// we check A against B, B super classes, E, and F.
   ///
   /// Internally we avoid reporting errors twice and we visit classes bottom up
@@ skipping 17 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }