ruby-lsp 0.27.0.beta1 → 0.27.0.beta3

data/lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -9,65 +9,101 @@ module RubyLsp
     class TypeHierarchySupertypes < Request
       include Support::Common
 
-      #: (RubyIndexer::Index index, Hash[Symbol, untyped] item) -> void
-      def initialize(index, item)
+      #: (GlobalState, Hash[Symbol, untyped]) -> void
+      def initialize(global_state, item)
         super()
 
-        @index = index
+        @graph = global_state.graph #: Rubydex::Graph
         @item = item
       end
 
       # @override
       #: -> Array[Interface::TypeHierarchyItem]?
       def perform
-        name = @item[:name]
-        entries = @index[name]
-
-        parents = Set.new #: Set[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|
-            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
+        fully_qualified_name = @item.dig(:data, :fully_qualified_name) || @item[:name] #: String?
+        return unless fully_qualified_name
+
+        declaration = @graph[fully_qualified_name]
+        return unless declaration.is_a?(Rubydex::Namespace)
 
-        parents.map { |entry| hierarchy_item(entry) }
+        compute_supertypes(declaration).filter_map { |name, backing| hierarchy_item(name, backing) }
       end
 
       private
 
-      #: (RubyIndexer::Entry entry) -> Interface::TypeHierarchyItem
-      def hierarchy_item(entry)
-        Interface::TypeHierarchyItem.new(
-          name: entry.name,
-          kind: kind_for_entry(entry),
-          uri: entry.uri.to_s,
-          range: range_from_location(entry.location),
-          selection_range: range_from_location(entry.name_location),
-          detail: entry.file_name,
+      # Returns an array of `[display_name, backing_declaration]` pairs. `display_name` is the name shown in the type
+      # hierarchy item (which may be a synthesized singleton class name like `Object::<Object>`). `backing_declaration`
+      # is the namespace whose primary definition provides the location for the hierarchy item — it may differ from the
+      # display name when the singleton class is implicit and has no definitions of its own, in which case we fall back
+      # to the attached object's definition so the user still lands somewhere useful.
+      #
+      #: (Rubydex::Namespace) -> Array[[String, Rubydex::Namespace]]
+      def compute_supertypes(declaration)
+        case declaration
+        when Rubydex::SingletonClass
+          singleton_supertypes(declaration)
+        when Rubydex::Class
+          class_supertypes(declaration)
+        else
+          explicit_supertypes(declaration)
+        end
+      end
+
+      #: (Rubydex::Class) -> Array[[String, Rubydex::Namespace]]
+      def class_supertypes(declaration)
+        # `BasicObject` is the root of the Ruby class hierarchy
+        supertypes = explicit_supertypes(declaration)
+        return supertypes if declaration.name == "BasicObject"
+
+        # If the class has any superclass reference (resolved or unresolved), don't re-add the implicit `Object`.
+        has_superclass = declaration.definitions.any? do |d|
+          d.is_a?(Rubydex::ClassDefinition) && !d.superclass.nil?
+        end
+        return supertypes if has_superclass
+
+        object = @graph["Object"] #: as Rubydex::Namespace
+        supertypes << ["Object", object]
+        supertypes
+      end
+
+      #: (Rubydex::Namespace) -> Array[[String, Rubydex::Namespace]]
+      def explicit_supertypes(declaration)
+        declaration.direct_supertypes.map { |s| [s.name, s] }
+      end
+
+      # Singleton classes don't have their own superclass references. Their direct supertype is the singleton class of
+      # the attached object's superclass, computed recursively so that nested singleton classes (e.g.
+      # `Foo::<Foo>::<<Foo>>`) still resolve to the matching depth on the parent chain. When the synthesized singleton
+      # class name has no backing declaration with definitions (implicit singleton), we fall back to the attached
+      # supertype's backing so the user is still navigated to a meaningful location.
+      #
+      #: (Rubydex::SingletonClass) -> Array[[String, Rubydex::Namespace]]
+      def singleton_supertypes(declaration)
+        attached = declaration.owner
+        return [] unless attached.is_a?(Rubydex::Namespace)
+
+        compute_supertypes(attached).map do |parent_name, parent_backing|
+          singleton_name = singleton_name_of(parent_name)
+          found = @graph[singleton_name]
+          backing = found.is_a?(Rubydex::Namespace) && found.definitions.any? ? found : parent_backing
+          [singleton_name, backing]
+        end
+      end
+
+      #: (String) -> String
+      def singleton_name_of(name)
+        unqualified = name.split("::").last || name
+        "#{name}::<#{unqualified}>"
+      end
+
+      #: (String, Rubydex::Namespace) -> Interface::TypeHierarchyItem?
+      def hierarchy_item(name, declaration)
+        primary = declaration.definitions.first #: Rubydex::Definition?
+        return unless primary
+
+        primary.to_lsp_type_hierarchy_item(
+          name,
+          detail: declaration.lsp_type_hierarchy_detail,
         )
       end
     end

data/lib/ruby_lsp/ruby_document.rb

@@ -4,22 +4,6 @@
 module RubyLsp
   #: [ParseResultType = Prism::ParseLexResult]
   class RubyDocument < Document
-    METHODS_THAT_CHANGE_DECLARATIONS = [
-      :private_constant,
-      :attr_reader,
-      :attr_writer,
-      :attr_accessor,
-      :alias_method,
-      :include,
-      :prepend,
-      :extend,
-      :public,
-      :protected,
-      :private,
-      :module_function,
-      :private_class_method,
-    ].freeze
-
     class << self
       #: (Prism::Node node, Integer char_position, code_units_cache: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache), ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
       def locate(node, char_position, code_units_cache:, node_types: [])
@@ -190,62 +174,5 @@ module RubyLsp
         node_types: node_types,
       )
     end
-
-    #: -> bool
-    def should_index?
-      # This method controls when we should index documents. If there's no recent edit and the document has just been
-      # opened, we need to index it
-      return true unless @last_edit
-
-      last_edit_may_change_declarations?
-    end
-
-    private
-
-    #: -> bool
-    def last_edit_may_change_declarations?
-      case @last_edit
-      when Delete
-        # Not optimized yet. It's not trivial to identify that a declaration has been removed since the source is no
-        # longer there and we don't remember the deleted text
-        true
-      when Insert, Replace
-        position_may_impact_declarations?(@last_edit.range[:start])
-      else
-        false
-      end
-    end
-
-    #: (Hash[Symbol, Integer] position) -> bool
-    def position_may_impact_declarations?(position)
-      node_context = locate_node(position)
-      node_at_edit = node_context.node
-
-      # Adjust to the parent when editing the constant of a class/module declaration
-      if node_at_edit.is_a?(Prism::ConstantReadNode) || node_at_edit.is_a?(Prism::ConstantPathNode)
-        node_at_edit = node_context.parent
-      end
-
-      case node_at_edit
-      when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode,
-          Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
-          Prism::ConstantPathAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantWriteNode,
-          Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode, Prism::GlobalVariableAndWriteNode,
-          Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode,
-          Prism::GlobalVariableWriteNode, Prism::InstanceVariableWriteNode, Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableTargetNode, Prism::AliasMethodNode
-        true
-      when Prism::MultiWriteNode
-        [*node_at_edit.lefts, *node_at_edit.rest, *node_at_edit.rights].any? do |node|
-          node.is_a?(Prism::ConstantTargetNode) || node.is_a?(Prism::ConstantPathTargetNode)
-        end
-      when Prism::CallNode
-        receiver = node_at_edit.receiver
-        (!receiver || receiver.is_a?(Prism::SelfNode)) && METHODS_THAT_CHANGE_DECLARATIONS.include?(node_at_edit.name)
-      else
-        false
-      end
-    end
   end
 end

data/lib/ruby_lsp/rubydex/declaration.rb

@@ -0,0 +1,174 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rubydex
+  # @abstract
+  class Declaration
+    # Detail text shown on a `TypeHierarchyItem` for this declaration. Hints at multiplicity
+    # when the declaration spans more than one re-open; otherwise falls back to the primary
+    # definition's file name so users can quickly see where the type comes from.
+    #
+    #: -> String?
+    def lsp_type_hierarchy_detail
+      defs = definitions
+      count = defs.count
+      return "#{count} definitions" if count > 1
+
+      primary = defs.first
+      return unless primary
+
+      uri = URI(primary.location.uri)
+      path = uri.full_path
+      path ? File.basename(path) : uri.to_s
+    end
+
+    # @abstract
+    #: -> Integer
+    def to_lsp_completion_kind
+      raise RubyLsp::AbstractMethodInvokedError
+    end
+  end
+
+  # @abstract
+  class Namespace
+    # Resolved, deduplicated direct supertypes across every re-open of this declaration.
+    # Aggregates each definition's own `superclass`/`include`/`prepend` references and drops
+    # unresolved ones. Order is stable (first-seen across definitions).
+    #: -> Array[Rubydex::Namespace]
+    def direct_supertypes
+      seen = {} #: Hash[String, Rubydex::Namespace]
+
+      definitions.each do |definition|
+        definition.direct_supertype_references.each do |ref|
+          next unless ref.is_a?(ResolvedConstantReference)
+
+          target = ref.declaration
+          next unless target.is_a?(Namespace)
+          next if seen.key?(target.name)
+
+          seen[target.name] = target
+        end
+      end
+
+      seen.values
+    end
+  end
+
+  class Class
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CLASS
+    end
+  end
+
+  class Module
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::MODULE
+    end
+  end
+
+  class SingletonClass
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CLASS
+    end
+  end
+
+  class Todo
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CLASS
+    end
+  end
+
+  class Constant
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CONSTANT
+    end
+  end
+
+  class ConstantAlias
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CONSTANT
+    end
+  end
+
+  class Method
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::METHOD
+    end
+
+    # All signatures collected across every definition (re-opens, RBS overloads, alias targets) of this method.
+    #: () -> Array[Rubydex::Signature]
+    def signatures
+      definitions.flat_map do |defn|
+        case defn
+        when Rubydex::MethodDefinition, Rubydex::MethodAliasDefinition
+          defn.signatures
+        else
+          []
+        end
+      end
+    end
+
+    # Decorated parameter list of the first signature, e.g. `(a, b = <default>, &block)`. Returns `()` when there are
+    # no signatures (e.g. an unresolved alias).
+    #: () -> String
+    def decorated_parameters
+      first = signatures.first
+      return "()" unless first
+
+      "(#{first.format})"
+    end
+
+    # Suffix line that hints at additional overloads beyond the first signature, matching the legacy index entry
+    # rendering used in hover.
+    #: () -> String
+    def formatted_signatures
+      count = signatures.size
+      case count
+      when 0, 1
+        ""
+      when 2
+        "\n(+1 overload)"
+      else
+        "\n(+#{count - 1} overloads)"
+      end
+    end
+  end
+
+  class InstanceVariable
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::FIELD
+    end
+  end
+
+  class ClassVariable
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::FIELD
+    end
+  end
+
+  class GlobalVariable
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::VARIABLE
+    end
+  end
+end

data/lib/ruby_lsp/rubydex/definition.rb

@@ -21,6 +21,29 @@ module Rubydex
       raise RubyLsp::AbstractMethodInvokedError
     end
 
+    # Direct ancestor references contributed by this definition (superclass, includes, prepends).
+    # Extends are intentionally excluded here because they extend the singleton class, not the
+    # instance-side ancestor chain. Definition subclasses that can't contribute ancestors return [].
+    #: () -> Array[Rubydex::ConstantReference]
+    def direct_supertype_references
+      []
+    end
+
+    #: (String name, ?detail: String?) -> RubyLsp::Interface::TypeHierarchyItem
+    def to_lsp_type_hierarchy_item(name, detail: nil)
+      range = to_lsp_selection_range
+
+      RubyLsp::Interface::TypeHierarchyItem.new(
+        name: name,
+        kind: to_lsp_kind,
+        uri: location.uri,
+        range: range,
+        selection_range: to_lsp_name_range || range,
+        detail: detail,
+        data: { fully_qualified_name: name },
+      )
+    end
+
     #: (String name) -> RubyLsp::Interface::WorkspaceSymbol
     def to_lsp_workspace_symbol(name)
       # We use the namespace as the container name, but we also use the full name as the regular name. The reason we do
@@ -86,15 +109,47 @@ module Rubydex
     end
   end
 
+  # Shared supertype aggregation for Rubydex definition types that carry namespace mixins
+  # (`ClassDefinition`, `ModuleDefinition`, `SingletonClassDefinition`). The including class is
+  # expected to provide `#mixins`, which every Rubydex namespace definition already does.
+  # @abstract
+  module NamespaceDefinition
+    # @abstract
+    #: () -> Array[Rubydex::Mixin]
+    def mixins
+      raise RubyLsp::AbstractMethodInvokedError
+    end
+
+    #: () -> Array[Rubydex::ConstantReference]
+    def direct_supertype_references
+      mixins.filter_map do |mixin|
+        mixin.constant_reference if mixin.is_a?(Include) || mixin.is_a?(Prepend)
+      end
+    end
+  end
+
   class ClassDefinition
+    include NamespaceDefinition
+
     # @override
     #: () -> Integer
     def to_lsp_kind
       RubyLsp::Constant::SymbolKind::CLASS
     end
+
+    # @override
+    #: () -> Array[Rubydex::ConstantReference]
+    def direct_supertype_references
+      refs = super
+      superclass_ref = superclass
+      refs << superclass_ref if superclass_ref
+      refs
+    end
   end
 
   class ModuleDefinition
+    include NamespaceDefinition
+
     # @override
     #: () -> Integer
     def to_lsp_kind
@@ -103,6 +158,8 @@ module Rubydex
   end
 
   class SingletonClassDefinition
+    include NamespaceDefinition
+
     # @override
     #: () -> Integer
     def to_lsp_kind
@@ -126,6 +183,14 @@ module Rubydex
     end
   end
 
+  class ConstantVisibilityDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CONSTANT
+    end
+  end
+
   class MethodDefinition
     # @override
     #: () -> Integer
@@ -142,6 +207,14 @@ module Rubydex
     end
   end
 
+  class MethodVisibilityDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::METHOD
+    end
+  end
+
   class AttrReaderDefinition
     # @override
     #: () -> Integer

data/lib/ruby_lsp/rubydex/reference.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module Rubydex
-  class ConstantReference
+  class Reference
     #: () -> RubyLsp::Interface::Range
     def to_lsp_range
       loc = location
@@ -12,5 +12,10 @@ module Rubydex
         end: RubyLsp::Interface::Position.new(line: loc.end_line, character: loc.end_column),
       )
     end
+
+    #: () -> RubyLsp::Interface::Location
+    def to_lsp_location
+      RubyLsp::Interface::Location.new(uri: location.uri, range: to_lsp_range)
+    end
   end
 end

data/lib/ruby_lsp/rubydex/signature.rb

@@ -0,0 +1,107 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rubydex
+  class Signature
+    # Returns a string with the decorated names of the parameters of this signature, e.g.
+    # `(a, b = <default>, *c, d, e:, f: <default>, **g, &h)`.
+    #: () -> String
+    def format
+      parameters.map { |param| decorated_name(param) }.join(", ")
+    end
+
+    # Returns `true` if the given call node arguments array matches this signature. The matching is intentionally lenient
+    # because this method is used to detect which overload should be displayed in signature help while the user is still
+    # typing the call. We prefer returning `true` for situations that cannot be analyzed statically (e.g. presence of
+    # splats, keyword splats, forwarding) and accept missing arguments since the user may not be done typing yet.
+    #: (Array[Prism::Node] arguments) -> bool
+    def matches?(arguments)
+      min_pos = 0
+      max_pos = 0 #: (Integer | Float)
+      names = []
+      has_forward = false #: bool
+      has_keyword_rest = false #: bool
+
+      parameters.each do |param|
+        case param
+        when PositionalParameter, PostParameter
+          min_pos += 1
+          max_pos += 1
+        when OptionalPositionalParameter
+          max_pos += 1
+        when RestPositionalParameter
+          max_pos = Float::INFINITY
+        when ForwardParameter
+          max_pos = Float::INFINITY
+          has_forward = true
+        when KeywordParameter, OptionalKeywordParameter
+          names << param.name
+        when RestKeywordParameter
+          has_keyword_rest = true
+        end
+      end
+
+      keyword_hash_nodes, positional_args = arguments.partition { |arg| arg.is_a?(Prism::KeywordHashNode) }
+      keyword_args = keyword_hash_nodes.first #: as Prism::KeywordHashNode?
+        &.elements
+      forwarding_arguments, positionals = positional_args.partition do |arg|
+        arg.is_a?(Prism::ForwardingArgumentsNode)
+      end
+
+      return true if has_forward && min_pos == 0
+
+      # If the only argument passed is a forwarding argument, then anything will match
+      (positionals.empty? && forwarding_arguments.any?) ||
+        (
+          positional_arguments_match?(positionals, forwarding_arguments, keyword_args, min_pos, max_pos) &&
+          (has_forward || has_keyword_rest || keyword_arguments_match?(keyword_args, names))
+        )
+    end
+
+    private
+
+    #: (Parameter) -> String
+    def decorated_name(param)
+      case param
+      when OptionalPositionalParameter
+        "#{param.name} = <default>"
+      when RestPositionalParameter
+        "*#{param.name}"
+      when KeywordParameter
+        "#{param.name}:"
+      when OptionalKeywordParameter
+        "#{param.name}: <default>"
+      when RestKeywordParameter
+        "**#{param.name}"
+      when BlockParameter
+        "&#{param.name}"
+      else
+        param.name.to_s
+      end
+    end
+
+    #: (Array[Prism::Node] positional_args, Array[Prism::Node] forwarding_arguments, Array[Prism::Node]? keyword_args, Integer min_pos, (Integer | Float) max_pos) -> bool
+    def positional_arguments_match?(positional_args, forwarding_arguments, keyword_args, min_pos, max_pos)
+      (min_pos > 0 && positional_args.any? { |arg| arg.is_a?(Prism::SplatNode) }) ||
+        (min_pos - positional_args.length > 0 && keyword_args&.any? { |arg| arg.is_a?(Prism::AssocSplatNode) }) ||
+        (min_pos - positional_args.length > 0 && forwarding_arguments.any?) ||
+        (min_pos > 0 && positional_args.length <= max_pos) ||
+        (min_pos == 0 && positional_args.empty?)
+    end
+
+    #: (Array[Prism::Node]? args, Array[Symbol] names) -> bool
+    def keyword_arguments_match?(args, names)
+      return true unless args
+      return true if args.any? { |arg| arg.is_a?(Prism::AssocSplatNode) }
+
+      arg_names = args.filter_map do |arg|
+        next unless arg.is_a?(Prism::AssocNode)
+
+        key = arg.key
+        key.value&.to_sym if key.is_a?(Prism::SymbolNode)
+      end
+
+      (arg_names - names).empty?
+    end
+  end
+end

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -5,7 +5,7 @@ def compose(raw_initialize, **options)
   require_relative "../setup_bundler"
   require "json"
   require "uri"
-  require_relative "../../ruby_indexer/lib/ruby_indexer/uri"
+  require_relative "../uri"
 
   initialize_request = JSON.parse(raw_initialize, symbolize_names: true)
   workspace_uri = initialize_request.dig(:params, :workspaceFolders, 0, :uri)