ruby-lsp 0.14.6 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c364aee0d80e6187f66e8eb6d50d7cdd21ffb129e0a0b17c9dc7bd5d8a18cad
-  data.tar.gz: 65964ec1d89f10adf9bcbf113efed6d43a977b669abe51182e90dd9870032623
+  metadata.gz: 9749ddfd5f25d0f6e3c0636a070d8977c19af973943e33deba4e49cba9b473d6
+  data.tar.gz: 1c3f663fd6487e8517154a2595be253659e2f2f9bd6a4df23c8b16a91e159c4d
 SHA512:
-  metadata.gz: 971af8a3c02903597143a8ec49915eead6bc0f65a0175e4a443e381d671dd4a88f776a26f62af1bd69ee7dc3f478b36bef122febbfaed7656907eb1a6a7a3354
-  data.tar.gz: 15148c1c3765390f9bb92dbafe7043ac15b22de6b5c415c424a063f4742026d92831d84bcde2013ab742c4a889dc16d666d4ec5d18863d0db8acf793ce87f0a6
+  metadata.gz: '039fc58aa31af82930cc2852819208fdd9045ed493cf368702f87e9ffd814487bf63fe522124fa3210336cfc72d806b828e2e338114a66913dbd688ed85980c3'
+  data.tar.gz: bb4d62e3ce21fe07cda085f0284b69c356a10694125454b8160bd0c5e87789481b2d4f8036cdb4cdc2b0667c8a78c7e7a1409307722a532122172fcff8c5450c

data/VERSION

@@ -1 +1 @@
-0.14.6
+0.15.0

data/exe/ruby-lsp

@@ -68,22 +68,7 @@ if ENV["BUNDLE_GEMFILE"].nil?
   exit exec(env, "bundle exec ruby-lsp #{original_args.join(" ")}")
 end
 
-require "sorbet-runtime"
-
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses call validation errors
-  T::Configuration.call_validation_error_handler = ->(*) {}
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
-end
+require "ruby_lsp/load_sorbet"
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"

data/exe/ruby-lsp-check

@@ -3,16 +3,7 @@
 
 # This executable checks if all automatic LSP requests run successfully on every Ruby file under the current directory
 
-require "sorbet-runtime"
-
-begin
-  T::Configuration.default_checked_level = :never
-  T::Configuration.call_validation_error_handler = ->(*) {}
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  nil
-end
+require "ruby_lsp/load_sorbet"
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
@@ -24,30 +15,30 @@ files = Dir.glob("#{Dir.pwd}/**/*.rb")
 puts "Verifying that all automatic LSP requests execute successfully. This may take a while..."
 
 errors = {}
-store = RubyLsp::Store.new
-message_queue = Thread::Queue.new
-RubyLsp::Addon.load_addons(message_queue)
-executor = RubyLsp::Executor.new(store, message_queue)
+server = RubyLsp::Server.new(test_mode: true)
 
 files.each_with_index do |file, index|
   uri = URI("file://#{file}")
-  store.set(uri: uri, source: File.read(file), version: 1)
+  server.process_message({
+    method: "textDocument/didOpen",
+    params: { textDocument: { uri: uri, text: File.read(file), version: 1 } },
+  })
 
   # Executing any of the automatic requests will execute all of them, so here we just pick one
-  result = executor.execute({
+  server.process_message({
+    id: 1,
     method: "textDocument/documentSymbol",
-    params: { textDocument: { uri: uri.to_s } },
+    params: { textDocument: { uri: uri } },
   })
 
-  error = result.error
-  errors[file] = error if error
+  result = server.pop_response
+  errors[file] = result.message if result.is_a?(RubyLsp::Error)
 ensure
-  store.delete(uri)
+  server.process_message({ method: "textDocument/didClose", params: { textDocument: { uri: uri } } })
+  server.pop_response
   print("\033[M\033[0KCompleted #{index + 1}/#{files.length}") unless ENV["CI"]
 end
-
 puts "\n"
-message_queue.close
 
 # Indexing
 puts "Verifying that indexing executes successfully. This may take a while..."

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -43,20 +43,6 @@ module RubyIndexer
       )
     end
 
-    sig { void }
-    def load_config
-      return unless File.exist?(".index.yml")
-
-      config = YAML.parse_file(".index.yml")
-      return unless config
-
-      config_hash = config.to_ruby
-      validate_config!(config_hash)
-      apply_config(config_hash)
-    rescue Psych::SyntaxError => e
-      raise e, "Syntax error while loading .index.yml configuration: #{e.message}"
-    end
-
     sig { returns(T::Array[IndexablePath]) }
     def indexables
       excluded_gems = @excluded_gems - @included_gems
@@ -158,6 +144,17 @@ module RubyIndexer
       @magic_comment_regex ||= T.let(/^#\s*#{@excluded_magic_comments.join("|")}/, T.nilable(Regexp))
     end
 
+    sig { params(config: T::Hash[String, T.untyped]).void }
+    def apply_config(config)
+      validate_config!(config)
+
+      @excluded_gems.concat(config["excluded_gems"]) if config["excluded_gems"]
+      @included_gems.concat(config["included_gems"]) if config["included_gems"]
+      @excluded_patterns.concat(config["excluded_patterns"]) if config["excluded_patterns"]
+      @included_patterns.concat(config["included_patterns"]) if config["included_patterns"]
+      @excluded_magic_comments.concat(config["excluded_magic_comments"]) if config["excluded_magic_comments"]
+    end
+
     private
 
     sig { params(config: T::Hash[String, T.untyped]).void }
@@ -175,15 +172,6 @@ module RubyIndexer
       raise ArgumentError, errors.join("\n") if errors.any?
     end
 
-    sig { params(config: T::Hash[String, T.untyped]).void }
-    def apply_config(config)
-      @excluded_gems.concat(config["excluded_gems"]) if config["excluded_gems"]
-      @included_gems.concat(config["included_gems"]) if config["included_gems"]
-      @excluded_patterns.concat(config["excluded_patterns"]) if config["excluded_patterns"]
-      @included_patterns.concat(config["included_patterns"]) if config["included_patterns"]
-      @excluded_magic_comments.concat(config["excluded_magic_comments"]) if config["excluded_magic_comments"]
-    end
-
     sig { returns(T::Array[String]) }
     def initial_excluded_gems
       excluded, others = Bundler.definition.dependencies.partition do |dependency|

data/lib/ruby_indexer/test/configuration_test.rb

@@ -10,7 +10,7 @@ module RubyIndexer
     end
 
     def test_load_configuration_executes_configure_block
-      @config.load_config
+      @config.apply_config({ "excluded_patterns" => ["**/test/fixtures/**/*.rb"] })
       indexables = @config.indexables
 
       assert(indexables.none? { |indexable| indexable.full_path.include?("test/fixtures") })
@@ -21,7 +21,6 @@ module RubyIndexer
     end
 
     def test_indexables_only_includes_gem_require_paths
-      @config.load_config
       indexables = @config.indexables
 
       Bundler.locked_gems.specs.each do |lazy_spec|
@@ -35,7 +34,6 @@ module RubyIndexer
     end
 
     def test_indexables_does_not_include_default_gem_path_when_in_bundle
-      @config.load_config
       indexables = @config.indexables
 
       assert(
@@ -44,7 +42,6 @@ module RubyIndexer
     end
 
     def test_indexables_includes_default_gems
-      @config.load_config
       indexables = @config.indexables.map(&:full_path)
 
       assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
@@ -53,7 +50,6 @@ module RubyIndexer
     end
 
     def test_indexables_includes_project_files
-      @config.load_config
       indexables = @config.indexables.map(&:full_path)
 
       Dir.glob("#{Dir.pwd}/lib/**/*.rb").each do |path|
@@ -66,7 +62,6 @@ module RubyIndexer
     def test_indexables_avoids_duplicates_if_bundle_path_is_inside_project
       Bundler.settings.set_global("path", "vendor/bundle")
       config = Configuration.new
-      config.load_config
 
       assert_includes(config.instance_variable_get(:@excluded_patterns), "#{Dir.pwd}/vendor/bundle/**/*.rb")
     ensure
@@ -74,7 +69,6 @@ module RubyIndexer
     end
 
     def test_indexables_does_not_include_gems_own_installed_files
-      @config.load_config
       indexables = @config.indexables
 
       assert(
@@ -95,17 +89,14 @@ module RubyIndexer
     end
 
     def test_paths_are_unique
-      @config.load_config
       indexables = @config.indexables
 
       assert_equal(indexables.uniq.length, indexables.length)
     end
 
     def test_configuration_raises_for_unknown_keys
-      Psych::Nodes::Document.any_instance.expects(:to_ruby).returns({ "unknown_config" => 123 })
-
       assert_raises(ArgumentError) do
-        @config.load_config
+        @config.apply_config({ "unknown_config" => 123 })
       end
     end
 

data/lib/ruby_lsp/addon.rb

@@ -121,22 +121,23 @@ module RubyLsp
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
+        global_state: GlobalState,
         uri: URI::Generic,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_code_lens_listener(response_builder, uri, dispatcher); end
+    def create_code_lens_listener(response_builder, global_state, uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
     sig do
       overridable.params(
         response_builder: ResponseBuilders::Hover,
+        global_state: GlobalState,
         nesting: T::Array[String],
-        index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_hover_listener(response_builder, nesting, index, dispatcher); end
+    def create_hover_listener(response_builder, global_state, nesting, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do
@@ -159,12 +160,24 @@ module RubyLsp
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+        global_state: GlobalState,
         uri: URI::Generic,
         nesting: T::Array[String],
-        index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_definition_listener(response_builder, uri, nesting, index, dispatcher); end
+    def create_definition_listener(response_builder, global_state, uri, nesting, dispatcher); end
+
+    # Creates a new Completion listener. This method is invoked on every Completion request
+    sig do
+      overridable.params(
+        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
+        global_state: GlobalState,
+        nesting: T::Array[String],
+        dispatcher: Prism::Dispatcher,
+        uri: URI::Generic,
+      ).void
+    end
+    def create_completion_listener(response_builder, global_state, nesting, dispatcher, uri); end
   end
 end

data/lib/ruby_lsp/base_server.rb

@@ -0,0 +1,147 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class BaseServer
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { params(test_mode: T::Boolean).void }
+    def initialize(test_mode: false)
+      @test_mode = T.let(test_mode, T::Boolean)
+      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
+      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
+      @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
+      @outgoing_queue = T.let(Thread::Queue.new, Thread::Queue)
+      @cancelled_requests = T.let([], T::Array[Integer])
+      @mutex = T.let(Mutex.new, Mutex)
+      @worker = T.let(new_worker, Thread)
+      @current_request_id = T.let(1, Integer)
+      @store = T.let(Store.new, Store)
+      @outgoing_dispatcher = T.let(
+        Thread.new do
+          unless test_mode
+            while (message = @outgoing_queue.pop)
+              @mutex.synchronize { @writer.write(message.to_hash) }
+            end
+          end
+        end,
+        Thread,
+      )
+
+      Thread.main.priority = 1
+    end
+
+    sig { void }
+    def start
+      @reader.read do |message|
+        method = message[:method]
+
+        # We must parse the document under a mutex lock or else we might switch threads and accept text edits in the
+        # source. Altering the source reference during parsing will put the parser in an invalid internal state, since
+        # it started parsing with one source but then it changed in the middle. We don't want to do this for text
+        # synchronization notifications
+        @mutex.synchronize do
+          uri = message.dig(:params, :textDocument, :uri)
+
+          if uri
+            begin
+              parsed_uri = URI(uri)
+              message[:params][:textDocument][:uri] = parsed_uri
+
+              # We don't want to try to parse documents on text synchronization notifications
+              @store.get(parsed_uri).parse unless method.start_with?("textDocument/did")
+            rescue Errno::ENOENT
+              # If we receive a request for a file that no longer exists, we don't want to fail
+            end
+          end
+        end
+
+        # We need to process shutdown and exit from the main thread in order to close queues and wait for other threads
+        # to finish. Everything else is pushed into the incoming queue
+        case method
+        when "shutdown"
+          $stderr.puts("Shutting down Ruby LSP...")
+
+          shutdown
+
+          @mutex.synchronize do
+            run_shutdown
+            @writer.write(Result.new(id: message[:id], response: nil).to_hash)
+          end
+        when "exit"
+          @mutex.synchronize do
+            status = @incoming_queue.closed? ? 0 : 1
+            $stderr.puts("Shutdown complete with status #{status}")
+            exit(status)
+          end
+        else
+          @incoming_queue << message
+        end
+      end
+    end
+
+    sig { void }
+    def run_shutdown
+      @incoming_queue.clear
+      @outgoing_queue.clear
+      @incoming_queue.close
+      @outgoing_queue.close
+      @cancelled_requests.clear
+
+      @worker.join
+      @outgoing_dispatcher.join
+      @store.clear
+    end
+
+    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
+    sig { returns(T.untyped) }
+    def pop_response
+      @outgoing_queue.pop
+    end
+
+    sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
+    def process_message(message); end
+
+    sig { abstract.void }
+    def shutdown; end
+
+    sig { returns(Thread) }
+    def new_worker
+      Thread.new do
+        while (message = T.let(@incoming_queue.pop, T.nilable(T::Hash[Symbol, T.untyped])))
+          id = message[:id]
+
+          # Check if the request was cancelled before trying to process it
+          @mutex.synchronize do
+            if id && @cancelled_requests.include?(id)
+              send_message(Result.new(id: id, response: nil))
+              @cancelled_requests.delete(id)
+              next
+            end
+          end
+
+          process_message(message)
+        end
+      end
+    end
+
+    sig { params(message: T.any(Result, Error, Notification, Request)).void }
+    def send_message(message)
+      # When we're shutting down the server, there's a small race condition between closing the thread queues and
+      # finishing remaining requests. We may close the queue in the middle of processing a request, which will then fail
+      # when trying to send a response back
+      return if @outgoing_queue.closed?
+
+      @outgoing_queue << message
+      @current_request_id += 1 if message.is_a?(Request)
+    end
+
+    sig { params(id: Integer).void }
+    def send_empty_response(id)
+      send_message(Result.new(id: id, response: nil))
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -180,11 +180,6 @@ module RubyLsp
       end
     end
 
-    sig { returns(T::Boolean) }
-    def typechecker_enabled?
-      DependencyDetector.instance.typechecker && sorbet_sigil_is_true_or_higher
-    end
-
     class Scanner
       extend T::Sig
 

data/lib/ruby_lsp/{requests/support/dependency_detector.rb → global_state.rb}

@@ -1,27 +1,41 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "singleton"
-
 module RubyLsp
-  class DependencyDetector
-    include Singleton
+  class GlobalState
     extend T::Sig
 
     sig { returns(String) }
-    attr_reader :detected_formatter
+    attr_reader :test_library
 
     sig { returns(String) }
-    attr_reader :detected_test_library
+    attr_accessor :formatter
 
     sig { returns(T::Boolean) }
     attr_reader :typechecker
 
+    sig { returns(RubyIndexer::Index) }
+    attr_reader :index
+
     sig { void }
     def initialize
-      @detected_formatter = T.let(detect_formatter, String)
-      @detected_test_library = T.let(detect_test_library, String)
+      @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
+
+      @formatter = T.let(detect_formatter, String)
+      @test_library = T.let(detect_test_library, String)
       @typechecker = T.let(detect_typechecker, T::Boolean)
+      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
+    end
+
+    sig { params(options: T::Hash[Symbol, T.untyped]).void }
+    def apply_options(options)
+      workspace_uri = options.dig(:workspaceFolders, 0, :uri)
+      @workspace_uri = URI(workspace_uri) if workspace_uri
+    end
+
+    sig { returns(String) }
+    def workspace_path
+      T.must(@workspace_uri.to_standardized_path)
     end
 
     sig { returns(String) }
@@ -63,8 +77,15 @@ module RubyLsp
     def detect_typechecker
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
+      # We can't read the env from within `Bundle.with_original_env` so we need to set it here.
+      ruby_lsp_env_is_test = (ENV["RUBY_LSP_ENV"] == "test")
       Bundler.with_original_env do
-        Bundler.locked_gems.specs.any? { |spec| spec.name == "sorbet-static" }
+        sorbet_static_detected = Bundler.locked_gems.specs.any? { |spec| spec.name == "sorbet-static" }
+        # Don't show message while running tests, since it's noisy
+        if sorbet_static_detected && !ruby_lsp_env_is_test
+          $stderr.puts("Ruby LSP detected this is a Sorbet project so will defer to Sorbet LSP for some functionality")
+        end
+        sorbet_static_detected
       end
     rescue Bundler::GemfileNotFound
       false

data/lib/ruby_lsp/internal.rb

@@ -20,12 +20,13 @@ require "prism/visitor"
 require "language_server-protocol"
 
 require "ruby-lsp"
+require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/parameter_scope"
+require "ruby_lsp/global_state"
 require "ruby_lsp/server"
-require "ruby_lsp/executor"
 require "ruby_lsp/requests"
 require "ruby_lsp/response_builders"
 require "ruby_lsp/document"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -27,12 +27,14 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
+          global_state: GlobalState,
           uri: URI::Generic,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, uri, dispatcher)
+      def initialize(response_builder, global_state, uri, dispatcher)
         @response_builder = response_builder
+        @global_state = global_state
         @uri = T.let(uri, URI::Generic)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
@@ -156,7 +158,7 @@ module RubyLsp
       sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         # don't add code lenses if the test library is not supported or unknown
-        return unless SUPPORTED_TEST_LIBRARIES.include?(DependencyDetector.instance.detected_test_library) && @path
+        return unless SUPPORTED_TEST_LIBRARIES.include?(@global_state.test_library) && @path
 
         arguments = [
           @path,
@@ -208,7 +210,7 @@ module RubyLsp
       def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
         command = BASE_COMMAND + T.must(@path)
 
-        case DependencyDetector.instance.detected_test_library
+        case @global_state.test_library
         when "minitest"
           last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
           command += if last_dynamic_reference_index
@@ -264,12 +266,14 @@ module RubyLsp
 
         return unless name
 
-        add_test_code_lens(
-          node,
-          name: name,
-          command: generate_test_command(spec_name: name),
-          kind: kind,
-        )
+        if @path
+          add_test_code_lens(
+            node,
+            name: name,
+            command: generate_test_command(spec_name: name),
+            kind: kind,
+          )
+        end
       end
     end
   end

data/lib/ruby_lsp/listeners/completion.rb

@@ -10,16 +10,17 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           nesting: T::Array[String],
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
         ).void
       end
-      def initialize(response_builder, index, nesting, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, nesting, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
-        @index = index
+        @global_state = global_state
+        @index = T.let(global_state.index, RubyIndexer::Index)
         @nesting = nesting
         @typechecker_enabled = typechecker_enabled
         @uri = uri
@@ -35,7 +36,7 @@ module RubyLsp
       # Handle completion on regular constant references (e.g. `Bar`)
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @global_state.typechecker
 
         name = constant_name(node)
         return if name.nil?
@@ -56,7 +57,7 @@ module RubyLsp
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @global_state.typechecker
 
         name = constant_name(node)
         return if name.nil?
@@ -77,7 +78,10 @@ module RubyLsp
 
         real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
 
-        candidates = @index.prefix_search("#{real_namespace}::#{incomplete_name}", top_level_reference ? [] : @nesting)
+        candidates = @index.prefix_search(
+          "#{real_namespace}::#{incomplete_name}",
+          top_level_reference ? [] : @nesting,
+        )
         candidates.each do |entries|
           # The only time we may have a private constant reference from outside of the namespace is if we're dealing
           # with ConstantPath and the entry name doesn't start with the current nesting
@@ -124,7 +128,9 @@ module RubyLsp
 
         return unless path_node_to_complete.is_a?(Prism::StringNode)
 
-        @index.search_require_paths(path_node_to_complete.content).map!(&:require_path).sort!.each do |path|
+        matched_indexable_paths = @index.search_require_paths(path_node_to_complete.content)
+
+        matched_indexable_paths.map!(&:require_path).sort!.each do |path|
           @response_builder << build_completion(T.must(path), path_node_to_complete)
         end
       end
@@ -284,13 +290,6 @@ module RubyLsp
             new_text: insertion_text,
           ),
           kind: kind,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            description: entries.map(&:file_name).join(","),
-          ),
-          documentation: Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(real_name, entries),
-          ),
         )
       end
 

data/lib/ruby_lsp/listeners/definition.rb

@@ -10,18 +10,19 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          global_state: GlobalState,
           uri: URI::Generic,
           nesting: T::Array[String],
-          index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(response_builder, uri, nesting, index, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
+        @global_state = global_state
+        @index = T.let(global_state.index, RubyIndexer::Index)
         @uri = uri
         @nesting = nesting
-        @index = index
         @typechecker_enabled = typechecker_enabled
 
         dispatcher.register(