ruby-lsp 0.23.15 → 0.26.9

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -13,14 +13,9 @@ module RubyLsp
       NEW_METHOD_NAME = "new_method"
 
       class CodeActionError < StandardError; end
-
-      class Error < ::T::Enum
-        enums do
-          EmptySelection = new
-          InvalidTargetRange = new
-          UnknownCodeAction = new
-        end
-      end
+      class EmptySelectionError < CodeActionError; end
+      class InvalidTargetRangeError < CodeActionError; end
+      class UnknownCodeActionError < CodeActionError; end
 
       #: (RubyDocument document, GlobalState global_state, Hash[Symbol, untyped] code_action) -> void
       def initialize(document, global_state, code_action)
@@ -31,9 +26,9 @@ module RubyLsp
       end
 
       # @override
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def perform
-        return Error::EmptySelection if @document.source.empty?
+        raise EmptySelectionError, "Invalid selection for refactor" if @document.source.empty?
 
         case @code_action[:title]
         when CodeActions::EXTRACT_TO_VARIABLE_TITLE
@@ -47,26 +42,52 @@ module RubyLsp
              CodeActions::CREATE_ATTRIBUTE_ACCESSOR
           create_attribute_accessor
         else
-          Error::UnknownCodeAction
+          raise UnknownCodeActionError, "Unknown code action: #{@code_action[:title]}"
         end
       end
 
       private
 
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def switch_block_style
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        if source_range[:start] == source_range[:end]
+          block_context = @document.locate_node(
+            source_range[:start],
+            node_types: [Prism::BlockNode],
+          )
+          node = block_context.node
+          unless node.is_a?(Prism::BlockNode)
+            raise InvalidTargetRangeError, "Cursor is not inside a block"
+          end
 
-        target = @document.locate_first_within_range(
-          @code_action.dig(:data, :range),
-          node_types: [Prism::CallNode],
-        )
+          # Find the call node at the block node's start position.
+          # This should be the call node whose block the cursor is inside of.
+          call_context = RubyDocument.locate(
+            @document.ast,
+            node.location.cached_start_code_units_offset(@document.code_units_cache),
+            node_types: [Prism::CallNode],
+            code_units_cache: @document.code_units_cache,
+          )
+          target = call_context.node
+          unless target.is_a?(Prism::CallNode) && target.block == node
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
+        else
+          target = @document.locate_first_within_range(
+            @code_action.dig(:data, :range),
+            node_types: [Prism::CallNode],
+          )
 
-        return Error::InvalidTargetRange unless target.is_a?(Prism::CallNode)
+          unless target.is_a?(Prism::CallNode)
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
-        node = target.block
-        return Error::InvalidTargetRange unless node.is_a?(Prism::BlockNode)
+          node = target.block
+          unless node.is_a?(Prism::BlockNode)
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
+        end
 
         indentation = " " * target.location.start_column unless node.opening_loc.slice == "do"
 
@@ -91,17 +112,17 @@ module RubyLsp
         )
       end
 
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def refactor_variable
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        raise EmptySelectionError, "Invalid selection for refactor" if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
         extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = RubyDocument
-          .locate(@document.parse_result.value,
+          .locate(@document.ast,
             start_index,
             node_types: [
               Prism::StatementsNode,
@@ -111,16 +132,20 @@ module RubyLsp
 
         closest_statements = node_context.node
         parent_statements = node_context.parent
-        return Error::InvalidTargetRange if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
+        if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         # Find the node with the end line closest to the requested position, so that we can place the refactor
         # immediately after that closest node
-        closest_node = T.must(closest_statements.child_nodes.compact.min_by do |node|
+        closest_node = closest_statements.child_nodes.compact.min_by do |node|
           distance = source_range.dig(:start, :line) - (node.location.end_line - 1)
           distance <= 0 ? Float::INFINITY : distance
-        end)
+        end #: as !nil
 
-        return Error::InvalidTargetRange if closest_node.is_a?(Prism::MissingNode)
+        if closest_node.is_a?(Prism::MissingNode)
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         closest_node_loc = closest_node.location
         # If the parent expression is a single line block, then we have to extract it inside of the one-line block
@@ -151,7 +176,9 @@ module RubyLsp
           lines = @document.source.lines
 
           indentation_line = lines[indentation_line_number]
-          return Error::InvalidTargetRange unless indentation_line
+          unless indentation_line
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
           indentation = indentation_line[/\A */] #: as !nil
             .size
@@ -162,7 +189,9 @@ module RubyLsp
           }
 
           line = lines[target_line]
-          return Error::InvalidTargetRange unless line
+          unless line
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
           variable_source = if line.strip.empty?
             "\n#{" " * indentation}#{NEW_VARIABLE_NAME} = #{extracted_source}"
@@ -190,27 +219,31 @@ module RubyLsp
         )
       end
 
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def refactor_method
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        raise EmptySelectionError, "Invalid selection for refactor" if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
         extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
         node_context = RubyDocument.locate(
-          @document.parse_result.value,
+          @document.ast,
           start_index,
           node_types: [Prism::DefNode],
           code_units_cache: @document.code_units_cache,
         )
         closest_node = node_context.node
-        return Error::InvalidTargetRange unless closest_node
+        unless closest_node
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         target_range = if closest_node.is_a?(Prism::DefNode)
           end_keyword_loc = closest_node.end_keyword_loc
-          return Error::InvalidTargetRange unless end_keyword_loc
+          unless end_keyword_loc
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
           end_line = end_keyword_loc.end_line - 1
           character = end_keyword_loc.end_column
@@ -331,7 +364,7 @@ module RubyLsp
         indentation ? body_content.gsub(";", "\n") : "#{body_content.gsub("\n", ";")} "
       end
 
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def create_attribute_accessor
         source_range = @code_action.dig(:data, :range)
 
@@ -349,20 +382,12 @@ module RubyLsp
           )
           node = node_context.node
 
-          return Error::EmptySelection unless CodeActions::INSTANCE_VARIABLE_NODES.include?(node.class)
+          unless CodeActions::INSTANCE_VARIABLE_NODES.include?(node.class)
+            raise EmptySelectionError, "Invalid selection for refactor"
+          end
         end
 
-        node = T.cast(
-          node,
-          T.any(
-            Prism::InstanceVariableAndWriteNode,
-            Prism::InstanceVariableOperatorWriteNode,
-            Prism::InstanceVariableOrWriteNode,
-            Prism::InstanceVariableReadNode,
-            Prism::InstanceVariableTargetNode,
-            Prism::InstanceVariableWriteNode,
-          ),
-        )
+        node = node #: as Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode
 
         node_context = @document.locate_node(
           {
@@ -376,20 +401,20 @@ module RubyLsp
           ],
         )
         closest_node = node_context.node
-        return Error::InvalidTargetRange if closest_node.nil?
+        if closest_node.nil?
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         attribute_name = node.name[1..]
         indentation = " " * (closest_node.location.start_column + 2)
-        attribute_accessor_source = T.must(
-          case @code_action[:title]
-          when CodeActions::CREATE_ATTRIBUTE_READER
-            "#{indentation}attr_reader :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_WRITER
-            "#{indentation}attr_writer :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
-            "#{indentation}attr_accessor :#{attribute_name}\n\n"
-          end,
-        )
+        attribute_accessor_source = case @code_action[:title]
+        when CodeActions::CREATE_ATTRIBUTE_READER
+          "#{indentation}attr_reader :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_WRITER
+          "#{indentation}attr_writer :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
+          "#{indentation}attr_accessor :#{attribute_name}\n\n"
+        end #: as !nil
 
         target_start_line = closest_node.location.start_line
         target_range = {

data/lib/ruby_lsp/requests/code_actions.rb

@@ -63,12 +63,8 @@ module RubyLsp
             kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
             data: { range: @range, uri: @uri.to_s },
           )
-          code_actions << Interface::CodeAction.new(
-            title: TOGGLE_BLOCK_STYLE_TITLE,
-            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
-            data: { range: @range, uri: @uri.to_s },
-          )
         end
+        code_actions.concat(toggle_block_style_action)
         code_actions.concat(attribute_actions)
 
         code_actions
@@ -113,6 +109,25 @@ module RubyLsp
           ),
         ]
       end
+
+      #: -> Array[Interface::CodeAction]
+      def toggle_block_style_action
+        if @range[:start] == @range[:end]
+          block_context = @document.locate_node(
+            @range[:start],
+            node_types: [Prism::BlockNode],
+          )
+          return [] unless block_context.node.is_a?(Prism::BlockNode)
+        end
+
+        [
+          Interface::CodeAction.new(
+            title: TOGGLE_BLOCK_STYLE_TITLE,
+            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+        ]
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -14,26 +14,47 @@ module RubyLsp
       class << self
         #: -> Interface::CodeLensOptions
         def provider
-          Interface::CodeLensOptions.new(resolve_provider: false)
+          Interface::CodeLensOptions.new(resolve_provider: true)
         end
       end
 
-      #: (GlobalState global_state, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
-      def initialize(global_state, uri, dispatcher)
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens]
+      #: (GlobalState, RubyDocument | ERBDocument, Prism::Dispatcher) -> void
+      def initialize(global_state, document, dispatcher)
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens]
         super()
-        Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
+
+        @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)
+          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
 
         Addon.addons.each do |addon|
           addon.create_code_lens_listener(@response_builder, uri, dispatcher)
+
+          if global_state.enabled_feature?(:fullTestDiscovery) && test_lenses_enabled
+            addon.create_discover_tests_listener(@test_builder, dispatcher, uri)
+          end
         end
       end
 
       # @override
       #: -> Array[Interface::CodeLens]
       def perform
-        @response_builder.response
+        @document.cache_set("rubyLsp/discoverTests", @test_builder.response)
+        @response_builder.response + @test_builder.code_lens
       end
     end
   end

data/lib/ruby_lsp/requests/completion.rb

@@ -21,7 +21,7 @@ module RubyLsp
         end
       end
 
-      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] params, RubyDocument::SorbetLevel sorbet_level, Prism::Dispatcher dispatcher) -> void
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] params, SorbetLevel sorbet_level, Prism::Dispatcher dispatcher) -> void
       def initialize(document, global_state, params, sorbet_level, dispatcher)
         super()
         @target = nil #: Prism::Node?
@@ -33,7 +33,7 @@ module RubyLsp
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
-          document.parse_result.value,
+          document.ast,
           char_position,
           node_types: [
             Prism::CallNode,
@@ -60,7 +60,7 @@ module RubyLsp
           ],
           code_units_cache: document.code_units_cache,
         )
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem]
 
         Listeners::Completion.new(

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -68,10 +68,12 @@ module RubyLsp
           "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
         end
 
-        @item[:documentation] = Interface::MarkupContent.new(
-          kind: "markdown",
-          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
-        )
+        unless @item[:kind] == Constant::CompletionItemKind::FILE
+          @item[:documentation] = Interface::MarkupContent.new(
+            kind: "markdown",
+            value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
+          )
+        end
 
         @item
       end
@@ -84,7 +86,7 @@ module RubyLsp
         content = KEYWORD_DOCS[keyword]
 
         if content
-          doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+          doc_uri = URI::Generic.from_path(path: File.join(STATIC_DOCS_PATH, "#{keyword}.md"))
 
           @item[:documentation] = Interface::MarkupContent.new(
             kind: "markdown",
@@ -93,7 +95,7 @@ module RubyLsp
               #{keyword}
               ```
 
-              [Read more](#{doc_path})
+              [Read more](#{doc_uri})
 
               #{content}
             MARKDOWN

data/lib/ruby_lsp/requests/definition.rb

@@ -9,21 +9,18 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_definition) jumps to the
     # definition of the symbol under the cursor.
     class Definition < Request
-      extend T::Generic
-
-      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[
-          T.any(Interface::Location, Interface::LocationLink)
-        ].new #: ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)]
         @dispatcher = dispatcher
 
         char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
-          document.parse_result.value,
+          document.ast,
           char_position,
           node_types: [
             Prism::CallNode,

data/lib/ruby_lsp/requests/discover_tests.rb

@@ -43,7 +43,7 @@ module RubyLsp
             addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
           end
 
-          @dispatcher.visit(@document.parse_result.value)
+          @dispatcher.visit(@document.ast)
         else
           @global_state.synchronize do
             RubyIndexer::DeclarationListener.new(
@@ -64,7 +64,7 @@ module RubyLsp
             # Dispatch the events both for indexing the test file and discovering the tests. The order here is
             # important because we need the index to be aware of the existing classes/modules/methods before the test
             # listeners can do their work
-            @dispatcher.visit(@document.parse_result.value)
+            @dispatcher.visit(@document.ast)
           end
         end
 

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -20,12 +20,12 @@ module RubyLsp
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
-          document.parse_result.value,
+          document.ast,
           char_position,
           code_units_cache: document.code_units_cache,
         )
 
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight]
         Listeners::DocumentHighlight.new(
           @response_builder,

data/lib/ruby_lsp/requests/document_link.rb

@@ -19,7 +19,7 @@ module RubyLsp
       #: (URI::Generic uri, Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(uri, comments, dispatcher)
         super()
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink]
         Listeners::DocumentLink.new(@response_builder, uri, comments, dispatcher)
       end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -18,7 +18,7 @@ module RubyLsp
       #: (Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(comments, dispatcher)
         super()
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange]
         @listener = Listeners::FoldingRanges.new(@response_builder, comments, dispatcher) #: Listeners::FoldingRanges
       end

data/lib/ruby_lsp/requests/go_to_relevant_file.rb

@@ -8,8 +8,6 @@ module RubyLsp
     # that navigates to the relevant file for the current document.
     # Currently, it supports source code file <> test file navigation.
     class GoToRelevantFile < Request
-      extend T::Sig
-
       TEST_KEYWORDS = ["test", "spec", "integration_test"]
 
       TEST_PREFIX_PATTERN = /^(#{TEST_KEYWORDS.join("_|")}_)/
@@ -37,24 +35,78 @@ module RubyLsp
 
       #: -> Array[String]
       def find_relevant_paths
-        candidate_paths = Dir.glob(File.join("**", relevant_filename_pattern))
+        patterns = relevant_filename_patterns
+
+        candidate_paths = patterns.flat_map do |pattern|
+          Dir.glob(File.join(search_root, "**", pattern))
+        end
+
         return [] if candidate_paths.empty?
 
-        find_most_similar_with_jaccard(candidate_paths).map { File.join(@workspace_path, _1) }
+        find_most_similar_with_jaccard(candidate_paths).map { |path| File.expand_path(path, @workspace_path) }
       end
 
+      # Determine the search roots based on the closest test directories.
+      # This scopes the search to reduce the number of files that need to be checked.
       #: -> String
-      def relevant_filename_pattern
-        input_basename = File.basename(@path, File.extname(@path))
+      def search_root
+        current_path = File.join(".", @path)
+        current_dir = File.dirname(current_path)
+        while current_dir != "."
+          dir_basename = File.basename(current_dir)
+
+          # If current directory is a test directory, return its parent as search root
+          if TEST_KEYWORDS.include?(dir_basename)
+            return File.dirname(current_dir)
+          end
 
-        relevant_basename_pattern =
-          if input_basename.match?(TEST_PATTERN)
-            input_basename.gsub(TEST_PATTERN, "")
-          else
-            "{{#{TEST_PREFIX_GLOB}}#{input_basename},#{input_basename}{#{TEST_SUFFIX_GLOB}}}"
+          # Search the test directories by walking up the directory tree
+          begin
+            contains_test_dir = Dir
+              .entries(current_dir)
+              .filter { |entry| TEST_KEYWORDS.include?(entry) }
+              .any? { |entry| File.directory?(File.join(current_dir, entry)) }
+
+            return current_dir if contains_test_dir
+          rescue Errno::EACCES, Errno::ENOENT
+            # Skip directories we can't read
           end
 
-        "#{relevant_basename_pattern}#{File.extname(@path)}"
+          # Move up one level
+          parent_dir = File.dirname(current_dir)
+          current_dir = parent_dir
+        end
+
+        "."
+      end
+
+      #: -> Array[String]
+      def relevant_filename_patterns
+        extension = File.extname(@path)
+        input_basename = File.basename(@path, extension)
+
+        if input_basename.match?(TEST_PATTERN)
+          # Test file -> find implementation
+          base = input_basename.gsub(TEST_PATTERN, "")
+          parent_dir = File.basename(File.dirname(@path))
+
+          # If test file is in a directory matching the implementation name
+          # (e.g., go_to_relevant_file/test_go_to_relevant_file_a.rb)
+          # return patterns for both the base file name and the parent directory name
+          if base.include?(parent_dir) && base != parent_dir
+            ["#{base}#{extension}", "#{parent_dir}#{extension}"]
+          else
+            ["#{base}#{extension}"]
+          end
+        else
+          # Implementation file -> find tests (including in matching directory)
+          [
+            "{#{TEST_PREFIX_GLOB}}#{input_basename}#{extension}",
+            "#{input_basename}{#{TEST_SUFFIX_GLOB}}#{extension}",
+            "#{input_basename}/{#{TEST_PREFIX_GLOB}}*#{extension}",
+            "#{input_basename}/*{#{TEST_SUFFIX_GLOB}}#{extension}",
+          ]
+        end
       end
 
       # Using the Jaccard algorithm to determine the similarity between the

data/lib/ruby_lsp/requests/hover.rb

@@ -7,9 +7,8 @@ module RubyLsp
   module Requests
     # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
     # displays the documentation for the symbol currently under the cursor.
+    #: [ResponseType = Interface::Hover?]
     class Hover < Request
-      extend T::Generic
-
       class << self
         #: -> Interface::HoverOptions
         def provider
@@ -17,9 +16,7 @@ module RubyLsp
         end
       end
 
-      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
-
-      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
 
@@ -27,7 +24,7 @@ module RubyLsp
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
-          document.parse_result.value,
+          document.ast,
           char_position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
           code_units_cache: document.code_units_cache,

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[Interface::InlayHint]
+        @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

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -162,7 +162,7 @@ module RubyLsp
 
       #: (Integer line, Integer character) -> void
       def move_cursor_to(line, character)
-        return unless /Visual Studio Code|Cursor|VSCodium/.match?(@client_name)
+        return unless /Visual Studio Code|Cursor|VSCodium|Windsurf/.match?(@client_name)
 
         position = Interface::Position.new(
           line: line,