ruby-lsp 0.23.10 → 0.23.12

data/lib/ruby_lsp/server.rb

@@ -3,13 +3,12 @@
 
 module RubyLsp
   class Server < BaseServer
-    extend T::Sig
-
     # Only for testing
-    sig { returns(GlobalState) }
+    #: GlobalState
     attr_reader :global_state
 
-    sig { override.params(message: T::Hash[Symbol, T.untyped]).void }
+    # @override
+    #: (Hash[Symbol, untyped] message) -> void
     def process_message(message)
       case message[:method]
       when "initialize"
@@ -108,6 +107,14 @@ module RubyLsp
         )
       when "rubyLsp/composeBundle"
         compose_bundle(message)
+      when "rubyLsp/diagnoseState"
+        diagnose_state(message)
+      when "rubyLsp/discoverTests"
+        discover_tests(message)
+      when "rubyLsp/resolveTestCommands"
+        resolve_test_commands(message)
+      when "experimental/goToRelevantFile"
+        experimental_go_to_relevant_file(message)
       when "$/cancelRequest"
         @global_state.synchronize { @cancelled_requests << message[:params][:id] }
       when nil
@@ -157,7 +164,7 @@ module RubyLsp
     end
 
     # Process responses to requests that were sent to the client
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def process_response(message)
       case message.dig(:result, :method)
       when "window/showMessageRequest"
@@ -165,7 +172,7 @@ module RubyLsp
       end
     end
 
-    sig { params(include_project_addons: T::Boolean).void }
+    #: (?include_project_addons: bool) -> void
     def load_addons(include_project_addons: true)
       # If invoking Bundler.setup failed, then the load path will not be configured properly and trying to load add-ons
       # with Gem.find_files will find every single version installed of an add-on, leading to requiring several
@@ -205,7 +212,7 @@ module RubyLsp
 
     private
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def run_initialize(message)
       options = message[:params]
       global_state_notifications = @global_state.apply_options(options)
@@ -286,6 +293,7 @@ module RubyLsp
           experimental: {
             addon_detection: true,
             compose_bundle: true,
+            go_to_relevant_file: true,
           },
         ),
         serverInfo: {
@@ -342,7 +350,7 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def run_initialized
       load_addons
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
@@ -369,7 +377,7 @@ module RubyLsp
       check_formatter_is_available
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_did_open(message)
       @global_state.synchronize do
         text_document = message.dig(:params, :textDocument)
@@ -408,7 +416,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_did_close(message)
       @global_state.synchronize do
         uri = message.dig(:params, :textDocument, :uri)
@@ -419,7 +427,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_did_change(message)
       params = message[:params]
       text_document = params[:textDocument]
@@ -429,7 +437,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_selection_range(message)
       uri = message.dig(:params, :textDocument, :uri)
       ranges = @store.cache_fetch(uri, "textDocument/selectionRange") do |document|
@@ -455,7 +463,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def run_combined_requests(message)
       uri = URI(message.dig(:params, :textDocument, :uri))
       document = @store.get(uri)
@@ -514,7 +522,7 @@ module RubyLsp
     alias_method :text_document_code_lens, :run_combined_requests
     alias_method :text_document_folding_range, :run_combined_requests
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_semantic_tokens_full(message)
       document = @store.get(message.dig(:params, :textDocument, :uri))
 
@@ -535,7 +543,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: semantic_highlighting.perform))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_semantic_tokens_delta(message)
       document = @store.get(message.dig(:params, :textDocument, :uri))
 
@@ -560,7 +568,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_semantic_tokens_range(message)
       params = message[:params]
       range = params[:range]
@@ -589,7 +597,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_range_formatting(message)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
       if @global_state.formatter == "none"
@@ -617,7 +625,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_formatting(message)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
       if @global_state.formatter == "none"
@@ -661,7 +669,7 @@ module RubyLsp
       send_empty_response(message[:id])
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_document_highlight(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -677,7 +685,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_on_type_formatting(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -700,7 +708,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_hover(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -725,7 +733,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_rename(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -745,7 +753,7 @@ module RubyLsp
       send_message(Error.new(id: message[:id], code: Constant::ErrorCodes::REQUEST_FAILED, message: e.message))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_prepare_rename(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -763,7 +771,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_references(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -781,7 +789,7 @@ module RubyLsp
       )
     end
 
-    sig { params(document: Document[T.untyped]).returns(RubyDocument::SorbetLevel) }
+    #: (Document[untyped] document) -> RubyDocument::SorbetLevel
     def sorbet_level(document)
       return RubyDocument::SorbetLevel::Ignore unless @global_state.has_type_checker
       return RubyDocument::SorbetLevel::Ignore unless document.is_a?(RubyDocument)
@@ -789,7 +797,7 @@ module RubyLsp
       document.sorbet_level
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_inlay_hint(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -823,7 +831,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: result.select { |hint| range.cover?(hint.position[:line]) }))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_code_action(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -845,7 +853,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def code_action_resolve(message)
       params = message[:params]
       uri = URI(params.dig(:data, :uri))
@@ -870,7 +878,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_diagnostic(message)
       # Do not compute diagnostics for files outside of the workspace. For example, if someone is looking at a gem's
       # source code, we don't want to show diagnostics for it
@@ -910,7 +918,7 @@ module RubyLsp
       send_empty_response(message[:id])
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_completion(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -935,7 +943,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_completion_item_resolve(message)
       # When responding to a delegated completion request, it means we're handling a completion item that isn't related
       # to Ruby (probably related to an ERB host language like HTML). We need to return the original completion item
@@ -954,7 +962,7 @@ module RubyLsp
       ))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_signature_help(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -980,7 +988,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_definition(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -1005,8 +1013,23 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def workspace_did_change_watched_files(message)
+      # If indexing is not complete yet, delay processing did change watched file notifications. We need initial
+      # indexing to be in place so that we can handle file changes appropriately without risking duplicates. We also
+      # have to sleep before re-inserting the notification in the queue otherwise the worker can get stuck in its own
+      # loop of pushing and popping the same notification
+      unless @global_state.index.initial_indexing_completed
+        Thread.new do
+          sleep(2)
+          # We have to ensure that the queue is not closed yet, since nothing stops the user from saving a file and then
+          # immediately telling the LSP to shutdown
+          @incoming_queue << message unless @incoming_queue.closed?
+        end
+
+        return
+      end
+
       changes = message.dig(:params, :changes)
       # We allow add-ons to register for watching files and we have no restrictions for what they register for. If the
       # same pattern is registered more than once, the LSP will receive duplicate change notifications. Receiving them
@@ -1042,32 +1065,34 @@ module RubyLsp
       end
     end
 
-    sig { params(index: RubyIndexer::Index, file_path: String, change_type: Integer).void }
+    #: (RubyIndexer::Index index, String file_path, Integer change_type) -> void
     def handle_ruby_file_change(index, file_path, change_type)
-      load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
-      uri = URI::Generic.from_path(load_path_entry: load_path_entry, path: file_path)
-
-      content = File.read(file_path)
-
-      case change_type
-      when Constant::FileChangeType::CREATED
-        # If we receive a late created notification for a file that has already been claimed by the client, we want to
-        # handle change for that URI so that the require path tree is updated
-        @store.key?(uri) ? index.handle_change(uri, content) : index.index_single(uri, content)
-      when Constant::FileChangeType::CHANGED
-        # We only handle changes on file watched notifications if the client is not the one managing this URI.
-        # Otherwise, these changes are handled when running the combined requests
-        index.handle_change(uri, content) unless @store.key?(uri)
-      when Constant::FileChangeType::DELETED
-        index.delete(uri)
-      end
-    rescue Errno::ENOENT
-      # If a file is created and then delete immediately afterwards, we will process the created notification before we
-      # receive the deleted one, but the file no longer exists. This may happen when running a test suite that creates
-      # and deletes files automatically.
+      @global_state.synchronize do
+        load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
+        uri = URI::Generic.from_path(load_path_entry: load_path_entry, path: file_path)
+
+        case change_type
+        when Constant::FileChangeType::CREATED
+          content = File.read(file_path)
+          # If we receive a late created notification for a file that has already been claimed by the client, we want to
+          # handle change for that URI so that the require path tree is updated
+          @store.key?(uri) ? index.handle_change(uri, content) : index.index_single(uri, content)
+        when Constant::FileChangeType::CHANGED
+          content = File.read(file_path)
+          # We only handle changes on file watched notifications if the client is not the one managing this URI.
+          # Otherwise, these changes are handled when running the combined requests
+          index.handle_change(uri, content) unless @store.key?(uri)
+        when Constant::FileChangeType::DELETED
+          index.delete(uri)
+        end
+      rescue Errno::ENOENT
+        # If a file is created and then delete immediately afterwards, we will process the created notification before
+        # we receive the deleted one, but the file no longer exists. This may happen when running a test suite that
+        # creates and deletes files automatically.
+      end
     end
 
-    sig { params(uri: URI::Generic).void }
+    #: (URI::Generic uri) -> void
     def handle_rubocop_config_change(uri)
       return unless defined?(Requests::Support::RuboCopFormatter)
 
@@ -1087,7 +1112,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def workspace_symbol(message)
       send_message(
         Result.new(
@@ -1100,7 +1125,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_show_syntax_tree(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -1119,7 +1144,26 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
+    def experimental_go_to_relevant_file(message)
+      path = message.dig(:params, :textDocument, :uri).to_standardized_path
+      unless path.nil? || path.start_with?(@global_state.workspace_path)
+        send_empty_response(message[:id])
+        return
+      end
+
+      unless path
+        send_empty_response(message[:id])
+        return
+      end
+
+      response = {
+        locations: Requests::GoToRelevantFile.new(path, @global_state.workspace_path).perform,
+      }
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_prepare_type_hierarchy(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -1138,7 +1182,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def type_hierarchy_supertypes(message)
       response = Requests::TypeHierarchySupertypes.new(
         @global_state.index,
@@ -1147,14 +1191,14 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def type_hierarchy_subtypes(message)
       # TODO: implement subtypes
       # The current index representation doesn't allow us to find the children of an entry.
       send_message(Result.new(id: message[:id], response: nil))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def workspace_dependencies(message)
       unless @global_state.top_level_bundle
         send_message(Result.new(id: message[:id], response: []))
@@ -1182,12 +1226,13 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { override.void }
+    # @override
+    #: -> void
     def shutdown
       Addon.unload_addons
     end
 
-    sig { void }
+    #: -> void
     def perform_initial_indexing
       # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
       # stuck indexing files
@@ -1219,7 +1264,7 @@ module RubyLsp
       end
     end
 
-    sig { params(id: String, title: String, percentage: Integer).void }
+    #: (String id, String title, ?percentage: Integer) -> void
     def begin_progress(id, title, percentage: 0)
       return unless @global_state.client_capabilities.supports_progress
 
@@ -1232,14 +1277,14 @@ module RubyLsp
       send_message(Notification.progress_begin(id, title, percentage: percentage, message: "#{percentage}% completed"))
     end
 
-    sig { params(id: String, percentage: Integer).void }
+    #: (String id, Integer percentage) -> void
     def progress(id, percentage)
       return unless @global_state.client_capabilities.supports_progress
 
       send_message(Notification.progress_report(id, percentage: percentage, message: "#{percentage}% completed"))
     end
 
-    sig { params(id: String).void }
+    #: (String id) -> void
     def end_progress(id)
       return unless @global_state.client_capabilities.supports_progress
 
@@ -1249,7 +1294,7 @@ module RubyLsp
       # notification
     end
 
-    sig { void }
+    #: -> void
     def check_formatter_is_available
       return if @setup_error
       # Warn of an unavailable `formatter` setting, e.g. `rubocop_internal` on a project which doesn't have RuboCop.
@@ -1267,7 +1312,7 @@ module RubyLsp
       end
     end
 
-    sig { params(indexing_options: T.nilable(T::Hash[Symbol, T.untyped])).void }
+    #: (Hash[Symbol, untyped]? indexing_options) -> void
     def process_indexing_configuration(indexing_options)
       # Need to use the workspace URI, otherwise, this will fail for people working on a project that is a symlink.
       index_path = File.join(@global_state.workspace_path, ".index.yml")
@@ -1308,7 +1353,7 @@ module RubyLsp
       configuration.apply_config(indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase })
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def window_show_message_request(message)
       result = message[:result]
       return unless result
@@ -1323,7 +1368,7 @@ module RubyLsp
     # NOTE: all servers methods are void because they can produce several messages for the client. The only reason this
     # method returns the created thread is to that we can join it in tests and avoid flakiness. The implementation is
     # not supposed to rely on the return of this method
-    sig { params(message: T::Hash[Symbol, T.untyped]).returns(T.nilable(Thread)) }
+    #: (Hash[Symbol, untyped] message) -> Thread?
     def compose_bundle(message)
       already_composed_path = File.join(@global_state.workspace_path, ".ruby-lsp", "bundle_is_composed")
       id = message[:id]
@@ -1368,5 +1413,57 @@ module RubyLsp
         end
       end
     end
+
+    # Returns internal state information for debugging purposes
+    #: (Hash[Symbol, untyped] message) -> void
+    def diagnose_state(message)
+      documents = {}
+      @store.each { |uri, document| documents[uri] = document.source }
+
+      send_message(
+        Result.new(
+          id: message[:id],
+          response: {
+            workerAlive: @worker.alive?,
+            backtrace: @worker.backtrace,
+            documents: documents,
+            incomingQueueSize: @incoming_queue.length,
+          },
+        ),
+      )
+    end
+
+    # Discovers all available test groups and examples in a given file taking into consideration the merged response of
+    # all add-ons
+    #: (Hash[Symbol, untyped] message) -> void
+    def discover_tests(message)
+      document = @store.get(message.dig(:params, :textDocument, :uri))
+
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      cached_response = document.cache_get("rubyLsp/discoverTests")
+      if cached_response != Document::EMPTY_CACHE
+        send_message(Result.new(id: message[:id], response: cached_response.map(&:to_hash)))
+        return
+      end
+
+      items = Requests::DiscoverTests.new(@global_state, document, Prism::Dispatcher.new).perform
+      document.cache_set("rubyLsp/discoverTests", items)
+
+      send_message(Result.new(id: message[:id], response: items.map(&:to_hash)))
+    end
+
+    #: (Hash[Symbol, untyped] message) -> void
+    def resolve_test_commands(message)
+      items = message.dig(:params, :items)
+
+      send_message(Result.new(
+        id: message[:id],
+        response: { commands: Listeners::TestStyle.resolve_test_commands(items) },
+      ))
+    end
   end
 end