[analysis_server] Always show type parameters in LSP type hierarchy, not type arguments

The change at 27ba8fc (to fix Dart-Code/Dart-Code#4217) added type arguments to the LSP Type Hierarchy (before, neither type args or type params were shown).

Showing type arguments seemed reasonable when looking at supertypes, but behaves oddly for subtypes (and also when invoked on a type with arguments), so this partly reverts that and shows type parameters in all cases instead.

This simplified the code a bit and removed the `TypeHierarchyAnchor` class we were round-tripping in order to preserve the type arguments.

Fixes #60549

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

Author: DanTup

pkg/analysis_server/lib/src/computer/computer_lazy_type_hierarchy.dart

@@ -49,36 +49,16 @@ class DartLazyTypeHierarchyComputer {
   }
 
   /// Finds supertypes for the [Element2] at [location].
-  ///
-  /// If [anchor] is provided, it will be used to navigate to the element at
-  /// [location] to preserve type arguments that have been provided along the
-  /// way.
-  ///
-  /// Anchors are included in returned types (where necessary to preserve type
-  /// arguments) that can be used when calling for the next level of types.
   Future<List<TypeHierarchyRelatedItem>?> findSupertypes(
-    ElementLocation location, {
-    TypeHierarchyAnchor? anchor,
-  }) async {
+    ElementLocation location,
+  ) async {
     var targetElement = await _findTargetElement(location);
     if (targetElement == null) {
       return null;
     }
     var targetType = targetElement.thisType;
 
-    // If we were provided an anchor, use it to re-locate the target type so
-    // that any type arguments supplied along the way will be preserved in the
-    // new node.
-    if (anchor != null) {
-      targetType =
-          await _locateTargetFromAnchor(anchor, targetType) ?? targetType;
-    }
-
-    // If we had no existing anchor, create one that starts from this target as
-    // the starting point for the new supertypes.
-    anchor ??= TypeHierarchyAnchor(location: location, path: []);
-
-    return _getSupertypes(targetType, anchor: anchor);
+    return _getSupertypes(targetType);
   }
 
   /// Finds a target for starting type hierarchy navigation at [offset].
@@ -101,7 +81,9 @@ class DartLazyTypeHierarchyComputer {
       }
     }
 
-    return type is InterfaceType ? TypeHierarchyItem.forType(type) : null;
+    return type is InterfaceType
+        ? TypeHierarchyItem.forElement(type.element3)
+        : null;
   }
 
   /// Locate the [Element2] referenced by [location].
@@ -153,10 +135,7 @@ class DartLazyTypeHierarchyComputer {
   /// Includes all elements that contribute implementation to the type
   /// such as supertypes and mixins, but not interfaces, constraints or
   /// extended types.
-  List<TypeHierarchyRelatedItem> _getSupertypes(
-    InterfaceType type, {
-    TypeHierarchyAnchor? anchor,
-  }) {
+  List<TypeHierarchyRelatedItem> _getSupertypes(InterfaceType type) {
     var supertype = type.superclass;
     var interfaces = type.interfaces;
     var mixins = type.mixins;
@@ -170,19 +149,6 @@ class DartLazyTypeHierarchyComputer {
           ...mixins.map(TypeHierarchyRelatedItem.mixesIn),
         ].nonNulls.toList();
 
-    if (anchor != null) {
-      for (var (index, item) in supertypes.indexed) {
-        // We only need to carry the anchor along if the supertype has type
-        // arguments that we may be populating.
-        if (item._type.typeArguments.isNotEmpty) {
-          item._anchor = TypeHierarchyAnchor(
-            location: anchor.location,
-            path: [...anchor.path, index],
-          );
-        }
-      }
-    }
-
     return supertypes;
   }
 
@@ -193,29 +159,6 @@ class DartLazyTypeHierarchyComputer {
       declaration is MixinDeclaration ||
       declaration is ExtensionTypeDeclaration ||
       declaration is EnumDeclaration;
-
-  /// Navigate to [target] from [anchor], preserving type arguments supplied
-  /// along the way.
-  Future<InterfaceType?> _locateTargetFromAnchor(
-    TypeHierarchyAnchor anchor,
-    InterfaceType target,
-  ) async {
-    // Start from the anchor.
-    var anchorElement = await _findTargetElement(anchor.location);
-    var anchorPath = anchor.path;
-
-    // Follow the provided path.
-    var type = anchorElement?.thisType;
-    for (int i = 0; i < anchorPath.length && type != null; i++) {
-      var index = anchorPath[i];
-      var supertypes = _getSupertypes(type);
-      type = supertypes.length >= index + 1 ? supertypes[index]._type : null;
-    }
-
-    // Verify the element we arrived at matches the targetElement to guard
-    // against code changes that made the path from the anchor invalid.
-    return type != null && type.element3 == target.element3 ? type : null;
-  }
 }
 
 class TypeHierarchyAnchor {
@@ -241,9 +184,6 @@ class TypeHierarchyItem {
   /// names/identifiers have not changed).
   final ElementLocation location;
 
-  /// The type being displayed.
-  final InterfaceType _type;
-
   /// The file that contains the declaration of this item.
   final String file;
 
@@ -254,28 +194,26 @@ class TypeHierarchyItem {
   final SourceRange codeRange;
 
   TypeHierarchyItem({
-    required InterfaceType type,
     required this.displayName,
     required this.location,
     required this.file,
     required this.nameRange,
     required this.codeRange,
-  }) : _type = type;
+  });
 
-  TypeHierarchyItem._forType({
-    required InterfaceType type,
+  TypeHierarchyItem._forElement({
+    required InterfaceElement2 element,
     required this.location,
-  }) : _type = type,
-       displayName = _displayNameForType(type),
-       nameRange = _nameRangeForElement(type.element3),
-       codeRange = _codeRangeForElement(type.element3),
-       file = type.element3.firstFragment.libraryFragment.source.fullName;
-
-  static TypeHierarchyItem? forType(InterfaceType type) {
-    var location = ElementLocation.forElement(type.element3);
+  }) : displayName = _displayNameForElement(element),
+       nameRange = _nameRangeForElement(element),
+       codeRange = _codeRangeForElement(element),
+       file = element.firstFragment.libraryFragment.source.fullName;
+
+  static TypeHierarchyItem? forElement(InterfaceElement2 element) {
+    var location = ElementLocation.forElement(element);
     if (location == null) return null;
 
-    return TypeHierarchyItem._forType(type: type, location: location);
+    return TypeHierarchyItem._forElement(element: element, location: location);
   }
 
   /// Returns the [SourceRange] of the code for [element].
@@ -285,9 +223,9 @@ class TypeHierarchyItem {
     return SourceRange(firstFragment.codeOffset!, firstFragment.codeLength!);
   }
 
-  /// Returns a name to display in the hierarchy for [type].
-  static String _displayNameForType(InterfaceType type) {
-    return type.getDisplayString();
+  /// Returns a name to display in the hierarchy for [element].
+  static String _displayNameForElement(InterfaceElement2 element) {
+    return element.baseElement.thisType.getDisplayString();
   }
 
   /// Returns the [SourceRange] of the name for [element].
@@ -316,51 +254,48 @@ class TypeHierarchyRelatedItem extends TypeHierarchyItem {
   /// The relationship this item has with the target item.
   final TypeHierarchyItemRelationship relationship;
 
-  TypeHierarchyAnchor? _anchor;
-
-  TypeHierarchyRelatedItem({
-    required super.type,
+  TypeHierarchyRelatedItem.forElement({
+    required super.element,
     required this.relationship,
-    required super.displayName,
     required super.location,
-    required super.file,
-    required super.nameRange,
-    required super.codeRange,
-  });
-
-  TypeHierarchyRelatedItem.forType({
-    required super.type,
-    required this.relationship,
-    required super.location,
-  }) : super._forType();
-
-  /// An optional anchor element used to preserve type args.
-  TypeHierarchyAnchor? get anchor => _anchor;
+  }) : super._forElement();
 
   static TypeHierarchyRelatedItem? constrainedTo(InterfaceType type) =>
-      _forType(type, relationship: TypeHierarchyItemRelationship.constrainedTo);
+      _forElement(
+        type.element3,
+        relationship: TypeHierarchyItemRelationship.constrainedTo,
+      );
 
-  static TypeHierarchyRelatedItem? extends_(InterfaceType type) =>
-      _forType(type, relationship: TypeHierarchyItemRelationship.extends_);
+  static TypeHierarchyRelatedItem? extends_(InterfaceType type) => _forElement(
+    type.element3,
+    relationship: TypeHierarchyItemRelationship.extends_,
+  );
 
   static TypeHierarchyRelatedItem? implements(InterfaceType type) =>
-      _forType(type, relationship: TypeHierarchyItemRelationship.implements);
+      _forElement(
+        type.element3,
+        relationship: TypeHierarchyItemRelationship.implements,
+      );
 
-  static TypeHierarchyRelatedItem? mixesIn(InterfaceType type) =>
-      _forType(type, relationship: TypeHierarchyItemRelationship.mixesIn);
+  static TypeHierarchyRelatedItem? mixesIn(InterfaceType type) => _forElement(
+    type.element3,
+    relationship: TypeHierarchyItemRelationship.mixesIn,
+  );
 
-  static TypeHierarchyRelatedItem? unknown(InterfaceType type) =>
-      _forType(type, relationship: TypeHierarchyItemRelationship.unknown);
+  static TypeHierarchyRelatedItem? unknown(InterfaceType type) => _forElement(
+    type.element3,
+    relationship: TypeHierarchyItemRelationship.unknown,
+  );
 
-  static TypeHierarchyRelatedItem? _forType(
-    InterfaceType type, {
+  static TypeHierarchyRelatedItem? _forElement(
+    InterfaceElement2 element, {
     required TypeHierarchyItemRelationship relationship,
   }) {
-    var location = ElementLocation.forElement(type.element3);
+    var location = ElementLocation.forElement(element);
     if (location == null) return null;
 
-    return TypeHierarchyRelatedItem.forType(
-      type: type,
+    return TypeHierarchyRelatedItem.forElement(
+      element: element,
       relationship: relationship,
       location: location,
     );

pkg/analysis_server/lib/src/lsp/handlers/handler_type_hierarchy.dart

@@ -190,26 +190,11 @@ class TypeHierarchySupertypesHandler
       }
 
       var location = ElementLocation.decode(data.ref);
-      var anchor = _toServerAnchor(data);
-      var calls = await computer.findSupertypes(location, anchor: anchor);
+      var calls = await computer.findSupertypes(location);
       var results = calls != null ? _convertItems(unit, calls) : null;
       return success(results);
     });
   }
-
-  /// Reads the anchor from [data] (if available) and converts it to a server
-  /// [type_hierarchy.TypeHierarchyAnchor].
-  type_hierarchy.TypeHierarchyAnchor? _toServerAnchor(
-    TypeHierarchyItemInfo data,
-  ) {
-    var anchor = data.anchor;
-    return anchor != null
-        ? type_hierarchy.TypeHierarchyAnchor(
-          location: ElementLocation.decode(anchor.ref),
-          path: anchor.path,
-        )
-        : null;
-  }
 }
 
 /// Utility methods used by all Type Hierarchy handlers.
@@ -224,24 +209,13 @@ mixin _TypeHierarchyUtils on HandlerHelperMixin<AnalysisServer> {
     type_hierarchy.TypeHierarchyItem item,
     LineInfo lineInfo,
   ) {
-    var anchor =
-        item is type_hierarchy.TypeHierarchyRelatedItem ? item.anchor : null;
     return TypeHierarchyItem(
       name: item.displayName,
       kind: SymbolKind.Class,
       uri: uriConverter.toClientUri(item.file),
       range: sourceRangeToRange(lineInfo, item.codeRange),
       selectionRange: sourceRangeToRange(lineInfo, item.nameRange),
-      data: TypeHierarchyItemInfo(
-        ref: item.location.encoding,
-        anchor:
-            anchor != null
-                ? TypeHierarchyAnchor(
-                  ref: anchor.location.encoding,
-                  path: anchor.path,
-                )
-                : null,
-      ),
+      data: TypeHierarchyItemInfo(ref: item.location.encoding),
     );
   }
 

pkg/analysis_server/test/lsp/type_hierarchy_test.dart

@@ -418,8 +418,8 @@ extension type E^2(A a) implements B, E1 {}
     );
   }
 
-  /// Ensure that type arguments flow across multiple levels of the tree.
-  Future<void> test_generics_typeArgsFlow() async {
+  /// Ensure that we always show type parameters and not type arguments.
+  Future<void> test_generics_typeParameters() async {
     var content = '''
 class A<T1, T2> {}
 class B<T1, T2> extends A<T1, T2> {}
@@ -442,14 +442,7 @@ class ^E extends D {}
     }
 
     // Check for substituted type args.
-    expect(names, [
-      'E',
-      'D',
-      'C<int>',
-      'B<int, String>',
-      'A<int, String>',
-      'Object',
-    ]);
+    expect(names, ['E', 'D', 'C<T1>', 'B<T1, T2>', 'A<T1, T2>', 'Object']);
   }
 
   Future<void> test_implements() async {