Issue 61914. Fixes for FunctionReferenceImpl and PrefixedIdentifierImpl function, when prefix is not in scope.

Bug: #61914
Change-Id: I331cdb812e5bfe890e2f9d05c87cb4e9582d08b6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/460205
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analysis_server/test/analysis/get_hover_test.dart

@@ -1254,7 +1254,7 @@ void f(A<int> a) {
     expect(hover.elementDescription, 'int foo<U>(int t, U u)');
     expect(hover.elementKind, 'method');
     // types
-    expect(hover.staticType, isNull);
+    expect(hover.staticType, 'int Function<U>(int, U)');
     expect(hover.propagatedType, isNull);
     // no parameter
     expect(hover.parameter, isNull);
@@ -1281,7 +1281,7 @@ void f() {
     expect(hover.elementDescription, 'int foo<U>(U u)');
     expect(hover.elementKind, 'method');
     // types
-    expect(hover.staticType, isNull);
+    expect(hover.staticType, 'int Function<U>(U)');
     expect(hover.propagatedType, isNull);
     // no parameter
     expect(hover.parameter, isNull);

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

@@ -88,32 +88,6 @@ class FunctionReferenceResolver {
     }
   }
 
-  /// Checks for a type instantiation of a `dynamic`-typed expression.
-  ///
-  /// Returns `true` if an error was reported, and resolution can stop.
-  bool _checkDynamicTypeInstantiation(
-    FunctionReferenceImpl node,
-    PrefixedIdentifierImpl function,
-    Element prefixElement,
-  ) {
-    DartType? prefixType;
-    if (prefixElement is VariableElement) {
-      prefixType = prefixElement.type;
-    } else if (prefixElement is PropertyAccessorElement) {
-      prefixType = prefixElement.variable.type;
-    }
-
-    if (prefixType is DynamicType) {
-      _diagnosticReporter.atNode(
-        function,
-        CompileTimeErrorCode.genericMethodTypeInstantiationOnDynamic,
-      );
-      node.recordStaticType(InvalidTypeImpl.instance, resolver: _resolver);
-      return true;
-    }
-    return false;
-  }
-
   List<TypeImpl> _checkTypeArguments(
     TypeArgumentList typeArgumentList,
     String? name,
@@ -433,63 +407,30 @@ class FunctionReferenceResolver {
     FunctionReferenceImpl node,
     PrefixedIdentifierImpl function,
   ) {
-    var prefixElement = function.prefix.scopeLookupResult!.getter;
+    _resolver.analyzeExpression(function, _resolver.operations.unknownType);
+    _resolver.popRewrite();
 
-    if (prefixElement == null) {
-      _diagnosticReporter.atNode(
-        function.prefix,
-        CompileTimeErrorCode.undefinedIdentifier,
-        arguments: [function.name],
-      );
-      function.setPseudoExpressionStaticType(InvalidTypeImpl.instance);
+    var propertyType = function.typeOrThrow;
+
+    if (function.element is ExtensionElement) {
       node.recordStaticType(InvalidTypeImpl.instance, resolver: _resolver);
       return;
     }
 
-    function.prefix.element = prefixElement;
-    function.prefix.setPseudoExpressionStaticType(
-      prefixElement is PromotableElementImpl
-          ? _resolver.localVariableTypeProvider.getType(
-              function.prefix,
-              isRead: true,
-            )
-          : prefixElement.referenceType,
-    );
-    var functionName = function.identifier.name;
-
-    if (prefixElement is PrefixElement) {
-      var functionElement = prefixElement.scope.lookup(functionName).getter;
-      if (functionElement == null) {
-        _diagnosticReporter.atNode(
-          function.identifier,
-          CompileTimeErrorCode.undefinedPrefixedName,
-          arguments: [functionName, function.prefix.name],
-        );
-        function.setPseudoExpressionStaticType(InvalidTypeImpl.instance);
-        node.recordStaticType(InvalidTypeImpl.instance, resolver: _resolver);
-        return;
-      } else {
-        _resolveReceiverPrefix(node, prefixElement, function, functionElement);
-        return;
-      }
-    }
-
-    if (_checkDynamicTypeInstantiation(node, function, prefixElement)) {
+    if (propertyType is InvalidType) {
+      node.recordStaticType(InvalidTypeImpl.instance, resolver: _resolver);
       return;
     }
 
-    if (prefixElement is TopLevelFunctionElement &&
-        functionName == MethodElement.CALL_METHOD_NAME) {
-      _resolve(node: node, rawType: prefixElement.type, name: functionName);
+    if (propertyType is DynamicTypeImpl) {
+      _diagnosticReporter.atNode(
+        function,
+        CompileTimeErrorCode.genericMethodTypeInstantiationOnDynamic,
+      );
+      node.recordStaticType(InvalidTypeImpl.instance, resolver: _resolver);
       return;
     }
 
-    var propertyType = _resolveTypeProperty(
-      receiver: function.prefix,
-      name: function.identifier,
-      nameErrorEntity: function,
-    );
-
     var callMethod = _getCallMethod(node, propertyType);
     if (callMethod is MethodElement) {
       _resolveAsImplicitCallReference(node, callMethod);
@@ -498,20 +439,22 @@ class FunctionReferenceResolver {
 
     if (propertyType is FunctionType) {
       function.setPseudoExpressionStaticType(propertyType);
+      var functionName = function.identifier.name;
       _resolve(node: node, rawType: propertyType, name: functionName);
       return;
     }
 
-    if (propertyType != null) {
-      // If the property is unknown, [UNDEFINED_GETTER] is reported elsewhere.
-      // If it is known, we must report the bad type instantiation here.
-      _diagnosticReporter.atNode(
-        function.identifier,
-        CompileTimeErrorCode.disallowedTypeInstantiationExpression,
-      );
+    if (function.prefix.element case PrefixElement prefixElement) {
+      if (function.element case var functionElement?) {
+        _resolveReceiverPrefix(node, prefixElement, function, functionElement);
+        return;
+      }
     }
-    _resolver.analyzeExpression(function, _resolver.operations.unknownType);
-    _resolver.popRewrite();
+
+    _diagnosticReporter.atNode(
+      function.identifier,
+      CompileTimeErrorCode.disallowedTypeInstantiationExpression,
+    );
     node.recordStaticType(InvalidTypeImpl.instance, resolver: _resolver);
   }
 
@@ -635,36 +578,12 @@ class FunctionReferenceResolver {
         _resolveConstructorReference(node);
         return;
       } else if (element is InterfaceElementImpl) {
-        _resolver.analyzeExpression(
-          node.function,
-          _resolver.operations.unknownType,
-        );
-        _resolver.popRewrite();
         _resolveDirectTypeLiteral(node, prefix, element);
         return;
       } else if (element is TypeAliasElementImpl) {
-        _resolver.analyzeExpression(prefix, _resolver.operations.unknownType);
-        _resolver.popRewrite();
         _resolveTypeAlias(node: node, element: element, typeAlias: prefix);
         return;
       }
-    } else if (element is ExecutableElement) {
-      _resolver.analyzeExpression(
-        node.function,
-        _resolver.operations.unknownType,
-      );
-      _resolver.popRewrite();
-      var callMethod = _getCallMethod(node, node.function.staticType);
-      if (callMethod is MethodElement) {
-        _resolveAsImplicitCallReference(node, callMethod);
-        return;
-      }
-      _resolve(
-        node: node,
-        rawType: node.function.typeOrThrow as FunctionType,
-        name: element.name,
-      );
-      return;
     } else if (element is ExtensionElement) {
       prefix.identifier.element = element;
       prefix.identifier.setPseudoExpressionStaticType(InvalidTypeImpl.instance);