ruby-lsp 0.26.9 → 0.27.0.beta2

data/lib/ruby_lsp/requests/rename.rb

@@ -22,6 +22,7 @@ module RubyLsp
       def initialize(global_state, store, document, params)
         super()
         @global_state = global_state
+        @graph = global_state.graph #: Rubydex::Graph
         @store = store
         @document = document
         @position = params[:position] #: Hash[Symbol, Integer]
@@ -56,17 +57,14 @@ module RubyLsp
         name = RubyIndexer::Index.constant_name(target)
         return unless name
 
-        entries = @global_state.index.resolve(name, node_context.nesting)
-        return unless entries
+        declaration = @graph.resolve_constant(name, node_context.nesting)
+        return unless declaration
 
-        if (conflict_entries = @global_state.index.resolve(@new_name, node_context.nesting))
-          raise InvalidNameError, "The new name is already in use by #{conflict_entries.first&.name}"
+        if (conflict = @graph.resolve_constant(@new_name, node_context.nesting))
+          raise InvalidNameError, "The new name is already in use by #{conflict.name}"
         end
 
-        fully_qualified_name = entries.first #: as !nil
-          .name
-        reference_target = RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
-        changes = collect_text_edits(reference_target, name)
+        changes = collect_text_edits(declaration, name)
 
         # If the client doesn't support resource operations, such as renaming files, then we can only return the basic
         # text changes
@@ -78,99 +76,93 @@ module RubyLsp
         # renamed and then the URI associated to the text edit no longer exists, causing it to be dropped
         document_changes = changes.map do |uri, edits|
           Interface::TextDocumentEdit.new(
-            text_document: Interface::VersionedTextDocumentIdentifier.new(uri: uri, version: nil),
+            text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(uri: uri, version: nil),
             edits: edits,
           )
         end
 
-        collect_file_renames(fully_qualified_name, document_changes)
+        collect_file_renames(declaration, document_changes)
         Interface::WorkspaceEdit.new(document_changes: document_changes)
       end
 
       private
 
-      #: (String fully_qualified_name, Array[(Interface::RenameFile | Interface::TextDocumentEdit)] document_changes) -> void
-      def collect_file_renames(fully_qualified_name, document_changes)
+      #: (Rubydex::Declaration, Array[(Interface::RenameFile | Interface::TextDocumentEdit)]) -> void
+      def collect_file_renames(declaration, document_changes)
         # Check if the declarations of the symbol being renamed match the file name. In case they do, we automatically
         # rename the files for the user.
         #
         # We also look for an associated test file and rename it too
-        short_name = fully_qualified_name.split("::").last #: as !nil
 
-        @global_state.index[fully_qualified_name]&.each do |entry|
+        unless [
+          Rubydex::Class,
+          Rubydex::Module,
+          Rubydex::Constant,
+          Rubydex::ConstantAlias,
+        ].any? { |type| declaration.is_a?(type) }
+          return
+        end
+
+        short_name = declaration.unqualified_name
+
+        declaration.definitions.each do |definition|
           # Do not rename files that are not part of the workspace
-          uri = entry.uri
+          uri = URI(definition.location.uri)
           file_path = uri.full_path
           next unless file_path&.start_with?(@global_state.workspace_path)
 
-          case entry
-          when RubyIndexer::Entry::Class, RubyIndexer::Entry::Module, RubyIndexer::Entry::Constant,
-               RubyIndexer::Entry::ConstantAlias, RubyIndexer::Entry::UnresolvedConstantAlias
-
-            file_name = file_from_constant_name(short_name)
+          file_name = file_from_constant_name(short_name)
+          next unless "#{file_name}.rb" == File.basename(file_path)
 
-            if "#{file_name}.rb" == entry.file_name
-              new_file_name = file_from_constant_name(
-                @new_name.split("::").last, #: as !nil
-              )
+          new_file_name = file_from_constant_name(
+            @new_name.split("::").last, #: as !nil
+          )
 
-              new_uri = URI::Generic.from_path(path: File.join(
-                File.dirname(file_path),
-                "#{new_file_name}.rb",
-              )).to_s
+          new_uri = URI::Generic.from_path(path: File.join(
+            File.dirname(file_path),
+            "#{new_file_name}.rb",
+          )).to_s
 
-              document_changes << Interface::RenameFile.new(kind: "rename", old_uri: uri.to_s, new_uri: new_uri)
-            end
-          end
+          document_changes << Interface::RenameFile.new(kind: "rename", old_uri: uri.to_s, new_uri: new_uri)
         end
       end
 
-      #: (RubyIndexer::ReferenceFinder::Target target, String name) -> Hash[String, Array[Interface::TextEdit]]
-      def collect_text_edits(target, name)
-        changes = {}
-
-        Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
-          uri = URI::Generic.from_path(path: path)
-          # If the document is being managed by the client, then we should use whatever is present in the store instead
-          # of reading from disk
-          next if @store.key?(uri)
-
-          parse_result = Prism.parse_file(path)
-          edits = collect_changes(target, parse_result.value, name, uri)
-          changes[uri.to_s] = edits unless edits.empty?
-        rescue Errno::EISDIR, Errno::ENOENT
-          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
-        end
-
-        @store.each do |uri, document|
-          next unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
+      #: (Rubydex::Declaration declaration, String name) -> Hash[String, Array[Interface::TextEdit]]
+      def collect_text_edits(declaration, name)
+        changes = {} #: Hash[String, Array[Interface::TextEdit]]
+        short_name = name.split("::").last #: as !nil
+        new_short_name = @new_name.split("::").last #: as !nil
+
+        # Collect edits for definition sites (where the constant is declared)
+        declaration.definitions.each do |definition|
+          name_loc = definition.name_location
+          next unless name_loc
+
+          uri_string = name_loc.uri
+          edits = (changes[uri_string] ||= [])
+
+          # The name_location spans the constant name as written in the definition.
+          # We only replace the unqualified name portion (the last segment).
+          range = Interface::Range.new(
+            start: Interface::Position.new(
+              line: name_loc.end_line,
+              character: name_loc.end_column - short_name.length,
+            ),
+            end: Interface::Position.new(line: name_loc.end_line, character: name_loc.end_column),
+          )
 
-          edits = collect_changes(target, document.ast, name, document.uri)
-          changes[uri] = edits unless edits.empty?
+          edits << Interface::TextEdit.new(range: range, new_text: new_short_name)
         end
 
-        changes
-      end
-
-      #: (RubyIndexer::ReferenceFinder::Target target, Prism::Node ast, String name, URI::Generic uri) -> Array[Interface::TextEdit]
-      def collect_changes(target, ast, name, uri)
-        dispatcher = Prism::Dispatcher.new
-        finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher, uri)
-        dispatcher.visit(ast)
-
-        finder.references.map do |reference|
-          adjust_reference_for_edit(name, reference)
+        # Collect edits for reference sites (where the constant is used)
+        declaration.references.each do |reference|
+          ref = reference #: as Rubydex::ConstantReference
+          uri_string = ref.location.uri
+          edits = (changes[uri_string] ||= [])
+          edits << Interface::TextEdit.new(range: ref.to_lsp_range, new_text: new_short_name)
         end
-      end
-
-      #: (String name, RubyIndexer::ReferenceFinder::Reference reference) -> Interface::TextEdit
-      def adjust_reference_for_edit(name, reference)
-        # The reference may include a namespace in front. We need to check if the rename new name includes namespaces
-        # and then adjust both the text and the location to produce the correct edit
-        location = reference.location
-        new_text = reference.name.sub(name, @new_name)
 
-        Interface::TextEdit.new(range: range_from_location(location), new_text: new_text)
+        changes
       end
 
       #: (String constant_name) -> String

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)
@@ -64,6 +77,46 @@ module RubyLsp
           receiver.nil? || receiver.is_a?(Prism::SelfNode)
         end
 
+        #: (String, Enumerable[Rubydex::Definition], ?Integer?) -> Hash[Symbol, String]
+        def categorized_markdown_from_definitions(title, definitions, max_entries = nil)
+          markdown_title = "```ruby\n#{title}\n```"
+          file_links = []
+          content = +""
+          defs = max_entries ? definitions.take(max_entries) : definitions
+          defs.each do |definition|
+            # For Markdown links, we need 1 based display locations
+            loc = definition.location.to_display
+            uri = URI(loc.uri)
+            file_name = if uri.scheme == "untitled"
+              uri.opaque #: as !nil
+            else
+              File.basename(
+                uri.full_path, #: as !nil
+              )
+            end
+
+            # The format for VS Code file URIs is `file:///path/to/file.rb#Lstart_line,start_column-end_line,end_column`
+            string_uri = "#{loc.uri}#L#{loc.start_line},#{loc.start_column}-#{loc.end_line},#{loc.end_column}"
+            file_links << "[#{file_name}](#{string_uri})"
+            content << "\n\n#{definition.comments.map { |comment| comment.string.delete_prefix("# ") }.join("\n")}" unless definition.comments.empty?
+          end
+
+          total_definitions = definitions.count
+
+          additional_entries_text = if max_entries && total_definitions > max_entries
+            additional = total_definitions - max_entries
+            " | #{additional} other#{additional > 1 ? "s" : ""}"
+          else
+            ""
+          end
+
+          {
+            title: markdown_title,
+            links: "**Definitions**: #{file_links.join(" | ")}#{additional_entries_text}",
+            documentation: content,
+          }
+        end
+
         #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries) -> Hash[Symbol, String]
         def categorized_markdown_from_index_entries(title, entries, max_entries = nil)
           markdown_title = "```ruby\n#{title}\n```"

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/requests/workspace_symbol.rb

@@ -12,54 +12,32 @@ module RubyLsp
       #: (GlobalState global_state, String? query) -> void
       def initialize(global_state, query)
         super()
-        @global_state = global_state
         @query = query
-        @index = global_state.index #: RubyIndexer::Index
+        @graph = global_state.graph #: Rubydex::Graph
       end
 
       # @override
       #: -> Array[Interface::WorkspaceSymbol]
       def perform
-        fuzzy_search.filter_map do |entry|
-          kind = kind_for_entry(entry)
-          loc = entry.location
+        response = []
 
-          # We use the namespace as the container name, but we also use the full name as the regular name. The reason we
-          # do this is to allow people to search for fully qualified names (e.g.: `Foo::Bar`). If we only included the
-          # short name `Bar`, then searching for `Foo::Bar` would not return any results
-          *container, _short_name = entry.name.split("::")
+        @graph.fuzzy_search(@query || "").each do |declaration|
+          name = declaration.name
 
-          Interface::WorkspaceSymbol.new(
-            name: entry.name,
-            container_name: container.join("::"),
-            kind: kind,
-            location: Interface::Location.new(
-              uri: entry.uri.to_s,
-              range:  Interface::Range.new(
-                start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column),
-                end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
-              ),
-            ),
-          )
-        end
-      end
-
-      private
+          declaration.definitions.each do |definition|
+            location = definition.location
+            uri = URI(location.uri)
+            file_path = uri.full_path
 
-      #: -> Array[RubyIndexer::Entry]
-      def fuzzy_search
-        @index.fuzzy_search(@query) do |entry|
-          file_path = entry.uri.full_path
+            # We only show symbols declared in the workspace
+            in_dependencies = file_path && !not_in_dependencies?(file_path)
+            next if in_dependencies
 
-          # We only show symbols declared in the workspace
-          in_dependencies = file_path && !not_in_dependencies?(file_path)
-          next if in_dependencies
-
-          # We should never show private symbols when searching the entire workspace
-          next if entry.private?
-
-          true
+            response << definition.to_lsp_workspace_symbol(name)
+          end
         end
+
+        response
       end
     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