Analyzer: resolve type to bound in FunctionExpressionInvocationResolver.

Consider the following code:

    void f<T extends void Function(int)>(List<T> x) {
      x.first(0);
    }

While analyzing the expression `x.first(0)`, the analyzer has to do two things:

- Convert the AST representation from a MethodInvocation (which is
  what was initially parsed) to a FunctionExpressionInvocation
  targeting a PrefixedIdentifier. This reflects the fact that the
  invocation isn't a method invocation after all; it's a function call
  invocation applied to a property get.

- Convert the static type of `x.first` from `T` to its bound, `void
  Function(int)`, in order to type check the invocation. This is done
  using the `TypeSystemImpl.resolveToBound` method.

Previously, `TypeSystemImpl.resolveToBound` was called as part of
converting the AST representation, and the resolved bound (`void
Function(int)` in this example) was stored as the static type of the
FunctionExpressionInvocation target. This led to some minor
inaccuracies in the AST representation (since the type returned by
`TypeSystemImpl.resolveToBound` is *not* the correct type of the
FunctionExpressionInvocation target).

With this change, the call to `TypeSystemImpl.resolveToBound` happens
during resolution of the FunctionExpressionInvocation instead,
allowing the target of the FunctionExpressionInvocation to retain its
correct static type.

I'm in the middle of a larger arc of work trying to introduce a new,
simpler mechanism for flow analysis to be told about the static types
of property gets, and part of that arc of work will involve
introducing a temporary check to verify that the old and new
mechanisms see the same static types. Fixing this incorrect type will
allow the temporary check to pass.

This change also has the side effect of fixing
#56907 (Analyzer fails to
propery type check invocations of complex expressions whose type is a
type parameter). This bug was happening in circumstances where a
FunctionExpressionInvocation arises directly from parsing (rather than
being created from a MethodInvocation), and the static type of the
target is a type variable. Previously, the analyzer was failing to
convert the static type to its bound when analyzing the
FunctionExpressionInvocation, so it was failing to type check the
invocation. Moving the call to `TypeSystemImpl.resolveToBound` into
FunctionExpressionInvocation resolution ensures that the type is
properly resolved to its bound in _all_ circumstances where a
FunctionExpressionInvocation occurs.

Fixes #56907.

Bug: #56907
Change-Id: Id648d5289a6cabe95b8410abd19898acb97fc5e7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/390661
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

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

@@ -8,6 +8,7 @@ import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/extension_member_resolver.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
@@ -32,6 +33,8 @@ class FunctionExpressionInvocationResolver {
   NullableDereferenceVerifier get _nullableDereferenceVerifier =>
       _resolver.nullableDereferenceVerifier;
 
+  TypeSystemImpl get _typeSystem => _resolver.typeSystem;
+
   void resolve(FunctionExpressionInvocationImpl node,
       List<WhyNotPromotedGetter> whyNotPromotedList,
       {required DartType contextType}) {
@@ -50,6 +53,7 @@ class FunctionExpressionInvocationResolver {
       return;
     }
 
+    receiverType = _typeSystem.resolveToBound(receiverType);
     if (receiverType is FunctionType) {
       _nullableDereferenceVerifier.expression(
         CompileTimeErrorCode.UNCHECKED_INVOCATION_OF_NULLABLE_VALUE,

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

@@ -949,7 +949,7 @@ class MethodInvocationResolver with ScopeHelpers {
   FunctionExpressionInvocationImpl _rewriteAsFunctionExpressionInvocation(
       MethodInvocationImpl node, DartType getterReturnType,
       {bool isSuperAccess = false}) {
-    var targetType = _typeSystem.resolveToBound(getterReturnType);
+    var targetType = getterReturnType;
 
     ExpressionImpl functionExpression;
     var target = node.target;

pkg/analyzer/test/src/dart/resolution/method_invocation_test.dart

@@ -2049,8 +2049,7 @@ FunctionExpressionInvocation
     token: foo
     staticElement: <testLibraryFragment>::@class::C::@getter::foo
     element: <testLibraryFragment>::@class::C::@getter::foo#element
-    staticType: double Function(int)
-      alias: <testLibraryFragment>::@typeAlias::MyFunction
+    staticType: T
   argumentList: ArgumentList
     leftParenthesis: (
     arguments
@@ -8120,6 +8119,70 @@ FunctionExpressionInvocation
 ''');
   }
 
+  test_rewrite_with_target() async {
+    await assertNoErrorsInCode(r'''
+test<T extends Function>(List<T> x) {
+  x.first();
+}
+''');
+
+    var node = findNode.functionExpressionInvocation('x.first()');
+    assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: PropertyAccess
+    target: SimpleIdentifier
+      token: x
+      staticElement: <testLibraryFragment>::@function::test::@parameter::x
+      element: <testLibraryFragment>::@function::test::@parameter::x#element
+      staticType: List<T>
+    operator: .
+    propertyName: SimpleIdentifier
+      token: first
+      staticElement: GetterMember
+        base: dart:core::<fragment>::@class::Iterable::@getter::first
+        substitution: {E: T, E: T}
+      element: dart:core::<fragment>::@class::Iterable::@getter::first#element
+      staticType: T
+    staticType: T
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticElement: <null>
+  element: <null>
+  staticInvokeType: dynamic
+  staticType: dynamic
+''');
+  }
+
+  test_rewrite_without_target() async {
+    await assertNoErrorsInCode(r'''
+extension E<T extends Function> on List<T> {
+  test() {
+    first();
+  }
+}
+''');
+
+    var node = findNode.functionExpressionInvocation('first()');
+    assertResolvedNodeText(node, r'''
+FunctionExpressionInvocation
+  function: SimpleIdentifier
+    token: first
+    staticElement: GetterMember
+      base: dart:core::<fragment>::@class::Iterable::@getter::first
+      substitution: {E: T, E: T}
+    element: dart:core::<fragment>::@class::Iterable::@getter::first#element
+    staticType: T
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  staticElement: <null>
+  element: <null>
+  staticInvokeType: dynamic
+  staticType: dynamic
+''');
+  }
+
   test_superQualifier_identifier_methodOfMixin_inEnum() async {
     await assertNoErrorsInCode(r'''
 mixin M {

pkg/analyzer/test/src/dart/resolution/non_nullable_test.dart

@@ -208,7 +208,7 @@ m<T extends Function>() {
 ''');
 // Do not assert no test errors. Deliberately invokes nullable type.
     var invocation = findNode.functionExpressionInvocation('first()');
-    assertType(invocation.function, 'Function?');
+    assertType(invocation.function, 'T?');
   }
 
   test_mixin_hierarchy() async {

pkg/analyzer/test/src/dart/resolution/type_inference/function_expression_test.dart

@@ -6,10 +6,12 @@ import 'package:analyzer/src/error/codes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../context_collection_resolution.dart';
+import '../node_text_expectations.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(FunctionExpressionTest);
+    defineReflectiveTests(UpdateNodeTextExpectations);
   });
 }
 
@@ -862,6 +864,80 @@ var v = () sync* {
     _assertReturnType('() sync* {', 'Iterable<int>');
   }
 
+  test_targetBoundedByFunctionType_argumentTypeMismatch() async {
+    await assertErrorsInCode(r'''
+int test<T extends int Function(int)>(T Function() createT) {
+  return createT()('');
+}
+''', [
+      error(CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 81, 2),
+    ]);
+
+    var node = findNode.functionExpressionInvocation("('')");
+    assertResolvedNodeText(node, r'''FunctionExpressionInvocation
+  function: FunctionExpressionInvocation
+    function: SimpleIdentifier
+      token: createT
+      staticElement: <testLibraryFragment>::@function::test::@parameter::createT
+      element: <testLibraryFragment>::@function::test::@parameter::createT#element
+      staticType: T Function()
+    argumentList: ArgumentList
+      leftParenthesis: (
+      rightParenthesis: )
+    staticElement: <null>
+    element: <null>
+    staticInvokeType: T Function()
+    staticType: T
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      SimpleStringLiteral
+        literal: ''
+    rightParenthesis: )
+  staticElement: <null>
+  element: <null>
+  staticInvokeType: int Function(int)
+  staticType: int
+''');
+  }
+
+  test_targetBoundedByFunctionType_ok() async {
+    await assertNoErrorsInCode(r'''
+int test<T extends int Function(int)>(T Function() createT) {
+  return createT()(0);
+}
+''');
+
+    var node = findNode.functionExpressionInvocation('(0)');
+    assertResolvedNodeText(node, r'''FunctionExpressionInvocation
+  function: FunctionExpressionInvocation
+    function: SimpleIdentifier
+      token: createT
+      staticElement: <testLibraryFragment>::@function::test::@parameter::createT
+      element: <testLibraryFragment>::@function::test::@parameter::createT#element
+      staticType: T Function()
+    argumentList: ArgumentList
+      leftParenthesis: (
+      rightParenthesis: )
+    staticElement: <null>
+    element: <null>
+    staticInvokeType: T Function()
+    staticType: T
+  argumentList: ArgumentList
+    leftParenthesis: (
+    arguments
+      IntegerLiteral
+        literal: 0
+        parameter: root::@parameter::
+        staticType: int
+    rightParenthesis: )
+  staticElement: <null>
+  element: <null>
+  staticInvokeType: int Function(int)
+  staticType: int
+''');
+  }
+
   void _assertReturnType(String search, String expected) {
     var element = findNode.functionExpression(search).declaredElement!;
     assertType(element.returnType, expected);

tests/language/function/call_via_bound_argument_type_mismatch_error_test.dart

@@ -0,0 +1,24 @@
+// Copyright (c) 2024, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+// This test verifies that if the target of a function expression invocation has
+// a static type which is a type parameter, the type parameter is resolved to
+// its bound in order to check argument types.
+
+int testSimpleTarget<T extends int Function(int)>(T Function() createT) {
+  var tValue = createT();
+  return tValue('');
+  //            ^^
+  // [analyzer] COMPILE_TIME_ERROR.ARGUMENT_TYPE_NOT_ASSIGNABLE
+  // [cfe] The argument type 'String' can't be assigned to the parameter type 'int'.
+}
+
+int testComplexTarget<T extends int Function(int)>(T Function() createT) {
+  return createT()('');
+  //               ^^
+  // [analyzer] COMPILE_TIME_ERROR.ARGUMENT_TYPE_NOT_ASSIGNABLE
+  // [cfe] The argument type 'String' can't be assigned to the parameter type 'int'.
+}
+
+main() {}