fix #28141, fix super generic method bounds check

pkg/analyzer/lib/src/generated/error_verifier.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.generated.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 803 matching lines @@
 
   @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     Expression functionExpression = node.function;
     DartType expressionType = functionExpression.staticType;
     if (!_isFunctionType(expressionType)) {
       _errorReporter.reportErrorForNode(
           StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION,
           functionExpression);
     } else if (expressionType is FunctionType) {
-      _checkTypeArguments(expressionType.element, node.typeArguments);
+      _checkTypeArguments(node);
     }
     _checkForImplicitDynamicInvoke(node);
     return super.visitFunctionExpressionInvocation(node);
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     _checkForBuiltInIdentifierAsName(
         node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     _checkForDefaultValueInFunctionTypeAlias(node);
@@ skipping 190 matching lines @@
   Object visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     SimpleIdentifier methodName = node.methodName;
     if (target != null) {
       ClassElement typeReference = ElementResolver.getTypeReference(target);
       _checkForStaticAccessToInstanceMember(typeReference, methodName);
       _checkForInstanceAccessToStaticMember(typeReference, methodName);
     } else {
       _checkForUnqualifiedReferenceToNonLocalStaticMember(methodName);
     }
-    _checkTypeArguments(
-        node.methodName.staticElement, node.typeArguments, target?.staticType);
+    _checkTypeArguments(node);
     _checkForImplicitDynamicInvoke(node);
     return super.visitMethodInvocation(node);
   }
 
   @override
   Object visitNativeClause(NativeClause node) {
     // TODO(brianwilkerson) Figure out the right rule for when 'native' is
     // allowed.
     if (!_isInSystemLibrary) {
       _errorReporter.reportErrorForNode(
@@ skipping 5102 matching lines @@
       }
     }
   }
 
   /**
    * Verify that the given [typeArguments] are all within their bounds, as
    * defined by the given [element].
    *
    * See [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS].
    */
-  void _checkTypeArguments(Element element, TypeArgumentList typeArguments,
-      [DartType targetType]) {
-    if (element == null || typeArguments == null) {
+  void _checkTypeArguments(InvocationExpression node) {

[Jennifer Messerly, 2017/01/24 03:09:16]

rewrote this to simplify

in general -- when we stick to the world of types (vs elements) we're going to
have a better time tracking type parameters.

+    NodeList<TypeAnnotation> typeArgumentList = node.typeArguments?.arguments;
+    if (typeArgumentList == null) {
       return;
     }
-    void reportError(TypeAnnotation argument, DartType argumentType,
-        DartType parameterType) {
-      _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
-          argument,
-          [argumentType, parameterType]);
-    }
 
-    if (element is FunctionTypedElement) {
-      _checkTypeArgumentsAgainstBounds(
-          element.typeParameters, typeArguments, targetType, reportError);
-    } else if (element is ClassElement) {
-      _checkTypeArgumentsAgainstBounds(
-          element.typeParameters, typeArguments, targetType, reportError);
-    } else if (element is ParameterElement || element is LocalVariableElement) {
-      // TODO(brianwilkerson) Implement this case
-    } else {
-      print('Unhandled element type: ${element.runtimeType}');
-    }
-  }
+    var genericType = node.function.staticType;
+    var instantiatedType = node.staticInvokeType;
+    if (genericType is FunctionType && instantiatedType is FunctionType) {
+      var fnTypeParams =
+          TypeParameterTypeImpl.getTypes(genericType.typeFormals);
+      var typeArgs = typeArgumentList.map((t) => t.type).toList();
 
-  void _checkTypeArgumentsAgainstBounds(
-      List<TypeParameterElement> typeParameters,
-      TypeArgumentList typeArgumentList,
-      DartType targetType,
-      void reportError(TypeAnnotation argument, DartType argumentType,
-          DartType parameterType)) {
-    NodeList<TypeAnnotation> typeArguments = typeArgumentList.arguments;
-    int argumentsLength = typeArguments.length;
-    int maxIndex = math.min(typeParameters.length, argumentsLength);
-
-    bool shouldSubstitute =
-        argumentsLength != 0 && argumentsLength == typeParameters.length;
-    List<DartType> argumentTypes = shouldSubstitute
-        ? typeArguments.map((TypeAnnotation type) => type.type).toList()
-        : null;
-    List<DartType> parameterTypes = shouldSubstitute
-        ? typeParameters
-            .map((TypeParameterElement element) => element.type)
-            .toList()
-        : null;
-    List<DartType> targetTypeParameterTypes = null;
-    for (int i = 0; i < maxIndex; i++) {
-      TypeAnnotation argument = typeArguments[i];
-      DartType argType = argument.type;
-      DartType boundType = typeParameters[i].bound;
-      if (argType != null && boundType != null) {
-        if (targetType is ParameterizedType) {
-          if (targetTypeParameterTypes == null) {
-            targetTypeParameterTypes = targetType.typeParameters
-                .map((TypeParameterElement element) => element.type)
-                .toList();
-          }
-          boundType = boundType.substitute2(
-              targetType.typeArguments, targetTypeParameterTypes);
-        }
-        if (shouldSubstitute) {
-          boundType = boundType.substitute2(argumentTypes, parameterTypes);
-        }
-        if (!_typeSystem.isSubtypeOf(argType, boundType)) {
-          reportError(argument, argType, boundType);
+      for (int i = 0, len = math.min(typeArgs.length, fnTypeParams.length);
+          i < len;
+          i++) {
+        // Check the `extends` clause for the type parameter, if any.
+        //
+        // Also substitute to handle cases like this:
+        //
+        //     <TFrom, TTo extends TFrom>
+        //     <TFrom, TTo extends Iterable<TFrom>>
+        //     <T extends Clonable<T>>
+        //
+        DartType argType = typeArgs[i];
+        DartType bound =
+            fnTypeParams[i].bound.substitute2(typeArgs, fnTypeParams);
+        if (!_typeSystem.isSubtypeOf(argType, bound)) {
+          _errorReporter.reportTypeErrorForNode(
+              StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
+              typeArgumentList[i],
+              [argType, bound]);
         }
       }
     }
   }
 
   void _checkUseOfCovariantInParameters(FormalParameterList node) {
     AstNode parent = node.parent;
     if (parent is MethodDeclaration && !parent.isStatic) {
       return;
     }
@@ skipping 859 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }