Make types concrete when checking 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 86 matching lines @@
 
 /// Checks the body of functions and properties.
 class CodeChecker extends RecursiveAstVisitor {
   final StrongTypeSystemImpl rules;
   final TypeProvider typeProvider;
   final AnalysisErrorListener reporter;
   final _OverrideChecker _overrideChecker;
   final bool _hints;
 
   bool _failure = false;
-  CodeChecker(this.typeProvider, StrongTypeSystemImpl rules,
+  CodeChecker(TypeProvider typeProvider, StrongTypeSystemImpl rules,
       AnalysisErrorListener reporter,
       {bool hints: false})
-      : rules = rules,
+      : typeProvider = typeProvider,
+        rules = rules,
         reporter = reporter,
         _hints = hints,
-        _overrideChecker = new _OverrideChecker(rules, reporter);
+        _overrideChecker = new _OverrideChecker(typeProvider, rules, reporter);
 
   bool get failure => _failure || _overrideChecker._failure;
 
   void checkArgument(Expression arg, DartType expectedType) {
     // Preserve named argument structure, so their immediate parent is the
     // method invocation.
     Expression baseExpression = arg is NamedExpression ? arg.expression : arg;
     checkAssignment(baseExpression, expectedType);
   }
 
@@ skipping 825 matching lines @@
     return normalReturnType;
   }
 }
 
 /// Checks for overriding declarations of fields and methods. This is used to
 /// check overrides between classes and superclasses, interfaces, and mixin
 /// applications.
 class _OverrideChecker {
   bool _failure = false;
   final StrongTypeSystemImpl rules;
+  final TypeProvider _typeProvider;
   final AnalysisErrorListener _reporter;
 
-  _OverrideChecker(this.rules, this._reporter);
+  _OverrideChecker(this._typeProvider, this.rules, this._reporter);
 
   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 246 matching lines @@
 
     if (isSubclass && element is PropertyAccessorElement) {
       // Disallow any overriding if the base class defines this member
       // as a field.  We effectively treat fields as final / non-virtual.
       PropertyInducingElement field = _getMemberField(type, element);
       if (field != null) {
         _recordMessage(new InvalidFieldOverride(
             errorLocation, element, type, subType, baseType));
       }
     }
-    if (!rules.isSubtypeOf(subType, baseType)) {
+    FunctionType concreteSubType = subType;
+    FunctionType concreteBaseType = baseType;
+    if (element is MethodElement) {
+      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.
@@ skipping 39 matching lines @@
     } while (!current.isObject && !visited.contains(current));
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
     _reporter.onError(error);
   }
 }