fix #28141, fix super generic method bounds check

pkg/analyzer/lib/src/dart/element/member.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.dart.element.member;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 890 matching lines @@
  *     class C<T> {
  *       S m<S extends T>(S s);
  *     }
  *
  * If we have `C<num>.m` and we ask for the type parameter "S", we should get
  * `<S extends num>` instead of `<S extends T>`. This is how the parameter
  * and return types work, see: [FunctionType.parameters],
  * [FunctionType.returnType], and [ParameterMember].
  */
 class TypeParameterMember extends Member implements TypeParameterElement {
-  @override
-  final DartType bound;
-
+  DartType _bound;
   DartType _type;
 
   TypeParameterMember(
-      TypeParameterElement baseElement, DartType definingType, this.bound)
+      TypeParameterElement baseElement, DartType definingType, this._bound)
       : super(baseElement, definingType) {
     _type = new TypeParameterTypeImpl(this);
   }
 
   @override
   TypeParameterElement get baseElement =>
       super.baseElement as TypeParameterElement;
 
   @override
+  DartType get bound => _bound;
+
+  @override
   Element get enclosingElement => baseElement.enclosingElement;
 
   @override
   int get hashCode => baseElement.hashCode;
 
   @override
   TypeParameterType get type => _type;
 
   @override
   /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
       visitor.visitTypeParameterElement(this);
 
   /**
    * If the given [parameter]'s type is different when any type parameters from
    * the defining type's declaration are replaced with the actual type
    * arguments from the [definingType], create a parameter member representing
    * the given parameter. Return the member that was created, or the base
    * parameter if no member was created.
    */
-  static TypeParameterElement from(
-      TypeParameterElement parameter, ParameterizedType definingType) {
-    if (parameter?.bound == null || definingType.typeArguments.isEmpty) {
-      return parameter;
+  static List<TypeParameterElement> from(
+      List<TypeParameterElement> formals, FunctionType definingType) {
+    List<DartType> argumentTypes = definingType.typeArguments;
+    if (argumentTypes.isEmpty) {
+      return formals;
     }
-
-    DartType bound = parameter.bound;
-    List<DartType> argumentTypes = definingType.typeArguments;
     List<DartType> parameterTypes =
         TypeParameterTypeImpl.getTypes(definingType.typeParameters);
-    DartType substitutedBound =
-        bound.substitute2(argumentTypes, parameterTypes);
-    return new TypeParameterMember(parameter, definingType, substitutedBound);
+    List<TypeParameterType> formalTypes =
+        TypeParameterTypeImpl.getTypes(formals);
+
+    // Create type formals with specialized bounds.
+    // For example `<U extends T>` where T comes from an outer scope.
+    var result = formals.toList(growable: false);
+    for (int i = 0; i < result.length; i++) {
+      var formal = formals[i];
+      DartType bound = formal?.bound;
+      if (bound != null) {
+        // substitute type arguments from the function.
+        bound = bound.substitute2(argumentTypes, parameterTypes);
+        var newTypeFormal =
+            new TypeParameterMember(formal, definingType, bound);
+        result[i] = newTypeFormal;
+        // recursive bounds are allowed too, so make sure these are updated
+        // to refer to any new TypeParameterMember we just made, rather than
+        // the original type parameter
+        // TODO(jmesserly): this is required so substituting for the
+        // typeFormal will work. Investigate if there's a better solution,
+        // e.g. TypeParameterMember.
+        newTypeFormal._bound = bound.substitute2(

[Leaf, 2017/01/24 19:10:05]

Consider doing this in a separate loop afterwards to avoid relying on a left to
right ordering of the parameter dependencies. e.g.

var newTypeVariables = ....getTypes(result);
result.forEach((f) = f._bound = bound.substitute2(newTypeVariables,
formalTypes);
return result;

[Jennifer Messerly, 2017/01/24 22:44:00]

excellent idea

+            TypeParameterTypeImpl.getTypes(result), formalTypes);
+      }
+    }
+    return result;
   }
 }
 
 /**
  * A variable element defined in a parameterized type where the values of the
  * type parameters are known.
  */
 abstract class VariableMember extends Member implements VariableElement {
   @override
   final DartType type;
@@ skipping 57 matching lines @@
   DartObject computeConstantValue() => baseElement.computeConstantValue();
 
   @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used
     // below so that we can safely invoke them.
     super.visitChildren(visitor);
     baseElement.initializer?.accept(visitor);
   }
 }