Elements. Migrate FunctionTypeBuilder.

Change-Id: I9fc6acd85170a328c99b624da29d8e6fd7ffb769
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/407162
Reviewed-by: Samuel Rawlins <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -4654,6 +4654,10 @@ class FormalParameterElementImpl extends PromotableElementImpl2
   // TODO(augmentations): Implement the merge of formal parameters.
   TypeImpl get type => wrappedElement.type;
 
+  set type(TypeImpl value) {
+    wrappedElement.type = value;
+  }
+
   @override
   // TODO(augmentations): Implement the merge of formal parameters.
   List<TypeParameterElement2> get typeParameters2 => const [];

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

@@ -55,20 +55,20 @@ class ReplacementVisitor
 
   DartType? createFunctionTypeBuilder({
     required FunctionTypeBuilder type,
-    required List<TypeParameterElement2>? newTypeParameters,
-    required List<FormalParameterElement>? newParameters,
+    required List<TypeParameterElementImpl2>? newTypeParameters,
+    required List<FormalParameterElementImpl>? newFormalParameters,
     required TypeImpl? newReturnType,
     required NullabilitySuffix? newNullability,
   }) {
     if (newNullability == null &&
         newReturnType == null &&
-        newParameters == null) {
+        newFormalParameters == null) {
       return null;
     }
 
     return FunctionTypeBuilder.v2(
       typeParameters: newTypeParameters ?? type.typeParameters,
-      formalParameters: newParameters ?? type.formalParameters,
+      formalParameters: newFormalParameters ?? type.formalParameters,
       returnType: newReturnType ?? type.returnType,
       nullabilitySuffix: newNullability ?? type.nullabilitySuffix,
     );
@@ -330,7 +330,7 @@ class ReplacementVisitor
 
     changeVariance();
 
-    List<FormalParameterElement>? newParameters;
+    List<FormalParameterElementImpl>? newFormalParameters;
     for (var i = 0; i < node.formalParameters.length; i++) {
       var parameter = node.formalParameters[i];
 
@@ -341,8 +341,8 @@ class ReplacementVisitor
       var newKind = visitParameterKind(kind);
 
       if (newType != null || newKind != null) {
-        newParameters ??= node.formalParameters.toList(growable: false);
-        newParameters[i] = parameter.copyWith(
+        newFormalParameters ??= node.formalParameters.toList(growable: false);
+        newFormalParameters[i] = parameter.copyWith(
           type: newType,
           kind: newKind,
         );
@@ -354,7 +354,7 @@ class ReplacementVisitor
     return createFunctionTypeBuilder(
       type: node,
       newTypeParameters: newTypeParameters,
-      newParameters: newParameters,
+      newFormalParameters: newFormalParameters,
       newReturnType: newReturnType,
       newNullability: newNullability,
     );

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

@@ -544,18 +544,21 @@ abstract class _TypeSubstitutor
     int before = useCounter;
 
     var inner = this;
-    var typeFormals = type.typeFormals;
-    if (typeFormals.isNotEmpty) {
+    var typeParameters = type.typeParameters;
+    if (typeParameters.isNotEmpty) {
       inner = newInnerEnvironment();
-      typeFormals = inner.freshTypeParameters(typeFormals);
+      typeParameters = inner
+          .freshTypeParameters(typeParameters.map((e) => e.asElement).toList())
+          .map((e) => e.asElement2 as TypeParameterElementImpl2)
+          .toList();
     }
 
     // Invert the variance when translating parameters.
     inner.invertVariance();
 
-    var parameters = type.parameters.map((parameter) {
-      var type = parameter.type.accept(inner);
-      return parameter.copyWith(type: type);
+    var formalParameters = type.formalParameters.map((formalParameter) {
+      var type = formalParameter.type.accept(inner);
+      return formalParameter.copyWith(type: type);
     }).toList();
 
     inner.invertVariance();
@@ -567,8 +570,8 @@ abstract class _TypeSubstitutor
     if (useCounter == before) return type;
 
     return FunctionTypeBuilder(
-      typeFormals,
-      parameters,
+      typeParameters,
+      formalParameters,
       returnType,
       type.nullabilitySuffix,
     );

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

@@ -2,10 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// ignore_for_file: analyzer_use_new_elements
-
-import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/type_visitor.dart';
@@ -17,14 +13,13 @@ import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_visitor.dart';
 import 'package:analyzer/src/summary2/type_builder.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
-import 'package:analyzer/src/utilities/extensions/element.dart';
 
 /// The type builder for a [GenericFunctionType].
 class FunctionTypeBuilder extends TypeBuilder {
   static DynamicTypeImpl get _dynamicType => DynamicTypeImpl.instance;
 
-  final List<TypeParameterElement> typeFormals;
-  final List<ParameterElement> parameters;
+  final List<TypeParameterElementImpl2> typeParameters;
+  final List<FormalParameterElementImpl> formalParameters;
   final TypeImpl returnType;
 
   @override
@@ -42,8 +37,8 @@ class FunctionTypeBuilder extends TypeBuilder {
   FunctionTypeImpl? _type;
 
   FunctionTypeBuilder(
-    this.typeFormals,
-    this.parameters,
+    this.typeParameters,
+    this.formalParameters,
     this.returnType,
     this.nullabilitySuffix, {
     this.node,
@@ -63,29 +58,21 @@ class FunctionTypeBuilder extends TypeBuilder {
   }
 
   factory FunctionTypeBuilder.v2({
-    required List<TypeParameterElement2> typeParameters,
-    required List<FormalParameterElement> formalParameters,
+    required List<TypeParameterElementImpl2> typeParameters,
+    required List<FormalParameterElementImpl> formalParameters,
     required TypeImpl returnType,
     required NullabilitySuffix nullabilitySuffix,
     GenericFunctionTypeImpl? node,
   }) {
     return FunctionTypeBuilder(
-      typeParameters.map((e) => e.asElement).toList(),
-      formalParameters.map((e) => e.asElement).toList(),
+      typeParameters,
+      formalParameters,
       returnType,
       nullabilitySuffix,
       node: node,
     );
   }
 
-  List<FormalParameterElementMixin> get formalParameters {
-    return parameters.map((p) => p.asElement2).toList(growable: false);
-  }
-
-  List<TypeParameterElementImpl2> get typeParameters => typeFormals
-      .map((fragment) => fragment.asElement2 as TypeParameterElementImpl2)
-      .toList();
-
   @override
   R accept<R>(TypeVisitor<R> visitor) {
     if (visitor is LinkingTypeVisitor<R>) {
@@ -103,27 +90,26 @@ class FunctionTypeBuilder extends TypeBuilder {
       return type;
     }
 
-    for (var typeParameter in typeFormals) {
-      var typeParameterImpl = typeParameter as TypeParameterElementImpl;
-      var bound = typeParameterImpl.bound;
+    for (var typeParameter in typeParameters) {
+      var bound = typeParameter.bound;
       if (bound != null) {
-        typeParameterImpl.bound = _buildType(bound);
+        typeParameter.bound = _buildType(bound);
       }
     }
 
-    for (var parameter in parameters) {
-      (parameter as ParameterElementImpl).type = _buildType(parameter.type);
+    for (var formalParameter in formalParameters) {
+      formalParameter.type = _buildType(formalParameter.type);
     }
 
     var builtReturnType = _buildType(returnType);
-    type = FunctionTypeImpl(
-      typeFormals: typeFormals,
-      parameters: parameters,
+    type = FunctionTypeImpl.v2(
+      typeParameters: typeParameters,
+      formalParameters: formalParameters,
       returnType: builtReturnType,
       nullabilitySuffix: nullabilitySuffix,
     );
 
-    var fresh = getFreshTypeParameters(typeFormals);
+    var fresh = getFreshTypeParameters2(typeParameters);
     type = fresh.applyToFunctionType(type);
 
     _type = type;
@@ -135,14 +121,14 @@ class FunctionTypeBuilder extends TypeBuilder {
   String toString() {
     var buffer = StringBuffer();
 
-    if (typeFormals.isNotEmpty) {
+    if (typeParameters.isNotEmpty) {
       buffer.write('<');
-      buffer.write(typeFormals.join(', '));
+      buffer.write(typeParameters.join(', '));
       buffer.write('>');
     }
 
     buffer.write('(');
-    buffer.write(parameters.join(', '));
+    buffer.write(formalParameters.join(', '));
     buffer.write(')');
 
     buffer.write(' → ');
@@ -158,19 +144,19 @@ class FunctionTypeBuilder extends TypeBuilder {
     }
 
     return FunctionTypeBuilder(
-      typeFormals,
-      parameters,
+      typeParameters,
+      formalParameters,
       returnType,
       nullabilitySuffix,
       node: node,
     );
   }
 
-  static List<ParameterElementImpl> getParameters(
-    FormalParameterList node,
+  static List<FormalParameterElementImpl> getParameters(
+    FormalParameterListImpl node,
   ) {
-    return node.parameters.asImpl.map((parameter) {
-      return ParameterElementImpl.synthetic(
+    return node.parameters.map((parameter) {
+      return FormalParameterElementImpl.synthetic(
         parameter.name?.lexeme ?? '',
         _getParameterType(parameter),
         parameter.kind,
@@ -197,12 +183,12 @@ class FunctionTypeBuilder extends TypeBuilder {
   }
 
   /// Return the type of the [node] as is, possibly a [TypeBuilder].
-  static DartType _getParameterType(FormalParameter node) {
-    if (node is DefaultFormalParameter) {
+  static DartType _getParameterType(FormalParameterImpl node) {
+    if (node is DefaultFormalParameterImpl) {
       return _getParameterType(node.parameter);
-    } else if (node is SimpleFormalParameter) {
+    } else if (node is SimpleFormalParameterImpl) {
       return _getNodeType(node.type);
-    } else if (node is FunctionTypedFormalParameter) {
+    } else if (node is FunctionTypedFormalParameterImpl) {
       NullabilitySuffix nullabilitySuffix;
       if (node.question != null) {
         nullabilitySuffix = NullabilitySuffix.question;
@@ -221,10 +207,12 @@ class FunctionTypeBuilder extends TypeBuilder {
     }
   }
 
-  static List<TypeParameterElement> _getTypeParameters(
-    TypeParameterList? node,
+  static List<TypeParameterElementImpl2> _getTypeParameters(
+    TypeParameterListImpl? node,
   ) {
     if (node == null) return const [];
-    return node.typeParameters.map((n) => n.declaredElement!).toFixedList();
+    return node.typeParameters.map((node) {
+      return node.declaredFragment!.element;
+    }).toFixedList();
   }
 }

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

@@ -104,8 +104,8 @@ class VarianceBuilder {
       return _computeFunctionType(
         variable,
         returnType: type.returnType,
-        typeFormals: type.typeFormals,
-        parameters: type.parameters,
+        typeFormals: type.typeParameters.map((e) => e.asElement).toList(),
+        parameters: type.formalParameters.map((e) => e.asElement).toList(),
       );
     } else if (type is RecordTypeBuilder) {
       var result = Variance.unrelated;
@@ -153,7 +153,7 @@ class VarianceBuilder {
     return result;
   }
 
-  void _functionTypeAlias(FunctionTypeAlias node) {
+  void _functionTypeAlias(FunctionTypeAliasImpl node) {
     var parameterList = node.typeParameters;
     if (parameterList == null) {
       return;
@@ -179,7 +179,9 @@ class VarianceBuilder {
           parameter.declaredElement!,
           returnType: node.returnType?.type,
           typeFormals: null,
-          parameters: FunctionTypeBuilder.getParameters(node.parameters),
+          parameters: FunctionTypeBuilder.getParameters(node.parameters)
+              .map((e) => e.asElement)
+              .toList(),
         );
         _setVariance(parameter, variance);
       }
@@ -231,9 +233,9 @@ class VarianceBuilder {
     var node = _linker.getLinkingNode(element);
     if (node == null) {
       // Not linking.
-    } else if (node is GenericTypeAlias) {
+    } else if (node is GenericTypeAliasImpl) {
       _genericTypeAlias(node);
-    } else if (node is FunctionTypeAlias) {
+    } else if (node is FunctionTypeAliasImpl) {
       _functionTypeAlias(node);
     } else {
       throw UnimplementedError('(${node.runtimeType}) $node');