ruby-lsp 0.23.20 → 0.26.1

data/lib/ruby_lsp/server.rb

@@ -94,13 +94,10 @@ module RubyLsp
             id: message[:id],
             response:
               Addon.addons.map do |addon|
-                version_method = addon.method(:version)
-
-                # If the add-on doesn't define a `version` method, we'd be calling the abstract method defined by
-                # Sorbet, which would raise an error.
-                # Therefore, we only call the method if it's defined by the add-on itself
-                if version_method.owner != Addon
-                  version = addon.version
+                version = begin
+                  addon.version
+                rescue AbstractMethodInvokedError
+                  nil
                 end
 
                 { name: addon.name, version: version, errored: addon.error? }
@@ -124,30 +121,22 @@ module RubyLsp
       end
     rescue DelegateRequestError
       send_message(Error.new(id: message[:id], code: DelegateRequestError::CODE, message: "DELEGATE_REQUEST"))
-    rescue StandardError, LoadError => e
+    rescue StandardError, LoadError, SystemExit => e
       # If an error occurred in a request, we have to return an error response or else the editor will hang
       if message[:id]
         # If a document is deleted before we are able to process all of its enqueued requests, we will try to read it
         # from disk and it raise this error. This is expected, so we don't include the `data` attribute to avoid
-        # reporting these to our telemetry
+        # reporting these to our telemetry.
+        #
+        # Similarly, if we receive a location for an invalid position in the
+        # document, we don't report it to telemetry
         case e
-        when Store::NonExistingDocumentError
+        when Store::NonExistingDocumentError, Document::InvalidLocationError
           send_message(Error.new(
             id: message[:id],
             code: Constant::ErrorCodes::INVALID_PARAMS,
             message: e.full_message,
           ))
-        when Document::LocationNotFoundError
-          send_message(Error.new(
-            id: message[:id],
-            code: Constant::ErrorCodes::REQUEST_FAILED,
-            message: <<~MESSAGE,
-              Request #{message[:method]} failed to find the target position.
-              The file might have been modified while the server was in the middle of searching for the target.
-              If you experience this regularly, please report any findings and extra information on
-              https://github.com/Shopify/ruby-lsp/issues/2446
-            MESSAGE
-          ))
         else
           send_message(Error.new(
             id: message[:id],
@@ -182,6 +171,7 @@ module RubyLsp
       return if @setup_error
 
       errors = Addon.load_addons(@global_state, @outgoing_queue, include_project_addons: include_project_addons)
+      return if test_mode?
 
       if errors.any?
         send_log_message(
@@ -194,21 +184,13 @@ module RubyLsp
 
       if errored_addons.any?
         send_message(
-          Notification.new(
-            method: "window/showMessage",
-            params: Interface::ShowMessageParams.new(
-              type: Constant::MessageType::WARNING,
-              message: "Error loading add-ons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
-            ),
+          Notification.window_show_message(
+            "Error loading add-ons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
+            type: Constant::MessageType::WARNING,
           ),
         )
 
-        unless @test_mode
-          send_log_message(
-            errored_addons.map(&:errors_details).join("\n\n"),
-            type: Constant::MessageType::WARNING,
-          )
-        end
+        send_log_message(errored_addons.map(&:errors_details).join("\n\n"), type: Constant::MessageType::WARNING)
       end
     end
 
@@ -224,10 +206,6 @@ module RubyLsp
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
 
-      configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
-      @store.features_configuration.dig(:inlayHint) #: as !nil
-        .configuration.merge!(configured_hints) if configured_hints
-
       enabled_features = case configured_features
       when Array
         # If the configuration is using an array, then absent features are disabled and present ones are enabled. That's
@@ -381,56 +359,53 @@ module RubyLsp
 
       perform_initial_indexing
       check_formatter_is_available
+      update_server if @global_state.enabled_feature?(:launcher)
     end
 
     #: (Hash[Symbol, untyped] message) -> void
     def text_document_did_open(message)
-      @global_state.synchronize do
-        text_document = message.dig(:params, :textDocument)
-        language_id = case text_document[:languageId]
-        when "erb", "eruby"
-          :erb
-        when "rbs"
-          :rbs
-        else
-          :ruby
-        end
+      text_document = message.dig(:params, :textDocument)
+      language_id = case text_document[:languageId]
+      when "erb", "eruby"
+        :erb
+      when "rbs"
+        :rbs
+      else
+        :ruby
+      end
 
-        document = @store.set(
-          uri: text_document[:uri],
-          source: text_document[:text],
-          version: text_document[:version],
-          language_id: language_id,
-        )
+      document = @store.set(
+        uri: text_document[:uri],
+        source: text_document[:text],
+        version: text_document[:version],
+        language_id: language_id,
+      )
 
-        if document.past_expensive_limit? && text_document[:uri].scheme == "file"
-          log_message = <<~MESSAGE
-            The file #{text_document[:uri].path} is too long. For performance reasons, semantic highlighting and
-            diagnostics will be disabled.
-          MESSAGE
+      if document.past_expensive_limit? && text_document[:uri].scheme == "file"
+        log_message = <<~MESSAGE
+          The file #{text_document[:uri].path} is too long. For performance reasons, semantic highlighting and
+          diagnostics will be disabled.
+        MESSAGE
 
-          send_message(
-            Notification.new(
-              method: "window/logMessage",
-              params: Interface::LogMessageParams.new(
-                type: Constant::MessageType::WARNING,
-                message: log_message,
-              ),
+        send_message(
+          Notification.new(
+            method: "window/logMessage",
+            params: Interface::LogMessageParams.new(
+              type: Constant::MessageType::WARNING,
+              message: log_message,
             ),
-          )
-        end
+          ),
+        )
       end
     end
 
     #: (Hash[Symbol, untyped] message) -> void
     def text_document_did_close(message)
-      @global_state.synchronize do
-        uri = message.dig(:params, :textDocument, :uri)
-        @store.delete(uri)
+      uri = message.dig(:params, :textDocument, :uri)
+      @store.delete(uri)
 
-        # Clear diagnostics for the closed file, so that they no longer appear in the problems tab
-        send_message(Notification.publish_diagnostics(uri.to_s, []))
-      end
+      # Clear diagnostics for the closed file, so that they no longer appear in the problems tab
+      send_message(Notification.publish_diagnostics(uri.to_s, []))
     end
 
     #: (Hash[Symbol, untyped] message) -> void
@@ -438,9 +413,7 @@ module RubyLsp
       params = message[:params]
       text_document = params[:textDocument]
 
-      @global_state.synchronize do
-        @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
-      end
+      @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
     end
 
     #: (Hash[Symbol, untyped] message) -> void
@@ -494,8 +467,8 @@ module RubyLsp
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       inlay_hint = Requests::InlayHints.new(
+        @global_state,
         document,
-        @store.features_configuration.dig(:inlayHint), #: as !nil
         dispatcher,
       )
 
@@ -512,13 +485,13 @@ module RubyLsp
           @global_state.index.handle_change(uri) do |index|
             index.delete(uri, skip_require_paths_tree: true)
             RubyIndexer::DeclarationListener.new(index, dispatcher, parse_result, uri, collect_comments: true)
-            code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
-            dispatcher.dispatch(parse_result.value)
+            code_lens = Requests::CodeLens.new(@global_state, document, dispatcher)
+            dispatcher.dispatch(document.ast)
           end
         end
       else
-        code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
-        dispatcher.dispatch(parse_result.value)
+        code_lens = Requests::CodeLens.new(@global_state, document, dispatcher)
+        dispatcher.dispatch(document.ast)
       end
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
@@ -557,7 +530,7 @@ module RubyLsp
 
       dispatcher = Prism::Dispatcher.new
       semantic_highlighting = Requests::SemanticHighlighting.new(@global_state, dispatcher, document, nil)
-      dispatcher.visit(document.parse_result.value)
+      dispatcher.visit(document.ast)
 
       send_message(Result.new(id: message[:id], response: semantic_highlighting.perform))
     end
@@ -583,7 +556,7 @@ module RubyLsp
         document,
         message.dig(:params, :previousResultId),
       )
-      dispatcher.visit(document.parse_result.value)
+      dispatcher.visit(document.ast)
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
@@ -612,7 +585,7 @@ module RubyLsp
         nil,
         range: range.dig(:start, :line)..range.dig(:end, :line),
       )
-      dispatcher.visit(document.parse_result.value)
+      dispatcher.visit(document.ast)
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
@@ -704,7 +677,7 @@ module RubyLsp
       end
 
       request = Requests::DocumentHighlight.new(@global_state, document, params[:position], dispatcher)
-      dispatcher.dispatch(document.parse_result.value)
+      dispatcher.dispatch(document.ast)
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
@@ -842,7 +815,6 @@ module RubyLsp
         return
       end
 
-      hints_configurations = @store.features_configuration.dig(:inlayHint) #: as !nil
       dispatcher = Prism::Dispatcher.new
 
       unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
@@ -850,8 +822,8 @@ module RubyLsp
         return
       end
 
-      request = Requests::InlayHints.new(document, hints_configurations, dispatcher)
-      dispatcher.visit(document.parse_result.value)
+      request = Requests::InlayHints.new(@global_state, document, dispatcher)
+      dispatcher.visit(document.ast)
       result = request.perform
       document.cache_set("textDocument/inlayHint", result)
 
@@ -1124,11 +1096,7 @@ module RubyLsp
       @global_state.register_formatter("rubocop_internal", Requests::Support::RuboCopFormatter.new)
 
       # Clear all document caches for pull diagnostics
-      @global_state.synchronize do
-        @store.each do |_uri, document|
-          document.clear_cache("textDocument/diagnostic")
-        end
-      end
+      @store.each { |_uri, document| document.clear_cache("textDocument/diagnostic") }
 
       # Request a pull diagnostic refresh from the editor
       if @global_state.client_capabilities.supports_diagnostic_refresh
@@ -1243,7 +1211,7 @@ module RubyLsp
             }
           end
         end
-      rescue Bundler::GemNotFound
+      rescue Bundler::GemNotFound, Bundler::GemfileNotFound
         []
       end
 
@@ -1426,8 +1394,38 @@ module RubyLsp
 
       # We compose the bundle in a thread so that the LSP continues to work while we're checking for its validity. Once
       # we return the response back to the editor, then the restart is triggered
+      launch_bundle_compose("Recomposing the bundle ahead of restart") do |stderr, status|
+        if status&.exitstatus == 0
+          # Create a signal for the restart that it can skip composing the bundle and launch directly
+          FileUtils.touch(already_composed_path)
+          send_message(Result.new(id: id, response: { success: true }))
+        else
+          # This special error code makes the extension avoid restarting in case we already know that the composed
+          # bundle is not valid
+          send_message(
+            Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle\n#{stderr}"),
+          )
+        end
+      end
+    end
+
+    #: -> void
+    def update_server
+      return unless File.exist?(File.join(@global_state.workspace_path, ".ruby-lsp", "needs_update"))
+
+      launch_bundle_compose("Trying to update server") do |stderr, status|
+        if status&.exitstatus == 0
+          send_log_message("Successfully updated the server")
+        else
+          send_log_message("Failed to update server\n#{stderr}", type: Constant::MessageType::ERROR)
+        end
+      end
+    end
+
+    #: (String) { (IO, Process::Status?) -> void } -> Thread
+    def launch_bundle_compose(log, &block)
       Thread.new do
-        send_log_message("Recomposing the bundle ahead of restart")
+        send_log_message(log)
 
         _stdout, stderr, status = Bundler.with_unbundled_env do
           Open3.capture3(
@@ -1442,17 +1440,7 @@ module RubyLsp
           )
         end
 
-        if status&.exitstatus == 0
-          # Create a signal for the restart that it can skip composing the bundle and launch directly
-          FileUtils.touch(already_composed_path)
-          send_message(Result.new(id: id, response: { success: true }))
-        else
-          # This special error code makes the extension avoid restarting in case we already know that the composed
-          # bundle is not valid
-          send_message(
-            Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle\n#{stderr}"),
-          )
-        end
+        block.call(stderr, status)
       end
     end
 
@@ -1509,10 +1497,7 @@ module RubyLsp
 
       send_message(Result.new(
         id: message[:id],
-        response: {
-          commands: commands,
-          reporterPaths: [Listeners::TestStyle::MINITEST_REPORTER_PATH, Listeners::TestStyle::TEST_UNIT_REPORTER_PATH],
-        },
+        response: { commands: commands },
       ))
     end
 

data/lib/ruby_lsp/setup_bundler.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "bundler"
 require "bundler/cli"
 require "bundler/cli/install"
@@ -12,19 +11,24 @@ require "digest"
 require "time"
 require "uri"
 
-# This file is a script that will configure a composed bundle for the Ruby LSP. The composed bundle allows developers to use
-# the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
-# exact locked versions of dependencies.
+# This file is a script that will configure a composed bundle for the Ruby LSP. The composed bundle allows developers to
+# use the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to
+# the exact locked versions of dependencies.
 
 Bundler.ui.level = :silent
 
 module RubyLsp
   class SetupBundler
-    extend T::Sig
-
     class BundleNotLocked < StandardError; end
     class BundleInstallFailure < StandardError; end
 
+    module ThorPatch
+      #: -> IO
+      def stdout
+        $stderr
+      end
+    end
+
     FOUR_HOURS = 4 * 60 * 60 #: Integer
 
     #: (String project_path, **untyped options) -> void
@@ -61,6 +65,7 @@ module RubyLsp
       @bundler_version = bundler_version #: Gem::Version?
       @rails_app = rails_app? #: bool
       @retry = false #: bool
+      @needs_update_path = @custom_dir + "needs_update" #: Pathname
     end
 
     # Sets up the composed bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
@@ -229,6 +234,14 @@ module RubyLsp
         # If no error occurred, then clear previous errors
         @error_path.delete if @error_path.exist?
         $stderr.puts("Ruby LSP> Composed bundle installation complete")
+      rescue Errno::EPIPE
+        # If the $stderr pipe was closed by the client, for example when closing the editor during running bundle
+        # install, we don't want to write the error to a file or else we will report to telemetry on the next launch and
+        # it does not represent an actual error.
+        #
+        # This situation may happen because while running bundle install, the server is not yet ready to receive
+        # shutdown requests and we may continue doing work until the process is killed.
+        @error_path.delete if @error_path.exist?
       rescue => e
         # Write the error object to a file so that we can read it from the parent process
         @error_path.write(Marshal.dump(e))
@@ -256,19 +269,50 @@ module RubyLsp
     #: (Hash[String, String] env, ?force_install: bool) -> Hash[String, String]
     def run_bundle_install_directly(env, force_install: false)
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
+      return update(env) if @needs_update_path.exist?
 
       # The ENV can only be merged after checking if an update is required because we depend on the original value of
       # ENV["BUNDLE_GEMFILE"], which gets overridden after the merge
-      should_update = should_bundle_update?
-      ENV #: as untyped
-        .merge!(env)
+      FileUtils.touch(@needs_update_path) if should_bundle_update?
+      ENV.merge!(env)
 
-      unless should_update && !force_install
-        Bundler::CLI::Install.new({ "no-cache" => true }).run
-        correct_relative_remote_paths if @custom_lockfile.exist?
-        return env
+      $stderr.puts("Ruby LSP> Checking if the composed bundle is satisfied...")
+      missing_gems = bundle_check
+
+      unless missing_gems.empty?
+        $stderr.puts(<<~MESSAGE)
+          Ruby LSP> Running bundle install because the following gems are not installed:
+          #{missing_gems.map { |g| "#{g.name}: #{g.version}" }.join("\n")}
+        MESSAGE
+
+        bundle_install
       end
 
+      $stderr.puts("Ruby LSP> Bundle already satisfied")
+      env
+    rescue => e
+      $stderr.puts("Ruby LSP> Running bundle install because #{e.message}")
+      bundle_install
+      env
+    end
+
+    # Essentially the same as bundle check, but simplified
+    #: -> Array[Gem::Specification]
+    def bundle_check
+      definition = Bundler.definition
+      definition.validate_runtime!
+      definition.check!
+      definition.missing_specs
+    end
+
+    #: -> void
+    def bundle_install
+      Bundler::CLI::Install.new({ "no-cache" => true }).run
+      correct_relative_remote_paths if @custom_lockfile.exist?
+    end
+
+    #: (Hash[String, String]) -> Hash[String, String]
+    def update(env)
       # Try to auto upgrade the gems we depend on, unless they are in the Gemfile as that would result in undesired
       # source control changes
       gems = ["ruby-lsp", "debug", "prism"].reject { |dep| @dependencies[dep] }
@@ -276,11 +320,9 @@ module RubyLsp
 
       Bundler::CLI::Update.new({ conservative: true }, gems).run
       correct_relative_remote_paths if @custom_lockfile.exist?
+      @needs_update_path.delete
       @last_updated_path.write(Time.now.iso8601)
       env
-    rescue Bundler::GemNotFound, Bundler::GitError
-      # If a gem is not installed, skip the upgrade and try to install it with a single retry
-      @retry ? env : run_bundle_install_directly(env, force_install: true)
     end
 
     #: (Hash[String, String] env) -> Hash[String, String]
@@ -440,15 +482,7 @@ module RubyLsp
     def patch_thor_to_print_progress_to_stderr!
       return unless defined?(Bundler::Thor::Shell::Basic)
 
-      Bundler::Thor::Shell::Basic.prepend(Module.new do
-        extend T::Sig
-
-        sig { returns(IO) }
-        def stdout
-          $stderr
-        end
-      end)
-
+      Bundler::Thor::Shell::Basic.prepend(ThorPatch)
       Bundler.ui.level = :info
     end
   end

data/lib/ruby_lsp/static_docs.rb

@@ -14,6 +14,7 @@ module RubyLsp
 
   # A map of keyword => short documentation to be displayed on hover or completion
   KEYWORD_DOCS = {
+    "break" => "Terminates the execution of a block or loop",
     "yield" => "Invokes the passed block with the given arguments",
   }.freeze #: Hash[String, String]
 end

data/lib/ruby_lsp/store.rb

@@ -5,9 +5,6 @@ module RubyLsp
   class Store
     class NonExistingDocumentError < StandardError; end
 
-    #: Hash[Symbol, RequestConfig]
-    attr_accessor :features_configuration
-
     #: String
     attr_accessor :client_name
 
@@ -15,13 +12,6 @@ module RubyLsp
     def initialize(global_state)
       @global_state = global_state
       @state = {} #: Hash[String, Document[untyped]]
-      @features_configuration = {
-        inlayHint: RequestConfig.new({
-          enableAll: false,
-          implicitRescue: false,
-          implicitHashValue: false,
-        }),
-      } #: Hash[Symbol, RequestConfig]
       @client_name = "Unknown" #: String
     end
 

data/lib/ruby_lsp/test_helper.rb

@@ -4,13 +4,10 @@
 # NOTE: This module is intended to be used by addons for writing their own tests, so keep that in mind if changing.
 
 module RubyLsp
+  # @requires_ancestor: Kernel
   module TestHelper
     class TestError < StandardError; end
 
-    extend T::Helpers
-
-    requires_ancestor { Kernel }
-
     #: [T] (?String? source, ?URI::Generic uri, ?stub_no_typechecker: bool, ?load_addons: bool) { (RubyLsp::Server server, URI::Generic uri) -> T } -> T
     def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
       &block)

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -6,28 +6,39 @@ require "json"
 require "socket"
 require "singleton"
 require "tmpdir"
+require_relative "../../ruby_indexer/lib/ruby_indexer/uri"
 
 module RubyLsp
   class LspReporter
     include Singleton
 
-    #: bool
-    attr_reader :invoked_shutdown
+    # https://code.visualstudio.com/api/references/vscode-api#Position
+    #: type position = { line: Integer, character: Integer }
+
+    # https://code.visualstudio.com/api/references/vscode-api#Range
+    #: type range = { start: position, end: position }
+
+    # https://code.visualstudio.com/api/references/vscode-api#BranchCoverage
+    #: type branch_coverage = { executed: Integer, label: String, location: range }
+
+    # https://code.visualstudio.com/api/references/vscode-api#StatementCoverage
+    #: type statement_coverage = { executed: Integer, location: position, branches: Array[branch_coverage] }
 
     #: -> void
     def initialize
       dir_path = File.join(Dir.tmpdir, "ruby-lsp")
       FileUtils.mkdir_p(dir_path)
 
-      port_path = File.join(dir_path, "test_reporter_port")
+      port_db_path = File.join(dir_path, "test_reporter_port_db.json")
       port = ENV["RUBY_LSP_REPORTER_PORT"]
 
       @io = begin
         # The environment variable is only used for tests. The extension always writes to the temporary file
         if port
           TCPSocket.new("localhost", port)
-        elsif File.exist?(port_path)
-          TCPSocket.new("localhost", File.read(port_path))
+        elsif File.exist?(port_db_path)
+          db = JSON.load_file(port_db_path)
+          TCPSocket.new("localhost", db[Dir.pwd])
         else
           # For tests that don't spawn the TCP server
           require "stringio"
@@ -123,7 +134,7 @@ module RubyLsp
     #       ["Foo", :bar, 6, 21, 6, 65] => 0
     #     }
     # }
-    #: -> Hash[String, StatementCoverage]
+    #: -> Hash[String, statement_coverage]
     def gather_coverage_results
       # Ignore coverage results inside dependencies
       bundle_path = Bundler.bundle_path.to_s
@@ -181,7 +192,7 @@ module RubyLsp
 
     #: -> void
     def at_exit
-      internal_shutdown unless invoked_shutdown
+      internal_shutdown unless @invoked_shutdown
     end
 
     class << self