analyzer: Replace ClassElement.isExtendableIn with getter

For the third use of `ClassElement.isExtendableIn`
(https://dart-review.googlesource.com/c/sdk/+/442705), I found that I
would have to "make up" an outside library to check. It was suggested
that we can change the API to not require the user specify an outside
library, but instead we can just answer "is this ClassElement
extendable "outside."

(Same with `ClassElement.isImplementableIn`,
`ClassElement.isMixableIn`, and `MixinElement.isImplementableIn`.)

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

Author: srawlins

pkg/analysis_server/lib/src/cider/local_library_contributor.dart

@@ -61,14 +61,21 @@ class LibraryElementSuggestionBuilder
   @override
   void visitClassElement(ClassElement element) {
     AstNode node = request.target.containingNode;
-    var libraryElement = request.libraryElement;
-    if (node is ExtendsClause && !element.isExtendableIn(libraryElement)) {
-      return;
-    } else if (node is ImplementsClause &&
-        !element.isImplementableIn(libraryElement)) {
-      return;
-    } else if (node is WithClause && !element.isMixableIn(libraryElement)) {
-      return;
+    if (node is ExtendsClause) {
+      if (element.library != request.libraryElement &&
+          !element.isExtendableOutside) {
+        return;
+      }
+    } else if (node is ImplementsClause) {
+      if (element.library != request.libraryElement &&
+          !element.isImplementableOutside) {
+        return;
+      }
+    } else if (node is WithClause) {
+      if (element.library != request.libraryElement &&
+          !element.isMixableOutside) {
+        return;
+      }
     }
     _visitInterfaceElement(element);
   }
@@ -128,7 +135,8 @@ class LibraryElementSuggestionBuilder
   visitMixinElement(MixinElement element) {
     AstNode node = request.target.containingNode;
     if (node is ImplementsClause &&
-        !element.isImplementableIn(request.libraryElement)) {
+        request.libraryElement != element.library &&
+        !element.isImplementableOutside) {
       return;
     }
     _visitInterfaceElement(element);

pkg/analysis_server/lib/src/services/completion/dart/declaration_helper.dart

@@ -1741,35 +1741,50 @@ class DeclarationHelper {
 
   /// Adds a suggestion for the class represented by the [element].
   void _suggestClass(ClassElement element, ImportData? importData) {
-    if (visibilityTracker.isVisible(element: element, importData: importData)) {
-      if ((mustBeExtendable &&
-              !element.isExtendableIn(request.libraryElement)) ||
-          (mustBeImplementable &&
-              !element.isImplementableIn(request.libraryElement)) ||
-          (mustBeMixable && !element.isMixableIn(request.libraryElement))) {
+    if (!visibilityTracker.isVisible(
+      element: element,
+      importData: importData,
+    )) {
+      return;
+    }
+    if (mustBeExtendable) {
+      if (request.libraryElement != element.library &&
+          !element.isExtendableOutside) {
         return;
       }
-      if (!(mustBeConstant && !objectPatternAllowed) && !excludeTypeNames) {
-        var matcherScore = state.matcher.score(element.displayName);
-        if (matcherScore != -1) {
-          var suggestion = ClassSuggestion(
-            importData: importData,
-            element: element,
-            matcherScore: matcherScore,
-          );
-          collector.addSuggestion(suggestion);
-        }
+    }
+    if (mustBeImplementable) {
+      if (request.libraryElement != element.library &&
+          !element.isImplementableOutside) {
+        return;
       }
-      if (!mustBeType) {
-        _suggestStaticFields(element.fields, importData);
-        _suggestConstructors(
-          element.constructors,
-          importData,
-          allowNonFactory: !element.isAbstract,
-          checkVisibility: false,
+    }
+    if (mustBeMixable) {
+      if (request.libraryElement != element.library &&
+          !element.isMixableOutside) {
+        return;
+      }
+    }
+    if (!(mustBeConstant && !objectPatternAllowed) && !excludeTypeNames) {
+      var matcherScore = state.matcher.score(element.displayName);
+      if (matcherScore != -1) {
+        var suggestion = ClassSuggestion(
+          importData: importData,
+          element: element,
+          matcherScore: matcherScore,
         );
+        collector.addSuggestion(suggestion);
       }
     }
+    if (!mustBeType) {
+      _suggestStaticFields(element.fields, importData);
+      _suggestConstructors(
+        element.constructors,
+        importData,
+        allowNonFactory: !element.isAbstract,
+        checkVisibility: false,
+      );
+    }
   }
 
   /// Adds a suggestion for the constructor represented by the [element].
@@ -2083,10 +2098,12 @@ class DeclarationHelper {
   /// Adds a suggestion for the mixin represented by the [element].
   void _suggestMixin(MixinElement element, ImportData? importData) {
     if (visibilityTracker.isVisible(element: element, importData: importData)) {
-      if (mustBeExtendable ||
-          (mustBeImplementable &&
-              !element.isImplementableIn(request.libraryElement))) {
-        return;
+      if (mustBeExtendable) return;
+      if (mustBeImplementable) {
+        if (request.libraryElement != element.library &&
+            !element.isImplementableOutside) {
+          return;
+        }
       }
       var matcherScore = state.matcher.score(element.displayName);
       if (matcherScore != -1) {

pkg/analyzer/CHANGELOG.md

@@ -13,6 +13,10 @@
 * Deprecate `DartObject.variable2`, use `variable` instead.
 * Deprecate `DartObject.toFunctionValue2`, use `toFunctionValue` instead.
 * Deprecate `Annotatable`, use `documentationComment` and `metadata` of `Element` or `Fragment` directly.
+* Deprecate `ClassElement.isExtendableIn`; use `isExtendableOutside` instead.
+* Deprecate `ClassElement.isImplementableIn`; use `isImplementableOutside` instead.
+* Deprecate `ClassElement.isMixableIn`; use `isMixableOutside` instead.
+* Deprecate `MixinElement.isImplementableIn`; use `isImplementableOutside` instead.
 
 ## 8.0.0
 * Remove deprecated element model V1.

pkg/analyzer/api.txt

@@ -3308,17 +3308,20 @@ package:analyzer/dart/element/element.dart:
     isDartCoreEnum (getter: bool)
     isDartCoreObject (getter: bool)
     isExhaustive (getter: bool)
+    isExtendableOutside (getter: bool)
     isFinal (getter: bool)
+    isImplementableOutside (getter: bool)
     isInterface (getter: bool)
+    isMixableOutside (getter: bool)
     isMixinApplication (getter: bool)
     isMixinClass (getter: bool)
     isSealed (getter: bool)
     isValidMixin (getter: bool)
-    isExtendableIn (method: bool Function(LibraryElement))
+    isExtendableIn (method: bool Function(LibraryElement), deprecated)
     isExtendableIn2 (method: bool Function(LibraryElement), deprecated)
-    isImplementableIn (method: bool Function(LibraryElement))
+    isImplementableIn (method: bool Function(LibraryElement), deprecated)
     isImplementableIn2 (method: bool Function(LibraryElement), deprecated)
-    isMixableIn (method: bool Function(LibraryElement))
+    isMixableIn (method: bool Function(LibraryElement), deprecated)
     isMixableIn2 (method: bool Function(LibraryElement), deprecated)
   ClassFragment (class extends Object implements InterfaceFragment):
     new (constructor: ClassFragment Function())
@@ -3989,8 +3992,9 @@ package:analyzer/dart/element/element.dart:
     firstFragment (getter: MixinFragment)
     fragments (getter: List<MixinFragment>)
     isBase (getter: bool)
+    isImplementableOutside (getter: bool)
     superclassConstraints (getter: List<InterfaceType>)
-    isImplementableIn (method: bool Function(LibraryElement))
+    isImplementableIn (method: bool Function(LibraryElement), deprecated)
     isImplementableIn2 (method: bool Function(LibraryElement), deprecated)
   MixinFragment (class extends Object implements InterfaceFragment):
     new (constructor: MixinFragment Function())

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

@@ -268,6 +268,9 @@ abstract class ClassElement implements InterfaceElement {
   /// you have covered all possible instances of the type.
   bool get isExhaustive;
 
+  /// Whether this class can be extended outside of its library.
+  bool get isExtendableOutside;
+
   /// Whether the class is a final class.
   ///
   /// A class is a final class if it has an explicit `final` modifier, or the
@@ -276,6 +279,9 @@ abstract class ClassElement implements InterfaceElement {
   /// or mixed in.
   bool get isFinal;
 
+  /// Whether the class can be implemented outside of its library.
+  bool get isImplementableOutside;
+
   /// Whether the class is an interface class.
   ///
   /// A class is an interface class if it has an explicit `interface` modifier,
@@ -284,6 +290,9 @@ abstract class ClassElement implements InterfaceElement {
   /// not extended or mixed in.
   bool get isInterface;
 
+  /// Whether the class can be mixed-in outside of its library.
+  bool get isMixableOutside;
+
   /// Whether the class is a mixin application.
   ///
   /// A class is a mixin application if it was declared using the syntax
@@ -314,31 +323,34 @@ abstract class ClassElement implements InterfaceElement {
   /// </blockquote>
   bool get isValidMixin;
 
-  /// Whether the class, assuming that it is within scope, can be extended by
-  /// classes in the given [library].
+  /// Whether the class, assuming that it is within scope, can be extended in
+  /// the given [library].
+  @Deprecated('Use isExtendableOutside instead')
   bool isExtendableIn(LibraryElement library);
 
-  /// Whether the class, assuming that it is within scope, can be extended by
-  /// classes in the given [library].
-  @Deprecated('Use isExtendableIn instead')
+  /// Whether the class, assuming that it is within scope, can be extended in
+  /// the given [library].
+  @Deprecated('Use isExtendableOutside instead')
   bool isExtendableIn2(LibraryElement library);
 
-  /// Whether the class, assuming that it is within scope, can be implemented by
-  /// classes, mixins, and enums in the given [library].
+  /// Whether the class, assuming that it is within scope, can be implemented in
+  /// the given [library].
+  @Deprecated('Use isImplementableOutside instead')
   bool isImplementableIn(LibraryElement library);
 
-  /// Whether the class, assuming that it is within scope, can be implemented by
-  /// classes, mixins, and enums in the given [library].
-  @Deprecated('Use isImplementableIn instead')
+  /// Whether the class, assuming that it is within scope, can be implemented in
+  /// the given [library].
+  @Deprecated('Use isImplementableOutside instead')
   bool isImplementableIn2(LibraryElement library);
 
-  /// Whether the class, assuming that it is within scope, can be mixed-in by
-  /// classes and enums in the given [library].
+  /// Whether the class, assuming that it is within scope, can be mixed-in in
+  /// the given [library].
+  @Deprecated('Use isMixableOutside instead')
   bool isMixableIn(LibraryElement library);
 
-  /// Whether the class, assuming that it is within scope, can be mixed-in by
-  /// classes and enums in the given [library].
-  @Deprecated('Use isMixableIn instead')
+  /// Whether the class, assuming that it is within scope, can be mixed-in in
+  /// the given [library].
+  @Deprecated('Use isMixableOutside instead')
   bool isMixableIn2(LibraryElement library);
 }
 
@@ -3286,6 +3298,10 @@ abstract class MixinElement implements InterfaceElement {
   /// The base modifier allows a mixin to be mixed in, but not implemented.
   bool get isBase;
 
+  /// Whether the mixin can be implemented by declarations outside of its
+  /// library.
+  bool get isImplementableOutside;
+
   /// The superclass constraints defined for this mixin.
   ///
   /// If the declaration does not have an `on` clause, then the list will
@@ -3298,13 +3314,14 @@ abstract class MixinElement implements InterfaceElement {
   /// guard against infinite loops.
   List<InterfaceType> get superclassConstraints;
 
-  /// Whether the element, assuming that it is within scope, is
-  /// implementable to classes, mixins, and enums in the given [library].
+  /// Whether the mixin, assuming that it is within scope, is implementable by
+  /// declarations in the given [library].
+  @Deprecated('Use isImplementableOutside instead')
   bool isImplementableIn(LibraryElement library);
 
-  /// Whether the element, assuming that it is within scope, is
-  /// implementable to classes, mixins, and enums in the given [library].
-  @Deprecated('Use isImplementableIn instead')
+  /// Whether the mixin, assuming that it is within scope, is implementable by
+  /// declarations in the given [library].
+  @Deprecated('Use isImplementableOutside instead')
   bool isImplementableIn2(LibraryElement library);
 }