ruby-lsp 0.27.0.beta1 → 0.27.0.beta2

data/lib/ruby_lsp/requests/request.rb

@@ -5,6 +5,8 @@ module RubyLsp
   module Requests
     # @abstract
     class Request
+      include Support::Common
+
       class InvalidFormatter < StandardError; end
 
       # @abstract
@@ -26,24 +28,6 @@ module RubyLsp
         end
       end
 
-      # Checks if a location covers a position
-      #: (Prism::Location location, untyped position) -> bool
-      def cover?(location, position)
-        start_covered =
-          location.start_line - 1 < position[:line] ||
-          (
-            location.start_line - 1 == position[:line] &&
-              location.start_column <= position[:character]
-          )
-        end_covered =
-          location.end_line - 1 > position[:line] ||
-          (
-            location.end_line - 1 == position[:line] &&
-              location.end_column >= position[:character]
-          )
-        start_covered && end_covered
-      end
-
       # Based on a constant node target, a constant path node parent and a position, this method will find the exact
       # portion of the constant path that matches the requested position, for higher precision in hover and
       # definition. For example:
@@ -62,27 +46,13 @@ module RubyLsp
         parent = target #: as Prism::ConstantPathNode
           .parent #: Prism::Node?
 
-        while parent && cover?(parent.location, position)
+        while parent && covers_position?(parent.location, position)
           target = parent
           parent = target.is_a?(Prism::ConstantPathNode) ? target.parent : nil
         end
 
         target
       end
-
-      # Checks if a given location covers the position requested
-      #: (Prism::Location? location, Hash[Symbol, untyped] position) -> bool
-      def covers_position?(location, position)
-        return false unless location
-
-        start_line = location.start_line - 1
-        end_line = location.end_line - 1
-        line = position[:line]
-        character = position[:character]
-
-        (start_line < line || (start_line == line && location.start_column <= character)) &&
-          (end_line > line || (end_line == line && location.end_column >= character))
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/support/common.rb

@@ -34,6 +34,19 @@ module RubyLsp
           )
         end
 
+        #: (Prism::Location? location, Hash[Symbol, untyped] position) -> bool
+        def covers_position?(location, position)
+          return false unless location
+
+          start_line = location.start_line - 1
+          end_line = location.end_line - 1
+          line = position[:line]
+          character = position[:character]
+
+          (start_line < line || (start_line == line && location.start_column <= character)) &&
+            (end_line > line || (end_line == line && location.end_column >= character))
+        end
+
         #: (Prism::Node node, title: String, command_name: String, arguments: Array[untyped]?, data: Hash[untyped, untyped]?) -> Interface::CodeLens
         def create_code_lens(node, title:, command_name:, arguments:, data:)
           range = range_from_node(node)

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/rubydex/declaration.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rubydex
+  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
+  end
+
+  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
+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

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/server.rb

@@ -3,7 +3,11 @@
 
 module RubyLsp
   class Server < BaseServer
-    NON_REPORTABLE_SETUP_ERRORS = [Bundler::GemNotFound, Bundler::GitError].freeze #: Array[singleton(StandardError)]
+    NON_REPORTABLE_SETUP_ERRORS = [
+      Bundler::GemNotFound,
+      Bundler::GitError,
+      Bundler::Dsl::DSLError,
+    ].freeze #: Array[singleton(StandardError)]
 
     # Only for testing
     #: GlobalState
@@ -120,6 +124,16 @@ module RubyLsp
         @global_state.synchronize { @cancelled_requests << message[:params][:id] }
       when nil
         process_response(message) if message[:result]
+      else
+        id = message[:id]
+
+        if id
+          send_message(Error.new(
+            id: id,
+            code: Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Method not found: #{message[:method]}",
+          ))
+        end
       end
     rescue DelegateRequestError
       send_message(Error.new(id: message[:id], code: DelegateRequestError::CODE, message: "DELEGATE_REQUEST"))
@@ -422,8 +436,11 @@ module RubyLsp
 
       if [:ruby, :rbs].include?(language_id)
         graph = @global_state.graph
-        graph.index_source(text_document[:uri].to_s, document.source, language_id.to_s)
-        graph.resolve
+
+        benchmark("index_source") do
+          graph.index_source(text_document[:uri].to_s, document.source, language_id.to_s)
+        end
+        benchmark("incremental_resolve") { graph.resolve }
       end
     end
 
@@ -1056,8 +1073,8 @@ module RubyLsp
           acc << path
         end
       end
-      graph.index_all(additions_and_changes)
-      graph.resolve
+      benchmark("index_all") { graph.index_all(additions_and_changes) }
+      benchmark("incremental_resolve") { graph.resolve }
 
       index = @global_state.index
       changes.each do |change|
@@ -1195,7 +1212,7 @@ module RubyLsp
 
       response = Requests::PrepareTypeHierarchy.new(
         document,
-        @global_state.index,
+        @global_state,
         params[:position],
       ).perform
 
@@ -1205,7 +1222,7 @@ module RubyLsp
     #: (Hash[Symbol, untyped] message) -> void
     def type_hierarchy_supertypes(message)
       response = Requests::TypeHierarchySupertypes.new(
-        @global_state.index,
+        @global_state,
         message.dig(:params, :item),
       ).perform
       send_message(Result.new(id: message[:id], response: response))
@@ -1255,10 +1272,10 @@ module RubyLsp
     #: -> void
     def perform_initial_indexing
       progress("indexing-progress", message: "Indexing workspace...")
-      @global_state.graph.index_workspace
+      benchmark("index_workspace") { @global_state.graph.index_workspace }
 
       progress("indexing-progress", message: "Resolving graph...")
-      @global_state.graph.resolve
+      benchmark("full_resolve") { @global_state.graph.resolve }
 
       # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
       # stuck indexing files
@@ -1558,5 +1575,28 @@ module RubyLsp
         response: code_lens,
       ))
     end
+
+    #: [T] (String) { () -> T } -> T
+    def benchmark(label, &block)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      result = block.call
+      duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
+
+      send_message(Notification.telemetry({
+        type: "data",
+        eventName: "ruby_lsp.response_time",
+        data: {
+          type: "histogram",
+          value: duration,
+          attributes: {
+            message: label,
+            lspVersion: RubyLsp::VERSION,
+            rubyVersion: RUBY_VERSION,
+          },
+        },
+      }))
+
+      result
+    end
   end
 end

data/lib/ruby_lsp/type_inferrer.rb

@@ -19,7 +19,7 @@ module RubyLsp
         infer_receiver_for_call_node(node, node_context)
       when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
         Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
-        Prism::SuperNode, Prism::ForwardingSuperNode
+        Prism::SuperNode, Prism::ForwardingSuperNode, Prism::DefNode
         self_receiver_handling(node_context)
       when Prism::ClassVariableAndWriteNode, Prism::ClassVariableWriteNode, Prism::ClassVariableOperatorWriteNode,
         Prism::ClassVariableOrWriteNode, Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
@@ -129,21 +129,99 @@ module RubyLsp
       GuessedType.new(declaration.name)
     end
 
-    #: (NodeContext node_context) -> Type
+    #: (NodeContext node_context) -> Type?
     def self_receiver_handling(node_context)
       nesting = node_context.nesting
       # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
       # inherits from Object
       return Type.new("Object") if nesting.empty?
-      return Type.new(node_context.fully_qualified_name) if node_context.surrounding_method
+
+      surrounding_method = node_context.surrounding_method
+
+      if surrounding_method
+        receiver_name = surrounding_method.receiver
+
+        case receiver_name
+        when "self"
+          # `def self.foo` — self is the singleton of the enclosing class/module
+          return resolve_singleton_type_from_nesting(nesting)
+        when "none"
+          # Instance method — self is an instance of the enclosing class/module
+          return resolve_type_from_nesting(nesting)
+        when nil
+          # Dynamic receiver that we cannot handle
+          return
+        else
+          # Explicit constant receiver (e.g. `def Bar.baz`) — self is that constant's singleton class
+          resolved = resolve_receiver_singleton_type(receiver_name, nesting)
+          return resolved if resolved
+
+          return resolve_type_from_nesting(nesting)
+        end
+      end
 
       # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
-      # context.
-      #
-      # If the class/module definition is using compact style (e.g.: `class Foo::Bar`), then we need to split the name
-      # into its individual parts to build the correct singleton name
-      parts = nesting.flat_map { |part| part.split("::") }
-      Type.new("#{parts.join("::")}::<#{parts.last}>")
+      # context. Resolve through the graph to get the correct fully qualified name
+      resolve_singleton_type_from_nesting(nesting)
+    end
+
+    # Resolves the fully qualified name of the innermost constant from the nesting and returns it as a type.
+    # For instance methods, the nesting won't have singleton markers, so the result is an instance type.
+    # For `def self.` methods, the nesting includes a singleton marker, which is preserved in the result.
+    #: (Array[String] nesting) -> Type
+    def resolve_type_from_nesting(nesting)
+      resolved_name = resolve_nesting_fully_qualified_name(nesting)
+      Type.new(resolved_name)
+    end
+
+    # Resolves the nesting and returns a singleton type (appends `::<Last>`)
+    #: (Array[String] nesting) -> Type
+    def resolve_singleton_type_from_nesting(nesting)
+      resolved_name = resolve_nesting_fully_qualified_name(nesting)
+      last_part = resolved_name.split("::").last #: as !nil
+      Type.new("#{resolved_name}::<#{last_part}>")
+    end
+
+    # Resolves the innermost constant in the nesting through the graph, handling compact-path definitions
+    # like `class Bar::Baz` inside a different module where the lexical nesting doesn't reflect the true
+    # constant hierarchy. Falls back to lexical joining if resolution fails.
+    #: (Array[String] nesting) -> String
+    def resolve_nesting_fully_qualified_name(nesting)
+      nesting_parts = nesting.dup
+      trailing_singletons = [] #: Array[String]
+
+      nesting_parts.reverse_each do |part|
+        break unless part.start_with?("<")
+
+        popped = nesting_parts.pop #: as !nil
+        trailing_singletons.unshift(popped)
+      end
+
+      if nesting_parts.any?
+        resolved = @graph.resolve_constant(
+          nesting_parts.last, #: as !nil
+          nesting_parts[0...-1], #: as !nil
+        )
+
+        if resolved
+          parts = resolved.name.split("::") + trailing_singletons
+          return parts.join("::")
+        end
+      end
+
+      # Fallback to lexical joining if resolution fails
+      nesting.flat_map { |part| part.split("::") }.join("::")
+    end
+
+    #: (String, Array[String]) -> Type?
+    def resolve_receiver_singleton_type(receiver_name, nesting)
+      receiver_declaration = @graph.resolve_constant(receiver_name, nesting)
+      return unless receiver_declaration.is_a?(Rubydex::Namespace)
+
+      singleton = receiver_declaration.singleton_class
+      return unless singleton
+
+      Type.new(singleton.name)
     end
 
     #: (NodeContext node_context) -> Type?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.27.0.beta1
+  version: 0.27.0.beta2
 platform: ruby
 authors:
 - Shopify
@@ -106,7 +106,6 @@ files:
 - lib/ruby_indexer/lib/ruby_indexer/location.rb
 - lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
 - lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb
-- lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb
 - lib/ruby_indexer/lib/ruby_indexer/uri.rb
 - lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb
 - lib/ruby_indexer/ruby_indexer.rb
@@ -182,6 +181,7 @@ files:
 - lib/ruby_lsp/response_builders/signature_help.rb
 - lib/ruby_lsp/response_builders/test_collection.rb
 - lib/ruby_lsp/ruby_document.rb
+- lib/ruby_lsp/rubydex/declaration.rb
 - lib/ruby_lsp/rubydex/definition.rb
 - lib/ruby_lsp/rubydex/reference.rb
 - lib/ruby_lsp/scope.rb
@@ -189,7 +189,6 @@ files:
 - lib/ruby_lsp/scripts/compose_bundle_windows.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/setup_bundler.rb
-- lib/ruby_lsp/static_docs.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/test_helper.rb
 - lib/ruby_lsp/test_reporters/lsp_reporter.rb
@@ -197,8 +196,6 @@ files:
 - lib/ruby_lsp/test_reporters/test_unit_reporter.rb
 - lib/ruby_lsp/type_inferrer.rb
 - lib/ruby_lsp/utils.rb
-- static_docs/break.md
-- static_docs/yield.md
 homepage: https://github.com/Shopify/ruby-lsp
 licenses:
 - MIT