ruby-lsp 0.17.5 → 0.17.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ab87e9f42251fafcf8c085d14272b6e0cc0fb6e6968db3fc4c304e92000c63
-  data.tar.gz: 305592ad82c3e41b72dff4c0a48ff60e6158ffba6d06b802844418c3873a6ef9
+  metadata.gz: 7299237468ae17d80028a1454903f58b1be4ff34428a6c8a538530b5caad54d1
+  data.tar.gz: 26351e5be1671219a9b3624076b2f50fb68c5838303fe1a021eecb39c4e3e9f1
 SHA512:
-  metadata.gz: 3a38745ee99e4e62843f3bc2a698ec8c447d9bbb39091e158b2a64e36e46a1612962d1062635a007e13aabd3709733b9726a302ef680bd2881673e6abd48e038
-  data.tar.gz: 57b5327b0f17af4530b21ba3c51eb2bff13912e76df77f78284cd9644cebef252e1cbdd38b960de19cc64a68d9daf3788c6e78ef3b95b4bb5d6dc7f97e56c58f
+  metadata.gz: 54cc76a3506a268398cfc51645a70300e2d14bda5b39c12274863270f70ed666b33bfebdf50dac8e013410e8ddba5645f4f435863af795d268710e0ccf9d8814
+  data.tar.gz: 95e52a4aa6f68785495f7435fe54cc395c062809ad3754703f808c68d2599bc34a619578bbb8453cb54de88a8312ac49eff8dd2e72a82bc04554c7b659c477cd

data/VERSION

@@ -1 +1 @@
-0.17.5
+0.17.6

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

@@ -288,6 +288,14 @@ module RubyIndexer
     class BlockParameter < Parameter
       DEFAULT_NAME = T.let(:"<anonymous block>", Symbol)
 
+      class << self
+        extend T::Sig
+        sig { returns(BlockParameter) }
+        def anonymous
+          new(name: DEFAULT_NAME)
+        end
+      end
+
       sig { override.returns(Symbol) }
       def decorated_name
         :"&#{@name}"

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

@@ -389,7 +389,7 @@ module RubyIndexer
       # If we don't have an entry for `name`, raise
       entries = self[fully_qualified_name]
 
-      if singleton_levels > 0 && !entries
+      if singleton_levels > 0 && !entries && indexed?(attached_class_name)
         entries = [existing_or_new_singleton_class(attached_class_name)]
       end
 

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -15,20 +15,25 @@ module RubyIndexer
       loader = RBS::EnvironmentLoader.new
       RBS::Environment.from_loader(loader).resolve_type_names
 
-      loader.each_signature do |source, pathname, _buffer, declarations, _directives|
-        process_signature(source, pathname, declarations)
+      loader.each_signature do |_source, pathname, _buffer, declarations, _directives|
+        process_signature(pathname, declarations)
       end
     end
 
-    private
-
-    sig { params(source: T.untyped, pathname: Pathname, declarations: T::Array[RBS::AST::Declarations::Base]).void }
-    def process_signature(source, pathname, declarations)
+    sig do
+      params(
+        pathname: Pathname,
+        declarations: T::Array[RBS::AST::Declarations::Base],
+      ).void
+    end
+    def process_signature(pathname, declarations)
       declarations.each do |declaration|
         process_declaration(declaration, pathname)
       end
     end
 
+    private
+
     sig { params(declaration: RBS::AST::Declarations::Base, pathname: Pathname).void }
     def process_declaration(declaration, pathname)
       case declaration
@@ -122,7 +127,102 @@ module RubyIndexer
       end
 
       real_owner = member.singleton? ? @index.existing_or_new_singleton_class(owner.name) : owner
-      @index.add(Entry::Method.new(name, file_path, location, location, comments, [], visibility, real_owner))
+      signatures = signatures(member)
+      @index.add(Entry::Method.new(name, file_path, location, location, comments, signatures, visibility, real_owner))
+    end
+
+    sig { params(member: RBS::AST::Members::MethodDefinition).returns(T::Array[Entry::Signature]) }
+    def signatures(member)
+      member.overloads.map do |overload|
+        parameters = process_overload(overload)
+        Entry::Signature.new(parameters)
+      end
+    end
+
+    sig { params(overload: RBS::AST::Members::MethodDefinition::Overload).returns(T::Array[Entry::Parameter]) }
+    def process_overload(overload)
+      function = T.cast(overload.method_type.type, RBS::Types::Function)
+      parameters = parse_arguments(function)
+
+      block = overload.method_type.block
+      parameters << Entry::BlockParameter.anonymous if block&.required
+
+      parameters
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::Parameter]) }
+    def parse_arguments(function)
+      parameters = []
+      parameters.concat(process_required_and_optional_positionals(function))
+      parameters.concat(process_trailing_positionals(function)) if function.trailing_positionals
+      parameters << process_rest_positionals(function) if function.rest_positionals
+      parameters.concat(process_required_keywords(function)) if function.required_keywords
+      parameters.concat(process_optional_keywords(function)) if function.optional_keywords
+      parameters << process_rest_keywords(function) if function.rest_keywords
+      parameters
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::RequiredParameter]) }
+    def process_required_and_optional_positionals(function)
+      argument_offset = 0
+
+      required = function.required_positionals.map.with_index(argument_offset) do |param, i|
+        # Some parameters don't have names, e.g.
+        #   def self.try_convert: [U] (untyped) -> ::Array[U]?
+        name = param.name || :"arg#{i}"
+        argument_offset += 1
+
+        Entry::RequiredParameter.new(name: name)
+      end
+
+      optional = function.optional_positionals.map.with_index(argument_offset) do |param, i|
+        # Optional positionals may be unnamed, e.g.
+        #  def self.polar: (Numeric, ?Numeric) -> Complex
+        name = param.name || :"arg#{i}"
+
+        Entry::OptionalParameter.new(name: name)
+      end
+
+      required + optional
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::OptionalParameter]) }
+    def process_trailing_positionals(function)
+      function.trailing_positionals.map do |param|
+        Entry::OptionalParameter.new(name: param.name)
+      end
+    end
+
+    sig { params(function: RBS::Types::Function).returns(Entry::RestParameter) }
+    def process_rest_positionals(function)
+      rest = function.rest_positionals
+
+      rest_name = rest.name || Entry::RestParameter::DEFAULT_NAME
+
+      Entry::RestParameter.new(name: rest_name)
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::KeywordParameter]) }
+    def process_required_keywords(function)
+      function.required_keywords.map do |name, _param|
+        Entry::KeywordParameter.new(name: name)
+      end
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::OptionalKeywordParameter]) }
+    def process_optional_keywords(function)
+      function.optional_keywords.map do |name, _param|
+        Entry::OptionalKeywordParameter.new(name: name)
+      end
+    end
+
+    sig { params(function: RBS::Types::Function).returns(Entry::KeywordRestParameter) }
+    def process_rest_keywords(function)
+      param = function.rest_keywords
+
+      name = param.name || Entry::KeywordRestParameter::DEFAULT_NAME
+
+      Entry::KeywordRestParameter.new(name: name)
     end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -1707,5 +1707,11 @@ module RubyIndexer
         @index.linearized_ancestors_of("A::<Class:A>"),
       )
     end
+
+    def test_linearizing_a_singleton_class_with_no_attached
+      assert_raises(Index::NonExistingNamespaceError) do
+        @index.linearized_ancestors_of("A::<Class:A>")
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -123,8 +123,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(1, entry.parameters.length)
-      parameter = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      parameter = parameters.first
       assert_equal(:a, parameter.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
@@ -139,8 +140,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(1, entry.parameters.length)
-      parameter = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      parameter = parameters.first
       assert_equal(:"(a, (b, ))", parameter.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
@@ -155,8 +157,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(1, entry.parameters.length)
-      parameter = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      parameter = parameters.first
       assert_equal(:a, parameter.name)
       assert_instance_of(Entry::OptionalParameter, parameter)
     end
@@ -171,8 +174,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(2, entry.parameters.length)
-      a, b = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      a, b = parameters
 
       assert_equal(:a, a.name)
       assert_instance_of(Entry::KeywordParameter, a)
@@ -191,8 +195,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(2, entry.parameters.length)
-      a, b = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      a, b = parameters
 
       assert_equal(:a, a.name)
       assert_instance_of(Entry::RestParameter, a)
@@ -216,8 +221,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(2, entry.parameters.length)
-      a, b = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      a, b = parameters
 
       assert_equal(:a, a.name)
       assert_instance_of(Entry::RestParameter, a)
@@ -226,8 +232,9 @@ module RubyIndexer
       assert_instance_of(Entry::RequiredParameter, b)
 
       entry = T.must(@index["baz"].first)
-      assert_equal(2, entry.parameters.length)
-      a, b = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      a, b = parameters
 
       assert_equal(:a, a.name)
       assert_instance_of(Entry::KeywordRestParameter, a)
@@ -236,8 +243,9 @@ module RubyIndexer
       assert_instance_of(Entry::RequiredParameter, b)
 
       entry = T.must(@index["qux"].first)
-      assert_equal(2, entry.parameters.length)
-      _a, second = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      _a, second = parameters
 
       assert_equal(:"(b, c)", second.name)
       assert_instance_of(Entry::RequiredParameter, second)
@@ -253,8 +261,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(1, entry.parameters.length)
-      param = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      param = parameters.first
 
       assert_equal(:"(a, *b)", param.name)
       assert_instance_of(Entry::RequiredParameter, param)
@@ -272,14 +281,16 @@ module RubyIndexer
       RUBY
 
       entry = T.must(@index["bar"].first)
-      param = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      param = parameters.first
       assert_equal(:block, param.name)
       assert_instance_of(Entry::BlockParameter, param)
 
       entry = T.must(@index["baz"].first)
-      assert_equal(1, entry.parameters.length)
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
 
-      param = entry.parameters.first
+      param = parameters.first
       assert_equal(Entry::BlockParameter::DEFAULT_NAME, param.name)
       assert_instance_of(Entry::BlockParameter, param)
     end
@@ -294,8 +305,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(2, entry.parameters.length)
-      first, second = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      first, second = parameters
 
       assert_equal(Entry::RestParameter::DEFAULT_NAME, first.name)
       assert_instance_of(Entry::RestParameter, first)
@@ -314,7 +326,8 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_empty(entry.parameters)
+      parameters = entry.signatures.first.parameters
+      assert_empty(parameters)
     end
 
     def test_keeps_track_of_method_owner

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -74,5 +74,253 @@ module RubyIndexer
 
       assert_same(entry.location, entry.name_location)
     end
+
+    def test_rbs_method_with_required_positionals
+      entries = @index["crypt"]
+      assert_equal(1, entries.length)
+
+      entry = entries.first
+      signatures = entry.signatures
+      assert_equal(1, signatures.length)
+
+      first_signature = signatures.first
+
+      # (::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)
+    end
+
+    def test_rbs_method_with_unnamed_required_positionals
+      entries = @index["try_convert"]
+      entry = entries.find { |entry| entry.owner.name == "Array::<Class:Array>" }
+
+      parameters = entry.signatures[0].parameters
+
+      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>" }
+
+      # def self.polar: (Numeric, ?Numeric) -> Complex
+
+      parameters = entry.signatures[0].parameters
+
+      assert_equal([:arg0, :arg1], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+    end
+
+    def test_rbs_method_with_optional_parameter
+      entries = @index["chomp"]
+      assert_equal(1, entries.length)
+
+      entry = entries.first
+      signatures = entry.signatures
+      assert_equal(1, signatures.length)
+
+      first_signature = signatures.first
+
+      # (?::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)
+    end
+
+    def test_rbs_method_with_required_and_optional_parameters
+      entries = @index["gsub"]
+      assert_equal(1, entries.length)
+
+      entry = entries.first
+
+      signatures = entry.signatures
+      assert_equal(3, signatures.length)
+
+      # (::Regexp | ::string pattern, ::string | ::hash[::String, ::_ToS] replacement) -> ::String
+      # | (::Regexp | ::string pattern) -> ::Enumerator[::String, ::String]
+      # | (::Regexp | ::string pattern) { (::String match) -> ::_ToS } -> ::String
+
+      parameters = signatures[0].parameters
+      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
+      assert_equal([:pattern], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+
+      parameters = signatures[2].parameters
+      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>" }
+
+      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
+      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
+      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])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+      assert_kind_of(Entry::BlockParameter, parameters[3])
+    end
+
+    def test_rbs_method_with_rest_positionals
+      entries = @index["count"]
+      entry = entries.find { |entry| entry.owner.name == "String" }
+
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, entry.signatures.length)
+
+      # (::String::selector selector_0, *::String::selector more_selectors) -> ::Integer
+
+      assert_equal([:selector_0, :more_selectors], parameters.map(&:name))
+      assert_kind_of(RubyIndexer::Entry::RequiredParameter, parameters[0])
+      assert_kind_of(RubyIndexer::Entry::RestParameter, parameters[1])
+    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>" }
+
+      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
+
+      parameters = signatures[0].parameters
+      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
+      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])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+      assert_kind_of(Entry::OptionalParameter, parameters[3])
+    end
+
+    def test_rbs_method_with_optional_keywords
+      entries = @index["step"]
+      entry = entries.find { |entry| entry.owner.name == "Numeric" }
+
+      signatures = entry.signatures
+      assert_equal(4, signatures.length)
+
+      # (?::Numeric limit, ?::Numeric step) { (::Numeric) -> void } -> self
+      # | (?::Numeric limit, ?::Numeric step) -> ::Enumerator[::Numeric, self]
+      # | (?by: ::Numeric, ?to: ::Numeric) { (::Numeric) -> void } -> self
+      # | (?by: ::Numeric, ?to: ::Numeric) -> ::Enumerator[::Numeric, self]
+
+      parameters = signatures[0].parameters
+      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
+      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
+      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
+      assert_equal([:by, :to], parameters.map(&:name))
+      assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
+      assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
+    end
+
+    def test_rbs_method_with_required_keywords
+      # There are no methods in Core that have required keyword arguments,
+      # so we test against RBS directly
+
+      rbs = <<~RBS
+        class File
+          def foo: (a: ::Numeric sz, b: ::Numeric) -> void
+        end
+      RBS
+      signatures = parse_rbs_methods(rbs, "foo")
+      parameters = signatures[0].parameters
+      assert_equal([:a, :b], parameters.map(&:name))
+      assert_kind_of(Entry::KeywordParameter, parameters[0])
+      assert_kind_of(Entry::KeywordParameter, parameters[1])
+    end
+
+    def test_rbs_method_with_rest_keywords
+      entries = @index["method_missing"]
+      entry = entries.find { |entry| entry.owner.name == "BasicObject" }
+      signatures = entry.signatures
+      assert_equal(1, signatures.length)
+
+      # (Symbol, *untyped, **untyped) ?{ (*untyped, **untyped) -> untyped } -> untyped
+
+      parameters = signatures[0].parameters
+      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])
+      assert_kind_of(Entry::KeywordRestParameter, parameters[2])
+    end
+
+    def test_parse_simple_rbs
+      rbs = <<~RBS
+        class File
+          def self?.open: (String name, ?String mode, ?Integer perm) -> IO?
+              | [T] (String name, ?String mode, ?Integer perm) { (IO) -> T } -> T
+        end
+      RBS
+      signatures = parse_rbs_methods(rbs, "open")
+      assert_equal(2, signatures.length)
+      parameters = signatures[0].parameters
+      assert_equal([: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 = signatures[1].parameters
+      assert_equal([:name, :mode, :perm, :"<anonymous block>"], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+      assert_kind_of(Entry::BlockParameter, parameters[3])
+    end
+
+    private
+
+    def parse_rbs_methods(rbs, method_name)
+      buffer = RBS::Buffer.new(content: rbs, name: "")
+      _, _, declarations = RBS::Parser.parse_signature(buffer)
+      index = RubyIndexer::Index.new
+      indexer = RubyIndexer::RBSIndexer.new(index)
+      pathname = Pathname.new("file.rbs")
+      indexer.process_signature(pathname, declarations)
+      entry = T.must(index[method_name]).first
+      T.cast(entry, Entry::Method).signatures
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.5
+  version: 0.17.6
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-09 00:00:00.000000000 Z
+date: 2024-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol