Elements. Migrate FunctionExpressionResolver.

Change-Id: I447bd537d1c70351f659efd12f5e404e7251a7c2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/406401
Reviewed-by: Keerti Parthasarathy <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -18119,8 +18119,7 @@ final class TypeParameterImpl extends DeclarationImpl implements TypeParameter {
 
   @experimental
   @override
-  TypeParameterFragment? get declaredFragment =>
-      declaredElement as TypeParameterFragment?;
+  TypeParameterElementImpl? get declaredFragment => declaredElement;
 
   @override
   Token get endToken {

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

@@ -11563,7 +11563,7 @@ class TypeParameterElementImpl2 extends TypeDefiningElementImpl2
   }
 
   @override
-  TypeParameterType instantiate({
+  TypeParameterTypeImpl instantiate({
     required NullabilitySuffix nullabilitySuffix,
   }) {
     return TypeParameterTypeImpl.v2(

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

@@ -2,9 +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/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
@@ -34,15 +31,15 @@ class FunctionExpressionResolver {
           .executableDeclaration_enter(node, node.parameters, isClosure: true);
     }
 
-    bool wasFunctionTypeSupplied = contextType is FunctionType;
+    bool wasFunctionTypeSupplied = contextType is FunctionTypeImpl;
     node.wasFunctionTypeSupplied = wasFunctionTypeSupplied;
     DartType? imposedType;
     if (wasFunctionTypeSupplied) {
       var instantiatedType = _matchTypeParameters(
         node.typeParameters,
         contextType,
       );
-      if (instantiatedType is FunctionType) {
+      if (instantiatedType is FunctionTypeImpl) {
         _inferFormalParameters(node.parameters, instantiatedType);
         var returnType = instantiatedType.returnType;
         if (!(returnType is DynamicType || returnType is UnknownInferredType)) {
@@ -82,7 +79,7 @@ class FunctionExpressionResolver {
       return;
     }
 
-    void inferType(ParameterElementImpl p, TypeImpl inferredType) {
+    void inferType(FormalParameterElementImpl p, TypeImpl inferredType) {
       // Check that there is no declared type, and that we have not already
       // inferred a type in some fashion.
       if (p.hasImplicitType && p.type is DynamicType) {
@@ -98,39 +95,45 @@ class FunctionExpressionResolver {
           inferredType = _typeSystem.objectQuestion;
         }
         if (inferredType is! DynamicType) {
-          p.type = inferredType;
+          p.firstFragment.type = inferredType;
         }
       }
     }
 
-    var parameters = node.parameterElements.nonNulls;
+    var nodeParameterFragments = node.parameterFragments.nonNulls;
     {
-      Iterator<ParameterElement> positional =
-          parameters.where((p) => p.isPositional).iterator;
-      Iterator<ParameterElement> fnPositional =
-          contextType.parameters.where((p) => p.isPositional).iterator;
-      while (positional.moveNext() && fnPositional.moveNext()) {
+      var nodePositional = nodeParameterFragments
+          .map((fragment) => fragment.element)
+          .where((element) => element.isPositional)
+          .iterator;
+      var contextPositional = contextType.formalParameters
+          .where((element) => element.isPositional)
+          .iterator;
+      while (nodePositional.moveNext() && contextPositional.moveNext()) {
         inferType(
-            positional.current as ParameterElementImpl,
-            // TODO(paulberry): eliminate this cast by changing the type of
-            // `contextType` to `FunctionTypeImpl`.
-            fnPositional.current.type as TypeImpl);
+          nodePositional.current as FormalParameterElementImpl,
+          // TODO(paulberry): eliminate this cast by changing the type of
+          // `contextType` to `FunctionTypeImpl`.
+          contextPositional.current.type as TypeImpl,
+        );
       }
     }
 
     {
-      Map<String, DartType> namedParameterTypes =
-          contextType.namedParameterTypes;
-      Iterable<ParameterElement> named = parameters.where((p) => p.isNamed);
-      for (var p in named) {
-        if (!namedParameterTypes.containsKey(p.name)) {
+      var contextNamedTypes = contextType.namedParameterTypes;
+      var nodeNamed = nodeParameterFragments
+          .map((fragment) => fragment.element)
+          .where((element) => element.isNamed);
+      for (var element in nodeNamed) {
+        if (!contextNamedTypes.containsKey(element.name3)) {
           continue;
         }
         inferType(
-            p as ParameterElementImpl,
-            // TODO(paulberry): eliminate this cast by changing the type of
-            // `contextType` to `FunctionTypeImpl`.
-            namedParameterTypes[p.name]! as TypeImpl);
+          element as FormalParameterElementImpl,
+          // TODO(paulberry): eliminate this cast by changing the type of
+          // `contextType` to `FunctionTypeImpl`.
+          contextNamedTypes[element.name3]! as TypeImpl,
+        );
       }
     }
   }
@@ -140,32 +143,35 @@ class FunctionExpressionResolver {
   ///
   /// Return `null` is the number of element in [typeParameterList] is not
   /// the same as the number of type parameters in the [type].
-  FunctionType? _matchTypeParameters(
-      TypeParameterList? typeParameterList, FunctionType type) {
+  FunctionTypeImpl? _matchTypeParameters(
+      TypeParameterListImpl? typeParameterList, FunctionTypeImpl type) {
     if (typeParameterList == null) {
-      if (type.typeFormals.isEmpty) {
+      if (type.typeParameters.isEmpty) {
         return type;
       }
       return null;
     }
 
     var typeParameters = typeParameterList.typeParameters;
-    if (typeParameters.length != type.typeFormals.length) {
+    if (typeParameters.length != type.typeParameters.length) {
       return null;
     }
 
     return type.instantiate(typeParameters.map((typeParameter) {
-      return typeParameter.declaredElement!.instantiate(
+      return typeParameter.declaredFragment!.element.instantiate(
         nullabilitySuffix: NullabilitySuffix.none,
       );
     }).toList());
   }
 
   void _resolve2(FunctionExpressionImpl node, DartType? imposedType) {
-    var functionElement = node.declaredElement as ExecutableElementImpl;
+    var functionElement =
+        node.declaredFragment!.element as ExecutableElementImpl2;
 
     if (_shouldUpdateReturnType(node)) {
-      functionElement.returnType = imposedType ?? DynamicTypeImpl.instance;
+      var firstFragment =
+          functionElement.firstFragment as ExecutableElementImpl;
+      firstFragment.returnType = imposedType ?? DynamicTypeImpl.instance;
     }
 
     node.recordStaticType(functionElement.type, resolver: _resolver);

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

@@ -1197,6 +1197,11 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
       return expression;
     }
 
+    // Don't rewrite function declarations.
+    if (expression.parent is FunctionDeclaration) {
+      return expression;
+    }
+
     var staticType = expression.staticType;
     if (staticType is! FunctionTypeImpl || staticType.typeFormals.isEmpty) {
       return expression;