Refactor FunctionExpressionInvocationResolver to support Never.

Bug: dart-lang/sdk#40055
Change-Id: Ic53b23178441a32d9de6fe0d2b6d5f4c646de75b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/131401
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -36,16 +36,33 @@ class FunctionExpressionInvocationResolver {
   ExtensionMemberResolver get _extensionResolver => _resolver.extensionResolver;
 
   void resolve(FunctionExpressionInvocationImpl node) {
-    var rawType = _resolveCallElement(node);
+    var function = node.function;
 
-    if (rawType == null) {
-      _setExplicitTypeArgumentTypes(node);
-      _resolveArguments(node);
-      node.staticInvokeType = DynamicTypeImpl.instance;
-      node.staticType = DynamicTypeImpl.instance;
+    if (function is ExtensionOverride) {
+      _resolveReceiverExtensionOverride(node, function);
+      return;
+    }
+
+    var receiverType = function.staticType;
+    if (receiverType is FunctionType) {
+      _resolve(node, receiverType);
       return;
     }
 
+    if (receiverType is InterfaceType) {
+      _resolveReceiverInterfaceType(node, function, receiverType);
+      return;
+    }
+
+    if (identical(receiverType, NeverTypeImpl.instance)) {
+      _unresolved(node, NeverTypeImpl.instance);
+      return;
+    }
+
+    _unresolved(node, DynamicTypeImpl.instance);
+  }
+
+  void _resolve(FunctionExpressionInvocationImpl node, FunctionType rawType) {
     _inferenceHelper.resolveFunctionExpressionInvocation(
       node: node,
       rawType: rawType,
@@ -62,60 +79,66 @@ class FunctionExpressionInvocationResolver {
     node.argumentList.accept(_resolver);
   }
 
-  FunctionType _resolveCallElement(FunctionExpressionInvocation node) {
-    Expression function = node.function;
+  void _resolveReceiverExtensionOverride(
+    FunctionExpressionInvocation node,
+    ExtensionOverride function,
+  ) {
+    var result = _extensionResolver.getOverrideMember(
+      function,
+      FunctionElement.CALL_METHOD_NAME,
+    );
+    var callElement = result.getter;
+    node.staticElement = callElement;
 
-    if (function is ExtensionOverride) {
-      var result = _extensionResolver.getOverrideMember(
+    if (callElement == null) {
+      _errorReporter.reportErrorForNode(
+        CompileTimeErrorCode.INVOCATION_OF_EXTENSION_WITHOUT_CALL,
         function,
-        FunctionElement.CALL_METHOD_NAME,
+        [function.extensionName.name],
       );
-      var callElement = result.getter;
-      node.staticElement = callElement;
-
-      if (callElement == null) {
-        _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INVOCATION_OF_EXTENSION_WITHOUT_CALL,
-          function,
-          [function.extensionName.name],
-        );
-        return null;
-      }
-
-      if (callElement.isStatic) {
-        _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.EXTENSION_OVERRIDE_ACCESS_TO_STATIC_MEMBER,
-          node.argumentList,
-        );
-      }
-
-      return _elementTypeProvider.getExecutableType(callElement);
+      return _unresolved(node, DynamicTypeImpl.instance);
     }
 
-    var receiverType = function.staticType;
-    if (receiverType is FunctionType) {
-      return receiverType;
+    if (callElement.isStatic) {
+      _errorReporter.reportErrorForNode(
+        CompileTimeErrorCode.EXTENSION_OVERRIDE_ACCESS_TO_STATIC_MEMBER,
+        node.argumentList,
+      );
     }
 
-    if (receiverType is InterfaceType) {
-      var result = _typePropertyResolver.resolve(
-        receiver: function,
-        receiverType: receiverType,
-        name: FunctionElement.CALL_METHOD_NAME,
-        receiverErrorNode: function,
-        nameErrorNode: function,
-      );
-      var callElement = result.getter;
+    var rawType = _elementTypeProvider.getExecutableType(callElement);
+    _resolve(node, rawType);
+  }
 
-      if (callElement?.kind != ElementKind.METHOD) {
-        return null;
-      }
+  void _resolveReceiverInterfaceType(
+    FunctionExpressionInvocationImpl node,
+    Expression function,
+    InterfaceType receiverType,
+  ) {
+    var result = _typePropertyResolver.resolve(
+      receiver: function,
+      receiverType: receiverType,
+      name: FunctionElement.CALL_METHOD_NAME,
+      receiverErrorNode: function,
+      nameErrorNode: function,
+    );
+    var callElement = result.getter;
 
-      node.staticElement = callElement;
-      return _elementTypeProvider.getExecutableType(callElement);
+    if (callElement?.kind != ElementKind.METHOD) {
+      _unresolved(node, DynamicTypeImpl.instance);
+      return;
     }
 
-    return null;
+    node.staticElement = callElement;
+    var rawType = _elementTypeProvider.getExecutableType(callElement);
+    _resolve(node, rawType);
+  }
+
+  void _unresolved(FunctionExpressionInvocationImpl node, DartType type) {
+    _setExplicitTypeArgumentTypes(node);
+    _resolveArguments(node);
+    node.staticInvokeType = DynamicTypeImpl.instance;
+    node.staticType = type;
   }
 
   /// Inference cannot be done, we still want to fill type argument types.

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

@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/src/dart/analysis/experiments.dart';
+import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -145,4 +146,44 @@ main(A a) {
       type: 'int',
     );
   }
+
+  test_never() async {
+    await assertErrorsInCode(r'''
+main(Never x) {
+  x<int>(1 + 2);
+}
+''', [
+      error(StaticWarningCode.INVALID_USE_OF_NEVER_VALUE, 18, 1),
+    ]);
+
+    assertFunctionExpressionInvocation(
+      findNode.functionExpressionInvocation('x<int>(1 + 2)'),
+      element: null,
+      typeArgumentTypes: ['int'],
+      invokeType: 'dynamic',
+      type: 'Never',
+    );
+
+    assertType(findNode.binary('1 + 2'), 'int');
+  }
+
+  test_neverQ() async {
+    await assertErrorsInCode(r'''
+main(Never? x) {
+  x<int>(1 + 2);
+}
+''', [
+      error(StaticWarningCode.UNCHECKED_USE_OF_NULLABLE_VALUE, 19, 1),
+    ]);
+
+    assertFunctionExpressionInvocation(
+      findNode.functionExpressionInvocation('x<int>(1 + 2)'),
+      element: null,
+      typeArgumentTypes: ['int'],
+      invokeType: 'dynamic',
+      type: 'dynamic',
+    );
+
+    assertType(findNode.binary('1 + 2'), 'int');
+  }
 }