Elements. Switch FunctionTypeImpl to typeParameters, remove typeFormals.

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

Author: scheglov

pkg/analysis_server/lib/src/services/correction/dart/create_method_or_function.dart

@@ -161,7 +161,7 @@ class CreateMethodOrFunction extends ResolvedCorrectionProducer {
     }
     if (parameterType is InterfaceType && parameterType.isDartCoreFunction) {
       return FunctionTypeImpl(
-        typeFormals: const [],
+        typeParameters: const [],
         parameters: const [],
         returnType: DynamicTypeImpl.instance,
         nullabilitySuffix: NullabilitySuffix.none,

pkg/analysis_server_plugin/lib/edit/dart/correction_producer.dart

@@ -517,7 +517,7 @@ abstract class ResolvedCorrectionProducer
         var type = conditionalExpression.correspondingParameter?.type;
         if (type is InterfaceType && type.isDartCoreFunction) {
           return FunctionTypeImpl(
-            typeFormals: const [],
+            typeParameters: const [],
             parameters: const [],
             returnType: DynamicTypeImpl.instance,
             nullabilitySuffix: NullabilitySuffix.none,

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -110,7 +110,7 @@ testFineAfterLibraryAnalyzerHook;
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 484;
+  static const int DATA_VERSION = 487;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

pkg/analyzer/lib/src/dart/constant/evaluation.dart

@@ -858,7 +858,7 @@ class ConstantVisitor extends UnifyingAstVisitor<Constant> {
 
     TypeAliasElement? viaTypeAlias;
     if (typeElement is TypeAliasElementImpl) {
-      if (constructorFunctionType.typeFormals.isNotEmpty &&
+      if (constructorFunctionType.typeParameters.isNotEmpty &&
           !typeElement.isProperRename) {
         // The type alias is not a proper rename of the aliased class, so
         // the constructor tear-off is distinct from the associated
@@ -2169,7 +2169,7 @@ class ConstantVisitor extends UnifyingAstVisitor<Constant> {
       return value;
     }
     var valueType = functionElement.type;
-    if (valueType.typeFormals.isNotEmpty) {
+    if (valueType.typeParameters.isNotEmpty) {
       var typeArgumentTypes = node.typeArgumentTypes;
       if (typeArgumentTypes != null && typeArgumentTypes.isNotEmpty) {
         var instantiatedType = functionElement.type.instantiate(
@@ -2204,7 +2204,7 @@ class ConstantVisitor extends UnifyingAstVisitor<Constant> {
       return value;
     }
     var valueType = functionElement.type;
-    if (valueType.typeFormals.isNotEmpty) {
+    if (valueType.typeParameters.isNotEmpty) {
       var tearOffTypeArgumentTypes = node.tearOffTypeArgumentTypes;
       if (tearOffTypeArgumentTypes != null &&
           tearOffTypeArgumentTypes.isNotEmpty) {
@@ -2710,15 +2710,15 @@ class DartObjectComputer {
   ) {
     var rawType = function.type;
     if (rawType is FunctionTypeImpl) {
-      if (typeArguments.length != rawType.typeFormals.length) {
+      if (typeArguments.length != rawType.typeParameters.length) {
         if (node is SimpleIdentifier) {
           return InvalidConstant.forEntity(
             entity: typeArgumentsErrorNode,
             diagnosticCode:
                 CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION,
             arguments: [
               node.name,
-              rawType.typeFormals.length,
+              rawType.typeParameters.length,
               typeArguments.length,
             ],
           );
@@ -2728,7 +2728,7 @@ class DartObjectComputer {
           diagnosticCode:
               CompileTimeErrorCode
                   .WRONG_NUMBER_OF_TYPE_ARGUMENTS_ANONYMOUS_FUNCTION,
-          arguments: [rawType.typeFormals.length, typeArguments.length],
+          arguments: [rawType.typeParameters.length, typeArguments.length],
         );
       }
       var type = rawType.instantiate(typeArguments);

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

@@ -1100,7 +1100,7 @@ class ConstructorFragmentImpl extends ExecutableFragmentImpl
   FunctionTypeImpl get type {
     // TODO(scheglov): Remove "element" in the breaking changes branch.
     return _type ??= FunctionTypeImpl(
-      typeFormals: typeParameters,
+      typeParameters: typeParameters.map((f) => f.asElement2).toList(),
       parameters: parameters.map((f) => f.asElement2).toList(),
       returnType: returnType,
       nullabilitySuffix: NullabilitySuffix.none,
@@ -2360,7 +2360,7 @@ abstract class ExecutableFragmentImpl extends _ExistingFragmentImpl
     if (_type != null) return _type!;
 
     return _type = FunctionTypeImpl(
-      typeFormals: typeParameters,
+      typeParameters: typeParameters.map((f) => f.asElement2).toList(),
       parameters: parameters.map((f) => f.asElement2).toList(),
       returnType: returnType,
       nullabilitySuffix: NullabilitySuffix.none,
@@ -4076,7 +4076,7 @@ class GenericFunctionTypeFragmentImpl extends _ExistingFragmentImpl
     if (_type != null) return _type!;
 
     return _type = FunctionTypeImpl(
-      typeFormals: typeParameters,
+      typeParameters: typeParameters.map((f) => f.asElement2).toList(),
       parameters: parameters.map((f) => f.asElement2).toList(),
       returnType: returnType,
       nullabilitySuffix:
@@ -9461,9 +9461,9 @@ class TypeAliasElementImpl extends TypeDefiningElementImpl
             : nullabilitySuffix;
 
     if (type is FunctionTypeImpl) {
-      return FunctionTypeImpl(
-        typeFormals: type.typeFormals,
-        parameters: type.parameters,
+      return FunctionTypeImpl.v2(
+        typeParameters: type.typeParameters,
+        formalParameters: type.parameters,
         returnType: type.returnType,
         nullabilitySuffix: resultNullability,
         alias: InstantiatedTypeAliasElementImpl(
@@ -9507,7 +9507,7 @@ class TypeAliasElementImpl extends TypeDefiningElementImpl
 
   FunctionTypeImpl _errorFunctionType(NullabilitySuffix nullabilitySuffix) {
     return FunctionTypeImpl(
-      typeFormals: const [],
+      typeParameters: const [],
       parameters: const [],
       returnType: DynamicTypeImpl.instance,
       nullabilitySuffix: nullabilitySuffix,
@@ -9659,6 +9659,11 @@ class TypeParameterElementImpl extends TypeDefiningElementImpl
     }
   }
 
+  factory TypeParameterElementImpl.synthetic({required String name}) {
+    var fragment = TypeParameterFragmentImpl.synthetic(name2: name);
+    return TypeParameterElementImpl(firstFragment: fragment, name3: name);
+  }
+
   @override
   TypeParameterElement get baseElement => this;
 

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

@@ -232,7 +232,7 @@ 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(
-      typeFormals: const [],
+      typeParameters: const [],
       parameters: fnType.parameters,
       returnType: fnType.returnType,
       nullabilitySuffix: fnType.nullabilitySuffix,
@@ -343,7 +343,7 @@ class GenericInferrer {
       }
 
       if (inferred is FunctionTypeImpl &&
-          inferred.typeFormals.isNotEmpty &&
+          inferred.typeParameters.isNotEmpty &&
           !genericMetadataIsEnabled &&
           _diagnosticReporter != null) {
         if (failAtError) {
@@ -357,15 +357,15 @@ class GenericInferrer {
           return null;
         }
 
-        var typeFormals = inferred.typeFormals;
-        var typeFormalsStr = typeFormals.map(_elementStr).join(', ');
+        var typeParameters = inferred.typeParameters;
+        var typeParametersStr = typeParameters.map(_elementStr).join(', ');
         _diagnosticReporter.atEntity(
           errorEntity!,
           CompileTimeErrorCode.COULD_NOT_INFER,
           arguments: [
             name,
             ' Inferred candidate type ${_typeStr(inferred)} has type parameters'
-                ' [$typeFormalsStr], but a function with'
+                ' [$typeParametersStr], but a function with'
                 ' type parameters cannot be used as a type argument.',
           ],
         );
@@ -621,8 +621,8 @@ class GenericInferrer {
     }
   }
 
-  String _elementStr(FragmentImpl element) {
-    return element.getDisplayString();
+  String _elementStr(ElementImpl element) {
+    return element.displayString2();
   }
 
   String _formatError(

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

@@ -253,8 +253,8 @@ class GreatestLowerBoundHelper {
   /// https://github.com/dart-lang/language
   /// See `resources/type-system/upper-lower-bounds.md`
   TypeImpl _functionType(FunctionTypeImpl f, FunctionTypeImpl g) {
-    var fTypeFormals = f.typeFormals;
-    var gTypeFormals = g.typeFormals;
+    var fTypeFormals = f.typeParameters;
+    var gTypeFormals = g.typeParameters;
 
     // The number of type parameters must be the same.
     // Otherwise the result is `Never`.

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

@@ -1083,7 +1083,8 @@ class InheritanceManager3 {
         nameOffset: -1,
       );
       resultFragment.enclosingElement3 = targetClass.firstFragment;
-      resultFragment.typeParameters = resultType.typeFormals;
+      resultFragment.typeParameters =
+          resultType.typeParameters.map((e) => e.firstFragment).toList();
       resultFragment.returnType = resultType.returnType;
       // TODO(scheglov): check if can type cast instead
       resultFragment.parameters =

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

@@ -15,7 +15,6 @@ import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
-import 'package:analyzer/src/utilities/extensions/element.dart';
 import 'package:collection/collection.dart';
 
 /// Returns a [List] of fixed length with given types.
@@ -92,9 +91,8 @@ class FunctionTypeImpl extends TypeImpl
   @override
   final TypeImpl returnType;
 
-  /// The formal type parameters of this generic function; for example,
-  /// `<T> T -> T`.
-  final List<TypeParameterFragmentImpl> typeFormals;
+  @override
+  final List<TypeParameterElementImpl> typeParameters;
 
   /// A list containing the parameters elements of this type of function.
   ///
@@ -126,7 +124,7 @@ class FunctionTypeImpl extends TypeImpl
   final List<FormalParameterElementMixin> sortedNamedParameters;
 
   factory FunctionTypeImpl({
-    required List<TypeParameterFragmentImpl> typeFormals,
+    required List<TypeParameterElementImpl> typeParameters,
     required List<FormalParameterElementMixin> parameters,
     required TypeImpl returnType,
     required NullabilitySuffix nullabilitySuffix,
@@ -176,7 +174,7 @@ class FunctionTypeImpl extends TypeImpl
       );
     }
     return FunctionTypeImpl._(
-      typeFormals: typeFormals,
+      typeParameters: typeParameters,
       parameters: parameters,
       returnType: returnType,
       nullabilitySuffix: nullabilitySuffix,
@@ -195,7 +193,7 @@ class FunctionTypeImpl extends TypeImpl
     InstantiatedTypeAliasElementImpl? alias,
   }) {
     return FunctionTypeImpl(
-      typeFormals: typeParameters.map((e) => e.asElement).toList(),
+      typeParameters: typeParameters,
       parameters: formalParameters,
       returnType: returnType,
       nullabilitySuffix: nullabilitySuffix,
@@ -204,7 +202,7 @@ class FunctionTypeImpl extends TypeImpl
   }
 
   FunctionTypeImpl._({
-    required this.typeFormals,
+    required this.typeParameters,
     required this.parameters,
     required this.returnType,
     required this.nullabilitySuffix,
@@ -254,10 +252,6 @@ class FunctionTypeImpl extends TypeImpl
   List<FormalParameterElementMixin> get sortedNamedParametersShared =>
       sortedNamedParameters;
 
-  @override
-  List<TypeParameterElementImpl> get typeParameters =>
-      typeFormals.map((fragment) => fragment.element).toList();
-
   @override
   List<TypeParameterElementImpl> get typeParametersShared => typeParameters;
 
@@ -272,13 +266,13 @@ class FunctionTypeImpl extends TypeImpl
         return false;
       }
 
-      if (other.typeFormals.length != typeFormals.length) {
+      if (other.typeParameters.length != typeParameters.length) {
         return false;
       }
       // `<T>T -> T` should be equal to `<U>U -> U`
       // To test this, we instantiate both types with the same (unique) type
       // variables, and see if the result is equal.
-      if (typeFormals.isNotEmpty) {
+      if (typeParameters.isNotEmpty) {
         var freshVariables = FunctionTypeImpl.relateTypeFormals(
           this,
           other,
@@ -330,7 +324,7 @@ class FunctionTypeImpl extends TypeImpl
 
     return FunctionTypeImpl(
       returnType: substitution.substituteType(returnType),
-      typeFormals: const [],
+      typeParameters: const [],
       parameters:
           parameters
               .map((p) => ParameterMember.from2(p, substitution))
@@ -341,8 +335,8 @@ class FunctionTypeImpl extends TypeImpl
 
   @override
   bool referencesAny(Set<TypeParameterElementImpl> parameters) {
-    if (typeFormals.any((element) {
-      assert(!parameters.contains(element.asElement2));
+    if (typeParameters.any((element) {
+      assert(!parameters.contains(element));
 
       var bound = element.bound;
       if (bound != null && bound.referencesAny(parameters)) {
@@ -369,7 +363,7 @@ class FunctionTypeImpl extends TypeImpl
   TypeImpl withNullability(NullabilitySuffix nullabilitySuffix) {
     if (this.nullabilitySuffix == nullabilitySuffix) return this;
     return FunctionTypeImpl._(
-      typeFormals: typeFormals,
+      typeParameters: typeParameters,
       parameters: parameters,
       returnType: returnType,
       nullabilitySuffix: nullabilitySuffix,
@@ -381,7 +375,7 @@ class FunctionTypeImpl extends TypeImpl
   }
 
   int _computeHashCode() {
-    if (typeFormals.isNotEmpty) {
+    if (typeParameters.isNotEmpty) {
       // Two generic function types are considered equivalent even if their type
       // formals have different names, so we need to normalize to a standard set
       // of type formals before taking the hash code.
@@ -391,7 +385,7 @@ class FunctionTypeImpl extends TypeImpl
       // parameter bounds will receive the same hash code; this should be rare
       // enough that it won't be a problem.
       return instantiate([
-        for (var i = 0; i < typeFormals.length; i++)
+        for (var i = 0; i < typeParameters.length; i++)
           TypeParameterTypeImpl(
             element: TypeParameterFragmentImpl.synthetic(name2: 'T$i').element,
             nullabilitySuffix: NullabilitySuffix.none,

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

@@ -66,7 +66,7 @@ FunctionTypeImpl replaceTypeParameters(
   FunctionTypeImpl type,
   List<TypeParameterElementImpl> newTypeParameters,
 ) {
-  assert(newTypeParameters.length == type.typeFormals.length);
+  assert(newTypeParameters.length == type.typeParameters.length);
   if (newTypeParameters.isEmpty) {
     return type;
   }
@@ -75,7 +75,10 @@ FunctionTypeImpl replaceTypeParameters(
       newTypeParameters
           .map((e) => e.instantiate(nullabilitySuffix: NullabilitySuffix.none))
           .toList();
-  var substitution = Substitution.fromPairs(type.typeFormals, typeArguments);
+  var substitution = Substitution.fromPairs2(
+    type.typeParameters,
+    typeArguments,
+  );
 
   FormalParameterElementMixin transformParameter(
     FormalParameterElementMixin p,