ruby-lsp 0.24.2 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11ac9bfd9d255db5feb97c0f1d88a98dd966572ca6d60b6007384169f1b060b2
-  data.tar.gz: fbdc59855c67ba1741be48ccf49bd94359d5aa8aca2fb38f41e45174e4383988
+  metadata.gz: 3e8b51ca9a97aa0e855fbf1109f07733aae195eb25dba844f79840665b36ac9a
+  data.tar.gz: 79d5c3af7ba9fb03c2da197b4213a861e366b7be5a60e677ac6ca9ae8269dbea
 SHA512:
-  metadata.gz: 0364d0f1049a03f9ade581ca98ddc209dd441f3e706561141ae1995903bf53e08e6d893f0650b31c7494a8333645030e1455023416b38a59002f177e3f024fcd
-  data.tar.gz: d4298637f7c8ba3acc70859a922ed43e4daadb3ad8d8885eb7ddb1fbadbfe078e9afe6f4fc22e60f854d5d5a16b76b9013fa36f5e3cceb62b5032bf6b17f934d
+  metadata.gz: 8cb30f7427f02460320becb1b883c502ea0fbfd48f5148192e1339350e94836ed6ba825df4b4b0fe0ff8d32325d6196af6a26ef94d566e4e32ecd235d66ed821
+  data.tar.gz: 68d5712e3ae16ecaa602eeccadcab5108d89cce1f1a282b82bd3244b3111131442ee6feda63b1e7049027624c07be25e5f3ae39a00b9df25130f12f43c2dac80

data/VERSION

@@ -1 +1 @@
-0.24.2
+0.26.0

data/exe/ruby-lsp

@@ -88,13 +88,17 @@ if ENV["BUNDLE_GEMFILE"].nil?
   exit exec(env, "#{base_command} exec ruby-lsp #{original_args.join(" ")}".strip)
 end
 
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
-require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -147,8 +151,10 @@ if options[:doctor]
   return
 end
 
+server = RubyLsp::Server.new
+
 # Ensure all output goes out stderr by default to allow puts/p/pp to work
 # without specifying output device.
 $> = $stderr
 
-RubyLsp::Server.new.start
+server.start

data/exe/ruby-lsp-check

@@ -3,13 +3,9 @@
 
 # This executable checks if all automatic LSP requests run successfully on every Ruby file under the current directory
 
-require "ruby_lsp/load_sorbet"
-
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 files = Dir.glob("#{Dir.pwd}/**/*.rb")
 
 puts "Verifying that all automatic LSP requests execute successfully. This may take a while..."

data/exe/ruby-lsp-launcher

@@ -6,6 +6,13 @@
 # composed bundle
 # !!!!!!!
 
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
 setup_error = nil
 install_error = nil
 reboot = false
@@ -28,7 +35,6 @@ else
   # Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
   # Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
   # to ensure that we're setting up the bundle in the right place
-  $stdin.binmode
   headers = $stdin.gets("\r\n\r\n")
   content_length = headers[/Content-Length: (\d+)/i, 1].to_i
   $stdin.read(content_length)
@@ -125,11 +131,8 @@ end
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already
 # configured the load path using the version of the Ruby LSP present in the composed bundle. Do not push any Ruby LSP
 # paths into the load path manually or we may end up requiring the wrong version of the gem
-require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 if ARGV.include?("--debug")
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -143,22 +146,28 @@ if ARGV.include?("--debug")
   end
 end
 
-# Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
-$> = $stderr
-
 initialize_request = JSON.parse(raw_initialize, symbolize_names: true) if raw_initialize
 
 begin
-  RubyLsp::Server.new(
+  server = RubyLsp::Server.new(
     install_error: install_error,
     setup_error: setup_error,
     initialize_request: initialize_request,
-  ).start
+  )
+
+  # Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+  $> = $stderr
+
+  server.start
 rescue ArgumentError
   # If the launcher is booting an outdated version of the server, then the initializer doesn't accept a keyword splat
   # and we already read the initialize request from the stdin pipe. In this case, we need to process the initialize
   # request manually and then start the main loop
   server = RubyLsp::Server.new
+
+  # Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+  $> = $stderr
+
   server.process_message(initialize_request)
   server.start
 end

data/exe/ruby-lsp-test-exec

@@ -1,18 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Append to RUBYOPT the necessary requires to hook our custom test reporters so that results are automatically
-# reflected in the test explorer
-rubyopt = [
-  *ENV["RUBYOPT"],
-  "-rbundler/setup",
-  "-r#{File.expand_path("../lib/ruby_lsp/test_reporters/minitest_reporter", __dir__)}",
-  "-r#{File.expand_path("../lib/ruby_lsp/test_reporters/test_unit_reporter", __dir__)}",
-].join(" ")
-
-# Replace this process with whatever command was passed. We only want to set RUBYOPT.
-# The way you use this executable is by prefixing your test command with `ruby-lsp-test-exec`, like so:
-#  ruby-lsp-test-exec bundle exec ruby -Itest test/example_test.rb
-#  ruby-lsp-test-exec bundle exec ruby -Ispec spec/example_spec.rb
-#  ruby-lsp-test-exec bundle exec rspec spec/example_spec.rb
-exec({ "RUBYOPT" => rubyopt }, *ARGV)
+# This executable will be removed thanks to the changes in https://github.com/Shopify/ruby-lsp/pull/3661.
+# Remove this a few months after extension updates have rolled out
+exec(*ARGV)

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "rubocop"
-require "sorbet-runtime"
 
 module RuboCop
   module Cop

data/lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "rubocop"
-require "sorbet-runtime"
 
 module RuboCop
   module Cop

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -294,7 +294,9 @@ module RubyIndexer
 
       # @abstract
       #: -> Array[Signature]
-      def signatures; end
+      def signatures
+        raise AbstractMethodInvokedError
+      end
 
       #: -> String
       def decorated_parameters
@@ -331,6 +333,7 @@ module RubyIndexer
     end
 
     class Method < Member
+      # @override
       #: Array[Signature]
       attr_reader :signatures
 

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -291,6 +291,15 @@ module RubyIndexer
 
       # Top level constants
       entries.concat(@entries_tree.search(name))
+
+      # Filter only constants since methods may have names that look like constants
+      entries.each do |definitions|
+        definitions.select! do |entry|
+          entry.is_a?(Entry::Constant) || entry.is_a?(Entry::ConstantAlias) ||
+            entry.is_a?(Entry::Namespace) || entry.is_a?(Entry::UnresolvedConstantAlias)
+        end
+      end
+
       entries.uniq!
       entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
     end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -20,7 +20,7 @@ module RubyIndexer
       assert(uris.none? { |uri| uri.full_path.include?("test/fixtures") })
       assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("minitest-reporters").to_s) })
       assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("ansi").to_s) })
-      assert(uris.any? { |uri| uri.full_path.include?(bundle_path.join("sorbet-runtime").to_s) })
+      assert(uris.any? { |uri| uri.full_path.include?(bundle_path.join("prism").to_s) })
       assert(uris.none? { |uri| uri.full_path == __FILE__ })
     end
 
@@ -59,7 +59,6 @@ module RubyIndexer
 
       assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
       assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
-      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/erb.rb")
     end
 
     def test_indexable_uris_includes_project_files

data/lib/ruby_indexer/test/index_test.rb

@@ -1983,6 +1983,18 @@ module RubyIndexer
       assert_equal(["XQRK"], result.map { |entries| entries.first&.name })
     end
 
+    def test_constant_completion_does_not_confuse_uppercase_methods
+      index(<<~RUBY)
+        class Foo
+          def Qux
+          end
+        end
+      RUBY
+
+      candidates = @index.constant_completion_candidates("Q", [])
+      refute_includes(candidates.flat_map { |entries| entries.map(&:name) }, "Qux")
+    end
+
     def test_constant_completion_candidates_for_empty_name
       index(<<~RUBY)
         module Foo

data/lib/ruby_lsp/addon.rb

@@ -57,11 +57,26 @@ module RubyLsp
 
         if include_project_addons
           project_addons = Dir.glob("#{global_state.workspace_path}/**/ruby_lsp/**/addon.rb")
-
-          # Ignore add-ons from dependencies if the bundle is stored inside the project. We already found those with
-          # `Gem.find_files`
           bundle_path = Bundler.bundle_path.to_s
-          project_addons.reject! { |path| path.start_with?(bundle_path) }
+          gems_dir = Bundler.bundle_path.join("gems")
+
+          # Create an array of rejection glob patterns to ignore add-ons already discovered through Gem.find_files if
+          # they are also copied inside the workspace for whatever reason. We received reports of projects having gems
+          # installed in vendor/bundle despite BUNDLE_PATH pointing elsewhere. Without this mechanism, we will
+          # double-require the same add-on, potentially for different versions of the same gem, which leads to incorrect
+          # behavior
+          reject_glob_patterns = addon_files.map do |path|
+            relative_gem_path = Pathname.new(path).relative_path_from(gems_dir)
+            first_part, *parts = relative_gem_path.to_s.split(File::SEPARATOR)
+            first_part&.gsub!(/-([0-9.]+)$/, "*")
+            "**/#{first_part}/#{parts.join("/")}"
+          end
+
+          project_addons.reject! do |path|
+            path.start_with?(bundle_path) ||
+              reject_glob_patterns.any? { |pattern| File.fnmatch?(pattern, path, File::Constants::FNM_PATHNAME) }
+          end
+
           addon_files.concat(project_addons)
         end
 
@@ -182,24 +197,32 @@ module RubyLsp
     # reading information into memory or even spawning a separate process
     # @abstract
     #: (GlobalState, Thread::Queue) -> void
-    def activate(global_state, outgoing_queue); end
+    def activate(global_state, outgoing_queue)
+      raise AbstractMethodInvokedError
+    end
 
-    # Each add-on should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
+    # Each add-on must implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
     # @abstract
     #: -> void
-    def deactivate; end
+    def deactivate
+      raise AbstractMethodInvokedError
+    end
 
     # Add-ons should override the `name` method to return the add-on name
     # @abstract
     #: -> String
-    def name; end
+    def name
+      raise AbstractMethodInvokedError
+    end
 
     # Add-ons should override the `version` method to return a semantic version string representing the add-on's
     # version. This is used for compatibility checks
     # @abstract
     #: -> String
-    def version; end
+    def version
+      raise AbstractMethodInvokedError
+    end
 
     # Handle a response from a window/showMessageRequest request. Add-ons must include the addon_name as part of the
     # original request so that the response is delegated to the correct add-on and must override this method to handle

data/lib/ruby_lsp/base_server.rb

@@ -6,11 +6,11 @@ module RubyLsp
   class BaseServer
     #: (**untyped options) -> void
     def initialize(**options)
+      @reader = MessageReader.new(options[:reader] || $stdin) #: MessageReader
+      @writer = MessageWriter.new(options[:writer] || $stdout) #: MessageWriter
       @test_mode = options[:test_mode] #: bool?
       @setup_error = options[:setup_error] #: StandardError?
       @install_error = options[:install_error] #: StandardError?
-      @writer = Transport::Stdio::Writer.new #: Transport::Stdio::Writer
-      @reader = Transport::Stdio::Reader.new #: Transport::Stdio::Reader
       @incoming_queue = Thread::Queue.new #: Thread::Queue
       @outgoing_queue = Thread::Queue.new #: Thread::Queue
       @cancelled_requests = [] #: Array[Integer]
@@ -36,7 +36,7 @@ module RubyLsp
 
     #: -> void
     def start
-      @reader.read do |message|
+      @reader.each_message 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
@@ -83,8 +83,7 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
-          "rubyLsp/diagnoseState"
+        when "initialize", "initialized", "rubyLsp/diagnoseState"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do
@@ -94,26 +93,13 @@ module RubyLsp
             @writer.write(Result.new(id: message[:id], response: nil).to_hash)
           end
         when "exit"
-          @global_state.synchronize { exit(@incoming_queue.closed? ? 0 : 1) }
+          exit(@incoming_queue.closed? ? 0 : 1)
         else
           @incoming_queue << message
         end
       end
     end
 
-    #: -> void
-    def run_shutdown
-      @incoming_queue.clear
-      @outgoing_queue.clear
-      @incoming_queue.close
-      @outgoing_queue.close
-      @cancelled_requests.clear
-
-      @worker.terminate
-      @outgoing_dispatcher.terminate
-      @store.clear
-    end
-
     # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
     #: -> untyped
     def pop_response
@@ -128,11 +114,35 @@ module RubyLsp
 
     # @abstract
     #: (Hash[Symbol, untyped] message) -> void
-    def process_message(message); end
+    def process_message(message)
+      raise AbstractMethodInvokedError
+    end
+
+    #: -> bool?
+    def test_mode?
+      @test_mode
+    end
+
+    #: -> void
+    def run_shutdown
+      @incoming_queue.clear
+      @outgoing_queue.clear
+      @incoming_queue.close
+      @outgoing_queue.close
+      @cancelled_requests.clear
+
+      @worker.terminate
+      @outgoing_dispatcher.terminate
+      @store.clear
+    end
+
+    private
 
     # @abstract
     #: -> void
-    def shutdown; end
+    def shutdown
+      raise AbstractMethodInvokedError
+    end
 
     #: (Integer id, String message, ?type: Integer) -> void
     def fail_request_and_notify(id, message, type: Constant::MessageType::INFO)

data/lib/ruby_lsp/document.rb

@@ -5,9 +5,8 @@ module RubyLsp
   # @abstract
   #: [ParseResultType]
   class Document
-    extend T::Generic
-
     class InvalidLocationError < StandardError; end
+
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
     # This is the same number used by the TypeScript extension in VS Code
     MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES = 100_000
@@ -61,7 +60,9 @@ module RubyLsp
 
     # @abstract
     #: -> Symbol
-    def language_id; end
+    def language_id
+      raise AbstractMethodInvokedError
+    end
 
     #: [T] (String request_name) { (Document[ParseResultType] document) -> T } -> T
     def cache_fetch(request_name, &block)
@@ -121,11 +122,15 @@ module RubyLsp
     # Returns `true` if the document was parsed and `false` if nothing needed parsing
     # @abstract
     #: -> bool
-    def parse!; end
+    def parse!
+      raise AbstractMethodInvokedError
+    end
 
     # @abstract
     #: -> bool
-    def syntax_error?; end
+    def syntax_error?
+      raise AbstractMethodInvokedError
+    end
 
     #: -> bool
     def past_expensive_limit?
@@ -134,12 +139,10 @@ module RubyLsp
 
     #: (Hash[Symbol, untyped] start_pos, ?Hash[Symbol, untyped]? end_pos) -> [Integer, Integer?]
     def find_index_by_position(start_pos, end_pos = nil)
-      @global_state.synchronize do
-        scanner = create_scanner
-        start_index = scanner.find_char_position(start_pos)
-        end_index = scanner.find_char_position(end_pos) if end_pos
-        [start_index, end_index]
-      end
+      scanner = create_scanner
+      start_index = scanner.find_char_position(start_pos)
+      end_index = scanner.find_char_position(end_pos) if end_pos
+      [start_index, end_index]
     end
 
     private
@@ -177,8 +180,6 @@ module RubyLsp
     # See https://microsoft.github.io/language-server-protocol/specification/#positionEncodingKind for more information
     # @abstract
     class Scanner
-      extend T::Sig
-
       LINE_BREAK = 0x0A #: Integer
       # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
       SURROGATE_PAIR_START = 0xFFFF #: Integer
@@ -193,7 +194,9 @@ module RubyLsp
       # character index regardless of whether we are searching positions based on bytes, code units, or codepoints.
       # @abstract
       #: (Hash[Symbol, untyped] position) -> Integer
-      def find_char_position(position); end
+      def find_char_position(position)
+        raise AbstractMethodInvokedError
+      end
     end
 
     # For the UTF-8 encoding, positions correspond to bytes

data/lib/ruby_lsp/global_state.rb

@@ -56,6 +56,17 @@ module RubyLsp
       @enabled_feature_flags = {} #: Hash[Symbol, bool]
       @mutex = Mutex.new #: Mutex
       @telemetry_machine_id = nil #: String?
+      @feature_configuration = {
+        inlayHint: RequestConfig.new({
+          enableAll: false,
+          implicitRescue: false,
+          implicitHashValue: false,
+        }),
+        codeLens: RequestConfig.new({
+          enableAll: false,
+          enableTestCodeLens: true,
+        }),
+      } #: Hash[Symbol, RequestConfig]
     end
 
     #: [T] { -> T } -> T
@@ -175,9 +186,19 @@ module RubyLsp
       @enabled_feature_flags = enabled_flags if enabled_flags
 
       @telemetry_machine_id = options.dig(:initializationOptions, :telemetryMachineId)
+
+      options.dig(:initializationOptions, :featuresConfiguration)&.each do |feature_name, config|
+        @feature_configuration[feature_name]&.merge!(config)
+      end
+
       notifications
     end
 
+    #: (Symbol) -> RequestConfig?
+    def feature_configuration(feature_name)
+      @feature_configuration[feature_name]
+    end
+
     #: (Symbol flag) -> bool?
     def enabled_feature?(flag)
       @enabled_feature_flags[:all] || @enabled_feature_flags[flag]

data/lib/ruby_lsp/internal.rb

@@ -6,8 +6,6 @@
 yarp_require_paths = Gem.loaded_specs["yarp"]&.full_require_paths
 $LOAD_PATH.delete_if { |path| yarp_require_paths.include?(path) } if yarp_require_paths
 
-require "sorbet-runtime"
-
 # Set Bundler's UI level to silent as soon as possible to prevent any prints to STDOUT
 require "bundler"
 Bundler.ui.level = :silent

data/lib/ruby_lsp/listeners/completion.rb

@@ -445,11 +445,14 @@ module RubyLsp
         return unless arguments_node
 
         path_node_to_complete = arguments_node.arguments.first
-
         return unless path_node_to_complete.is_a?(Prism::StringNode)
 
-        origin_dir = Pathname.new(@uri.to_standardized_path).dirname
+        # If the file is unsaved (e.g.: untitled:Untitled-1), we can't provide relative completion as we don't know
+        # where the user intends to save it
+        full_path = @uri.to_standardized_path
+        return unless full_path
 
+        origin_dir = Pathname.new(full_path).dirname
         content = path_node_to_complete.content
         # if the path is not a directory, glob all possible next characters
         # for example ../somethi| (where | is the cursor position)

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -8,10 +8,12 @@ module RubyLsp
 
       RESCUE_STRING_LENGTH = "rescue".length #: Integer
 
-      #: (ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint] response_builder, RequestConfig hints_configuration, Prism::Dispatcher dispatcher) -> void
-      def initialize(response_builder, hints_configuration, dispatcher)
+      #: (GlobalState, ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint], Prism::Dispatcher) -> void
+      def initialize(global_state, response_builder, dispatcher)
         @response_builder = response_builder
-        @hints_configuration = hints_configuration
+        @hints_configuration = ( # rubocop:disable Style/RedundantParentheses
+          global_state.feature_configuration(:inlayHint) #: as !nil
+        ) #: RequestConfig
 
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end

data/lib/ruby_lsp/listeners/test_style.rb

@@ -75,8 +75,9 @@ module RubyLsp
 
           unless full_files.empty?
             specs, tests = full_files.partition { |path| spec?(path) }
-            commands << "#{BASE_COMMAND} -Itest -e \"ARGV.each { |f| require f }\" #{tests.join(" ")}" if tests.any?
-            commands << "#{BASE_COMMAND} -Ispec -e \"ARGV.each { |f| require f }\" #{specs.join(" ")}" if specs.any?
+
+            commands << "#{COMMAND} -Itest -e \"ARGV.each { |f| require f }\" #{tests.join(" ")}" if tests.any?
+            commands << "#{COMMAND} -Ispec -e \"ARGV.each { |f| require f }\" #{specs.join(" ")}" if specs.any?
           end
 
           commands
@@ -113,7 +114,7 @@ module RubyLsp
           end
 
           load_path = spec?(file_path) ? "-Ispec" : "-Itest"
-          "#{BASE_COMMAND} #{load_path} #{file_path} --name \"/#{regex}/\""
+          "#{COMMAND} #{load_path} #{file_path} --name \"/#{regex}/\""
         end
 
         #: (String, Hash[String, Hash[Symbol, untyped]]) -> Array[String]
@@ -124,7 +125,7 @@ module RubyLsp
               Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
               ".*",
             )
-            command = +"#{BASE_COMMAND} -Itest #{file_path} --testcase \"/^#{group_regex}\\$/\""
+            command = +"#{COMMAND} -Itest #{file_path} --testcase \"/^#{group_regex}\\$/\""
 
             unless examples.empty?
               command << if examples.length == 1
@@ -143,13 +144,14 @@ module RubyLsp
 
       MINITEST_REPORTER_PATH = File.expand_path("../test_reporters/minitest_reporter.rb", __dir__) #: String
       TEST_UNIT_REPORTER_PATH = File.expand_path("../test_reporters/test_unit_reporter.rb", __dir__) #: String
-      ACCESS_MODIFIERS = [:public, :private, :protected].freeze
       BASE_COMMAND = begin
         Bundler.with_original_env { Bundler.default_lockfile }
         "bundle exec ruby"
       rescue Bundler::GemfileNotFound
         "ruby"
       end #: String
+      COMMAND = "#{BASE_COMMAND} -r#{MINITEST_REPORTER_PATH} -r#{TEST_UNIT_REPORTER_PATH}" #: String
+      ACCESS_MODIFIERS = [:public, :private, :protected].freeze
 
       #: (ResponseBuilders::TestCollection, GlobalState, Prism::Dispatcher, URI::Generic) -> void
       def initialize(response_builder, global_state, dispatcher, uri)

data/lib/ruby_lsp/requests/code_lens.rb

@@ -27,10 +27,16 @@ module RubyLsp
         @document = document
         @test_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
         uri = document.uri
+        file_path = uri.full_path
+        code_lens_config = global_state.feature_configuration(:codeLens)
+        test_lenses_enabled = (!code_lens_config || code_lens_config.enabled?(:enableTestCodeLens)) &&
+          file_path && File.fnmatch?(TEST_PATH_PATTERN, file_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
 
         if global_state.enabled_feature?(:fullTestDiscovery)
-          Listeners::TestStyle.new(@test_builder, global_state, dispatcher, uri)
-          Listeners::SpecStyle.new(@test_builder, global_state, dispatcher, uri)
+          if test_lenses_enabled
+            Listeners::TestStyle.new(@test_builder, global_state, dispatcher, uri)
+            Listeners::SpecStyle.new(@test_builder, global_state, dispatcher, uri)
+          end
         else
           Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
         end
@@ -38,7 +44,7 @@ module RubyLsp
         Addon.addons.each do |addon|
           addon.create_code_lens_listener(@response_builder, uri, dispatcher)
 
-          if global_state.enabled_feature?(:fullTestDiscovery)
+          if global_state.enabled_feature?(:fullTestDiscovery) && test_lenses_enabled
             addon.create_discover_tests_listener(@test_builder, dispatcher, uri)
           end
         end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -16,13 +16,13 @@ module RubyLsp
         end
       end
 
-      #: ((RubyDocument | ERBDocument) document, RequestConfig hints_configuration, Prism::Dispatcher dispatcher) -> void
-      def initialize(document, hints_configuration, dispatcher)
+      #: (GlobalState, (RubyDocument | ERBDocument), Prism::Dispatcher) -> void
+      def initialize(global_state, document, dispatcher)
         super()
 
         @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint]
-        Listeners::InlayHints.new(@response_builder, hints_configuration, dispatcher)
+        Listeners::InlayHints.new(global_state, @response_builder, dispatcher)
       end
 
       # @override