Improve method tearoff instantiation support for static methods.

* static method access with an explicit receiver
* the above, with a type alias of the receiver
* the two above, with a prefixed import
* many test cases for unsupported things

Bug: #46233
Change-Id: I982bc741aa8f57959d342b640921096170e94f0c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/205881
Commit-Queue: Samuel Rawlins <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: srawlins

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

@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/syntactic_entity.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ -12,7 +13,6 @@ import 'package:analyzer/src/dart/ast/ast_factory.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/dart/resolver/resolution_result.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ -83,35 +83,46 @@ class FunctionReferenceResolver {
     if (function is PrefixedIdentifierImpl) {
       var prefixElement =
           _resolver.nameScope.lookup(function.prefix.name).getter;
+      function.prefix.staticElement = prefixElement;
       if (prefixElement is PrefixElement) {
-        _resolveReceiverPrefix(node, prefixElement, function);
-        return;
+        var functionName = function.identifier.name;
+        var functionElement = prefixElement.scope.lookup(functionName).getter;
+        if (functionElement == null) {
+          _errorReporter.reportErrorForNode(
+            CompileTimeErrorCode.UNDEFINED_PREFIXED_NAME,
+            function.identifier,
+            [function.identifier.name, function.prefix.name],
+          );
+          function.staticType = DynamicTypeImpl.instance;
+          node.staticType = DynamicTypeImpl.instance;
+          return;
+        } else {
+          functionElement = _resolver.toLegacyElement(functionElement);
+          _resolveReceiverPrefix(
+              node, prefixElement, function, functionElement);
+          return;
+        }
+      } else if (prefixElement is VariableElement) {
+        function.prefix.staticType = prefixElement.type;
+      } else if (prefixElement is PropertyAccessorElement) {
+        function.prefix.staticType = prefixElement.returnType;
       }
 
-      ResolutionResult resolveTypeProperty(DartType prefixType) {
-        return _resolver.typePropertyResolver.resolve(
-          receiver: function.prefix,
-          receiverType: prefixType,
-          name: function.identifier.name,
-          propertyErrorEntity: function.identifier,
-          nameErrorEntity: function,
-        );
-      }
+      var methodElement = _resolveTypeProperty(
+        receiver: function.prefix,
+        receiverElement: prefixElement,
+        name: function.identifier,
+        nameErrorEntity: function,
+      );
 
-      function.prefix.staticElement = prefixElement;
-      ExecutableElement? methodElement;
-      if (prefixElement is VariableElement) {
-        var prefixType = prefixElement.type;
-        function.prefix.staticType = prefixType;
-        methodElement = resolveTypeProperty(prefixType).getter;
-      } else if (prefixElement is PropertyAccessorElement) {
-        var prefixType = prefixElement.returnType;
-        function.prefix.staticType = prefixType;
-        methodElement = resolveTypeProperty(prefixType).getter;
-      }
       if (methodElement is MethodElement) {
-        _resolveFunctionReferenceMethod(
-            node: node, function: function, element: methodElement);
+        function.identifier.staticElement = methodElement;
+        function.staticType = methodElement.type;
+        _resolve(
+          node: node,
+          name: function.identifier.name,
+          rawType: methodElement.type,
+        );
         return;
       }
 
@@ -143,11 +154,39 @@ class FunctionReferenceResolver {
           node.staticType = DynamicTypeImpl.instance;
           return;
         }
+      } else if (target is PrefixedIdentifierImpl) {
+        var prefixElement =
+            _resolver.nameScope.lookup(target.prefix.name).getter;
+        if (prefixElement is PrefixElement) {
+          var prefixName = target.identifier.name;
+          var targetElement = prefixElement.scope.lookup(prefixName).getter;
+
+          var methodElement = _resolveTypeProperty(
+            receiver: target,
+            receiverElement: targetElement,
+            name: function.propertyName,
+            nameErrorEntity: function,
+          );
+
+          if (methodElement == null) {
+            // TODO(srawlins): Can we get here?
+            node.staticType = DynamicTypeImpl.instance;
+            return;
+          } else {
+            _resolveReceiverPrefix(node, prefixElement, target, methodElement);
+            return;
+          }
+        } else {
+          // TODO(srawlins): Can we get here?
+          node.staticType = DynamicTypeImpl.instance;
+          return;
+        }
       } else {
-        // TODO(srawlins): Can we get here? PrefixedIdentifier?
+        // TODO(srawlins): Can we get here?
         node.staticType = DynamicTypeImpl.instance;
         return;
       }
+
       var propertyElement = _resolver.typePropertyResolver
           .resolve(
             receiver: function.realTarget,
@@ -238,55 +277,14 @@ class FunctionReferenceResolver {
     _resolveTypeLiteral(node: node, instantiatedType: type, name: name);
   }
 
-  void _resolveFunctionReferenceMethod({
-    required FunctionReferenceImpl node,
-    required PrefixedIdentifier function,
-    required MethodElement element,
-  }) {
-    function.accept(_resolver);
-    var receiver = function.prefix;
-    var receiverType = receiver.staticType;
-    if (receiverType == null) {
-      // TODO(srawlins): Handle this situation; see
-      //  `test_staticMethod_explicitReceiver` test case.
-      node.staticType = DynamicTypeImpl.instance;
-      return;
-    }
-    var nameNode = function.identifier;
-    var name = nameNode.name;
-    var result = _resolver.typePropertyResolver.resolve(
-      receiver: receiver,
-      receiverType: receiverType,
-      name: name,
-      propertyErrorEntity: nameNode,
-      nameErrorEntity: nameNode,
-    );
-
-    var target = result.getter;
-    if (target != null) {
-      // TODO(srawlins): Set static type on `nameNode`?
-
-      _resolve(node: node, name: name, rawType: element.type);
-      return;
-    }
-
-    // TODO(srawlins): Report unresolved identifier.
-    node.function.accept(_resolver);
-    node.staticType = DynamicTypeImpl.instance;
-  }
-
   void _resolveReceiverPrefix(
     FunctionReferenceImpl node,
     PrefixElement prefixElement,
     PrefixedIdentifier prefix,
+    Element element,
   ) {
     // TODO(srawlins): Handle `loadLibrary`, as in `p.loadLibrary<int>;`.
 
-    var nameNode = prefix.identifier;
-    var name = nameNode.name;
-    var element = prefixElement.scope.lookup(name).getter;
-    element = _resolver.toLegacyElement(element);
-
     if (element is MultiplyDefinedElement) {
       MultiplyDefinedElement multiply = element;
       element = multiply.conflictingElements[0];
@@ -310,7 +308,6 @@ class FunctionReferenceResolver {
         return;
       } else if (element is TypeAliasElement) {
         prefix.accept(_resolver);
-        (nameNode as SimpleIdentifierImpl).staticElement = element;
         _resolveTypeAlias(node: node, element: element, typeAlias: prefix);
         return;
       }
@@ -326,10 +323,26 @@ class FunctionReferenceResolver {
 
     // TODO(srawlins): Report undefined prefixed identifier.
 
-    node.function.accept(_resolver);
     node.staticType = DynamicTypeImpl.instance;
   }
 
+  /// Returns the element that represents the property named [propertyName] on
+  /// [classElement].
+  ExecutableElement? _resolveStaticElement(
+      ClassElement classElement, SimpleIdentifier propertyName) {
+    String name = propertyName.name;
+    ExecutableElement? element;
+    if (propertyName.inSetterContext()) {
+      element = classElement.getSetter(name);
+    }
+    element ??= classElement.getGetter(name);
+    element ??= classElement.getMethod(name);
+    if (element != null && element.isAccessibleIn(_resolver.definingLibrary)) {
+      return element;
+    }
+    return null;
+  }
+
   void _resolveTypeAlias({
     required FunctionReferenceImpl node,
     required TypeAliasElement element,
@@ -358,4 +371,53 @@ class FunctionReferenceResolver {
     typeLiteral.staticType = _typeType;
     NodeReplacer.replace(node, typeLiteral);
   }
+
+  /// Resolves [name] as a property on [receiver] (with element
+  /// [receiverElement]).
+  ///
+  /// Returns `null` if [receiverElement] is `null`, a [TypeParameterElement],
+  /// or a [TypeAliasElement] for a non-interface type.
+  ExecutableElement? _resolveTypeProperty({
+    required Expression receiver,
+    required Element? receiverElement,
+    required SimpleIdentifier name,
+    required SyntacticEntity nameErrorEntity,
+  }) {
+    if (receiverElement == null) {
+      return null;
+    }
+    if (receiverElement is TypeParameterElement) {
+      return null;
+    }
+    if (receiverElement is ClassElement) {
+      return _resolveStaticElement(receiverElement, name);
+    } else if (receiverElement is TypeAliasElement) {
+      var aliasedType = receiverElement.aliasedType;
+      if (aliasedType is InterfaceType) {
+        return _resolveStaticElement(aliasedType.element, name);
+      } else {
+        return null;
+      }
+    }
+
+    DartType receiverType;
+    if (receiverElement is VariableElement) {
+      receiverType = receiverElement.type;
+    } else if (receiverElement is PropertyAccessorElement) {
+      receiverType = receiverElement.returnType;
+    } else {
+      assert(false,
+          'Unexpected receiverElement type: ${receiverElement.runtimeType}');
+      return null;
+    }
+    return _resolver.typePropertyResolver
+        .resolve(
+          receiver: receiver,
+          receiverType: receiverType,
+          name: name.name,
+          propertyErrorEntity: name,
+          nameErrorEntity: nameErrorEntity,
+        )
+        .getter;
+  }
 }