ruby-lsp 0.17.5 → 0.17.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ab87e9f42251fafcf8c085d14272b6e0cc0fb6e6968db3fc4c304e92000c63
-  data.tar.gz: 305592ad82c3e41b72dff4c0a48ff60e6158ffba6d06b802844418c3873a6ef9
+  metadata.gz: 671bab4fdbd77d1980781f55874d6cd448e1dcd11a6f534a176dfb00b098d2eb
+  data.tar.gz: bd12fd2ef58588b3b5386fec48c0f561140efff180988f1971b67f635f0e1042
 SHA512:
-  metadata.gz: 3a38745ee99e4e62843f3bc2a698ec8c447d9bbb39091e158b2a64e36e46a1612962d1062635a007e13aabd3709733b9726a302ef680bd2881673e6abd48e038
-  data.tar.gz: 57b5327b0f17af4530b21ba3c51eb2bff13912e76df77f78284cd9644cebef252e1cbdd38b960de19cc64a68d9daf3788c6e78ef3b95b4bb5d6dc7f97e56c58f
+  metadata.gz: f3a2a3115e1745ad7263b7e113ef13795f9a1ed1ee118128a9ab2aaad703b17551acbd929f820700e6650efb76421418a13a78270ac8d3aaff080edc46731aee
+  data.tar.gz: d29bb4d6c60727eef1a10905762a6d0c8946b7afc8aac6148ef970c8d752365f1577403497702f52a7211689cde7940b3d7cd1e1e0eb03d038e0dc6f7ceed738

data/VERSION

@@ -1 +1 @@
-0.17.5
+0.17.7

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

@@ -331,14 +331,17 @@ module RubyIndexer
       params(
         method_name: String,
         receiver_name: String,
+        inherited_only: T::Boolean,
       ).returns(T.nilable(T::Array[T.any(Entry::Member, Entry::MethodAlias)]))
     end
-    def resolve_method(method_name, receiver_name)
+    def resolve_method(method_name, receiver_name, inherited_only: false)
       method_entries = self[method_name]
       return unless method_entries
 
       ancestors = linearized_ancestors_of(receiver_name.delete_prefix("::"))
       ancestors.each do |ancestor|
+        next if inherited_only && ancestor == receiver_name
+
         found = method_entries.filter_map do |entry|
           case entry
           when Entry::Member, Entry::MethodAlias
@@ -389,7 +392,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

@@ -285,6 +285,43 @@ module RubyIndexer
       assert_includes(second_entry.comments, "Hello from second `bar`")
     end
 
+    def test_resolve_method_inherited_only
+      index(<<~RUBY)
+        class Bar
+          def baz; end
+        end
+
+        class Foo < Bar
+          def baz; end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve_method("baz", "Foo", inherited_only: true).first)
+
+      assert_equal("Bar", T.must(entry.owner).name)
+    end
+
+    def test_resolve_method_inherited_only_for_prepended_module
+      index(<<~RUBY)
+        module Bar
+          def baz
+            super
+          end
+        end
+
+        class Foo
+          prepend Bar
+
+          def baz; end
+        end
+      RUBY
+
+      # This test is just to document the fact that we don't yet support resolving inherited methods for modules that
+      # are prepended. The only way to support this is to find all namespaces that have the module a subtype, so that we
+      # can show the results for everywhere the module has been prepended.
+      assert_nil(@index.resolve_method("baz", "Bar", inherited_only: true))
+    end
+
     def test_prefix_search_for_methods
       index(<<~RUBY)
         module Foo
@@ -1707,5 +1744,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

data/lib/ruby_lsp/document.rb

@@ -127,8 +127,18 @@ module RubyLsp
       parent = T.let(nil, T.nilable(Prism::Node))
       nesting_nodes = T.let(
         [],
-        T::Array[T.any(Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode)],
+        T::Array[T.any(
+          Prism::ClassNode,
+          Prism::ModuleNode,
+          Prism::SingletonClassNode,
+          Prism::DefNode,
+          Prism::BlockNode,
+          Prism::LambdaNode,
+          Prism::ProgramNode,
+        )],
       )
+
+      nesting_nodes << node if node.is_a?(Prism::ProgramNode)
       call_node = T.let(nil, T.nilable(Prism::CallNode))
 
       until queue.empty?
@@ -158,11 +168,8 @@ module RubyLsp
         # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
         # target when it is a constant
         case candidate
-        when Prism::ClassNode, Prism::ModuleNode
-          nesting_nodes << candidate
-        when Prism::SingletonClassNode
-          nesting_nodes << candidate
-        when Prism::DefNode
+        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode, Prism::BlockNode,
+          Prism::LambdaNode
           nesting_nodes << candidate
         end
 
@@ -203,24 +210,7 @@ module RubyLsp
         end
       end
 
-      nesting = []
-      surrounding_method = T.let(nil, T.nilable(String))
-
-      nesting_nodes.each do |node|
-        case node
-        when Prism::ClassNode, Prism::ModuleNode
-          nesting << node.constant_path.slice
-        when Prism::SingletonClassNode
-          nesting << "<Class:#{nesting.last}>"
-        when Prism::DefNode
-          surrounding_method = node.name.to_s
-          next unless node.receiver.is_a?(Prism::SelfNode)
-
-          nesting << "<Class:#{nesting.last}>"
-        end
-      end
-
-      NodeContext.new(closest, parent, nesting, call_node, surrounding_method)
+      NodeContext.new(closest, parent, nesting_nodes, call_node)
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/global_state.rb

@@ -69,7 +69,7 @@ module RubyLsp
       @formatter = detect_formatter(direct_dependencies, all_dependencies) if @formatter == "auto"
 
       specified_linters = options.dig(:initializationOptions, :linters)
-      @linters = specified_linters || detect_linters(direct_dependencies)
+      @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
       @test_library = detect_test_library(direct_dependencies)
       @has_type_checker = detect_typechecker(direct_dependencies)
 
@@ -127,10 +127,14 @@ module RubyLsp
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
     # single linter. To have multiple linters running, the user must configure them manually
-    sig { params(dependencies: T::Array[String]).returns(T::Array[String]) }
-    def detect_linters(dependencies)
+    sig { params(dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(T::Array[String]) }
+    def detect_linters(dependencies, all_dependencies)
       linters = []
-      linters << "rubocop" if dependencies.any?(/^rubocop/)
+
+      if dependencies.any?(/^rubocop/) || (all_dependencies.include?("rubocop") && dot_rubocop_yml_present)
+        linters << "rubocop"
+      end
+
       linters
     end
 

data/lib/ruby_lsp/listeners/completion.rb

@@ -277,6 +277,8 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode, name: String).void }
       def complete_methods(node, name)
+        add_local_completions(node, name)
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
@@ -322,6 +324,31 @@ module RubyLsp
         # We have not indexed this namespace, so we can't provide any completions
       end
 
+      sig { params(node: Prism::CallNode, name: String).void }
+      def add_local_completions(node, name)
+        return if @global_state.has_type_checker
+
+        # If the call node has a receiver, then it cannot possibly be a local variable
+        return if node.receiver
+
+        range = range_from_location(T.must(node.message_loc))
+
+        @node_context.locals_for_scope.each do |local|
+          local_name = local.to_s
+          next unless local_name.start_with?(name)
+
+          @response_builder << Interface::CompletionItem.new(
+            label: local_name,
+            filter_text: local_name,
+            text_edit: Interface::TextEdit.new(range: range, new_text: local_name),
+            kind: Constant::CompletionItemKind::VARIABLE,
+            data: {
+              skip_resolve: true,
+            },
+          )
+        end
+      end
+
       sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
       def build_completion(label, node)
         # We should use the content location as we only replace the content and not the delimiters of the string

data/lib/ruby_lsp/listeners/definition.rb

@@ -46,6 +46,8 @@ module RubyLsp
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
           :on_string_node_enter,
+          :on_super_node_enter,
+          :on_forwarding_super_node_enter,
         )
       end
 
@@ -133,8 +135,30 @@ module RubyLsp
         handle_instance_variable_definition(node.name.to_s)
       end
 
+      sig { params(node: Prism::SuperNode).void }
+      def on_super_node_enter(node)
+        handle_super_node_definition
+      end
+
+      sig { params(node: Prism::ForwardingSuperNode).void }
+      def on_forwarding_super_node_enter(node)
+        handle_super_node_definition
+      end
+
       private
 
+      sig { void }
+      def handle_super_node_definition
+        surrounding_method = @node_context.surrounding_method
+        return unless surrounding_method
+
+        handle_method_definition(
+          surrounding_method,
+          @type_inferrer.infer_receiver_type(@node_context),
+          inherited_only: true,
+        )
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
         type = @type_inferrer.infer_receiver_type(@node_context)
@@ -158,10 +182,10 @@ module RubyLsp
         # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
-      sig { params(message: String, receiver_type: T.nilable(String)).void }
-      def handle_method_definition(message, receiver_type)
+      sig { params(message: String, receiver_type: T.nilable(String), inherited_only: T::Boolean).void }
+      def handle_method_definition(message, receiver_type, inherited_only: false)
         methods = if receiver_type
-          @index.resolve_method(message, receiver_type)
+          @index.resolve_method(message, receiver_type, inherited_only: inherited_only)
         else
           # If the method doesn't have a receiver, then we provide a few candidates to jump to
           # But we don't want to provide too many candidates, as it can be overwhelming

data/lib/ruby_lsp/listeners/hover.rb

@@ -21,6 +21,8 @@ module RubyLsp
           Prism::InstanceVariableWriteNode,
           Prism::SymbolNode,
           Prism::StringNode,
+          Prism::SuperNode,
+          Prism::ForwardingSuperNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -64,6 +66,8 @@ module RubyLsp
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
+          :on_super_node_enter,
+          :on_forwarding_super_node_enter,
         )
       end
 
@@ -106,17 +110,7 @@ module RubyLsp
         message = node.message
         return unless message
 
-        type = @type_inferrer.infer_receiver_type(@node_context)
-        return unless type
-
-        methods = @index.resolve_method(message, type)
-        return unless methods
-
-        title = "#{message}#{T.must(methods.first).decorated_parameters}"
-
-        categorized_markdown_from_index_entries(title, methods).each do |category, content|
-          @response_builder.push(content, category: category)
-        end
+        handle_method_hover(message)
       end
 
       sig { params(node: Prism::InstanceVariableReadNode).void }
@@ -149,8 +143,41 @@ module RubyLsp
         handle_instance_variable_hover(node.name.to_s)
       end
 
+      sig { params(node: Prism::SuperNode).void }
+      def on_super_node_enter(node)
+        handle_super_node_hover
+      end
+
+      sig { params(node: Prism::ForwardingSuperNode).void }
+      def on_forwarding_super_node_enter(node)
+        handle_super_node_hover
+      end
+
       private
 
+      sig { void }
+      def handle_super_node_hover
+        surrounding_method = @node_context.surrounding_method
+        return unless surrounding_method
+
+        handle_method_hover(surrounding_method, inherited_only: true)
+      end
+
+      sig { params(message: String, inherited_only: T::Boolean).void }
+      def handle_method_hover(message, inherited_only: false)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type, inherited_only: inherited_only)
+        return unless methods
+
+        title = "#{message}#{T.must(methods.first).decorated_parameters}"
+
+        categorized_markdown_from_index_entries(title, methods).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_hover(name)
         type = @type_inferrer.infer_receiver_type(@node_context)

data/lib/ruby_lsp/node_context.rb

@@ -23,22 +23,82 @@ module RubyLsp
       params(
         node: T.nilable(Prism::Node),
         parent: T.nilable(Prism::Node),
-        nesting: T::Array[String],
+        nesting_nodes: T::Array[T.any(
+          Prism::ClassNode,
+          Prism::ModuleNode,
+          Prism::SingletonClassNode,
+          Prism::DefNode,
+          Prism::BlockNode,
+          Prism::LambdaNode,
+          Prism::ProgramNode,
+        )],
         call_node: T.nilable(Prism::CallNode),
-        surrounding_method: T.nilable(String),
       ).void
     end
-    def initialize(node, parent, nesting, call_node, surrounding_method)
+    def initialize(node, parent, nesting_nodes, call_node)
       @node = node
       @parent = parent
-      @nesting = nesting
+      @nesting_nodes = nesting_nodes
       @call_node = call_node
-      @surrounding_method = surrounding_method
+
+      nesting, surrounding_method = handle_nesting_nodes(nesting_nodes)
+      @nesting = T.let(nesting, T::Array[String])
+      @surrounding_method = T.let(surrounding_method, T.nilable(String))
     end
 
     sig { returns(String) }
     def fully_qualified_name
       @fully_qualified_name ||= T.let(@nesting.join("::"), T.nilable(String))
     end
+
+    sig { returns(T::Array[Symbol]) }
+    def locals_for_scope
+      locals = []
+
+      @nesting_nodes.each do |node|
+        if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode) || node.is_a?(Prism::SingletonClassNode) ||
+            node.is_a?(Prism::DefNode)
+          locals.clear
+        end
+
+        locals.concat(node.locals)
+      end
+
+      locals
+    end
+
+    private
+
+    sig do
+      params(nodes: T::Array[T.any(
+        Prism::ClassNode,
+        Prism::ModuleNode,
+        Prism::SingletonClassNode,
+        Prism::DefNode,
+        Prism::BlockNode,
+        Prism::LambdaNode,
+        Prism::ProgramNode,
+      )]).returns([T::Array[String], T.nilable(String)])
+    end
+    def handle_nesting_nodes(nodes)
+      nesting = []
+      surrounding_method = T.let(nil, T.nilable(String))
+
+      @nesting_nodes.each do |node|
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          nesting << node.constant_path.slice
+        when Prism::SingletonClassNode
+          nesting << "<Class:#{nesting.last}>"
+        when Prism::DefNode
+          surrounding_method = node.name.to_s
+          next unless node.receiver.is_a?(Prism::SelfNode)
+
+          nesting << "<Class:#{nesting.last}>"
+        end
+      end
+
+      [nesting, surrounding_method]
+    end
   end
 end

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -38,6 +38,8 @@ module RubyLsp
 
       sig { override.returns(T::Hash[Symbol, T.untyped]) }
       def perform
+        return @item if @item.dig(:data, :skip_resolve)
+
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
         # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behaviour might

data/lib/ruby_lsp/requests/definition.rb

@@ -62,6 +62,8 @@ module RubyLsp
             Prism::InstanceVariableWriteNode,
             Prism::SymbolNode,
             Prism::StringNode,
+            Prism::SuperNode,
+            Prism::ForwardingSuperNode,
           ],
         )
 

data/lib/ruby_lsp/type_inferrer.rb

@@ -20,16 +20,9 @@ module RubyLsp
       when Prism::CallNode
         infer_receiver_for_call_node(node, node_context)
       when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
-        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode
-        nesting = node_context.nesting
-        # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
-        # inherits from Object
-        return "Object" if nesting.empty?
-
-        fully_qualified_name = node_context.fully_qualified_name
-        return fully_qualified_name if node_context.surrounding_method
-
-        "#{fully_qualified_name}::<Class:#{nesting.last}>"
+        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
+        Prism::SuperNode, Prism::ForwardingSuperNode
+        self_receiver_handling(node_context)
       end
     end
 
@@ -41,15 +34,7 @@ module RubyLsp
 
       case receiver
       when Prism::SelfNode, nil
-        nesting = node_context.nesting
-        # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
-        # inherits from Object
-        return "Object" if nesting.empty?
-        return node_context.fully_qualified_name if node_context.surrounding_method
-
-        # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
-        # context
-        "#{nesting.join("::")}::<Class:#{nesting.last}>"
+        self_receiver_handling(node_context)
       when Prism::ConstantPathNode, Prism::ConstantReadNode
         # When the receiver is a constant reference, we have to try to resolve it to figure out the right
         # receiver. But since the invocation is directly on the constant, that's the singleton context of that
@@ -68,6 +53,19 @@ module RubyLsp
       end
     end
 
+    sig { params(node_context: NodeContext).returns(String) }
+    def self_receiver_handling(node_context)
+      nesting = node_context.nesting
+      # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
+      # inherits from Object
+      return "Object" if nesting.empty?
+      return node_context.fully_qualified_name if node_context.surrounding_method
+
+      # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
+      # context
+      "#{nesting.join("::")}::<Class:#{nesting.last}>"
+    end
+
     sig do
       params(
         node: T.any(

metadata

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