fix #25740 again, making sure we have the substituted bound in inference

The first fix only addressed part of the problem. Unfortunately we go back and forth between .element and .type, assuming they always return the other one, which was not the case for TypeParameterMember.

[email protected]

Review URL: https://codereview.chromium.org/2291103004 .

Author: John Messerly

pkg/analyzer/lib/src/dart/element/member.dart

@@ -937,9 +937,13 @@ class TypeParameterMember extends Member implements TypeParameterElement {
   @override
   final DartType bound;
 
+  DartType _type;
+
   TypeParameterMember(
       TypeParameterElement baseElement, DartType definingType, this.bound)
-      : super(baseElement, definingType);
+      : super(baseElement, definingType) {
+    _type = new TypeParameterTypeImpl(this);
+  }
 
   @override
   TypeParameterElement get baseElement =>
@@ -949,11 +953,20 @@ class TypeParameterMember extends Member implements TypeParameterElement {
   Element get enclosingElement => baseElement.enclosingElement;
 
   @override
-  TypeParameterType get type => baseElement.type;
+  TypeParameterType get type => _type;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
 
+  @override
+  int get hashCode => baseElement.hashCode;
+
+  @override
+  bool operator ==(obj) =>
+      // TODO(jmesserly): this equality should consider the bound, see:
+      // https://github.com/dart-lang/sdk/issues/27210
+      obj is TypeParameterMember && obj.baseElement == baseElement;
+
   /**
    * If the given [parameter]'s type is different when any type parameters from
    * the defining type's declaration are replaced with the actual type

pkg/analyzer/test/generated/type_system_test.dart

@@ -881,6 +881,80 @@ class StrongGenericFunctionInferenceTest {
     ]);
   }
 
+  void test_boundedByOuterClass() {
+    // Regression test for https://github.com/dart-lang/sdk/issues/25740.
+
+    // class A {}
+    var a = ElementFactory.classElement('A', objectType);
+
+    // class B extends A {}
+    var b = ElementFactory.classElement('B', a.type);
+
+    // class C<T extends A> {
+    var c = ElementFactory.classElement('C', objectType, ['T']);
+    (c.typeParameters[0] as TypeParameterElementImpl).bound = a.type;
+    //   S m<S extends T>(S);
+    var s = TypeBuilder.variable('S');
+    (s.element as TypeParameterElementImpl).bound = c.typeParameters[0].type;
+    var m = ElementFactory.methodElement('m', s, [s]);
+    m.typeParameters = [s.element];
+    c.methods = [m];
+    // }
+
+    // C<Object> cOfObject;
+    var cOfObject = c.type.instantiate([objectType]);
+    // C<A> cOfA;
+    var cOfA = c.type.instantiate([a.type]);
+    // C<B> cOfB;
+    var cOfB = c.type.instantiate([b.type]);
+    // B b;
+    // cOfB.m(b); // infer <B>
+    expect(_inferCall(cOfB.getMethod('m').type, [b.type]), [b.type, b.type]);
+    // cOfA.m(b); // infer <B>
+    expect(_inferCall(cOfA.getMethod('m').type, [b.type]), [a.type, b.type]);
+    // cOfObject.m(b); // infer <B>
+    expect(_inferCall(cOfObject.getMethod('m').type, [b.type]),
+        [objectType, b.type]);
+  }
+
+  void test_boundedByOuterClassSubstituted() {
+    // Regression test for https://github.com/dart-lang/sdk/issues/25740.
+
+    // class A {}
+    var a = ElementFactory.classElement('A', objectType);
+
+    // class B extends A {}
+    var b = ElementFactory.classElement('B', a.type);
+
+    // class C<T extends A> {
+    var c = ElementFactory.classElement('C', objectType, ['T']);
+    (c.typeParameters[0] as TypeParameterElementImpl).bound = a.type;
+    //   S m<S extends Iterable<T>>(S);
+    var s = TypeBuilder.variable('S');
+    var iterableOfT = iterableType.instantiate([c.typeParameters[0].type]);
+    (s.element as TypeParameterElementImpl).bound = iterableOfT;
+    var m = ElementFactory.methodElement('m', s, [s]);
+    m.typeParameters = [s.element];
+    c.methods = [m];
+    // }
+
+    // C<Object> cOfObject;
+    var cOfObject = c.type.instantiate([objectType]);
+    // C<A> cOfA;
+    var cOfA = c.type.instantiate([a.type]);
+    // C<B> cOfB;
+    var cOfB = c.type.instantiate([b.type]);
+    // List<B> b;
+    var listOfB = listType.instantiate([b.type]);
+    // cOfB.m(b); // infer <B>
+    expect(_inferCall(cOfB.getMethod('m').type, [listOfB]), [b.type, listOfB]);
+    // cOfA.m(b); // infer <B>
+    expect(_inferCall(cOfA.getMethod('m').type, [listOfB]), [a.type, listOfB]);
+    // cOfObject.m(b); // infer <B>
+    expect(_inferCall(cOfObject.getMethod('m').type, [listOfB]),
+        [objectType, listOfB]);
+  }
+
   void test_boundedRecursively() {
     // class Clonable<T extends Clonable<T>>
     ClassElementImpl clonable =

pkg/analyzer/test/src/task/strong/inferred_type_test.dart

@@ -1761,14 +1761,18 @@ main() {
     // Regression test for https://github.com/dart-lang/sdk/issues/25740.
     checkFile(r'''
 class Foo<T extends Pattern> {
-  void method/*<U extends T>*/(dynamic/*=U*/ u) {}
+  /*=U*/ method/*<U extends T>*/(/*=U*/ u) => u;
 }
 main() {
-  new Foo().method/*<String>*/("str");
+  String s;
+  var a = new Foo().method/*<String>*/("str");
+  s = a;
   new Foo();
 
-  new Foo<String>().method("str");
-  new Foo().method("str");
+  var b = new Foo<String>().method("str");
+  s = b;
+  var c = new Foo().method("str");
+  s = c;
 
   new Foo<String>().method(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/42);
 }