Handle typeHierarchy/supertypes requests

Signed-off-by: Alexandre Terrasa <[email protected]>

Author: Morriar

lib/ruby_lsp/requests.rb

@@ -48,6 +48,7 @@ module Requests
     autoload :WorkspaceSymbol, "ruby_lsp/requests/workspace_symbol"
     autoload :SignatureHelp, "ruby_lsp/requests/signature_help"
     autoload :PrepareTypeHierarchy, "ruby_lsp/requests/prepare_type_hierarchy"
+    autoload :TypeHierarchySupertypes, "ruby_lsp/requests/type_hierarchy_supertypes"
 
     # :nodoc:
     module Support

lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -0,0 +1,91 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Type hierarchy supertypes demo](../../type_hierarchy_supertypes.gif)
+    #
+    # The [type hierarchy supertypes
+    # request](https://microsoft.github.io/language-server-protocol/specification#typeHierarchy_supertypes)
+    # displays the list of ancestors (supertypes) for the selected type.
+    #
+    # # Example
+    #
+    # ```ruby
+    # class Foo; end
+    # class Bar < Foo; end
+    #
+    # puts Bar # <-- right click on `Bar` and select "Show Type Hierarchy"
+    # ```
+    class TypeHierarchySupertypes < Request
+      extend T::Sig
+
+      include Support::Common
+
+      sig { params(index: RubyIndexer::Index, item: T::Hash[Symbol, T.untyped]).void }
+      def initialize(index, item)
+        super()
+
+        @index = index
+        @item = item
+      end
+
+      sig { override.returns(T.nilable(T::Array[Interface::TypeHierarchyItem])) }
+      def perform
+        name = @item[:name]
+        entries = @index[name]
+
+        parents = T.let([], T::Array[RubyIndexer::Entry::Namespace])
+        return unless entries&.any?
+
+        entries.each do |entry|
+          next unless entry.is_a?(RubyIndexer::Entry::Namespace)
+
+          if entry.is_a?(RubyIndexer::Entry::Class)
+            parent_class_name = entry.parent_class
+            if parent_class_name
+              resolved_parent_entries = @index.resolve(parent_class_name, entry.nesting)
+              resolved_parent_entries&.each do |entry|
+                next unless entry.is_a?(RubyIndexer::Entry::Class)
+
+                parents << entry
+              end
+            end
+          end
+
+          entry.mixin_operations.each do |mixin_operation|
+            next if mixin_operation.is_a?(RubyIndexer::Entry::Extend)
+
+            mixin_name = mixin_operation.module_name
+            resolved_mixin_entries = @index.resolve(mixin_name, entry.nesting)
+            next unless resolved_mixin_entries
+
+            resolved_mixin_entries.each do |mixin_entry|
+              next unless mixin_entry.is_a?(RubyIndexer::Entry::Module)
+
+              parents << mixin_entry
+            end
+          end
+        end
+
+        parents.uniq.map { |entry| hierarchy_item(entry) }
+      end
+
+      private
+
+      sig { params(entry: RubyIndexer::Entry).returns(Interface::TypeHierarchyItem) }
+      def hierarchy_item(entry)
+        range = range_from_location(entry.location)
+
+        Interface::TypeHierarchyItem.new(
+          name: entry.name,
+          kind: kind_for_entry(entry),
+          uri: URI::Generic.from_path(path: entry.file_path).to_s,
+          range: range,
+          selection_range: range,
+          detail: entry.file_name,
+        )
+      end
+    end
+  end
+end

lib/ruby_lsp/server.rb

@@ -70,6 +70,8 @@ def process_message(message)
         text_document_definition(message)
       when "textDocument/prepareTypeHierarchy"
         text_document_prepare_type_hierarchy(message)
+      when "typeHierarchy/supertypes"
+        type_hierarchy_supertypes(message)
       when "workspace/didChangeWatchedFiles"
         workspace_did_change_watched_files(message)
       when "workspace/symbol"
@@ -688,6 +690,15 @@ def text_document_prepare_type_hierarchy(message)
       send_message(Result.new(id: message[:id], response: response))
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def type_hierarchy_supertypes(message)
+      response = Requests::TypeHierarchySupertypes.new(
+        @global_state.index,
+        message.dig(:params, :item),
+      ).perform
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def workspace_dependencies(message)
       response = begin

misc/type_hierarchy_supertypes.gif

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TypeHierarchySupertypesTest < Minitest::Test
+  def test_type_hierarchy_supertypes_returns_nil_if_item_name_not_indexed
+    source = +<<~RUBY
+      class Foo; end
+    RUBY
+
+    with_server(source) do |server, uri|
+      server.process_message(id: 1, method: "typeHierarchy/supertypes", params: {
+        textDocument: { uri: uri },
+        item: { name: "Bar" },
+      })
+      result = server.pop_response.response
+
+      assert_nil(result)
+    end
+  end
+
+  def test_type_hierarchy_supertypes_returns_empty_array_if_no_supertypes
+    source = +<<~RUBY
+      class Foo::Bar; end
+    RUBY
+
+    with_server(source) do |server, uri|
+      server.process_message(id: 1, method: "typeHierarchy/supertypes", params: {
+        textDocument: { uri: uri },
+        item: { name: "Foo::Bar" },
+      })
+      result = server.pop_response.response
+
+      assert_empty(result)
+    end
+  end
+
+  def test_type_hierarchy_returns_supertypes
+    source = <<~RUBY
+      module Foo
+        class Bar; end
+        class Baz < Bar; end
+        class Qux < Baz; end
+      end
+    RUBY
+
+    with_server(source) do |server, uri|
+      server.process_message(id: 1, method: "typeHierarchy/supertypes", params: {
+        textDocument: { uri: uri },
+        item: { name: "Foo::Qux" },
+      })
+      result = server.pop_response.response
+
+      assert_equal(["Foo::Baz"], result.map(&:name))
+
+      server.process_message(id: 2, method: "typeHierarchy/supertypes", params: {
+        textDocument: { uri: uri },
+        item: { name: "Foo::Baz" },
+      })
+      result = server.pop_response.response
+
+      assert_equal(["Foo::Bar"], result.map(&:name))
+
+      server.process_message(id: 2, method: "typeHierarchy/supertypes", params: {
+        textDocument: { uri: uri },
+        item: { name: "Foo::Bar" },
+      })
+      result = server.pop_response.response
+
+      assert_empty(result)
+    end
+  end
+end