fixes #25668, correctly infer generic method override

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';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, InheritanceManager;
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/dart/element/type.dart';
 
 /**
  * Sets the type of the field. This is stored in the field itself, and the
  * synthetic getter/setter types.
  */
 void setFieldType(VariableElement field, DartType newType) {
   (field as VariableElementImpl).type = newType;
   if (field.initializer != null) {
     (field.initializer as ExecutableElementImpl).returnType = newType;
   }
   if (field is PropertyInducingElementImpl) {
     (field.getter as ExecutableElementImpl).returnType = newType;
     if (!field.isFinal && !field.isConst) {
-      (field.setter.parameters[0] as ParameterElementImpl).type =
-          newType;
+      (field.setter.parameters[0] as ParameterElementImpl).type = newType;
     }
   }
 }
 
 /**
  * Return the element for the single parameter of the given [setter], or `null`
  * if the executable element is not a setter or does not have a single
  * parameter.
  */
 ParameterElement _getParameter(ExecutableElement setter) {
@@ skipping 72 matching lines @@
    * Compute the best type for the [parameter] at the given [index] that must be
    * compatible with the types of the corresponding parameters of the given
    * [overriddenMethods].
    *
    * 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<ExecutableElement> overriddenMethods) {
+      List<FunctionType> overriddenTypes) {
     DartType parameterType = null;
-    int length = overriddenMethods.length;
+    int length = overriddenTypes.length;
     for (int i = 0; i < length; i++) {
       DartType type = _getTypeOfCorrespondingParameter(
-          parameter, index, overriddenMethods[i]);
+          parameter, index, overriddenTypes[i].parameters);
       if (parameterType == null) {
         parameterType = type;
       } else if (parameterType != type) {
         return typeProvider.dynamicType;
       }
     }
-    return parameterType == null ? typeProvider.dynamicType : parameterType;
+    return parameterType ?? typeProvider.dynamicType;
   }
 
   /**
    * Compute the best return type for a method that must be compatible with the
-   * return types of each of the given [overriddenMethods].
+   * return types of each of the given [overriddenTypes].

[vsm, 2016/02/03 23:16:15]

s/overriddenTypes/overriddenReturnTypes/ to match the param name below.

[Jennifer Messerly, 2016/02/04 18:18:51]

Done.

    *
    * At the moment, this method will only return a type other than 'dynamic' if
    * the return types of all of the methods are the same. In the future we might
    * want to be smarter about it.
    */
-  DartType _computeReturnType(List<ExecutableElement> overriddenMethods) {
+  DartType _computeReturnType(Iterable<DartType> overriddenReturnTypes) {
     DartType returnType = null;
-    int length = overriddenMethods.length;
-    for (int i = 0; i < length; i++) {
-      DartType type = _getReturnType(overriddenMethods[i]);
+    for (DartType type in overriddenReturnTypes) {
+      if (type == null) {
+        type = typeProvider.dynamicType;
+      }
       if (returnType == null) {
         returnType = type;
       } else if (returnType != type) {
         return typeProvider.dynamicType;
       }
     }
-    return returnType == null ? typeProvider.dynamicType : returnType;
-  }
-
-  DartType _getReturnType(ExecutableElement element) {
-    DartType returnType = element.returnType;
-    if (returnType == null) {
-      return typeProvider.dynamicType;
-    }
-    return returnType;
+    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
    * it appears at the given [index] in its enclosing element's list of
    * parameters.
    */
-  DartType _getTypeOfCorrespondingParameter(
-      ParameterElement parameter, int index, ExecutableElement method) {
+  DartType _getTypeOfCorrespondingParameter(ParameterElement parameter,
+      int index, List<ParameterElement> methodParameters) {
     //
     // Find the corresponding parameter.
     //
-    List<ParameterElement> methodParameters = method.parameters;
     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(
           (ParameterElement methodParameter) =>
               methodParameter.parameterKind == ParameterKind.NAMED &&
               methodParameter.name == parameter.name,
@@ skipping 71 matching lines @@
 
   /**
    * If the given [element] represents a non-synthetic instance method,
    * getter or setter, infer the return type and any parameter type(s) where
    * they were not provided.
    */
   void _inferExecutable(ExecutableElement element) {
     if (element.isSynthetic || element.isStatic) {
       return;
     }
-    List<ExecutableElement> overriddenMethods = null;
+    List<ExecutableElement> overriddenMethods = inheritanceManager
+        .lookupOverrides(element.enclosingElement, element.name);
+    if (overriddenMethods.isEmpty ||
+        !_allSameElementKind(element, overriddenMethods)) {
+      return;
+    }
+
+    //
+    // Overridden methods must have the same number of generic type parameters
+    // as this method, or none.
+    //
+    // If we do have generic type parameters on the element we're inferring,
+    // we must express its parameter and return types in terms of its own
+    // parameters. For example, given `m<T>(t)` overriding `m<S>(S s)` we
+    // should infer this as `m<T>(T t)`.
+    //
+    List<DartType> typeFormals =
+        TypeParameterTypeImpl.getTypes(element.type.typeFormals);
+
+    List<FunctionType> overriddenTypes = new List<FunctionType>();
+    for (ExecutableElement overriddenMethod in overriddenMethods) {
+      FunctionType overriddenType = overriddenMethod.type;
+      if (overriddenType.typeFormals.isNotEmpty &&
+          overriddenType.typeFormals.length != typeFormals.length) {
+        return;
+      }
+      overriddenTypes.add(overriddenType.instantiate(typeFormals));
+    }
+
     //
     // Infer the return type.
     //
     if (element.hasImplicitReturnType) {
-      overriddenMethods = inheritanceManager.lookupOverrides(
-          element.enclosingElement, element.name);
-      if (overriddenMethods.isEmpty ||
-          !_allSameElementKind(element, overriddenMethods)) {
-        return;
-      }
       (element as ExecutableElementImpl).returnType =
-          _computeReturnType(overriddenMethods);
+          _computeReturnType(overriddenTypes.map((t) => t.returnType));
       if (element is PropertyAccessorElement) {
         _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) {
-        if (overriddenMethods == null) {
-          overriddenMethods = inheritanceManager.lookupOverrides(
-              element.enclosingElement, element.name);
-        }
-        if (overriddenMethods.isEmpty ||
-            !_allSameElementKind(element, overriddenMethods)) {
-          return;
-        }
-        parameter.type = _computeParameterType(parameter, i, overriddenMethods);
+        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) {
     if (!fieldElement.isSynthetic &&
         !fieldElement.isStatic &&
         fieldElement.hasImplicitType) {
       //
       // First look for overridden getters with the same name as the field.
       //
       List<ExecutableElement> overriddenGetters = inheritanceManager
           .lookupOverrides(fieldElement.enclosingElement, fieldElement.name);
       DartType newType = null;
       if (overriddenGetters.isNotEmpty && _onlyGetters(overriddenGetters)) {
-        newType = _computeReturnType(overriddenGetters);
+        newType =
+            _computeReturnType(overriddenGetters.map((e) => e.returnType));
         List<ExecutableElement> overriddenSetters =
             inheritanceManager.lookupOverrides(
                 fieldElement.enclosingElement, fieldElement.name + '=');
         if (!_isCompatible(newType, overriddenSetters)) {
           newType = null;
         }
       }
       //
       // If there is no overridden getter or if the overridden getter's type is
       // dynamic, then we can infer the type from the initialization expression
@@ skipping 124 matching lines @@
         results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}