Deprecate TypeParameterTypeImpl.getTypes()

Presubmit in google3 looks green.
https://test.corp.google.com/ui#id=OCL:272795904:BASE:272795986:1570167013170:de765f48

Change-Id: I9ef25658a8a8e806b7fcc23b8d9d4e1d297ebff8
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/120003
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

Author: scheglov

pkg/analyzer/lib/dart/element/element.dart

@@ -1207,6 +1207,7 @@ abstract class FunctionTypeAliasElement
   ///     typedef F<T> = void Function<U>(T, U);
   /// then a single type argument should be provided, and it will be substituted
   /// for T.
+  @deprecated
   FunctionType instantiate(List<DartType> argumentTypes);
 
   /// Produces the function type resulting from instantiating this typedef with

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

@@ -1312,16 +1312,17 @@ class ClassElementImpl extends AbstractClassElementImpl
     // to produce constructors for this class.  We want to be robust in the
     // face of errors, so drop any extra type arguments and fill in any missing
     // ones with `dynamic`.
-    List<DartType> parameterTypes =
-        TypeParameterTypeImpl.getTypes(supertype.typeParameters);
+    var superTypeParameters = supertype.typeParameters;
     List<DartType> argumentTypes = new List<DartType>.filled(
-        parameterTypes.length, DynamicTypeImpl.instance);
+        superTypeParameters.length, DynamicTypeImpl.instance);
     for (int i = 0; i < supertype.typeArguments.length; i++) {
       if (i >= argumentTypes.length) {
         break;
       }
       argumentTypes[i] = supertype.typeArguments[i];
     }
+    var substitution =
+        Substitution.fromPairs(superTypeParameters, argumentTypes);
 
     // Now create an implicit constructor for every constructor found above,
     // substituting type parameters as appropriate.
@@ -1353,7 +1354,7 @@ class ClassElementImpl extends AbstractClassElementImpl
           implicitParameter.parameterKind = superParameter.parameterKind;
           implicitParameter.isSynthetic = true;
           implicitParameter.type =
-              superParameter.type.substitute2(argumentTypes, parameterTypes);
+              substitution.substituteType(superParameter.type);
           implicitParameters[i] = implicitParameter;
         }
         implicitConstructor.parameters = implicitParameters;
@@ -6443,18 +6444,33 @@ class GenericTypeAliasElementImpl extends ElementImpl
 
   @override
   FunctionType instantiate(List<DartType> argumentTypes) {
-    return doInstantiate(this, argumentTypes);
+    return instantiate2(
+      typeArguments: argumentTypes,
+      nullabilitySuffix: NullabilitySuffix.star,
+    );
   }
 
   @override
   FunctionType instantiate2({
     @required List<DartType> typeArguments,
     @required NullabilitySuffix nullabilitySuffix,
   }) {
+    if (function == null) {
+      return null;
+    }
+
+    if (typeArguments.length != typeParameters.length) {
+      throw new ArgumentError(
+          "typeArguments.length (${typeArguments.length}) != "
+          "typeParameters.length (${typeParameters.length})");
+    }
+
+    var substitution = Substitution.fromPairs(typeParameters, typeArguments);
+    var type = substitution.substituteType(function.type) as FunctionType;
     return FunctionTypeImpl.synthetic(
-      returnType,
-      typeParameters,
-      parameters,
+      type.returnType,
+      type.typeFormals,
+      type.parameters,
       element: this,
       typeArguments: typeArguments,
       nullabilitySuffix: nullabilitySuffix,
@@ -6467,47 +6483,6 @@ class GenericTypeAliasElementImpl extends ElementImpl
     safelyVisitChildren(typeParameters, visitor);
     function?.accept(visitor);
   }
-
-  static FunctionType doInstantiate(
-      FunctionTypeAliasElement element, List<DartType> argumentTypes) {
-    if (argumentTypes.length != element.typeParameters.length) {
-      throw new ArgumentError('Wrong number of type arguments supplied');
-    }
-    if (element.typeParameters.isEmpty) return element.function.type;
-    return typeAfterSubstitution(element, argumentTypes);
-  }
-
-  /// Return the type of the function defined by this typedef after substituting
-  /// the given [typeArguments] for the type parameters defined for this typedef
-  /// (but not the type parameters defined by the function). If the number of
-  /// [typeArguments] does not match the number of type parameters, then
-  /// `dynamic` will be used in place of each of the type arguments.
-  static FunctionType typeAfterSubstitution(
-      FunctionTypeAliasElement element, List<DartType> typeArguments) {
-    GenericFunctionTypeElement function = element.function;
-    if (function == null) {
-      return null;
-    }
-    FunctionType functionType = function.type;
-
-    List<TypeParameterElement> parameterElements = element.typeParameters;
-    int parameterCount = parameterElements.length;
-
-    if (typeArguments == null ||
-        parameterElements.length != typeArguments.length) {
-      DartType dynamicType = element.context.typeProvider.dynamicType;
-      typeArguments = new List<DartType>.filled(parameterCount, dynamicType);
-    }
-
-    if (element is GenericTypeAliasElementImpl && element.linkedNode != null) {
-      return Substitution.fromPairs(parameterElements, typeArguments)
-          .substituteType(functionType);
-    }
-
-    List<DartType> parameterTypes =
-        TypeParameterTypeImpl.getTypes(parameterElements);
-    return functionType.substitute2(typeArguments, parameterTypes);
-  }
 }
 
 /// A concrete implementation of a [HideElementCombinator].

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

@@ -779,6 +779,7 @@ class FunctionTypeAliasElementHandle extends ElementHandle
   @override
   FunctionTypeAlias computeNode() => actualElement.computeNode();
 
+  @deprecated
   @override
   FunctionType instantiate(List<DartType> argumentTypes) =>
       actualElement.instantiate(argumentTypes);
@@ -837,6 +838,7 @@ class GenericTypeAliasElementHandle extends ElementHandle
   @override
   FunctionTypeAlias computeNode() => actualElement.computeNode();
 
+  @deprecated
   @override
   FunctionType instantiate(List<DartType> argumentTypes) =>
       actualElement.instantiate(argumentTypes);

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

@@ -2856,6 +2856,7 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
    * Return a list containing the type parameter types defined by the given
    * array of type parameter elements ([typeParameters]).
    */
+  @deprecated
   static List<TypeParameterType> getTypes(
       List<TypeParameterElement> typeParameters) {
     int count = typeParameters.length;

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

@@ -42,6 +42,43 @@ FreshTypeParameters getFreshTypeParameters(
   return new FreshTypeParameters(freshParameters, substitution);
 }
 
+/// Given a generic function [type] of a class member (so that it does not
+/// carry its element and type arguments), substitute its type parameters with
+/// the [newTypeParameters] in the formal parameters and return type.
+FunctionType replaceTypeParameters(
+  FunctionTypeImpl type,
+  List<TypeParameterElement> newTypeParameters,
+) {
+  assert(newTypeParameters.length == type.typeFormals.length);
+  if (newTypeParameters.isEmpty) {
+    return type;
+  }
+
+  var typeArguments = newTypeParameters
+      .map((e) => e.instantiate(nullabilitySuffix: type.nullabilitySuffix))
+      .toList();
+  var substitution = Substitution.fromPairs(type.typeFormals, typeArguments);
+
+  ParameterElement transformParameter(ParameterElement p) {
+    var type = p.type;
+    var newType = substitution.substituteType(type);
+    if (identical(newType, type)) return p;
+    return ParameterElementImpl.synthetic(
+      p.name,
+      newType,
+      // ignore: deprecated_member_use_from_same_package
+      p.parameterKind,
+    )..isExplicitlyCovariant = p.isCovariant;
+  }
+
+  return FunctionTypeImpl.synthetic(
+    substitution.substituteType(type.returnType),
+    newTypeParameters,
+    type.parameters.map(transformParameter).toList(),
+    nullabilitySuffix: type.nullabilitySuffix,
+  );
+}
+
 /// Returns a type where all occurrences of the given type parameters have been
 /// replaced with the corresponding types.
 ///

pkg/analyzer/lib/src/error/type_arguments_verifier.dart

@@ -308,8 +308,7 @@ class TypeArgumentsVerifier {
     var genericType = node.function.staticType;
     var instantiatedType = node.staticInvokeType;
     if (genericType is FunctionType && instantiatedType is FunctionType) {
-      var fnTypeParams =
-          TypeParameterTypeImpl.getTypes(genericType.typeFormals);
+      var fnTypeParams = genericType.typeFormals;
       var typeArgs = typeArgumentList.map((t) => t.type).toList();
 
       // If the amount mismatches, clean up the lists to be substitutable. The
@@ -338,8 +337,13 @@ class TypeArgumentsVerifier {
           continue;
         }
 
-        DartType bound =
-            fnTypeParams[i].bound.substitute2(typeArgs, fnTypeParams);
+        var rawBound = fnTypeParams[i].bound;
+        if (rawBound == null) {
+          continue;
+        }
+
+        var substitution = Substitution.fromPairs(fnTypeParams, typeArgs);
+        var bound = substitution.substituteType(rawBound);
         if (!_typeSystem.isSubtypeOf(argType, bound)) {
           _errorReporter.reportTypeErrorForNode(
               CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,

pkg/analyzer/lib/src/generated/resolver.dart

@@ -6208,9 +6208,11 @@ class TypeNameResolver {
         }
       }
       if (element is GenericTypeAliasElementImpl) {
-        type = GenericTypeAliasElementImpl.typeAfterSubstitution(
-                element, typeArguments) ??
-            dynamicType;
+        type = element.instantiate2(
+          typeArguments: typeArguments,
+          nullabilitySuffix: _getNullability(node.question != null),
+        );
+        type ??= dynamicType;
       } else {
         type = typeSystem.instantiateType(type, typeArguments);
       }
@@ -6219,14 +6221,14 @@ class TypeNameResolver {
       );
     } else {
       if (element is GenericTypeAliasElementImpl) {
-        List<DartType> typeArguments =
-            typeSystem.instantiateTypeFormalsToBounds2(element);
-        type = GenericTypeAliasElementImpl.typeAfterSubstitution(
-                element, typeArguments) ??
-            dynamicType;
-        type = (type as TypeImpl).withNullability(
-          _getNullability(node.question != null),
+        var typeArguments = typeSystem.instantiateTypeFormalsToBounds(
+          element.typeParameters,
+        );
+        type = element.instantiate2(
+          typeArguments: typeArguments,
+          nullabilitySuffix: _getNullability(node.question != null),
         );
+        type ??= dynamicType;
       } else {
         type = typeSystem.instantiateToBounds(type);
       }

pkg/analyzer/lib/src/generated/type_system.dart

@@ -1249,8 +1249,11 @@ class GenericInferrer {
 
     // Since we're trying to infer the instantiation, we want to ignore type
     // formals as we check the parameters and return type.
-    var inferFnType =
-        fnType.instantiate(TypeParameterTypeImpl.getTypes(fnType.typeFormals));
+    var inferFnType = FunctionTypeImpl.synthetic(
+      fnType.returnType,
+      const [],
+      fnType.parameters,
+    );
     tryMatchSubtypeOf(inferFnType, contextType, origin, covariant: true);
   }
 
@@ -2687,16 +2690,6 @@ abstract class TypeSystem implements public.TypeSystem {
     }
   }
 
-  /**
-   * Given a [DartType] type, return the [DartType]s corresponding
-   * to its formal type parameters (if any).
-   *
-   * @param type the type whose type arguments are to be returned
-   * @return the type arguments associated with the given type
-   */
-  List<DartType> typeFormalsAsTypes(DartType type) =>
-      TypeParameterTypeImpl.getTypes(typeFormalsAsElements(type));
-
   /**
    * Compute the least upper bound of function types [f] and [g].
    *

pkg/analyzer/lib/src/summary2/lazy_ast.dart

@@ -19,6 +19,7 @@ class LazyAst {
   static const _hasOverrideInferenceKey = 'lazyAst_hasOverrideInference';
   static const _inheritsCovariantKey = 'lazyAst_isCovariant';
   static const _isSimplyBoundedKey = 'lazyAst_simplyBounded';
+  static const _rawFunctionTypeKey = 'lazyAst_rawFunctionType';
   static const _returnTypeKey = 'lazyAst_returnType';
   static const _typeInferenceErrorKey = 'lazyAst_typeInferenceError';
   static const _typeKey = 'lazyAst_type';
@@ -39,6 +40,10 @@ class LazyAst {
     return node.getProperty(_inheritsCovariantKey) ?? false;
   }
 
+  static DartType getRawFunctionType(AstNode node) {
+    return node.getProperty(_rawFunctionTypeKey);
+  }
+
   static DartType getReturnType(AstNode node) {
     return node.getProperty(_returnTypeKey);
   }
@@ -75,6 +80,10 @@ class LazyAst {
     node.setProperty(_hasOverrideInferenceKey, true);
   }
 
+  static void setRawFunctionType(AstNode node, DartType type) {
+    node.setProperty(_rawFunctionTypeKey, type);
+  }
+
   static void setReturnType(AstNode node, DartType type) {
     node.setProperty(_returnTypeKey, type);
   }