ruby-lsp 0.23.15 → 0.26.9

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,27 +11,37 @@ 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
 
+    # Gems that should be kept up to date in the composed bundle. When updating, any of these gems that are not
+    # already in the user's Gemfile will be updated together.
+    GEMS_TO_UPDATE = ["ruby-lsp", "debug", "prism", "rbs"].freeze #: Array[String]
+    RUBY_LSP_MIN_VERSION = "0.18.0" #: String
+
     #: (String project_path, **untyped options) -> void
     def initialize(project_path, **options)
       @project_path = project_path
-      @branch = options[:branch] #: String?
       @launcher = options[:launcher] #: bool?
-      patch_thor_to_print_progress_to_stderr! if @launcher
+      @beta = options[:beta] #: bool?
+      force_output_to_stderr! if @launcher
 
       # Regular bundle paths
       @gemfile = begin
@@ -51,7 +60,7 @@ module RubyLsp
       @custom_dir = Pathname.new(".ruby-lsp").expand_path(@project_path) #: Pathname
       @custom_gemfile = @custom_dir + @gemfile_name #: Pathname
       @custom_lockfile = @custom_dir + (@lockfile&.basename || "Gemfile.lock") #: Pathname
-      @lockfile_hash_path = @custom_dir + "main_lockfile_hash" #: Pathname
+      @freshness_hash_path = @custom_dir + "freshness_hash" #: Pathname
       @last_updated_path = @custom_dir + "last_updated" #: Pathname
       @error_path = @custom_dir + "install_error" #: Pathname
       @already_composed_path = @custom_dir + "bundle_is_composed" #: Pathname
@@ -61,6 +70,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
@@ -109,17 +119,24 @@ module RubyLsp
         return run_bundle_install(@custom_gemfile)
       end
 
-      if @lockfile_hash && @custom_lockfile.exist? && @lockfile_hash_path.exist? &&
-          @lockfile_hash_path.read == @lockfile_hash
+      # Our freshness hash determines if we need to copy the lockfile from the main app again and run bundle install
+      # from scratch. We use a combination of the main app's lockfile and the composed Gemfile. The goal is to
+      # automatically account for CLI arguments which can change the Gemfile we compose. If the CLI arguments or the
+      # main lockfile change, we need to make sure we're re-composing.
+      freshness_digest = Digest::SHA256.hexdigest("#{@lockfile_hash}#{@custom_gemfile.read}")
+
+      if @lockfile_hash && @custom_lockfile.exist? && @freshness_hash_path.exist? &&
+          @freshness_hash_path.read == freshness_digest
         $stderr.puts(
           "Ruby LSP> Skipping composed bundle setup since #{@custom_lockfile} already exists and is up to date",
         )
         return run_bundle_install(@custom_gemfile)
       end
 
+      @needs_update_path.delete if @needs_update_path.exist?
       FileUtils.cp(@lockfile.to_s, @custom_lockfile.to_s)
       correct_relative_remote_paths
-      @lockfile_hash_path.write(@lockfile_hash)
+      @freshness_hash_path.write(freshness_digest)
       run_bundle_install(@custom_gemfile)
     end
 
@@ -159,9 +176,8 @@ module RubyLsp
       end
 
       unless @dependencies["ruby-lsp"]
-        ruby_lsp_entry = +'gem "ruby-lsp", require: false, group: :development'
-        ruby_lsp_entry << ", github: \"Shopify/ruby-lsp\", branch: \"#{@branch}\"" if @branch
-        parts << ruby_lsp_entry
+        version = @beta ? "0.a" : RUBY_LSP_MIN_VERSION
+        parts << "gem \"ruby-lsp\", \">= #{version}\", require: false, group: :development"
       end
 
       unless @dependencies["debug"]
@@ -229,6 +245,16 @@ 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, Bundler::HTTPError, Bundler::InstallError
+        # There are cases where we expect certain errors to happen occasionally, and we don't want to write them to
+        # a file, which would report to telemetry on the next launch.
+        #
+        # - The $stderr pipe might be closed by the client, for example when closing the editor during running bundle
+        # install. 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.
+        # - Bundler might also encounter a network error.
+        # - Native extension build failures (InstallError) are user environment issues that Ruby LSP cannot resolve.
+        @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))
@@ -257,41 +283,86 @@ module RubyLsp
     def run_bundle_install_directly(env, force_install: false)
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
-      # 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?
-      T.unsafe(ENV).merge!(env)
+      # The should_bundle_update? check needs to run on the original Bundler environment, but everything else (like
+      # updating or running install) requires the modified environment. Here we compute the check ahead of time and
+      # merge the environment to ensure correct results.
+      #
+      # The symptoms of having these operations in the wrong order is seeing unwanted modifications in the application's
+      # main lockfile because we accidentally run update on the main bundle instead of the composed one.
+      needs_update = 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 update(env) if @needs_update_path.exist?
+
+      FileUtils.touch(@needs_update_path) if needs_update
+
+      $stderr.puts("Ruby LSP> Checking if the composed bundle is satisfied...")
+
+      begin
+        missing_gems = bundle_check
+      rescue Errno::EPIPE, Bundler::HTTPError
+        # These are errors cases where we cannot recover
+        raise
+      rescue => e
+        # If anything fails with bundle check, try to bundle install
+        $stderr.puts("Ruby LSP> Running bundle install because #{e.message}")
+        bundle_install
         return env
       end
 
+      if missing_gems.empty?
+        $stderr.puts("Ruby LSP> Bundle already satisfied")
+      else
+        $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
+
+      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] }
+      gems = GEMS_TO_UPDATE.reject { |dep| @dependencies[dep] }
       gems << "ruby-lsp-rails" if @rails_app && !@dependencies["ruby-lsp-rails"]
 
       Bundler::CLI::Update.new({ conservative: true }, gems).run
       correct_relative_remote_paths if @custom_lockfile.exist?
+      @needs_update_path.delete if @needs_update_path.exist?
       @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]
     def run_bundle_install_through_command(env)
-      # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
-      # to upgrade them or else we'll produce undesired source control changes. If the composed bundle was just created
-      # and any of `ruby-lsp`, `ruby-lsp-rails` or `debug` weren't a part of the Gemfile, then we need to run `bundle
-      # install` for the first time to generate the Gemfile.lock with them included or else Bundler will complain that
-      # they're missing. We can only update if the custom `.ruby-lsp/Gemfile.lock` already exists and includes all gems
+      # If the gems in GEMS_TO_UPDATE (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't
+      # try to upgrade them or else we'll produce undesired source control changes. If the composed bundle was just
+      # created and any of those gems weren't a part of the Gemfile, then we need to run `bundle install` for the first
+      # time to generate the Gemfile.lock with them included or else Bundler will complain that they're missing. We can
+      # only update if the custom `.ruby-lsp/Gemfile.lock` already exists and includes all gems
 
       # When not updating, we run `(bundle check || bundle install)`
-      # When updating, we run `((bundle check && bundle update ruby-lsp debug) || bundle install)`
+      # When updating, we run `((bundle check && bundle update <GEMS_TO_UPDATE>) || bundle install)`
       bundler_path = File.join(Gem.default_bindir, "bundle")
       base_command = (!Gem.win_platform? && File.exist?(bundler_path) ? "#{Gem.ruby} #{bundler_path}" : "bundle").dup
 
@@ -302,12 +373,11 @@ module RubyLsp
       command = +"(#{base_command} check"
 
       if should_bundle_update?
-        # If any of `ruby-lsp`, `ruby-lsp-rails` or `debug` are not in the Gemfile, try to update them to the latest
-        # version
+        # If any of the gems in GEMS_TO_UPDATE (or `ruby-lsp-rails` for Rails apps) are not in the Gemfile, try to
+        # update them to the latest version
         command.prepend("(")
         command << " && #{base_command} update "
-        command << "ruby-lsp " unless @dependencies["ruby-lsp"]
-        command << "debug " unless @dependencies["debug"]
+        GEMS_TO_UPDATE.each { |gem| command << "#{gem} " unless @dependencies[gem] }
         command << "ruby-lsp-rails " if @rails_app && !@dependencies["ruby-lsp-rails"]
         command.delete_suffix!(" ")
         command << ")"
@@ -436,19 +506,16 @@ module RubyLsp
     end
 
     #: -> void
-    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
+    def force_output_to_stderr!
+      # Bundler and RubyGems have different UI objects used for printing. We need to ensure that both are configured to
+      # print only to stderr or else they'll break the connection with the editor
+      Gem::DefaultUserInteraction.ui = Gem::StreamUI.new($stdin, $stderr, $stderr, false)
 
-        sig { returns(IO) }
-        def stdout
-          $stderr
-        end
-      end)
+      ui = Bundler.ui
+      ui.output_stream = :stderr if ui.respond_to?(:output_stream=)
+      ui.level = :info
 
-      Bundler.ui.level = :info
+      Bundler::Thor::Shell::Basic.prepend(ThorPatch) if defined?(Bundler::Thor::Shell::Basic)
     end
   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
 
@@ -38,11 +28,11 @@ module RubyLsp
       ext = File.extname(path)
       language_id = case ext
       when ".erb", ".rhtml"
-        Document::LanguageId::ERB
+        :erb
       when ".rbs"
-        Document::LanguageId::RBS
+        :rbs
       else
-        Document::LanguageId::Ruby
+        :ruby
       end
 
       set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
@@ -51,12 +41,12 @@ module RubyLsp
       raise NonExistingDocumentError, uri.to_s
     end
 
-    #: (uri: URI::Generic, source: String, version: Integer, language_id: Document::LanguageId) -> Document[untyped]
+    #: (uri: URI::Generic, source: String, version: Integer, language_id: Symbol) -> Document[untyped]
     def set(uri:, source:, version:, language_id:)
       @state[uri.to_s] = case language_id
-      when Document::LanguageId::ERB
+      when :erb
         ERBDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
-      when Document::LanguageId::RBS
+      when :rbs
         RBSDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
       else
         RubyDocument.new(source: source, version: version, uri: uri, global_state: @global_state)

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

@@ -1,35 +1,110 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "English"
 require "json"
 require "socket"
-require "singleton"
+require "tmpdir"
+require_relative "../../ruby_indexer/lib/ruby_indexer/uri"
 
 module RubyLsp
   class LspReporter
-    include Singleton
+    @instance = nil #: LspReporter?
+
+    class << self
+      #: -> LspReporter
+      def instance
+        @instance ||= new
+      end
+
+      #: -> bool
+      def start_coverage?
+        ENV["RUBY_LSP_TEST_RUNNER"] == "coverage"
+      end
+
+      #: -> bool
+      def executed_under_test_runner?
+        !!(ENV["RUBY_LSP_TEST_RUNNER"] && ENV["RUBY_LSP_ENV"] != "test")
+      end
+
+      #: (Method | UnboundMethod) -> [URI::Generic, Integer?]?
+      def uri_and_line_for(method_object)
+        file_path, line = method_object.source_location
+        return unless file_path
+        return if file_path.start_with?("(eval at ")
+
+        uri = URI::Generic.from_path(path: File.expand_path(file_path))
+        zero_based_line = line ? line - 1 : nil
+        [uri, zero_based_line]
+      end
+    end
+
+    # 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_db_path = File.join(dir_path, "test_reporter_port_db.json")
       port = ENV["RUBY_LSP_REPORTER_PORT"]
-      @io = if port
-        TCPSocket.new("localhost", port)
-      else
-        # For tests that don't spawn the TCP server
+
+      @io = begin
+        # The environment variable is only used for tests. The extension always writes to the temporary file
+        if port
+          socket(port)
+        elsif File.exist?(port_db_path)
+          db = JSON.load_file(port_db_path)
+          socket(db[Dir.pwd])
+        else
+          # For tests that don't spawn the TCP server
+          require "stringio"
+          StringIO.new
+        end
+      rescue
         require "stringio"
         StringIO.new
       end #: IO | StringIO
+
+      @invoked_shutdown = false #: bool
+      @message_queue = Thread::Queue.new #: Thread::Queue
+      @writer = Thread.new { write_loop } #: Thread
     end
 
     #: -> void
     def shutdown
+      # When running in coverage mode, we don't want to inform the extension that we finished immediately after running
+      # tests. We only do it after we finish processing coverage results, by invoking `internal_shutdown`
+      return if ENV["RUBY_LSP_TEST_RUNNER"] == "coverage"
+
+      internal_shutdown
+    end
+
+    # This method is intended to be used by the RubyLsp::LspReporter class itself only. If you're writing a custom test
+    # reporter, use `shutdown` instead
+    #: -> void
+    def internal_shutdown
+      @invoked_shutdown = true
+
       send_message("finish")
+      @message_queue.close
+      @writer.join
       @io.close
     end
 
-    #: (id: String, uri: URI::Generic) -> void
-    def start_test(id:, uri:)
-      send_message("start", id: id, uri: uri.to_s)
+    #: (id: String, uri: URI::Generic, ?line: Integer?) -> void
+    def start_test(id:, uri:, line: nil)
+      send_message("start", id: id, uri: uri.to_s, line: line)
     end
 
     #: (id: String, uri: URI::Generic) -> void
@@ -79,14 +154,13 @@ 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
-      default_gems_path = File.dirname(RbConfig::CONFIG["rubylibdir"])
 
       result = Coverage.result.reject do |file_path, _coverage_info|
-        file_path.start_with?(bundle_path, default_gems_path, "eval")
+        file_path.start_with?(bundle_path) || !file_path.start_with?(Dir.pwd)
       end
 
       result.to_h do |file_path, coverage_info|
@@ -129,24 +203,54 @@ module RubyLsp
       end
     end
 
+    #: -> void
+    def at_coverage_exit
+      coverage_results = gather_coverage_results
+      File.write(File.join(".ruby-lsp", "coverage_result.json"), coverage_results.to_json)
+      internal_shutdown
+    end
+
+    #: -> void
+    def at_exit
+      internal_shutdown unless @invoked_shutdown
+    end
+
     private
 
-    #: (method_name: String?, params: untyped) -> void
+    #: (String) -> Socket
+    def socket(port)
+      socket = Socket.tcp("localhost", port)
+      socket.binmode
+      socket.sync = true
+      socket
+    end
+
+    #: (String?, **untyped) -> void
     def send_message(method_name, **params)
       json_message = { method: method_name, params: params }.to_json
-      @io.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+      @message_queue << "Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}"
+    end
+
+    #: -> void
+    def write_loop
+      while (message = @message_queue.pop)
+        @io.write(message)
+      end
     end
   end
 end
 
-if ENV["RUBY_LSP_TEST_RUNNER"] == "coverage"
+if RubyLsp::LspReporter.start_coverage?
   # Auto start coverage when running tests under that profile. This avoids the user from having to configure coverage
   # manually for their project or adding extra dependencies
   require "coverage"
   Coverage.start(:all)
+end
 
+if RubyLsp::LspReporter.executed_under_test_runner?
   at_exit do
-    coverage_results = RubyLsp::LspReporter.instance.gather_coverage_results
-    File.write(File.join(".ruby-lsp", "coverage_result.json"), coverage_results.to_json)
+    # Regular finish events are registered per test reporter. However, if the test crashes during loading the files
+    # (e.g.: a bad require), we need to ensure that the execution is finalized so that the extension is not left hanging
+    RubyLsp::LspReporter.instance.at_exit if $ERROR_INFO
   end
 end

data/lib/ruby_lsp/test_reporters/minitest_reporter.rb

@@ -8,7 +8,6 @@ rescue LoadError
 end
 
 require_relative "lsp_reporter"
-require "ruby_indexer/lib/ruby_indexer/uri"
 
 module RubyLsp
   # An override of the default progress reporter in Minitest to add color to the output
@@ -31,6 +30,30 @@ module RubyLsp
     end
   end
 
+  # This patch is here to prevent other gems from overriding or adding more Minitest reporters. Otherwise, they may
+  # break the integration between the server and extension
+  module PreventReporterOverridePatch
+    @lsp_reporters = [] #: Array[Minitest::AbstractReporter]
+
+    class << self
+      #: Array[Minitest::AbstractReporter]
+      attr_accessor :lsp_reporters
+    end
+
+    # Patch the writer to prevent replacing the entire array
+    #: (untyped) -> void
+    def reporters=(reporters)
+      # Do nothing. We don't want other gems to override our reporter
+    end
+
+    # Patch the reader to prevent appending more reporters. This method always returns a temporary copy of the real
+    # reporters so that if any gem mutates it, it continues to return the original reporters
+    #: -> Array[untyped]
+    def reporters
+      PreventReporterOverridePatch.lsp_reporters.dup
+    end
+  end
+
   class MinitestReporter < Minitest::AbstractReporter
     class << self
       #: (Hash[untyped, untyped]) -> void
@@ -46,21 +69,43 @@ module RubyLsp
 
         # Add the JSON RPC reporter
         reporters << MinitestReporter.new
+        PreventReporterOverridePatch.lsp_reporters = reporters
+        Minitest.reporter.class.prepend(PreventReporterOverridePatch)
       end
     end
 
-    #: (singleton(Minitest::Test) test_class, String method_name) -> void
-    def prerecord(test_class, method_name)
-      uri = uri_from_test_class(test_class, method_name)
+    #: (untyped, String) -> void
+    def prerecord(test_class_or_wrapper, method_name)
+      # In frameworks like Rails, they can control the Minitest execution by wrapping the test class
+      # But they conform to responding to `name`, so we can use that as a guarantee
+      # We are interested in the test class, not the wrapper
+      name = test_class_or_wrapper.name
+
+      klass = begin
+        Object.const_get(name) # rubocop:disable Sorbet/ConstantsFromStrings
+      rescue NameError
+        # Handle Minitest specs that create classes with invalid constant names like "MySpec::when something is true"
+        # If we can't resolve the constant, it means we were given the actual test class object, not the wrapper
+        test_class_or_wrapper
+      end
+
+      uri, line = LspReporter.uri_and_line_for(klass.instance_method(method_name))
       return unless uri
 
-      LspReporter.instance.start_test(id: "#{test_class.name}##{method_name}", uri: uri)
+      id = "#{name}##{handle_spec_test_id(method_name, line)}"
+      LspReporter.instance.start_test(id: id, uri: uri, line: line)
     end
 
     #: (Minitest::Result result) -> void
     def record(result)
-      id = "#{result.klass}##{result.name}"
-      uri = uri_from_result(result)
+      file_path, line = result.source_location
+      return unless file_path
+
+      zero_based_line = line ? line - 1 : nil
+      name = handle_spec_test_id(result.name, zero_based_line)
+      id = "#{result.klass}##{name}"
+
+      uri = URI::Generic.from_path(path: File.expand_path(file_path))
 
       if result.error?
         message = result.failures.first.message
@@ -80,26 +125,21 @@ module RubyLsp
       LspReporter.instance.shutdown
     end
 
-    private
-
-    #: (Minitest::Result result) -> URI::Generic
-    def uri_from_result(result)
-      file = result.source_location[0]
-      absolute_path = File.expand_path(file, Dir.pwd)
-      URI::Generic.from_path(path: absolute_path)
-    end
-
-    #: (singleton(Minitest::Test) test_class, String method_name) -> URI::Generic?
-    def uri_from_test_class(test_class, method_name)
-      file, _line = test_class.instance_method(method_name).source_location
-      return unless file
-
-      return if file.start_with?("(eval at ") # test is dynamically defined
-
-      absolute_path = File.expand_path(file, Dir.pwd)
-      URI::Generic.from_path(path: absolute_path)
+    #: (String, Integer?) -> String
+    def handle_spec_test_id(method_name, line)
+      method_name.gsub(/(?<=test_)\d{4}(?=_)/, format("%04d", line.to_s))
     end
   end
 end
 
 Minitest.extensions << RubyLsp::MinitestReporter
+
+if RubyLsp::LspReporter.start_coverage?
+  Minitest.after_run do
+    RubyLsp::LspReporter.instance.at_coverage_exit
+  end
+elsif RubyLsp::LspReporter.executed_under_test_runner?
+  Minitest.after_run do
+    RubyLsp::LspReporter.instance.at_exit
+  end
+end