ruby-lsp 0.17.3 → 0.17.4

data/lib/ruby_indexer/test/method_test.rb

@@ -13,7 +13,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
     end
 
     def test_conditional_method
@@ -24,7 +24,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
     end
 
     def test_singleton_method_using_self_receiver
@@ -35,7 +35,12 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::SingletonMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
+
+      entry = T.must(@index["bar"].first)
+      owner = T.must(entry.owner)
+      assert_equal("Foo::<Class:Foo>", owner.name)
+      assert_instance_of(Entry::SingletonClass, owner)
     end
 
     def test_singleton_method_using_other_receiver_is_not_indexed
@@ -83,9 +88,9 @@ module RubyIndexer
         def baz; end
       RUBY
 
-      assert_entry("foo", Entry::InstanceMethod, "/fake/path/foo.rb:0-8:1-3", visibility: Entry::Visibility::PRIVATE)
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:3-0:3-12", visibility: Entry::Visibility::PUBLIC)
-      assert_entry("baz", Entry::InstanceMethod, "/fake/path/foo.rb:7-0:7-12", visibility: Entry::Visibility::PROTECTED)
+      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:0-8:1-3", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:3-0:3-12", visibility: Entry::Visibility::PUBLIC)
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:7-0:7-12", visibility: Entry::Visibility::PROTECTED)
     end
 
     def test_visibility_tracking_with_nested_class_or_modules
@@ -103,9 +108,9 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("foo", Entry::InstanceMethod, "/fake/path/foo.rb:3-2:3-14", visibility: Entry::Visibility::PRIVATE)
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:6-4:6-16", visibility: Entry::Visibility::PUBLIC)
-      assert_entry("baz", Entry::InstanceMethod, "/fake/path/foo.rb:9-2:9-14", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:3-2:3-14", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:6-4:6-16", visibility: Entry::Visibility::PUBLIC)
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:9-2:9-14", visibility: Entry::Visibility::PRIVATE)
     end
 
     def test_method_with_parameters
@@ -116,7 +121,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      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
@@ -132,7 +137,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      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
@@ -148,7 +153,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      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
@@ -164,7 +169,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      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
@@ -184,7 +189,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      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
@@ -209,7 +214,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      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
@@ -246,7 +251,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      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
@@ -287,7 +292,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      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
@@ -307,7 +312,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_empty(entry.parameters)
     end
@@ -359,23 +364,23 @@ module RubyIndexer
     def test_properly_tracks_multiple_levels_of_nesting
       index(<<~RUBY)
         module Foo
-          def first; end
+          def first_method; end
 
           module Bar
-            def second; end
+            def second_method; end
           end
 
-          def third; end
+          def third_method; end
         end
       RUBY
 
-      entry = T.must(@index["first"]&.first)
+      entry = T.cast(@index["first_method"]&.first, Entry::Method)
       assert_equal("Foo", T.must(entry.owner).name)
 
-      entry = T.must(@index["second"]&.first)
+      entry = T.cast(@index["second_method"]&.first, Entry::Method)
       assert_equal("Foo::Bar", T.must(entry.owner).name)
 
-      entry = T.must(@index["third"]&.first)
+      entry = T.cast(@index["third_method"]&.first, Entry::Method)
       assert_equal("Foo", T.must(entry.owner).name)
     end
 
@@ -398,5 +403,30 @@ module RubyIndexer
       # Foo plus 3 valid aliases
       assert_equal(4, @index.instance_variable_get(:@entries).length - @default_indexed_entries.length)
     end
+
+    def test_singleton_methods
+      index(<<~RUBY)
+        class Foo
+          def self.bar; end
+
+          class << self
+            def baz; end
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:1-19")
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:4-4:4-16")
+
+      bar_owner = T.must(T.must(@index["bar"].first).owner)
+      baz_owner = T.must(T.must(@index["baz"].first).owner)
+
+      assert_instance_of(Entry::SingletonClass, bar_owner)
+      assert_instance_of(Entry::SingletonClass, baz_owner)
+
+      # Regardless of whether the method was added through `self.something` or `class << self`, the owner object must be
+      # the exact same
+      assert_same(bar_owner, baz_owner)
+    end
   end
 end

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -8,8 +8,9 @@ module RubyIndexer
     def test_index_core_classes
       entries = @index["Array"]
       refute_nil(entries)
-      assert_equal(1, entries.length)
-      entry = entries.first
+      # 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) }
       assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
       assert_equal("array.rbs", entry.file_name)
       assert_equal("Object", entry.parent_class)
@@ -38,5 +39,29 @@ module RubyIndexer
       assert_equal(0, entry.location.start_column)
       assert_operator(entry.location.end_column, :>, 0)
     end
+
+    def test_index_methods
+      entries = @index["initialize"]
+      refute_nil(entries)
+      entry = entries.find { |entry| entry.owner.name == "Array" }
+      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)
+
+      # Using fixed positions would be fragile, so let's just check some basics.
+      assert_operator(entry.location.start_line, :>, 0)
+      assert_operator(entry.location.end_line, :>, entry.location.start_line)
+      assert_equal(2, entry.location.start_column)
+      assert_operator(entry.location.end_column, :>, 0)
+    end
+
+    def test_attaches_correct_owner_to_singleton_methods
+      entries = @index["basename"]
+      refute_nil(entries)
+
+      owner = entries.first.owner
+      assert_instance_of(Entry::SingletonClass, owner)
+      assert_equal("File::<Class:File>", owner.name)
+    end
   end
 end

data/lib/ruby_lsp/document.rb

@@ -127,7 +127,10 @@ module RubyLsp
       queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
       closest = node
       parent = T.let(nil, T.nilable(Prism::Node))
-      nesting = T.let([], T::Array[T.any(Prism::ClassNode, Prism::ModuleNode)])
+      nesting_nodes = T.let(
+        [],
+        T::Array[T.any(Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode)],
+      )
       call_node = T.let(nil, T.nilable(Prism::CallNode))
 
       until queue.empty?
@@ -151,13 +154,18 @@ module RubyLsp
 
         # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level and
         # need to pop the stack
-        previous_level = nesting.last
-        nesting.pop if previous_level && loc.start_offset > previous_level.location.end_offset
+        previous_level = nesting_nodes.last
+        nesting_nodes.pop if previous_level && loc.start_offset > previous_level.location.end_offset
 
         # 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
-        if candidate.is_a?(Prism::ClassNode) || candidate.is_a?(Prism::ModuleNode)
-          nesting << candidate
+        case candidate
+        when Prism::ClassNode, Prism::ModuleNode
+          nesting_nodes << candidate
+        when Prism::SingletonClassNode
+          nesting_nodes << candidate
+        when Prism::DefNode
+          nesting_nodes << candidate
         end
 
         if candidate.is_a?(Prism::CallNode)
@@ -189,11 +197,32 @@ module RubyLsp
       # The correct target is `Foo::Bar` with an empty nesting. `Foo::Bar` should not appear in the nesting stack, even
       # though the class/module node does indeed enclose the target, because it would lead to incorrect behavior
       if closest.is_a?(Prism::ConstantReadNode) || closest.is_a?(Prism::ConstantPathNode)
-        last_level = nesting.last
-        nesting.pop if last_level && last_level.constant_path == closest
+        last_level = nesting_nodes.last
+
+        if (last_level.is_a?(Prism::ModuleNode) || last_level.is_a?(Prism::ClassNode)) &&
+            last_level.constant_path == closest
+          nesting_nodes.pop
+        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.map { |n| n.constant_path.location.slice }, call_node)
+      NodeContext.new(closest, parent, nesting, call_node, surrounding_method)
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/global_state.rb

@@ -12,7 +12,7 @@ module RubyLsp
     attr_accessor :formatter
 
     sig { returns(T::Boolean) }
-    attr_reader :typechecker
+    attr_reader :has_type_checker
 
     sig { returns(RubyIndexer::Index) }
     attr_reader :index
@@ -23,6 +23,9 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_reader :supports_watching_files
 
+    sig { returns(TypeInferrer) }
+    attr_reader :type_inferrer
+
     sig { void }
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
@@ -31,8 +34,9 @@ module RubyLsp
       @formatter = T.let("auto", String)
       @linters = T.let([], T::Array[String])
       @test_library = T.let("minitest", String)
-      @typechecker = T.let(true, T::Boolean)
+      @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
+      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
       @supports_watching_files = T.let(false, T::Boolean)
     end
@@ -66,7 +70,7 @@ module RubyLsp
       specified_linters = options.dig(:initializationOptions, :linters)
       @linters = specified_linters || detect_linters(direct_dependencies)
       @test_library = detect_test_library(direct_dependencies)
-      @typechecker = detect_typechecker(direct_dependencies)
+      @has_type_checker = detect_typechecker(direct_dependencies)
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?

data/lib/ruby_lsp/internal.rb

@@ -28,6 +28,7 @@ require "ruby_lsp/utils"
 require "ruby_lsp/parameter_scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
+require "ruby_lsp/type_inferrer"
 require "ruby_lsp/requests"
 require "ruby_lsp/response_builders"
 require "ruby_lsp/node_context"

data/lib/ruby_lsp/listeners/completion.rb

@@ -15,15 +15,26 @@ module RubyLsp
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
+          trigger_character: T.nilable(String),
         ).void
       end
-      def initialize(response_builder, global_state, node_context, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        response_builder,
+        global_state,
+        node_context,
+        typechecker_enabled,
+        dispatcher,
+        uri,
+        trigger_character
+      )
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
+        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
         @uri = uri
+        @trigger_character = trigger_character
 
         dispatcher.register(
           self,
@@ -42,7 +53,7 @@ module RubyLsp
       # Handle completion on regular constant references (e.g. `Bar`)
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if @global_state.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -63,7 +74,7 @@ module RubyLsp
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if @global_state.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -107,7 +118,7 @@ module RubyLsp
         when "require_relative"
           complete_require_relative(node)
         else
-          complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
+          complete_methods(node, name) unless @typechecker_enabled
         end
       end
 
@@ -158,7 +169,7 @@ module RubyLsp
           name.delete_suffix("::")
         else
           *namespace, incomplete_name = name.split("::")
-          T.must(namespace).join("::")
+          namespace.join("::")
         end
 
         nesting = @node_context.nesting
@@ -192,7 +203,10 @@ module RubyLsp
 
       sig { params(name: String, location: Prism::Location).void }
       def handle_instance_variable_completion(name, location)
-        @index.instance_variable_completion_candidates(name, @node_context.fully_qualified_name).each do |entry|
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        @index.instance_variable_completion_candidates(name, type).each do |entry|
           variable_name = entry.name
 
           @response_builder << Interface::CompletionItem.new(
@@ -257,20 +271,45 @@ module RubyLsp
       end
 
       sig { params(node: Prism::CallNode, name: String).void }
-      def complete_self_receiver_method(node, name)
-        receiver_entries = @index[@node_context.fully_qualified_name]
-        return unless receiver_entries
+      def complete_methods(node, name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        # When the trigger character is a dot, Prism matches the name of the call node to whatever is next in the source
+        # code, leading to us searching for the wrong name. What we want to do instead is show every available method
+        # when dot is pressed
+        method_name = @trigger_character == "." ? nil : name
+
+        range = if method_name
+          range_from_location(T.must(node.message_loc))
+        else
+          loc = T.must(node.call_operator_loc)
+          Interface::Range.new(
+            start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
+            end: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
+          )
+        end
 
-        receiver = T.must(receiver_entries.first)
+        @index.method_completion_candidates(method_name, type).each do |entry|
+          entry_name = entry.name
 
-        @index.method_completion_candidates(name, receiver.name).each do |entry|
-          @response_builder << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
+          @response_builder << Interface::CompletionItem.new(
+            label: entry_name,
+            filter_text: entry_name,
+            text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
+            kind: Constant::CompletionItemKind::METHOD,
+            data: {
+              owner_name: entry.owner&.name,
+            },
+          )
         end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # We have not indexed this namespace, so we can't provide any completions
       end
 
       sig do
         params(
-          entry: RubyIndexer::Entry::Member,
+          entry: T.any(RubyIndexer::Entry::Member, RubyIndexer::Entry::MethodAlias),
           node: Prism::CallNode,
         ).returns(Interface::CompletionItem)
       end
@@ -283,7 +322,7 @@ module RubyLsp
           text_edit: Interface::TextEdit.new(range: range_from_location(T.must(node.message_loc)), new_text: name),
           kind: Constant::CompletionItemKind::METHOD,
           label_details: Interface::CompletionItemLabelDetails.new(
-            detail: "(#{entry.parameters.map(&:decorated_name).join(", ")})",
+            detail: entry.decorated_parameters,
             description: entry.file_name,
           ),
           documentation: Interface::MarkupContent.new(

data/lib/ruby_lsp/listeners/definition.rb

@@ -23,6 +23,7 @@ module RubyLsp
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
+        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @uri = uri
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
@@ -48,7 +49,7 @@ module RubyLsp
         message = node.message
         return unless message
 
-        handle_method_definition(message, self_receiver?(node))
+        handle_method_definition(message, @type_inferrer.infer_receiver_type(@node_context))
       end
 
       sig { params(node: Prism::StringNode).void }
@@ -70,7 +71,7 @@ module RubyLsp
         value = expression.value
         return unless value
 
-        handle_method_definition(value, false)
+        handle_method_definition(value, nil)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
@@ -123,7 +124,10 @@ module RubyLsp
 
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
-        entries = @index.resolve_instance_variable(name, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_instance_variable(name, type)
         return unless entries
 
         entries.each do |entry|
@@ -141,10 +145,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, self_receiver: T::Boolean).void }
-      def handle_method_definition(message, self_receiver)
-        methods = if self_receiver
-          @index.resolve_method(message, @node_context.fully_qualified_name)
+      sig { params(message: String, receiver_type: T.nilable(String)).void }
+      def handle_method_definition(message, receiver_type)
+        methods = if receiver_type
+          @index.resolve_method(message, receiver_type)
         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

@@ -47,6 +47,7 @@ module RubyLsp
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
+        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
@@ -78,14 +79,14 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if @global_state.typechecker
+        return if @global_state.has_type_checker
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if @global_state.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -95,8 +96,6 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return unless self_receiver?(node)
-
         if @path && File.basename(@path) == GEMFILE_NAME && node.name == :gem
           generate_gem_hover(node)
           return
@@ -107,10 +106,15 @@ module RubyLsp
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type)
         return unless methods
 
-        categorized_markdown_from_index_entries(message, methods).each do |category, content|
+        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
@@ -149,7 +153,10 @@ module RubyLsp
 
       sig { params(name: String).void }
       def handle_instance_variable_hover(name)
-        entries = @index.resolve_instance_variable(name, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_instance_variable(name, type)
         return unless entries
 
         categorized_markdown_from_index_entries(name, entries).each do |category, content|

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -21,6 +21,7 @@ module RubyLsp
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
+        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @node_context = node_context
         dispatcher.register(self, :on_call_node_enter)
       end
@@ -28,12 +29,14 @@ module RubyLsp
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         return if @typechecker_enabled
-        return unless self_receiver?(node)
 
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type)
         return unless methods
 
         target_method = methods.first

data/lib/ruby_lsp/node_context.rb

@@ -16,19 +16,24 @@ module RubyLsp
     sig { returns(T.nilable(Prism::CallNode)) }
     attr_reader :call_node
 
+    sig { returns(T.nilable(String)) }
+    attr_reader :surrounding_method
+
     sig do
       params(
         node: T.nilable(Prism::Node),
         parent: T.nilable(Prism::Node),
         nesting: T::Array[String],
         call_node: T.nilable(Prism::CallNode),
+        surrounding_method: T.nilable(String),
       ).void
     end
-    def initialize(node, parent, nesting, call_node)
+    def initialize(node, parent, nesting, call_node, surrounding_method)
       @node = node
       @parent = parent
       @nesting = nesting
       @call_node = call_node
+      @surrounding_method = surrounding_method
     end
 
     sig { returns(String) }