fixes #25740, substitute type parameter bound taking into account outer scope type params

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/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 883 matching lines @@
             return true;
           }
         }
       }
     }
     return false;
   }
 }
 
 /**
+ * A type parameter defined inside of another parameterized type, where the
+ * values of the enclosing type parameters are known.
+ *
+ * For example:
+ *
+ *     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;
+
+  TypeParameterMember(
+      TypeParameterElement baseElement, DartType definingType, this.bound)
+      : super(baseElement, definingType);
+
+  @override
+  TypeParameterElement get baseElement =>
+      super.baseElement as TypeParameterElement;
+
+  @override
+  Element get enclosingElement => baseElement.enclosingElement;
+
+  @override
+  TypeParameterType get type => baseElement.type;
+
+  @override
+  accept(ElementVisitor 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;
+    }
+
+    DartType bound = parameter.bound;
+    List<DartType> argumentTypes = definingType.typeArguments;
+    List<DartType> parameterTypes =
+        TypeParameterTypeImpl.getTypes(definingType.typeParameters);
+    DartType substitutedBound =
+        bound.substitute2(argumentTypes, parameterTypes);
+    if (bound == substitutedBound) {
+      return parameter;
+    }
+    return new TypeParameterMember(parameter, definingType, substitutedBound);
+  }
+}
+
+/**
  * 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;
 
   /**
    * Initialize a newly created element to represent a variable, based on the
    * [baseElement], defined by the [definingType].
@@ skipping 48 matching lines @@
   bool get isStatic => baseElement.isStatic;
 
   @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);
     safelyVisitChild(baseElement.initializer, visitor);
   }
 }