Add new element model members to InheritanceManager3

Change-Id: I08e8f9d956c514728ec27d0dc1f68a1d1f323850
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/387062
Commit-Queue: Brian Wilkerson <brianwilkerson@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>

Author: bwilkerson

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

@@ -4482,7 +4482,14 @@ mixin FragmentedFunctionTypedElementMixin<E extends ExecutableFragment>
   // TODO(augmentations): This is wrong. The function type needs to be a merge
   //  of the function types of all of the fragments, but I don't know how to
   //  perform that merge.
-  FunctionType get type => (firstFragment as FunctionTypedElementImpl).type;
+  FunctionType get type {
+    if (firstFragment is ExecutableElementImpl) {
+      return (firstFragment as ExecutableElementImpl).type;
+    } else if (firstFragment is FunctionTypedElementImpl) {
+      return (firstFragment as FunctionTypedElementImpl).type;
+    }
+    throw UnimplementedError();
+  }
 }
 
 mixin FragmentedTypeParameterizedElementMixin<
@@ -9023,9 +9030,7 @@ class SetterElementImpl extends ExecutableElementImpl2
       firstFragment.correspondingGetter2?.element as GetterElement?;
 
   @override
-  String get displayName {
-    return name.substring(0, name.length - 1);
-  }
+  String get displayName => name.substring(0, name.length - 1);
 
   @override
   Element2? get enclosingElement2 => firstFragment.enclosingFragment?.element;

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

@@ -3,13 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/extensions.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
+import 'package:meta/meta.dart';
 
 /// Failure because of there is no most specific signature in [candidates].
 class CandidatesConflict extends Conflict {
@@ -145,6 +147,40 @@ class InheritanceManager3 {
     return getInheritedMap2(element)[name];
   }
 
+  /// Returns the result of [getInherited2] with [type] substitution.
+  // This is a replacement for `getInherited`.
+  @experimental
+  ExecutableElement2? getInherited3(InterfaceType type, Name name) {
+    var element = getInherited(type, name);
+    return (element as ExecutableFragment?)?.element;
+  }
+
+  /// Returns the most specific signature of the member with the given [name]
+  /// that [element] inherits from the mixins, superclasses, or interfaces.
+  ///
+  /// Returns `null` if no member is inherited because the member is not
+  /// declared at all, or because there is no the most specific signature.
+  ///
+  /// This is equivalent to `getInheritedMap(type)[name]`.
+  // This is a replacement for `getInherited2`.
+  @experimental
+  ExecutableElement2? getInherited4(InterfaceElement2 element, Name name) {
+    var oldElement = getInheritedMap2(
+        (element as AugmentedInterfaceElement).declaration)[name];
+    return (oldElement as ExecutableFragment?)?.element;
+  }
+
+  /// Returns signatures of all concrete members that the given [element]
+  /// inherits from the superclasses and mixins.
+  @experimental
+  Map<Name, ExecutableElement2> getInheritedConcreteMap(
+      InterfaceElement2 element) {
+    var map = getInheritedConcreteMap2(
+        (element as AugmentedInterfaceElement).declaration);
+    return map.map((name, element) =>
+        MapEntry(name, (element as ExecutableFragment).element));
+  }
+
   /// Return signatures of all concrete members that the given [element] inherits
   /// from the superclasses and mixins.
   Map<Name, ExecutableElement> getInheritedConcreteMap2(
@@ -157,6 +193,20 @@ class InheritanceManager3 {
     return interface.superImplemented.last;
   }
 
+  /// Returns the mapping from names to most specific signatures of members
+  /// inherited from the super-interfaces (superclasses, mixins, and
+  /// interfaces).
+  ///
+  /// If there is no most specific signature for a name, the corresponding name
+  /// will not be included.
+  @experimental
+  Map<Name, ExecutableElement2> getInheritedMap(InterfaceElement2 element) {
+    var map =
+        getInheritedMap2((element as AugmentedInterfaceElement).declaration);
+    return map.map((name, element) =>
+        MapEntry(name, (element as ExecutableFragment).element));
+  }
+
   /// Return the mapping from names to most specific signatures of members
   /// inherited from the super-interfaces (superclasses, mixins, and
   /// interfaces).  If there is no most specific signature for a name, the
@@ -211,6 +261,15 @@ class InheritanceManager3 {
     return result;
   }
 
+  /// Returns the interface of the given [element].
+  ///
+  /// The interface might include private members, not necessary accessible in
+  /// all libraries.
+  @experimental
+  Interface getInterface2(InterfaceElement2 element) {
+    return getInterface((element as AugmentedInterfaceElement).declaration);
+  }
+
   /// Return the result of [getMember2] with [type] substitution.
   ExecutableElement? getMember(
     InterfaceType type,
@@ -274,6 +333,75 @@ class InheritanceManager3 {
     return interface.map[name];
   }
 
+  /// Returns the result of [getMember4] with [type] substitution.
+  // This is a replacement for `getMember`.
+  @experimental
+  ExecutableElement2? getMember3(
+    InterfaceType type,
+    Name name, {
+    bool concrete = false,
+    int forMixinIndex = -1,
+    bool forSuper = false,
+  }) {
+    var element = getMember(
+      type,
+      name,
+      concrete: concrete,
+      forMixinIndex: forMixinIndex,
+      forSuper: forSuper,
+    );
+    return (element as ExecutableFragment?)?.element;
+  }
+
+  /// Returns the member with the given [name].
+  ///
+  /// If [concrete] is `true`, the concrete implementation is returned, whether
+  /// from the given [element] or its superclass.
+  ///
+  /// If [forSuper] is `true`, then [concrete] is implied, and only concrete
+  /// members from the superclass are considered.
+  ///
+  /// If [forMixinIndex] is specified, only the nominal superclass, and the
+  /// given number of mixins after it are considered. For example for `1` in
+  /// `class C extends S with M1, M2, M3`, only `S` and `M1` are considered.
+  // This is a replacement for `getMember2`.
+  @experimental
+  ExecutableElement2? getMember4(
+    InterfaceElement2 element,
+    Name name, {
+    bool concrete = false,
+    int forMixinIndex = -1,
+    bool forSuper = false,
+  }) {
+    var oldElement = getMember2(
+      (element as AugmentedInterfaceElement).declaration,
+      name,
+      concrete: concrete,
+      forMixinIndex: forMixinIndex,
+      forSuper: forSuper,
+    );
+    return (oldElement as ExecutableFragment?)?.element;
+  }
+
+  /// Returns all members of mixins, superclasses, and interfaces that a member
+  /// with the given [name], defined in the [element], would override.
+  ///
+  /// Returns `null` if no members would be overridden.
+  @experimental
+  List<ExecutableElement2>? getOverridden(
+      InterfaceElement2 element, Name name) {
+    var elements = getOverridden2(
+      (element as AugmentedInterfaceElement).declaration,
+      name,
+    );
+    if (elements == null) {
+      return null;
+    }
+    return elements
+        .map((fragment) => (fragment as ExecutableFragment).element)
+        .toList();
+  }
+
   /// Return all members of mixins, superclasses, and interfaces that a member
   /// with the given [name], defined in the [element], would override; or `null`
   /// if no members would be overridden.
@@ -1114,6 +1242,20 @@ class Interface {
     required this.conflicts,
   });
 
+  /// The map of declared names to their signatures.
+  @experimental
+  Map<Name, ExecutableElement2> get declared2 {
+    return declared.map((name, element) =>
+        MapEntry(name, (element as ExecutableFragment).element));
+  }
+
+  /// The map of names to their signature in the interface.
+  @experimental
+  Map<Name, ExecutableElement2> get map2 {
+    return map.map((name, element) =>
+        MapEntry(name, (element as ExecutableFragment).element));
+  }
+
   /// Return `true` if the [name] is implemented in the supertype.
   bool isSuperImplemented(Name name) {
     return superImplemented.last.containsKey(name);