Introduce ExtensionResolutionResult for use by ExtensionMemberResolver.

Previously, `ExtensionMemberResolver` used `ResolutionResult` to
return its results. This created unnecessary complexity, because
`ResolutionResult` needs to be able to represent a lot of resolution
results that aren't possible when resolving extensions (references to
`Function.call`, references to record fields, and various complex
error reporting scenarios). Conversely, `ExtensionResolutionResult`
needs to be able to represent some scenarios that arent relevant when
doing non-extension resolution (extension lookup resulting in no
result or an ambiguous result).

Splitting into two classes makes both classes simpler.

In a few cases, code needs to be able to handle either a
`ResolutionResult` or an `ExtensionResolutionResult`; for these cases,
I've added a common base class `SimpleResolutionResult`.

This change paves the way for some clean-up work I'm doing on
`TypePropertyResolver` (which uses `ResolutionResult`).

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

Author: stereotype441

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

@@ -11,8 +11,8 @@ import 'package:analyzer/src/dart/element/inheritance_manager3.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
+import 'package:analyzer/src/dart/resolver/extension_member_resolver.dart';
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
-import 'package:analyzer/src/dart/resolver/resolution_result.dart';
 import 'package:analyzer/src/generated/inference_log.dart';
 
 class InstantiatedExtensionWithMember {
@@ -26,8 +26,8 @@ class InstantiatedExtensionWithMember {
     this.extendedType,
   );
 
-  ResolutionResult get asResolutionResult {
-    return ResolutionResult(getter: getter, setter: setter);
+  ExtensionResolutionResult get asResolutionResult {
+    return SingleExtensionResolutionResult(getter: getter, setter: setter);
   }
 
   ExtensionElement get extension => candidate.extension;

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

@@ -78,11 +78,12 @@ class ExtensionMemberResolver {
   /// Returns the most specific accessible extension, applicable to [type],
   /// that defines the member with the given [name].
   ///
-  /// If no applicable extensions are found, returns [ResolutionResult.none].
+  /// If no applicable extensions are found, returns
+  /// [ExtensionResolutionResult.none].
   ///
   /// If the match is ambiguous, reports an error on the [nameEntity], and
-  /// returns [ResolutionResult.ambiguous].
-  ResolutionResult findExtension(
+  /// returns [ExtensionResolutionResult.ambiguous].
+  ExtensionResolutionResult findExtension(
       DartType type, SyntacticEntity nameEntity, Name name) {
     var extensions = _resolver.libraryFragment.accessibleExtensions
         .havingMemberWithBaseName(name)
@@ -92,7 +93,7 @@ class ExtensionMemberResolver {
         );
 
     if (extensions.isEmpty) {
-      return ResolutionResult.none;
+      return ExtensionResolutionError.none;
     }
 
     if (extensions.length == 1) {
@@ -140,14 +141,15 @@ class ExtensionMemberResolver {
         ],
       );
     }
-    return ResolutionResult.ambiguous;
+    return ExtensionResolutionError.ambiguous;
   }
 
   /// Resolve the [name] (without `=`) to the corresponding getter and setter
   /// members of the extension [node].
   ///
   /// The [node] is fully resolved, and its type arguments are set.
-  ResolutionResult getOverrideMember(ExtensionOverride node, String name) {
+  ExtensionResolutionResult getOverrideMember(
+      ExtensionOverride node, String name) {
     var element = node.element;
 
     ExecutableElement? getter;
@@ -161,7 +163,7 @@ class ExtensionMemberResolver {
     }
 
     if (getter == null && setter == null) {
-      return ResolutionResult.none;
+      return ExtensionResolutionError.none;
     }
 
     var substitution = Substitution.fromPairs(
@@ -174,7 +176,8 @@ class ExtensionMemberResolver {
     var setterMember =
         setter != null ? ExecutableMember.from2(setter, substitution) : null;
 
-    return ResolutionResult(getter: getterMember, setter: setterMember);
+    return SingleExtensionResolutionResult(
+        getter: getterMember, setter: setterMember);
   }
 
   /// Perform upward inference for the override.
@@ -450,3 +453,32 @@ class ExtensionMemberResolver {
         parent is PropertyAccess && parent.target == node;
   }
 }
+
+/// The result of a failed attempt to resolve an identifier to elements, where
+/// the result is expected to come from an extension.
+enum ExtensionResolutionError implements ExtensionResolutionResult {
+  /// Resolution failed because no elements were found.
+  none,
+
+  /// Resolution failed because multiple elements were found.
+  ambiguous;
+
+  @override
+  ExecutableElement? get getter => null;
+
+  @override
+  ExecutableElement? get setter => null;
+}
+
+/// The result of attempting to resolve an identifier to elements, where the
+/// result (if any) is known to come from an extension.
+sealed class ExtensionResolutionResult implements SimpleResolutionResult {}
+
+/// 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
+    implements ExtensionResolutionResult {
+  SingleExtensionResolutionResult(
+      {required super.getter, required super.setter})
+      : assert(getter != null || setter != null);
+}

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

@@ -49,7 +49,9 @@ class PropertyElementResolver with ScopeHelpers {
       var result = _extensionResolver.getOverrideMember(target, '[]');
 
       // TODO(scheglov): Change ExtensionResolver to set `needsGetterError`.
-      if (hasRead && result.getter == null && !result.isAmbiguous) {
+      if (hasRead &&
+          result.getter == null &&
+          result != ExtensionResolutionError.ambiguous) {
         // Extension overrides can only refer to named extensions, so it is safe
         // to assume that `target.staticElement!.name` is non-`null`.
         _reportUnresolvedIndex(
@@ -59,7 +61,9 @@ class PropertyElementResolver with ScopeHelpers {
         );
       }
 
-      if (hasWrite && result.setter == null && !result.isAmbiguous) {
+      if (hasWrite &&
+          result.setter == null &&
+          result != ExtensionResolutionError.ambiguous) {
         // Extension overrides can only refer to named extensions, so it is safe
         // to assume that `target.staticElement!.name` is non-`null`.
         _reportUnresolvedIndex(
@@ -889,7 +893,7 @@ class PropertyElementResolver with ScopeHelpers {
   }
 
   PropertyElementResolverResult _toIndexResult(
-    ResolutionResult result, {
+    SimpleResolutionResult result, {
     required bool atDynamicTarget,
     required bool hasRead,
     required bool hasWrite,

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

@@ -6,21 +6,7 @@ import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 
 /// The result of attempting to resolve an identifier to elements.
-class ResolutionResult {
-  /// An instance that can be used anywhere that no element was found.
-  static const ResolutionResult none =
-      ResolutionResult._(_ResolutionResultState.none);
-
-  /// An instance that can be used anywhere that multiple elements were found.
-  static const ResolutionResult ambiguous =
-      ResolutionResult._(_ResolutionResultState.ambiguous);
-
-  /// The state of the result.
-  final _ResolutionResultState state;
-
-  /// Return the element that is invoked for reading.
-  final ExecutableElement? getter;
-
+class ResolutionResult extends SimpleResolutionResult {
   /// If `true`, then the [getter] is `null`, and this is an error that has
   /// not yet been reported, and the client should report it.
   ///
@@ -34,9 +20,6 @@ class ResolutionResult {
   /// If `true`, the result type must be invalid.
   final bool isGetterInvalid;
 
-  /// Return the element that is invoked for writing.
-  final ExecutableElement? setter;
-
   /// If `true`, then the [setter] is `null`, and this is an error that has
   /// not yet been reported, and the client should report it.
   ///
@@ -56,38 +39,22 @@ class ResolutionResult {
   /// Initialize a newly created result to represent resolving a single
   /// reading and / or writing result.
   ResolutionResult({
-    this.getter,
+    super.getter,
     this.needsGetterError = true,
     this.isGetterInvalid = false,
-    this.setter,
+    super.setter,
     this.needsSetterError = true,
     this.callFunctionType,
     this.recordField,
-  }) : state = _ResolutionResultState.single;
-
-  /// Initialize a newly created result with no elements and the given [state].
-  const ResolutionResult._(this.state)
-      : getter = null,
-        needsGetterError = true,
-        isGetterInvalid = false,
-        setter = null,
-        needsSetterError = true,
-        callFunctionType = null,
-        recordField = null;
-
-  /// Return `true` if this result represents the case where multiple ambiguous
-  /// elements were found.
-  bool get isAmbiguous => state == _ResolutionResultState.ambiguous;
+  });
 }
 
-/// The state of a [ResolutionResult].
-enum _ResolutionResultState {
-  /// Indicates that no element was found.
-  none,
+class SimpleResolutionResult {
+  /// Return the element that is invoked for reading.
+  final ExecutableElement? getter;
 
-  /// Indicates that a single element was found.
-  single,
+  /// Return the element that is invoked for writing.
+  final ExecutableElement? setter;
 
-  /// Indicates that multiple ambiguous elements were found.
-  ambiguous
+  const SimpleResolutionResult({this.getter, this.setter});
 }

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

@@ -234,8 +234,8 @@ class TypePropertyResolver {
     var getterName = Name(_definingLibrary.source.uri, _name);
     var result =
         _extensionResolver.findExtension(type, _nameErrorEntity, getterName);
-    _reportedGetterError = result.isAmbiguous;
-    _reportedSetterError = result.isAmbiguous;
+    _reportedGetterError = result == ExtensionResolutionError.ambiguous;
+    _reportedSetterError = result == ExtensionResolutionError.ambiguous;
 
     if (result.getter != null) {
       _needsGetterError = false;