ruby-lsp 0.23.11 → 0.23.16

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -6,16 +6,16 @@ require_relative "test_case"
 module RubyIndexer
   class RBSIndexerTest < TestCase
     def test_index_core_classes
-      entries = @index["Array"]
+      entries = @index["Array"] #: as !nil
       refute_nil(entries)
       # Array is a class but also an instance method on Kernel
       assert_equal(2, entries.length)
-      entry = entries.find { |entry| entry.is_a?(RubyIndexer::Entry::Class) }
+      entry = entries.find { |entry| entry.is_a?(Entry::Class) } #: as Entry::Class
       assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
       assert_equal("array.rbs", entry.file_name)
       assert_equal("Object", entry.parent_class)
       assert_equal(1, entry.mixin_operations.length)
-      enumerable_include = entry.mixin_operations.first
+      enumerable_include = entry.mixin_operations.first #: as !nil
       assert_equal("Enumerable", enumerable_include.module_name)
 
       # Using fixed positions would be fragile, so let's just check some basics.
@@ -26,10 +26,10 @@ module RubyIndexer
     end
 
     def test_index_core_modules
-      entries = @index["Kernel"]
+      entries = @index["Kernel"] #: as !nil
       refute_nil(entries)
       assert_equal(1, entries.length)
-      entry = entries.first
+      entry = entries.first #: as Entry::Module
       assert_match(%r{/gems/rbs-.*/core/kernel.rbs}, entry.file_path)
       assert_equal("kernel.rbs", entry.file_name)
 
@@ -41,30 +41,23 @@ module RubyIndexer
     end
 
     def test_index_core_constants
-      entries = @index["RUBY_VERSION"]
+      entries = @index["RUBY_VERSION"] #: as !nil
       refute_nil(entries)
       assert_equal(1, entries.length)
 
-      # Complex::I is defined as `Complex::I = ...`
-      entries = @index["Complex::I"]
+      entries = @index["Complex::I"] #: as !nil
       refute_nil(entries)
       assert_equal(1, entries.length)
 
-      # Encoding::US_ASCII is defined as
-      # ```
-      # module Encoding
-      #   US_ASCII = ...
-      #   ...
-      # ````
-      entries = @index["Encoding::US_ASCII"]
+      entries = @index["Encoding::US_ASCII"] #: as !nil
       refute_nil(entries)
       assert_equal(1, entries.length)
     end
 
     def test_index_methods
-      entries = @index["initialize"]
+      entries = @index["initialize"] #: as Array[Entry::Method]
       refute_nil(entries)
-      entry = entries.find { |entry| entry.owner.name == "Array" }
+      entry = entries.find { |entry| entry.owner&.name == "Array" } #: as Entry::Method
       assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
       assert_equal("array.rbs", entry.file_name)
       assert_equal(Entry::Visibility::PUBLIC, entry.visibility)
@@ -77,11 +70,11 @@ module RubyIndexer
     end
 
     def test_index_global_declaration
-      entries = @index["$DEBUG"]
+      entries = @index["$DEBUG"] #: as Array[Entry::GlobalVariable]
       refute_nil(entries)
       assert_equal(1, entries.length)
 
-      entry = entries.first
+      entry = entries.first #: as Entry::GlobalVariable
 
       assert_instance_of(Entry::GlobalVariable, entry)
       assert_equal("$DEBUG", entry.name)
@@ -91,10 +84,10 @@ module RubyIndexer
     end
 
     def test_attaches_correct_owner_to_singleton_methods
-      entries = @index["basename"]
+      entries = @index["basename"] #: as Array[Entry::Method]
       refute_nil(entries)
 
-      owner = entries.first.owner
+      owner = entries.first&.owner #: as Entry::SingletonClass
       assert_instance_of(Entry::SingletonClass, owner)
       assert_equal("File::<Class:File>", owner.name)
     end
@@ -103,47 +96,47 @@ module RubyIndexer
       # NOTE: RBS does not store the name location for classes, modules or methods. This behavior is not exactly what
       # we would like, but for now we assign the same location to both
 
-      entries = @index["Array"]
+      entries = @index["Array"] #: as Array[Entry::Class]
       refute_nil(entries)
-      entry = entries.find { |entry| entry.is_a?(Entry::Class) }
+      entry = entries.find { |entry| entry.is_a?(Entry::Class) } #: as Entry::Class
 
       assert_same(entry.location, entry.name_location)
     end
 
     def test_rbs_method_with_required_positionals
-      entries = @index["crypt"]
+      entries = @index["crypt"] #: as Array[Entry::Method]
       assert_equal(1, entries.length)
 
-      entry = entries.first
+      entry = entries.first #: as Entry::Method
       signatures = entry.signatures
       assert_equal(1, signatures.length)
 
-      first_signature = signatures.first
+      first_signature = signatures.first #: as Entry::Signature
 
       # (::string salt_str) -> ::String
 
       assert_equal(1, first_signature.parameters.length)
       assert_kind_of(Entry::RequiredParameter, first_signature.parameters[0])
-      assert_equal(:salt_str, first_signature.parameters[0].name)
+      assert_equal(:salt_str, first_signature.parameters[0]&.name)
     end
 
     def test_rbs_method_with_unnamed_required_positionals
-      entries = @index["try_convert"]
-      entry = entries.find { |entry| entry.owner.name == "Array::<Class:Array>" }
+      entries = @index["try_convert"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "Array::<Class:Array>" } #: as Entry::Method
 
-      parameters = entry.signatures[0].parameters
+      parameters = entry.signatures[0]&.parameters #: as Array[Entry::Parameter]
 
       assert_equal([:arg0], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
     end
 
     def test_rbs_method_with_optional_positionals
-      entries = @index["polar"]
-      entry = entries.find { |entry| entry.owner.name == "Complex::<Class:Complex>" }
+      entries = @index["polar"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "Complex::<Class:Complex>" } #: as Entry::Method
 
       # def self.polar: (Numeric, ?Numeric) -> Complex
 
-      parameters = entry.signatures[0].parameters
+      parameters = entry.signatures[0]&.parameters #: as Array[Entry::Parameter]
 
       assert_equal([:arg0, :arg1], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
@@ -151,27 +144,27 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_optional_parameter
-      entries = @index["chomp"]
+      entries = @index["chomp"] #: as Array[Entry::Method]
       assert_equal(1, entries.length)
 
-      entry = entries.first
+      entry = entries.first #: as Entry::Method
       signatures = entry.signatures
       assert_equal(1, signatures.length)
 
-      first_signature = signatures.first
+      first_signature = signatures.first #: as Entry::Signature
 
       # (?::string? separator) -> ::String
 
       assert_equal(1, first_signature.parameters.length)
       assert_kind_of(Entry::OptionalParameter, first_signature.parameters[0])
-      assert_equal(:separator, first_signature.parameters[0].name)
+      assert_equal(:separator, first_signature.parameters[0]&.name)
     end
 
     def test_rbs_method_with_required_and_optional_parameters
-      entries = @index["gsub"]
+      entries = @index["gsub"] #: as Array[Entry::Method]
       assert_equal(1, entries.length)
 
-      entry = entries.first
+      entry = entries.first #: as Entry::Method
 
       signatures = entry.signatures
       assert_equal(3, signatures.length)
@@ -180,37 +173,37 @@ module RubyIndexer
       # | (::Regexp | ::string pattern) -> ::Enumerator[::String, ::String]
       # | (::Regexp | ::string pattern) { (::String match) -> ::_ToS } -> ::String
 
-      parameters = signatures[0].parameters
+      parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:pattern, :replacement], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::RequiredParameter, parameters[1])
 
-      parameters = signatures[1].parameters
+      parameters = signatures[1]&.parameters #: as !nil
       assert_equal([:pattern], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
 
-      parameters = signatures[2].parameters
+      parameters = signatures[2]&.parameters #: as !nil
       assert_equal([:pattern, :"<anonymous block>"], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::BlockParameter, parameters[1])
     end
 
     def test_rbs_anonymous_block_parameter
-      entries = @index["open"]
-      entry = entries.find { |entry| entry.owner.name == "File::<Class:File>" }
+      entries = @index["open"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "File::<Class:File>" } #: as Entry::Method
 
       assert_equal(2, entry.signatures.length)
 
       # (::String name, ?::String mode, ?::Integer perm) -> ::IO?
       # | [T] (::String name, ?::String mode, ?::Integer perm) { (::IO) -> T } -> T
 
-      parameters = entry.signatures[0].parameters
+      parameters = entry.signatures[0]&.parameters #: as !nil
       assert_equal([:file_name, :mode, :perm], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
       assert_kind_of(Entry::OptionalParameter, parameters[2])
 
-      parameters = entry.signatures[1].parameters
+      parameters = entry.signatures[1]&.parameters #: as !nil
       assert_equal([:file_name, :mode, :perm, :"<anonymous block>"], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
@@ -219,10 +212,10 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_rest_positionals
-      entries = @index["count"]
-      entry = entries.find { |entry| entry.owner.name == "String" }
+      entries = @index["count"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "String" } #: as Entry::Method
 
-      parameters = entry.signatures.first.parameters
+      parameters = entry.signatures.first&.parameters #: as !nil
       assert_equal(1, entry.signatures.length)
 
       # (::String::selector selector_0, *::String::selector more_selectors) -> ::Integer
@@ -233,8 +226,8 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_trailing_positionals
-      entries = @index["select"] # https://ruby-doc.org/3.3.3/IO.html#method-c-select
-      entry = entries.find { |entry| entry.owner.name == "IO::<Class:IO>" }
+      entries = @index["select"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "IO::<Class:IO>" } #: as !nil
 
       signatures = entry.signatures
       assert_equal(2, signatures.length)
@@ -242,13 +235,13 @@ module RubyIndexer
       # 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
 
-      parameters = signatures[0].parameters
+      parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:read_array, :write_array, :error_array], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
       assert_kind_of(Entry::OptionalParameter, parameters[2])
 
-      parameters = signatures[1].parameters
+      parameters = signatures[1]&.parameters #: as !nil
       assert_equal([:read_array, :write_array, :error_array, :timeout], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
@@ -257,8 +250,8 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_optional_keywords
-      entries = @index["step"]
-      entry = entries.find { |entry| entry.owner.name == "Numeric" }
+      entries = @index["step"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "Numeric" } #: as !nil
 
       signatures = entry.signatures
       assert_equal(4, signatures.length)
@@ -268,24 +261,24 @@ module RubyIndexer
       # | (?by: ::Numeric, ?to: ::Numeric) { (::Numeric) -> void } -> self
       # | (?by: ::Numeric, ?to: ::Numeric) -> ::Enumerator[::Numeric, self]
 
-      parameters = signatures[0].parameters
+      parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:limit, :step, :"<anonymous block>"], parameters.map(&:name))
       assert_kind_of(Entry::OptionalParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
       assert_kind_of(Entry::BlockParameter, parameters[2])
 
-      parameters = signatures[1].parameters
+      parameters = signatures[1]&.parameters #: as !nil
       assert_equal([:limit, :step], parameters.map(&:name))
       assert_kind_of(Entry::OptionalParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
 
-      parameters = signatures[2].parameters
+      parameters = signatures[2]&.parameters #: as !nil
       assert_equal([:by, :to, :"<anonymous block>"], parameters.map(&:name))
       assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
       assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
       assert_kind_of(Entry::BlockParameter, parameters[2])
 
-      parameters = signatures[3].parameters
+      parameters = signatures[3]&.parameters #: as !nil
       assert_equal([:by, :to], parameters.map(&:name))
       assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
       assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
@@ -308,14 +301,14 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_rest_keywords
-      entries = @index["method_missing"]
-      entry = entries.find { |entry| entry.owner.name == "BasicObject" }
+      entries = @index["method_missing"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "BasicObject" } #: as !nil
       signatures = entry.signatures
       assert_equal(1, signatures.length)
 
       # (Symbol, *untyped, **untyped) ?{ (*untyped, **untyped) -> untyped } -> untyped
 
-      parameters = signatures[0].parameters
+      parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:arg0, :"<anonymous splat>", :"<anonymous keyword splat>"], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::RestParameter, parameters[1])
@@ -348,24 +341,24 @@ module RubyIndexer
     def test_signature_alias
       # In RBS, an alias means that two methods have the same signature.
       # It does not mean the same thing as a Ruby alias.
-      any_entries = @index["any?"]
+      any_entries = @index["any?"] #: as Array[Entry::UnresolvedMethodAlias]
 
-      assert_equal(["Array", "Enumerable", "Hash"], any_entries.map { _1.owner.name })
+      assert_equal(["Array", "Enumerable", "Hash"], any_entries.map { _1.owner&.name })
 
-      entry = any_entries.find { |entry| entry.owner.name == "Array" }
+      entry = any_entries.find { |entry| entry.owner&.name == "Array" } #: as !nil
 
       assert_kind_of(RubyIndexer::Entry::UnresolvedMethodAlias, entry)
       assert_equal("any?", entry.name)
       assert_equal("all?", entry.old_name)
-      assert_equal("Array", entry.owner.name)
-      assert(entry.file_path.end_with?("core/array.rbs"))
-      assert_includes(entry.comments, "Returns `true` if any element of `self` meets a given criterion.")
+      assert_equal("Array", entry.owner&.name)
+      assert(entry.file_path&.end_with?("core/array.rbs"))
+      refute_empty(entry.comments)
     end
 
     def test_indexing_untyped_functions
-      entries = @index.resolve_method("call", "Method")
+      entries = @index.resolve_method("call", "Method") #: as Array[Entry::Method]
 
-      parameters = entries.first.signatures.first.parameters
+      parameters = entries.first&.signatures&.first&.parameters #: as !nil
       assert_equal(1, parameters.length)
       assert_instance_of(Entry::ForwardingParameter, parameters.first)
     end
@@ -379,7 +372,8 @@ module RubyIndexer
       indexer = RubyIndexer::RBSIndexer.new(index)
       pathname = Pathname.new("/file.rbs")
       indexer.process_signature(pathname, declarations)
-      entry = T.must(index[method_name]).first
+      entry = index[method_name] #: as !nil
+        .first
       T.cast(entry, Entry::Method).signatures
     end
   end

data/lib/ruby_indexer/test/test_case.rb

@@ -18,11 +18,11 @@ module RubyIndexer
     end
 
     def assert_entry(expected_name, type, expected_location, visibility: nil)
-      entries = @index[expected_name]
+      entries = @index[expected_name] #: as !nil
       refute_nil(entries, "Expected #{expected_name} to be indexed")
       refute_empty(entries, "Expected #{expected_name} to be indexed")
 
-      entry = entries.first
+      entry = entries.first #: as !nil
       assert_instance_of(type, entry, "Expected #{expected_name} to be a #{type}")
 
       location = entry.location

data/lib/ruby_indexer/test/uri_test.rb

@@ -12,12 +12,12 @@ module RubyIndexer
 
     def test_from_path_on_windows
       uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
-      assert_equal("/C:/some/windows/path/to/file.rb", uri.path)
+      assert_equal("/C%3A/some/windows/path/to/file.rb", uri.path)
     end
 
     def test_from_path_on_windows_with_lowercase_drive
       uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
-      assert_equal("/c:/some/windows/path/to/file.rb", uri.path)
+      assert_equal("/c%3A/some/windows/path/to/file.rb", uri.path)
     end
 
     def test_to_standardized_path_on_unix
@@ -68,5 +68,18 @@ module RubyIndexer
       uri.add_require_path_from_load_entry("/some/unix/path")
       assert_equal("to/file", uri.require_path)
     end
+
+    def test_from_path_escapes_colon_characters
+      uri = URI::Generic.from_path(path: "c:/some/windows/path with/spaces/file.rb")
+      assert_equal("c:/some/windows/path with/spaces/file.rb", uri.to_standardized_path)
+      assert_equal("file:///c%3A/some/windows/path%20with/spaces/file.rb", uri.to_s)
+    end
+
+    def test_from_path_with_unicode_characters
+      path = "/path/with/unicode/文件.rb"
+      uri = URI::Generic.from_path(path: path)
+      assert_equal(path, uri.to_standardized_path)
+      assert_equal("file:///path/with/unicode/%E6%96%87%E4%BB%B6.rb", uri.to_s)
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -25,42 +25,34 @@ module RubyLsp
 
     abstract!
 
-    @addons = T.let([], T::Array[Addon])
-    @addon_classes = T.let([], T::Array[T.class_of(Addon)])
+    @addons = [] #: Array[Addon]
+    @addon_classes = [] #: Array[singleton(Addon)]
     # Add-on instances that have declared a handler to accept file watcher events
-    @file_watcher_addons = T.let([], T::Array[Addon])
+    @file_watcher_addons = [] #: Array[Addon]
 
     AddonNotFoundError = Class.new(StandardError)
 
     class IncompatibleApiError < StandardError; end
 
     class << self
-      extend T::Sig
-
-      sig { returns(T::Array[Addon]) }
+      #: Array[Addon]
       attr_accessor :addons
 
-      sig { returns(T::Array[Addon]) }
+      #: Array[Addon]
       attr_accessor :file_watcher_addons
 
-      sig { returns(T::Array[T.class_of(Addon)]) }
+      #: Array[singleton(Addon)]
       attr_reader :addon_classes
 
       # Automatically track and instantiate add-on classes
-      sig { params(child_class: T.class_of(Addon)).void }
+      #: (singleton(Addon) child_class) -> void
       def inherited(child_class)
         addon_classes << child_class
         super
       end
 
       # Discovers and loads all add-ons. Returns a list of errors when trying to require add-ons
-      sig do
-        params(
-          global_state: GlobalState,
-          outgoing_queue: Thread::Queue,
-          include_project_addons: T::Boolean,
-        ).returns(T::Array[StandardError])
-      end
+      #: (GlobalState global_state, Thread::Queue outgoing_queue, ?include_project_addons: bool) -> Array[StandardError]
       def load_addons(global_state, outgoing_queue, include_project_addons: true)
         # Require all add-ons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb` or in the workspace under
@@ -98,7 +90,7 @@ module RubyLsp
       end
 
       # Unloads all add-ons. Only intended to be invoked once when shutting down the Ruby LSP server
-      sig { void }
+      #: -> void
       def unload_addons
         @addons.each(&:deactivate)
         @addons.clear
@@ -112,7 +104,7 @@ module RubyLsp
       # Important: if the add-on is not found, AddonNotFoundError will be raised. If the add-on is found, but its
       # current version does not satisfy the given version constraint, then IncompatibleApiError will be raised. It is
       # the responsibility of the add-ons using this API to handle these errors appropriately.
-      sig { params(addon_name: String, version_constraints: String).returns(Addon) }
+      #: (String addon_name, *String version_constraints) -> Addon
       def get(addon_name, *version_constraints)
         if version_constraints.empty?
           raise IncompatibleApiError, "Must specify version constraints when accessing other add-ons"
@@ -144,7 +136,7 @@ module RubyLsp
       #   end
       # end
       # ```
-      sig { params(version_constraints: String).void }
+      #: (*String version_constraints) -> void
       def depend_on_ruby_lsp!(*version_constraints)
         version_object = Gem::Version.new(RubyLsp::VERSION)
 
@@ -155,23 +147,23 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def initialize
-      @errors = T.let([], T::Array[StandardError])
+      @errors = [] #: Array[StandardError]
     end
 
-    sig { params(error: StandardError).returns(T.self_type) }
+    #: (StandardError error) -> self
     def add_error(error)
       @errors << error
       self
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def error?
       @errors.any?
     end
 
-    sig { returns(String) }
+    #: -> String
     def formatted_errors
       <<~ERRORS
         #{name}:
@@ -179,7 +171,7 @@ module RubyLsp
       ERRORS
     end
 
-    sig { returns(String) }
+    #: -> String
     def errors_details
       @errors.map(&:full_message).join("\n\n")
     end
@@ -207,69 +199,50 @@ module RubyLsp
     # original request so that the response is delegated to the correct add-on and must override this method to handle
     # the response
     # https://microsoft.github.io/language-server-protocol/specification#window_showMessageRequest
-    sig { overridable.params(title: String).void }
+    # @overridable
+    #: (String title) -> void
     def handle_window_show_message_response(title); end
 
     # Creates a new CodeLens listener. This method is invoked on every CodeLens request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-        uri: URI::Generic,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
     def create_code_lens_listener(response_builder, uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::Hover,
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::Hover response_builder, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
     def create_hover_listener(response_builder, node_context, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::DocumentSymbol,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> void
     def create_document_symbol_listener(response_builder, dispatcher); end
 
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::SemanticHighlighting,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::SemanticHighlighting response_builder, Prism::Dispatcher dispatcher) -> void
     def create_semantic_highlighting_listener(response_builder, dispatcher); end
 
     # Creates a new Definition listener. This method is invoked on every Definition request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
-          Interface::Location,
-          Interface::LocationLink,
-        )],
-        uri: URI::Generic,
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
     def create_definition_listener(response_builder, uri, node_context, dispatcher); end
 
     # Creates a new Completion listener. This method is invoked on every Completion request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-        uri: URI::Generic,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
     def create_completion_listener(response_builder, node_context, dispatcher, uri); end
+
+    # Creates a new Discover Tests listener. This method is invoked on every DiscoverTests request
+    # @overridable
+    #: (ResponseBuilders::TestCollection response_builder, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+    def create_discover_tests_listener(response_builder, dispatcher, uri); end
+
+    # Resolves the minimal set of commands required to execute the requested tests. Add-ons are responsible for only
+    # handling items related to the framework they add support for and have discovered themselves
+    # @overridable
+    #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+    def resolve_test_commands(items)
+      []
+    end
   end
 end