ruby-lsp 0.23.11 → 0.23.13

data/lib/ruby_lsp/requests/completion.rb

@@ -8,12 +8,8 @@ module RubyLsp
     # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
     # suggests possible completions according to what the developer is typing.
     class Completion < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::CompletionOptions) }
+        #: -> Interface::CompletionOptions
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
@@ -25,18 +21,10 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          global_state: GlobalState,
-          params: T::Hash[Symbol, T.untyped],
-          sorbet_level: RubyDocument::SorbetLevel,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] params, RubyDocument::SorbetLevel sorbet_level, Prism::Dispatcher dispatcher) -> void
       def initialize(document, global_state, params, sorbet_level, dispatcher)
         super()
-        @target = T.let(nil, T.nilable(Prism::Node))
+        @target = nil #: Prism::Node?
         @dispatcher = dispatcher
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
@@ -72,10 +60,8 @@ module RubyLsp
           ],
           code_units_cache: document.code_units_cache,
         )
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem]
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem]
 
         Listeners::Completion.new(
           @response_builder,
@@ -102,7 +88,8 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(T::Array[Interface::CompletionItem]) }
+      # @override
+      #: -> Array[Interface::CompletionItem]
       def perform
         return [] unless @target
 

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -14,21 +14,21 @@ module RubyLsp
     # At most 10 definitions are included, to ensure low latency during request processing and rendering the completion
     # item.
     class CompletionResolve < Request
-      extend T::Sig
       include Requests::Support::Common
 
       # set a limit on the number of documentation entries returned, to avoid rendering performance issues
       # https://github.com/Shopify/ruby-lsp/pull/1798
       MAX_DOCUMENTATION_ENTRIES = 10
 
-      sig { params(global_state: GlobalState, item: T::Hash[Symbol, T.untyped]).void }
+      #: (GlobalState global_state, Hash[Symbol, untyped] item) -> void
       def initialize(global_state, item)
         super()
-        @index = T.let(global_state.index, RubyIndexer::Index)
+        @index = global_state.index #: RubyIndexer::Index
         @item = item
       end
 
-      sig { override.returns(T::Hash[Symbol, T.untyped]) }
+      # @override
+      #: -> Hash[Symbol, untyped]
       def perform
         return @item if @item.dig(:data, :skip_resolve)
 
@@ -78,7 +78,7 @@ module RubyLsp
 
       private
 
-      sig { params(item: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      #: (Hash[Symbol, untyped] item) -> Hash[Symbol, untyped]
       def keyword_resolve(item)
         keyword = item[:label]
         content = KEYWORD_DOCS[keyword]

data/lib/ruby_lsp/requests/definition.rb

@@ -9,24 +9,14 @@ 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::Sig
       extend T::Generic
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          global_state: GlobalState,
-          position: T::Hash[Symbol, T.untyped],
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[T.any(Interface::Location, Interface::LocationLink)].new,
-          ResponseBuilders::CollectionResponseBuilder[T.any(Interface::Location, Interface::LocationLink)],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder[
+          T.any(Interface::Location, Interface::LocationLink)
+        ].new #: ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)]
         @dispatcher = dispatcher
 
         char_position, _ = document.find_index_by_position(position)
@@ -100,10 +90,11 @@ module RubyLsp
           end
         end
 
-        @target = T.let(target, T.nilable(Prism::Node))
+        @target = target #: Prism::Node?
       end
 
-      sig { override.returns(T::Array[T.any(Interface::Location, Interface::LocationLink)]) }
+      # @override
+      #: -> Array[(Interface::Location | Interface::LocationLink)]
       def perform
         @dispatcher.dispatch_once(@target) if @target
         @response_builder.response
@@ -111,7 +102,7 @@ module RubyLsp
 
       private
 
-      sig { params(position: T::Hash[Symbol, T.untyped], target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Hash[Symbol, untyped] position, Prism::Node? target) -> bool
       def position_outside_target?(position, target)
         case target
         when Prism::GlobalVariableAndWriteNode,

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -7,12 +7,8 @@ module RubyLsp
     # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
     # request informs the editor of RuboCop offenses for a given file.
     class Diagnostics < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DiagnosticRegistrationOptions) }
+        #: -> Interface::DiagnosticRegistrationOptions
         def provider
           Interface::DiagnosticRegistrationOptions.new(
             document_selector: nil,
@@ -22,15 +18,16 @@ module RubyLsp
         end
       end
 
-      sig { params(global_state: GlobalState, document: RubyDocument).void }
+      #: (GlobalState global_state, RubyDocument document) -> void
       def initialize(global_state, document)
         super()
-        @active_linters = T.let(global_state.active_linters, T::Array[Support::Formatter])
+        @active_linters = global_state.active_linters #: Array[Support::Formatter]
         @document = document
-        @uri = T.let(document.uri, URI::Generic)
+        @uri = document.uri #: URI::Generic
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Interface::Diagnostic], Object))) }
+      # @override
+      #: -> (Array[Interface::Diagnostic] & Object)?
       def perform
         diagnostics = []
         diagnostics.concat(syntax_error_diagnostics, syntax_warning_diagnostics)
@@ -50,7 +47,7 @@ module RubyLsp
 
       private
 
-      sig { returns(T::Array[Interface::Diagnostic]) }
+      #: -> Array[Interface::Diagnostic]
       def syntax_warning_diagnostics
         @document.parse_result.warnings.map do |warning|
           location = warning.location
@@ -73,7 +70,7 @@ module RubyLsp
         end
       end
 
-      sig { returns(T::Array[Interface::Diagnostic]) }
+      #: -> Array[Interface::Diagnostic]
       def syntax_error_diagnostics
         @document.parse_result.errors.map do |error|
           location = error.location

data/lib/ruby_lsp/requests/discover_tests.rb

@@ -1,27 +1,29 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/test_discovery"
 require "ruby_lsp/listeners/test_style"
+require "ruby_lsp/listeners/spec_style"
 
 module RubyLsp
   module Requests
     # This is a custom request to ask the server to parse a test file and discover all available examples in it. Add-ons
     # can augment the behavior through listeners, allowing them to handle discovery for different frameworks
     class DiscoverTests < Request
-      extend T::Sig
       include Support::Common
 
-      sig { params(global_state: GlobalState, document: RubyDocument, dispatcher: Prism::Dispatcher).void }
+      #: (GlobalState global_state, RubyDocument document, Prism::Dispatcher dispatcher) -> void
       def initialize(global_state, document, dispatcher)
         super()
         @global_state = global_state
         @document = document
         @dispatcher = dispatcher
-        @response_builder = T.let(ResponseBuilders::TestCollection.new, ResponseBuilders::TestCollection)
-        @index = T.let(global_state.index, RubyIndexer::Index)
+        @response_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
+        @index = global_state.index #: RubyIndexer::Index
       end
 
-      sig { override.returns(T::Array[Support::TestItem]) }
+      # @override
+      #: -> Array[Support::TestItem]
       def perform
         uri = @document.uri
 
@@ -35,6 +37,12 @@ module RubyLsp
         # in the index first and then discover the tests, all in the same traversal.
         if @index.entries_for(uri.to_s)
           Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+          Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+
+          Addon.addons.each do |addon|
+            addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
+          end
+
           @dispatcher.visit(@document.parse_result.value)
         else
           @global_state.synchronize do
@@ -47,6 +55,11 @@ module RubyLsp
             )
 
             Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+            Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+
+            Addon.addons.each do |addon|
+              addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
+            end
 
             # 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

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -13,16 +13,7 @@ module RubyLsp
     # For writable elements like constants or variables, their read/write occurrences should be highlighted differently.
     # This is achieved by sending different "kind" attributes to the editor (2 for read and 3 for write).
     class DocumentHighlight < Request
-      extend T::Sig
-
-      sig do
-        params(
-          global_state: GlobalState,
-          document: T.any(RubyDocument, ERBDocument),
-          position: T::Hash[Symbol, T.untyped],
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (GlobalState global_state, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher) -> void
       def initialize(global_state, document, position, dispatcher)
         super()
         char_position, _ = document.find_index_by_position(position)
@@ -34,10 +25,8 @@ module RubyLsp
           code_units_cache: document.code_units_cache,
         )
 
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight]
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight]
         Listeners::DocumentHighlight.new(
           @response_builder,
           node_context.node,
@@ -47,7 +36,8 @@ module RubyLsp
         )
       end
 
-      sig { override.returns(T::Array[Interface::DocumentHighlight]) }
+      # @override
+      #: -> Array[Interface::DocumentHighlight]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/document_link.rb

@@ -9,34 +9,23 @@ module RubyLsp
     # makes `# source://PATH_TO_FILE#line` comments in a Ruby/RBI file clickable if the file exists.
     # When the user clicks the link, it'll open that location.
     class DocumentLink < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DocumentLinkOptions) }
+        #: -> Interface::DocumentLinkOptions
         def provider
           Interface::DocumentLinkOptions.new(resolve_provider: false)
         end
       end
 
-      sig do
-        params(
-          uri: URI::Generic,
-          comments: T::Array[Prism::Comment],
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (URI::Generic uri, Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(uri, comments, dispatcher)
         super()
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink]
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink]
         Listeners::DocumentLink.new(@response_builder, uri, comments, dispatcher)
       end
 
-      sig { override.returns(T::Array[Interface::DocumentLink]) }
+      # @override
+      #: -> Array[Interface::DocumentLink]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -13,21 +13,17 @@ module RubyLsp
     # In VS Code, symbol search known as 'Go To Symbol in Editor' and can be accessed with Ctrl/Cmd-Shift-O,
     # or by opening the command palette and inserting an `@` symbol.
     class DocumentSymbol < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DocumentSymbolOptions) }
+        #: -> Interface::DocumentSymbolOptions
         def provider
           Interface::DocumentSymbolOptions.new
         end
       end
 
-      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
+      #: (URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(uri, dispatcher)
         super()
-        @response_builder = T.let(ResponseBuilders::DocumentSymbol.new, ResponseBuilders::DocumentSymbol)
+        @response_builder = ResponseBuilders::DocumentSymbol.new #: ResponseBuilders::DocumentSymbol
         Listeners::DocumentSymbol.new(@response_builder, uri, dispatcher)
 
         Addon.addons.each do |addon|
@@ -35,7 +31,8 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
+      # @override
+      #: -> Array[Interface::DocumentSymbol]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -8,31 +8,23 @@ module RubyLsp
     # The [folding ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange)
     # request informs the editor of the ranges where and how code can be folded.
     class FoldingRanges < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(TrueClass) }
+        #: -> TrueClass
         def provider
           true
         end
       end
 
-      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher).void }
+      #: (Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(comments, dispatcher)
         super()
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange],
-        )
-        @listener = T.let(
-          Listeners::FoldingRanges.new(@response_builder, comments, dispatcher),
-          Listeners::FoldingRanges,
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange]
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange]
+        @listener = Listeners::FoldingRanges.new(@response_builder, comments, dispatcher) #: Listeners::FoldingRanges
       end
 
-      sig { override.returns(T::Array[Interface::FoldingRange]) }
+      # @override
+      #: -> Array[Interface::FoldingRange]
       def perform
         @listener.finalize_response!
         @response_builder.response

data/lib/ruby_lsp/requests/formatting.rb

@@ -7,28 +7,25 @@ module RubyLsp
     # request uses RuboCop to fix auto-correctable offenses in the document. This requires enabling format on save and
     # registering the ruby-lsp as the Ruby formatter.
     class Formatting < Request
-      extend T::Sig
-
       class Error < StandardError; end
 
       class << self
-        extend T::Sig
-
-        sig { returns(TrueClass) }
+        #: -> TrueClass
         def provider
           true
         end
       end
 
-      sig { params(global_state: GlobalState, document: RubyDocument).void }
+      #: (GlobalState global_state, RubyDocument document) -> void
       def initialize(global_state, document)
         super()
         @document = document
-        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
-        @uri = T.let(document.uri, URI::Generic)
+        @active_formatter = global_state.active_formatter #: Support::Formatter?
+        @uri = document.uri #: URI::Generic
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
+      # @override
+      #: -> (Array[Interface::TextEdit] & Object)?
       def perform
         return unless @active_formatter
         return if @document.syntax_error?

data/lib/ruby_lsp/requests/go_to_relevant_file.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # GoTo Relevant File is a custom [LSP
+    # request](https://microsoft.github.io/language-server-protocol/specification#requestMessage)
+    # 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("_|")}_)/
+      TEST_SUFFIX_PATTERN = /(_#{TEST_KEYWORDS.join("|_")})$/
+      TEST_PATTERN = /#{TEST_PREFIX_PATTERN}|#{TEST_SUFFIX_PATTERN}/
+
+      TEST_PREFIX_GLOB = "#{TEST_KEYWORDS.join("_,")}_" #: String
+      TEST_SUFFIX_GLOB = "_#{TEST_KEYWORDS.join(",_")}" #: String
+
+      #: (String path, String workspace_path) -> void
+      def initialize(path, workspace_path)
+        super()
+
+        @workspace_path = workspace_path
+        @path = path.delete_prefix(workspace_path) #: String
+      end
+
+      # @override
+      #: -> Array[String]
+      def perform
+        find_relevant_paths
+      end
+
+      private
+
+      #: -> Array[String]
+      def find_relevant_paths
+        candidate_paths = Dir.glob(File.join("**", relevant_filename_pattern))
+        return [] if candidate_paths.empty?
+
+        find_most_similar_with_jaccard(candidate_paths).map { File.join(@workspace_path, _1) }
+      end
+
+      #: -> String
+      def relevant_filename_pattern
+        input_basename = File.basename(@path, File.extname(@path))
+
+        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}}}"
+          end
+
+        "#{relevant_basename_pattern}#{File.extname(@path)}"
+      end
+
+      # Using the Jaccard algorithm to determine the similarity between the
+      # input path and the candidate relevant file paths.
+      # Ref: https://en.wikipedia.org/wiki/Jaccard_index
+      # The main idea of this algorithm is to take the size of interaction and divide
+      # it by the size of union between two sets (in our case the elements in each set
+      # would be the parts of the path separated by path divider.)
+      #: (Array[String] candidates) -> Array[String]
+      def find_most_similar_with_jaccard(candidates)
+        dirs = get_dir_parts(@path)
+
+        _, results = candidates
+          .group_by do |other_path|
+            other_dirs = get_dir_parts(other_path)
+            # Similarity score between the two directories
+            (dirs & other_dirs).size.to_f / (dirs | other_dirs).size
+          end
+          .max_by(&:first)
+
+        results || []
+      end
+
+      #: (String path) -> Set[String]
+      def get_dir_parts(path)
+        Set.new(File.dirname(path).split(File::SEPARATOR))
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/hover.rb

@@ -8,13 +8,10 @@ module RubyLsp
     # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
     # displays the documentation for the symbol currently under the cursor.
     class Hover < Request
-      extend T::Sig
       extend T::Generic
 
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::HoverOptions) }
+        #: -> Interface::HoverOptions
         def provider
           Interface::HoverOptions.new
         end
@@ -22,15 +19,7 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          global_state: GlobalState,
-          position: T::Hash[Symbol, T.untyped],
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
 
@@ -59,9 +48,9 @@ module RubyLsp
         # Don't need to instantiate any listeners if there's no target
         return unless target
 
-        @target = T.let(target, T.nilable(Prism::Node))
+        @target = target #: Prism::Node?
         uri = document.uri
-        @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
+        @response_builder = ResponseBuilders::Hover.new #: ResponseBuilders::Hover
         Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level)
         Addon.addons.each do |addon|
           addon.create_hover_listener(@response_builder, node_context, dispatcher)
@@ -70,7 +59,8 @@ module RubyLsp
         @dispatcher = dispatcher
       end
 
-      sig { override.returns(ResponseType) }
+      # @override
+      #: -> ResponseType
       def perform
         return unless @target
 
@@ -88,14 +78,14 @@ module RubyLsp
 
       private
 
-      sig { params(parent: T.nilable(Prism::Node), target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Prism::Node? parent, Prism::Node? target) -> bool
       def should_refine_target?(parent, target)
         (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
         !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
           (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
       end
 
-      sig { params(position: T::Hash[Symbol, T.untyped], target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Hash[Symbol, untyped] position, Prism::Node? target) -> bool
       def position_outside_target?(position, target)
         case target
         when Prism::GlobalVariableAndWriteNode,

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -9,35 +9,24 @@ module RubyLsp
     # are labels added directly in the code that explicitly show the user something that might
     # otherwise just be implied.
     class InlayHints < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::InlayHintOptions) }
+        #: -> Interface::InlayHintOptions
         def provider
           Interface::InlayHintOptions.new(resolve_provider: false)
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          hints_configuration: RequestConfig,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, RequestConfig hints_configuration, Prism::Dispatcher dispatcher) -> void
       def initialize(document, hints_configuration, dispatcher)
         super()
 
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint]
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint]
         Listeners::InlayHints.new(@response_builder, hints_configuration, dispatcher)
       end
 
-      sig { override.returns(T::Array[Interface::InlayHint]) }
+      # @override
+      #: -> Array[Interface::InlayHint]
       def perform
         @response_builder.response
       end