ruby-lsp 0.24.1 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 981f87e306aa96edd6d2e04fc274d5da24ede96d3e3333bcfdeb63039e86c9ab
-  data.tar.gz: 5405216e985bed5ec6bce692baeeca9611980edc53fadf4655d00503488c277d
+  metadata.gz: 7637d6f68616069c2f8c0d870f3daf31808a1cccd8ab32d2bdaf1f67274f9b59
+  data.tar.gz: 7ea1d75ad921adbf01f69a0f5d2fba905673311c13b0999d44c08bdf54737053
 SHA512:
-  metadata.gz: a749ebc7c81100f0c76431d68865960ad8aeb04ed3aad37dad18c008e885a50d224157a2fdcd44b15abc2d5d5f8d7a4a2345f187662707478dbc66d191c214a2
-  data.tar.gz: 19a288a8121a4cf86b5fd60b9c6d11c4fd3cb26330f7667ac59b4742dbe91328b9f742dca5fb371bb58ad565afb9ec58516eb6b68dd85e641a800f89a23f81e9
+  metadata.gz: a354535a3853b0826635408fc46dc85cb7cee97c4993012dd983af11b8917121962d97bddf0853406b54f619faa8c2383cccca9638b4a0624309fb1e4c838249
+  data.tar.gz: 9e49e2436c63d90fc373b52ac9f6b65e83964fe108abd0a18fd46b655cd99bd55c471dd198624bb8701890f62175af2c9fcb50fcfa2bbf69e706406b9fa1e472

data/VERSION

@@ -1 +1 @@
-0.24.1
+0.25.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/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

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

@@ -266,7 +266,7 @@ module RubyIndexer
     def constant_completion_candidates(name, nesting)
       # If we have a top level reference, then we don't need to include completions inside the current nesting
       if name.start_with?("::")
-        return @entries_tree.search(name.delete_prefix("::")) #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]] # rubocop:disable Layout/LineLength
+        return @entries_tree.search(name.delete_prefix("::")) #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
       end
 
       # Otherwise, we have to include every possible constant the user might be referring to. This is essentially the
@@ -292,7 +292,7 @@ module RubyIndexer
       # Top level constants
       entries.concat(@entries_tree.search(name))
       entries.uniq!
-      entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]] # rubocop:disable Layout/LineLength
+      entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
     end
 
     # Resolve a constant to its declaration based on its name and the nesting where the reference was found. Parameter

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
 

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -232,8 +232,8 @@ module RubyIndexer
       signatures = entry.signatures
       assert_equal(2, signatures.length)
 
-      # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ] # rubocop:disable Layout/LineLength
-      #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]? # rubocop:disable Layout/LineLength
+      # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ]
+      #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]?
 
       parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:read_array, :write_array, :error_array], parameters.map(&:name))

data/lib/ruby_lsp/addon.rb

@@ -56,7 +56,13 @@ module RubyLsp
         addon_files = Gem.find_files("ruby_lsp/**/addon.rb")
 
         if include_project_addons
-          addon_files.concat(Dir.glob(File.join(global_state.workspace_path, "**", "ruby_lsp/**/addon.rb")))
+          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) }
+          addon_files.concat(project_addons)
         end
 
         errors = addon_files.filter_map do |addon_path|
@@ -176,24 +182,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
@@ -128,11 +128,15 @@ module RubyLsp
 
     # @abstract
     #: (Hash[Symbol, untyped] message) -> void
-    def process_message(message); end
+    def process_message(message)
+      raise AbstractMethodInvokedError
+    end
 
     # @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,7 +5,7 @@ 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
@@ -60,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)
@@ -120,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?
@@ -145,7 +151,14 @@ module RubyLsp
 
     #: -> Scanner
     def create_scanner
-      Scanner.new(@source, @encoding)
+      case @encoding
+      when Encoding::UTF_8
+        Utf8Scanner.new(@source)
+      when Encoding::UTF_16LE
+        Utf16Scanner.new(@source)
+      else
+        Utf32Scanner.new(@source)
+      end
     end
 
     # @abstract
@@ -163,81 +176,169 @@ module RubyLsp
     class Replace < Edit; end
     class Delete < Edit; end
 
+    # Parent class for all position scanners. Scanners are used to translate a position given by the editor into a
+    # string index that we can use to find the right place in the document source. The logic for finding the correct
+    # index depends on the encoding negotiated with the editor, so we have different subclasses for each encoding.
+    # 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
 
-      #: (String source, Encoding encoding) -> void
-      def initialize(source, encoding)
+      #: -> void
+      def initialize
         @current_line = 0 #: Integer
         @pos = 0 #: Integer
-        @bytes_or_codepoints = encoding == Encoding::UTF_8 ? source.bytes : source.codepoints #: Array[Integer]
-        @encoding = encoding
       end
 
-      # Finds the character index inside the source string for a given line and column
+      # Finds the character index inside the source string for a given line and column. This method always returns the
+      # 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)
-        # Find the character index for the beginning of the requested line
+        raise AbstractMethodInvokedError
+      end
+    end
+
+    # For the UTF-8 encoding, positions correspond to bytes
+    class Utf8Scanner < Scanner
+      #: (String source) -> void
+      def initialize(source)
+        super()
+        @bytes = source.bytes #: Array[Integer]
+        @character_length = 0 #: Integer
+      end
+
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Each group of bytes is a character. We advance based on the number of bytes to count how many full characters
+        # we have in the requested offset
         until @current_line == position[:line]
-          @pos += 1 until LINE_BREAK == @bytes_or_codepoints[@pos]
+          byte = @bytes[@pos] #: Integer?
+          raise InvalidLocationError unless byte
+
+          until LINE_BREAK == byte
+            @pos += character_byte_length(byte)
+            @character_length += 1
+            byte = @bytes[@pos]
+            raise InvalidLocationError unless byte
+          end
+
           @pos += 1
+          @character_length += 1
           @current_line += 1
         end
 
-        # For UTF-8, the code unit length is the same as bytes, but we want to return the character index
-        requested_position = if @encoding == Encoding::UTF_8
-          character_offset = 0
-          i = @pos
-
-          # Each group of bytes is a character. We advance based on the number of bytes to count how many full
-          # characters we have in the requested offset
-          while i < @pos + position[:character] && i < @bytes_or_codepoints.length
-            byte = @bytes_or_codepoints[i] #: as !nil
-            i += if byte < 0x80 # 1-byte character
-              1
-            elsif byte < 0xE0 # 2-byte character
-              2
-            elsif byte < 0xF0 # 3-byte character
-              3
-            else # 4-byte character
-              4
-            end
-
-            character_offset += 1
+        # @character_length has the number of characters until the beginning of the line. We don't accumulate on it for
+        # the character part because locating the same position twice must return the same value
+        line_byte_offset = 0
+        line_characters = 0
+
+        while line_byte_offset < position[:character]
+          byte = @bytes[@pos + line_byte_offset] #: Integer?
+          raise InvalidLocationError unless byte
+
+          line_byte_offset += character_byte_length(byte)
+          line_characters += 1
+        end
+
+        @character_length + line_characters
+      end
+
+      private
+
+      #: (Integer) -> Integer
+      def character_byte_length(byte)
+        if byte < 0x80 # 1-byte character
+          1
+        elsif byte < 0xE0 # 2-byte character
+          2
+        elsif byte < 0xF0 # 3-byte character
+          3
+        else # 4-byte character
+          4
+        end
+      end
+    end
+
+    # For the UTF-16 encoding, positions correspond to UTF-16 code units, which count characters beyond the surrogate
+    # pair as length 2
+    class Utf16Scanner < Scanner
+      #: (String) -> void
+      def initialize(source)
+        super()
+        @codepoints = source.codepoints #: Array[Integer]
+      end
+
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Find the character index for the beginning of the requested line
+        until @current_line == position[:line]
+          codepoint = @codepoints[@pos] #: Integer?
+          raise InvalidLocationError unless codepoint
+
+          until LINE_BREAK == @codepoints[@pos]
+            @pos += 1
+            codepoint = @codepoints[@pos] #: Integer?
+            raise InvalidLocationError unless codepoint
           end
 
-          @pos + character_offset
-        else
-          @pos + position[:character]
+          @pos += 1
+          @current_line += 1
         end
 
         # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
         # need to adjust for surrogate pairs
-        if @encoding == Encoding::UTF_16LE
-          requested_position -= utf_16_character_position_correction(@pos, requested_position)
+        line_characters = 0
+        line_code_units = 0
+
+        while line_code_units < position[:character]
+          code_point = @codepoints[@pos + line_characters]
+          raise InvalidLocationError unless code_point
+
+          line_code_units += if code_point > SURROGATE_PAIR_START
+            2 # Surrogate pair, so we skip the next code unit
+          else
+            1 # Single code unit character
+          end
+
+          line_characters += 1
         end
 
-        requested_position
+        @pos + line_characters
+      end
+    end
+
+    # For the UTF-32 encoding, positions correspond directly to codepoints
+    class Utf32Scanner < Scanner
+      #: (String) -> void
+      def initialize(source)
+        super()
+        @codepoints = source.codepoints #: Array[Integer]
       end
 
-      # Subtract 1 for each character after 0xFFFF in the current line from the column position, so that we hit the
-      # right character in the UTF-8 representation
-      #: (Integer current_position, Integer requested_position) -> Integer
-      def utf_16_character_position_correction(current_position, requested_position)
-        utf16_unicode_correction = 0
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Find the character index for the beginning of the requested line
+        until @current_line == position[:line]
+          codepoint = @codepoints[@pos] #: Integer?
+          raise InvalidLocationError unless codepoint
 
-        until current_position == requested_position
-          codepoint = @bytes_or_codepoints[current_position]
-          utf16_unicode_correction += 1 if codepoint && codepoint > SURROGATE_PAIR_START
+          until LINE_BREAK == @codepoints[@pos]
+            @pos += 1
+            codepoint = @codepoints[@pos] #: Integer?
+            raise InvalidLocationError unless codepoint
+          end
 
-          current_position += 1
+          @pos += 1
+          @current_line += 1
         end
 
-        utf16_unicode_correction
+        @pos + position[:character]
       end
     end
   end

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/hover.rb

@@ -7,6 +7,7 @@ module RubyLsp
       include Requests::Support::Common
 
       ALLOWED_TARGETS = [
+        Prism::BreakNode,
         Prism::CallNode,
         Prism::ConstantReadNode,
         Prism::ConstantWriteNode,
@@ -54,6 +55,7 @@ module RubyLsp
 
         dispatcher.register(
           self,
+          :on_break_node_enter,
           :on_constant_read_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_node_enter,
@@ -84,6 +86,11 @@ module RubyLsp
         )
       end
 
+      #: (Prism::BreakNode node) -> void
+      def on_break_node_enter(node)
+        handle_keyword_documentation(node.keyword)
+      end
+
       #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         if @path && File.basename(@path) == GEMFILE_NAME

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