Revert "Deprecate TypeParameterTypeImpl.getTypes()"

This reverts commit aa0bd58.

Reason for revert: https://dart-review.googlesource.com/c/sdk/+/119587 was reverted. So, this change now breaks bots because of deprecated
getTypes() usage in DDC.

Original change's description:
> 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>

TBR=scheglov@google.com,brianwilkerson@google.com

Change-Id: I3dc1a700f496c25eea9898de658a31138bbedcce
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/120141
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

Author: scheglov

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

@@ -1207,7 +1207,6 @@ 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,17 +1312,16 @@ 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`.
-    var superTypeParameters = supertype.typeParameters;
+    List<DartType> parameterTypes =
+        TypeParameterTypeImpl.getTypes(supertype.typeParameters);
     List<DartType> argumentTypes = new List<DartType>.filled(
-        superTypeParameters.length, DynamicTypeImpl.instance);
+        parameterTypes.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.
@@ -1354,7 +1353,7 @@ class ClassElementImpl extends AbstractClassElementImpl
           implicitParameter.parameterKind = superParameter.parameterKind;
           implicitParameter.isSynthetic = true;
           implicitParameter.type =
-              substitution.substituteType(superParameter.type);
+              superParameter.type.substitute2(argumentTypes, parameterTypes);
           implicitParameters[i] = implicitParameter;
         }
         implicitConstructor.parameters = implicitParameters;
@@ -6444,33 +6443,18 @@ class GenericTypeAliasElementImpl extends ElementImpl
 
   @override
   FunctionType instantiate(List<DartType> argumentTypes) {
-    return instantiate2(
-      typeArguments: argumentTypes,
-      nullabilitySuffix: NullabilitySuffix.star,
-    );
+    return doInstantiate(this, argumentTypes);
   }
 
   @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(
-      type.returnType,
-      type.typeFormals,
-      type.parameters,
+      returnType,
+      typeParameters,
+      parameters,
       element: this,
       typeArguments: typeArguments,
       nullabilitySuffix: nullabilitySuffix,
@@ -6483,6 +6467,47 @@ 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,7 +779,6 @@ class FunctionTypeAliasElementHandle extends ElementHandle
   @override
   FunctionTypeAlias computeNode() => actualElement.computeNode();
 
-  @deprecated
   @override
   FunctionType instantiate(List<DartType> argumentTypes) =>
       actualElement.instantiate(argumentTypes);
@@ -838,7 +837,6 @@ 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,7 +2856,6 @@ 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,43 +42,6 @@ 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,7 +308,8 @@ class TypeArgumentsVerifier {
     var genericType = node.function.staticType;
     var instantiatedType = node.staticInvokeType;
     if (genericType is FunctionType && instantiatedType is FunctionType) {
-      var fnTypeParams = genericType.typeFormals;
+      var fnTypeParams =
+          TypeParameterTypeImpl.getTypes(genericType.typeFormals);
       var typeArgs = typeArgumentList.map((t) => t.type).toList();
 
       // If the amount mismatches, clean up the lists to be substitutable. The
@@ -337,13 +338,8 @@ class TypeArgumentsVerifier {
           continue;
         }
 
-        var rawBound = fnTypeParams[i].bound;
-        if (rawBound == null) {
-          continue;
-        }
-
-        var substitution = Substitution.fromPairs(fnTypeParams, typeArgs);
-        var bound = substitution.substituteType(rawBound);
+        DartType bound =
+            fnTypeParams[i].bound.substitute2(typeArgs, fnTypeParams);
         if (!_typeSystem.isSubtypeOf(argType, bound)) {
           _errorReporter.reportTypeErrorForNode(
               CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,

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

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

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

@@ -1249,11 +1249,8 @@ 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 = FunctionTypeImpl.synthetic(
-      fnType.returnType,
-      const [],
-      fnType.parameters,
-    );
+    var inferFnType =
+        fnType.instantiate(TypeParameterTypeImpl.getTypes(fnType.typeFormals));
     tryMatchSubtypeOf(inferFnType, contextType, origin, covariant: true);
   }
 
@@ -2690,6 +2687,16 @@ 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,7 +19,6 @@ 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';
@@ -40,10 +39,6 @@ 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);
   }
@@ -80,10 +75,6 @@ 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);
   }