[analyzer] Implement static extension getters

This CL adds support for static extension getters in the CFE. The
feature is observable under the `static-extensions` experimental
feature flag. Only the positive support is added; the diagnostics will
be added in follow-up CLs.

Part of #61487

Change-Id: I6006c86d53e8ca5d20859481e7ab77840a63a1c2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/457024
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Chloe Stefantsova <[email protected]>

Author: chloestefantsova

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

@@ -2327,6 +2327,66 @@ class ExtensionElementImpl extends InstanceElementImpl
   @trackedIncludedInId
   ElementKind get kind => ElementKind.EXTENSION;
 
+  /// Computes the on-declaration of the extension.
+  ///
+  /// The on-declaration is computed a described in
+  /// https://github.com/dart-lang/language/blob/main/working/0723-static-extensions/feature-specification.md#syntax
+  /// In case the extension declaration doesn't have an on-declaration, `null`
+  /// is returned.
+  @trackedIndirectly
+  InterfaceElementImpl? get onDeclaration {
+    if (extendedType.nullabilitySuffix != NullabilitySuffix.question) {
+      switch (extendedType.element) {
+        // In an extension declaration of the form extension E on C {...} where C
+        // is an identifier (or an identifier with an import prefix) that denotes
+        // a class, mixin, enum, or extension type declaration, we say that the
+        // on-declaration of the extension is C.
+
+        // If C denotes a generic class then E is treated as extension E on C<T1
+        // ..  Tk> {...} where T1 .. Tk are obtained by instantiation to bound.
+
+        // In an extension of the form extension E on C<T1 .. Tk> {...} where C is
+        // an identifier or prefixed identifier that denotes a class, mixin, enum,
+        // or extension type declaration, we say that the on-declaration of E is
+        // C.
+
+        // In an extension of the form extension E on F<T1 .. Tk> {...} where F is
+        // a type alias whose transitive alias expansion denotes a class, mixin,
+        // enum, or extension type C, we say that the on-declaration of E is C,
+        // and the declaration is treated as if F<T1 .. Tk> were replaced by its
+        // transitive alias expansion.
+
+        // Implementation note: type aliases in [extendedType] are already
+        // unaliased at this point, so there's no need to consider them
+        // separately.
+
+        // For the purpose of identifying the on-declaration of a given extension,
+        // the types void, dynamic, and Never are not considered to be classes,
+        // and neither are record types or function types.
+
+        // Also note that none of the following types are classes:
+        //   * A type of the form T? or FutureOr<T>, for any type T.
+        //   * A type variable.
+        //   * An intersection type.
+        case ClassElementImpl() when !extendedType.isDartAsyncFutureOr:
+        case MixinElementImpl():
+        case EnumElementImpl():
+        case ExtensionTypeElementImpl():
+          return extendedType.element as InterfaceElementImpl;
+        default:
+          // In all other cases, an extension declaration does not have an
+          // on-declaration.
+          return null;
+      }
+    } else {
+      // Also note that none of the following types are classes:
+      //   * A type of the form T? or FutureOr<T>, for any type T.
+      //   * A type variable.
+      //   * An intersection type.
+      return null;
+    }
+  }
+
   @override
   @trackedIndirectly
   DartType get thisType => extendedType;

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

@@ -60,6 +60,13 @@ class InstantiatedExtensionWithoutMember {
   );
 }
 
+class _ExtensionWithMemberWithName {
+  final ExtensionElementImpl extension;
+  final InternalExecutableElement member;
+
+  _ExtensionWithMemberWithName({required this.extension, required this.member});
+}
+
 abstract class _NotInstantiatedExtension<R> {
   final ExtensionElementImpl extension;
 
@@ -127,7 +134,7 @@ extension ExtensionsExtensions on Iterable<ExtensionElement> {
   }
 
   /// Returns the sublist of [ExtensionElement]s that have an instance member
-  /// named [baseName].
+  /// with basename [baseName].
   List<_NotInstantiatedExtensionWithMember> havingMemberWithBaseName(
     Name baseName,
   ) {
@@ -180,6 +187,54 @@ extension ExtensionsExtensions on Iterable<ExtensionElement> {
     }
     return result;
   }
+
+  /// Returns the sublist of [ExtensionElement]s that have a static member
+  /// with name [name].
+  List<_ExtensionWithMemberWithName> havingStaticMemberWithName(Name name) {
+    var result = <_ExtensionWithMemberWithName>[];
+    for (var extension in this) {
+      if (!name.isAccessibleFor(extension.library.uri)) {
+        continue;
+      }
+
+      var getter = extension.getGetter(name.name);
+      if (getter != null && getter.isStatic) {
+        result.add(
+          _ExtensionWithMemberWithName(
+            // TODO(paulberry): eliminate this cast by changing the
+            // extension to apply only to `Iterable<ExtensionElementImpl>`.
+            extension: extension as ExtensionElementImpl,
+            member: getter as GetterElementImpl,
+          ),
+        );
+      }
+
+      var setter = extension.getSetter(name.name);
+      if (setter != null && setter.isStatic) {
+        result.add(
+          _ExtensionWithMemberWithName(
+            // TODO(paulberry): eliminate this cast by changing the
+            // extension to apply only to `Iterable<ExtensionElementImpl>`.
+            extension: extension as ExtensionElementImpl,
+            member: setter as SetterElementImpl,
+          ),
+        );
+      }
+
+      var method = extension.getMethod(name.name);
+      if (method != null && method.isStatic) {
+        result.add(
+          _ExtensionWithMemberWithName(
+            // TODO(paulberry): eliminate this cast by changing the
+            // extension to apply only to `Iterable<ExtensionElementImpl>`.
+            extension: extension as ExtensionElementImpl,
+            member: method as MethodElementImpl,
+          ),
+        );
+      }
+    }
+    return result;
+  }
 }
 
 extension NotInstantiatedExtensionsExtensions<R>

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

@@ -24,6 +24,18 @@ import 'package:analyzer/src/generated/inference_log.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/utilities/extensions/string.dart';
 
+/// The result of a failed attempt to resolve an identifier to the single
+/// element with the given name, where the result is expected to come from an
+/// extension. [AmbiguousStaticExtensionResolutionError] covers the case where
+/// multiple matching extensions were found, resulting in an ambiguity.
+class AmbiguousStaticExtensionResolutionError
+    extends StaticExtensionResolutionResult {
+  const AmbiguousStaticExtensionResolutionError();
+
+  @override
+  InternalExecutableElement? get member => null;
+}
+
 class ExtensionMemberResolver {
   final ResolverVisitor _resolver;
 
@@ -146,6 +158,36 @@ class ExtensionMemberResolver {
     return ExtensionResolutionError.ambiguous;
   }
 
+  /// Finds extensions applicable to [declaration] for static member lookups.
+  StaticExtensionResolutionResult findExtensionForDeclaration(
+    InterfaceElement declaration,
+    SyntacticEntity nameEntity,
+    Name name,
+  ) {
+    var extensions = [
+      for (var extension
+          in _resolver.libraryFragment.accessibleExtensions
+              .havingStaticMemberWithName(name))
+        if (extension.extension.onDeclaration == declaration) extension,
+    ];
+
+    if (extensions.isEmpty) {
+      return const NoneStaticExtensionResolutionError();
+    }
+
+    // When an extension is looked up for the declaration, only the exact match
+    // matters, since there is no inheritance of the static members. No attempts
+    // made to find the most precise match, and any ambiguity is treated as an
+    // error.
+    if (extensions.length == 1) {
+      var extension = extensions[0];
+      _resolver.libraryFragment.scope.notifyExtensionUsed(extension.extension);
+      return SingleStaticExtensionResolutionResult(member: extension.member);
+    }
+
+    return const AmbiguousStaticExtensionResolutionError();
+  }
+
   /// Resolve the [name] (without `=`) to the corresponding getter and setter
   /// members of the extension [node].
   ///
@@ -506,6 +548,18 @@ enum ExtensionResolutionError implements ExtensionResolutionResult {
 /// result (if any) is known to come from an extension.
 sealed class ExtensionResolutionResult implements SimpleResolutionResult {}
 
+/// The result of a failed attempt to resolve an identifier to the single
+/// element with the given name, where the result is expected to come from an
+/// extension. [NoneStaticExtensionResolutionError] covers the case where no
+/// matching extensions were found.
+class NoneStaticExtensionResolutionError
+    extends StaticExtensionResolutionResult {
+  const NoneStaticExtensionResolutionError();
+
+  @override
+  InternalExecutableElement? get member => null;
+}
+
 /// The result of a successful attempt to resolve an identifier to elements,
 /// where the result (if any) is known to come from an extension.
 class SingleExtensionResolutionResult extends SimpleResolutionResult
@@ -515,3 +569,25 @@ class SingleExtensionResolutionResult extends SimpleResolutionResult
     required super.setter2,
   }) : assert(getter2 != null || setter2 != null);
 }
+
+/// The result of a successful attempt to resolve an identifier to the single
+/// element with the given name, where the result (if any) is known to come from
+/// an extension.
+class SingleStaticExtensionResolutionResult
+    extends SimpleStaticExtensionResolutionResult
+    implements StaticExtensionResolutionResult {
+  SingleStaticExtensionResolutionResult({
+    required InternalExecutableElement member,
+  }) : super(member: member);
+
+  @override
+  InternalExecutableElement get member => super.member!;
+}
+
+/// The result of attempting to resolve an identifier to the single element with
+/// the given name, where the result (if any) is known to come from an
+/// extension.
+sealed class StaticExtensionResolutionResult
+    extends SimpleStaticExtensionResolutionResult {
+  const StaticExtensionResolutionResult({super.member});
+}

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

@@ -4,6 +4,7 @@
 
 import 'package:_fe_analyzer_shared/src/flow_analysis/flow_analysis.dart';
 import 'package:_fe_analyzer_shared/src/types/shared_type.dart';
+import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/error.dart';
@@ -798,6 +799,23 @@ class PropertyElementResolver with ScopeHelpers {
         }
       }
 
+      if (readElement == null) {
+        if (_definingLibrary.featureSet.isEnabled(Feature.static_extensions)) {
+          // When direct lookups fail, try static extension resolution.
+          var result = _resolver.typePropertyResolver.resolveForDeclaration(
+            declaration: typeReference,
+            name: propertyName.name,
+            hasRead: hasRead,
+            hasWrite: hasWrite,
+            propertyErrorEntity: propertyName,
+            nameErrorEntity: propertyName,
+          );
+          if (result.getter2 != null) {
+            readElement = result.getter2;
+          }
+        }
+      }
+
       if (readElement != null) {
         getType = readElement.returnType;
         if (_checkForStaticAccessToInstanceMember(propertyName, readElement)) {

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

@@ -59,3 +59,13 @@ class SimpleResolutionResult {
 
   const SimpleResolutionResult({this.getter2, this.setter2});
 }
+
+class SimpleStaticExtensionResolutionResult {
+  /// Returns the single element with the given name.
+  ///
+  /// Note that the resolution is performed on the name of the member, not on
+  /// its basename. Hence, the result is a single member.
+  final InternalExecutableElement? member;
+
+  const SimpleStaticExtensionResolutionResult({this.member});
+}

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

@@ -239,6 +239,42 @@ class TypePropertyResolver {
     }
   }
 
+  /// Resolve static invocations for [declaration].
+  ResolutionResult resolveForDeclaration({
+    required InterfaceElement declaration,
+    required String name,
+    required bool hasRead,
+    required bool hasWrite,
+    required SyntacticEntity propertyErrorEntity,
+    required SyntacticEntity nameErrorEntity,
+    AstNode? parentNode,
+  }) {
+    _name = name;
+    _hasRead = hasRead;
+    _hasWrite = hasWrite;
+    _nameErrorEntity = nameErrorEntity;
+    _resetResult();
+
+    var getterName = Name(_definingLibrary.uri, _name);
+    var result = _extensionResolver.findExtensionForDeclaration(
+      declaration,
+      _nameErrorEntity,
+      getterName,
+    );
+    // TODO(cstefantsova): Add the support for setters and methods.
+    _reportedGetterError =
+        result == const AmbiguousStaticExtensionResolutionError();
+    _reportedSetterError = false;
+
+    if (result.member != null) {
+      // TODO(cstefantsova): Add the support for setters and methods.
+      _needsGetterError = false;
+      _getterRequested = result.member;
+    }
+
+    return _toResult();
+  }
+
   void _lookupExtension(TypeImpl type) {
     var getterName = Name(_definingLibrary.uri, _name);
     var result = _extensionResolver.findExtension(