Substitute bounds of fresh type parameters using all fresh type parameters.

[email protected], [email protected]

Bug: #38365
Change-Id: I7603126bb7a5578b9ce2c74a7b130a591be0d4b9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/117640
Reviewed-by: Paul Berry <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -201,6 +201,34 @@ class _FreshTypeParametersSubstitutor extends _TypeSubstitutor {
     return freshElement;
   }
 
+  @override
+  List<TypeParameterElement> freshTypeParameters(
+      List<TypeParameterElement> elements) {
+    if (elements.isEmpty) {
+      return const <TypeParameterElement>[];
+    }
+
+    var freshElements = List<TypeParameterElement>(elements.length);
+    for (var i = 0; i < elements.length; i++) {
+      var element = elements[i];
+      var freshElement = TypeParameterElementImpl(element.name, -1);
+      freshElements[i] = freshElement;
+      var freshType = TypeParameterTypeImpl(freshElement);
+      freshElement.type = freshType;
+      substitution[element] = freshType;
+    }
+
+    for (var i = 0; i < freshElements.length; i++) {
+      var element = elements[i];
+      if (element.bound != null) {
+        TypeParameterElementImpl freshElement = freshElements[i];
+        freshElement.bound = visit(element.bound);
+      }
+    }
+
+    return freshElements;
+  }
+
   DartType lookup(TypeParameterElement parameter, bool upperBound) {
     return substitution[parameter];
   }
@@ -247,8 +275,8 @@ class _TopSubstitutor extends _TypeSubstitutor {
     }
   }
 
-  @override
-  TypeParameterElement freshTypeParameter(TypeParameterElement element) {
+  List<TypeParameterElement> freshTypeParameters(
+      List<TypeParameterElement> parameters) {
     throw 'Create a fresh environment first';
   }
 
@@ -283,15 +311,8 @@ abstract class _TypeSubstitutor extends DartTypeVisitor<DartType> {
     target.useCounter++;
   }
 
-  TypeParameterElement freshTypeParameter(TypeParameterElement element);
-
   List<TypeParameterElement> freshTypeParameters(
-      List<TypeParameterElement> parameters) {
-    if (parameters.isEmpty) {
-      return const <TypeParameterElement>[];
-    }
-    return parameters.map(freshTypeParameter).toList();
-  }
+      List<TypeParameterElement> elements);
 
   DartType getSubstitute(TypeParameterElement parameter) {
     var environment = this;
@@ -339,14 +360,18 @@ abstract class _TypeSubstitutor extends DartTypeVisitor<DartType> {
     // any uses, but does not tell if the resulting function type is distinct.
     // Our own use counter will get incremented if something from our
     // environment has been used inside the function.
-    var inner = type.typeFormals.isEmpty ? this : newInnerEnvironment();
     int before = this.useCounter;
 
+    var inner = this;
+    var typeFormals = type.typeFormals;
+    if (typeFormals.isNotEmpty) {
+      inner = newInnerEnvironment();
+      typeFormals = inner.freshTypeParameters(typeFormals);
+    }
+
     // Invert the variance when translating parameters.
     inner.invertVariance();
 
-    var typeFormals = inner.freshTypeParameters(type.typeFormals);
-
     var parameters = type.parameters.map((parameter) {
       var type = inner.visit(parameter.type);
       return _parameterElement(parameter, type);
@@ -376,14 +401,18 @@ abstract class _TypeSubstitutor extends DartTypeVisitor<DartType> {
     // any uses, but does not tell if the resulting function type is distinct.
     // Our own use counter will get incremented if something from our
     // environment has been used inside the function.
-    var inner = type.typeFormals.isEmpty ? this : newInnerEnvironment();
     int before = this.useCounter;
 
+    var inner = this;
+    var typeFormals = type.typeFormals;
+    if (typeFormals.isNotEmpty) {
+      inner = newInnerEnvironment();
+      typeFormals = inner.freshTypeParameters(typeFormals);
+    }
+
     // Invert the variance when translating parameters.
     inner.invertVariance();
 
-    var typeFormals = inner.freshTypeParameters(type.typeFormals);
-
     var parameters = type.parameters.map((parameter) {
       var type = inner.visit(parameter.type);
       return _parameterElement(parameter, type);

pkg/analyzer/test/src/dart/element/type_algebra_test.dart

@@ -113,56 +113,95 @@ class SubstituteTest extends _Base {
     _assertIdenticalType(typeProvider.dynamicType, {T: intType});
   }
 
-  test_function_noTypeParameters() async {
+  test_function_noSubstitutions() async {
     var type = functionType(required: [intType], returns: boolType);
 
     var T = typeParameter('T');
     _assertIdenticalType(type, {T: intType});
   }
 
-  test_function_typeFormals() async {
-    // typedef F<T> = T Function<U extends T>(U);
+  test_function_parameters_returnType() async {
+    // typedef F<T, U> = T Function(U u, bool);
     var T = typeParameter('T');
-    var U = typeParameter('U', bound: typeParameterType(T));
+    var U = typeParameter('U');
     var type = functionType(
-      typeFormals: [U],
       required: [
         typeParameterType(U),
+        boolType,
       ],
       returns: typeParameterType(T),
     );
 
-    assertElementTypeString(type, 'T Function<U extends T>(U)');
+    assertElementTypeString(type, 'T Function(U, bool)');
     _assertSubstitution(
       type,
       {T: intType},
-      'int Function<U extends int>(U)',
+      'int Function(U, bool)',
+    );
+    _assertSubstitution(
+      type,
+      {T: intType, U: doubleType},
+      'int Function(double, bool)',
     );
   }
 
-  test_function_typeParameters() async {
-    // typedef F<T, U> = T Function(U u, bool);
+  test_function_typeFormals() async {
+    // typedef F<T> = T Function<U extends T>(U);
     var T = typeParameter('T');
-    var U = typeParameter('U');
+    var U = typeParameter('U', bound: typeParameterType(T));
     var type = functionType(
+      typeFormals: [U],
       required: [
         typeParameterType(U),
-        boolType,
       ],
       returns: typeParameterType(T),
     );
 
-    assertElementTypeString(type, 'T Function(U, bool)');
+    assertElementTypeString(type, 'T Function<U extends T>(U)');
     _assertSubstitution(
       type,
       {T: intType},
-      'int Function(U, bool)',
+      'int Function<U extends int>(U)',
     );
-    _assertSubstitution(
+  }
+
+  test_function_typeFormals_bounds() async {
+    // class Triple<X, Y, Z> {}
+    // typedef F<V> = bool Function<T extends Triplet<T, U, V>, U>();
+    var classTriplet = class_(name: 'Triple', typeParameters: [
+      typeParameter('X'),
+      typeParameter('Y'),
+      typeParameter('Z'),
+    ]);
+
+    var T = typeParameter('T');
+    var U = typeParameter('U');
+    var V = typeParameter('V');
+    T.bound = interfaceType(classTriplet, typeArguments: [
+      typeParameterType(T),
+      typeParameterType(U),
+      typeParameterType(V),
+    ]);
+    var type = functionType(
+      typeFormals: [T, U],
+      returns: boolType,
+    );
+
+    assertElementTypeString(
       type,
-      {T: intType, U: doubleType},
-      'int Function(double, bool)',
+      'bool Function<T extends Triple<T, U, V>,U>()',
+    );
+
+    var result = substitute(type, {V: intType}) as FunctionType;
+    assertElementTypeString(
+      result,
+      'bool Function<T extends Triple<T, U, int>,U>()',
     );
+    var T2 = result.typeFormals[0];
+    var U2 = result.typeFormals[1];
+    var T2boundArgs = (T2.bound as InterfaceType).typeArguments;
+    expect((T2boundArgs[0] as TypeParameterType).element, same(T2));
+    expect((T2boundArgs[1] as TypeParameterType).element, same(U2));
   }
 
   test_interface_arguments() async {