ruby-lsp 0.27.0.beta1 → 0.27.0.beta2

data/lib/ruby_lsp/node_context.rb

@@ -5,6 +5,21 @@ module RubyLsp
   # This class allows listeners to access contextual information about a node in the AST, such as its parent,
   # its namespace nesting, and the surrounding CallNode (e.g. a method call).
   class NodeContext
+    # Represents the surrounding method definition context, tracking both the method name and its receiver
+    class MethodDef
+      #: String
+      attr_reader :name
+
+      #: String?
+      attr_reader :receiver
+
+      #: (String name, String? receiver) -> void
+      def initialize(name, receiver)
+        @name = name
+        @receiver = receiver
+      end
+    end
+
     #: Prism::Node?
     attr_reader :node, :parent
 
@@ -14,7 +29,7 @@ module RubyLsp
     #: Prism::CallNode?
     attr_reader :call_node
 
-    #: String?
+    #: MethodDef?
     attr_reader :surrounding_method
 
     #: (Prism::Node? node, Prism::Node? parent, Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nesting_nodes, Prism::CallNode? call_node) -> void
@@ -26,7 +41,7 @@ module RubyLsp
 
       nesting, surrounding_method = handle_nesting_nodes(nesting_nodes)
       @nesting = nesting #: Array[String]
-      @surrounding_method = surrounding_method #: String?
+      @surrounding_method = surrounding_method #: MethodDef?
     end
 
     #: -> String
@@ -52,10 +67,10 @@ module RubyLsp
 
     private
 
-    #: (Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nodes) -> [Array[String], String?]
+    #: (Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nodes) -> [Array[String], MethodDef?]
     def handle_nesting_nodes(nodes)
       nesting = []
-      surrounding_method = nil #: String?
+      surrounding_method = nil #: MethodDef?
 
       @nesting_nodes.each do |node|
         case node
@@ -64,10 +79,18 @@ module RubyLsp
         when Prism::SingletonClassNode
           nesting << "<#{nesting.flat_map { |n| n.split("::") }.last}>"
         when Prism::DefNode
-          surrounding_method = node.name.to_s
-          next unless node.receiver.is_a?(Prism::SelfNode)
-
-          nesting << "<#{nesting.flat_map { |n| n.split("::") }.last}>"
+          receiver = node.receiver
+
+          surrounding_method = case receiver
+          when nil
+            MethodDef.new(node.name.to_s, "none")
+          when Prism::SelfNode
+            MethodDef.new(node.name.to_s, "self")
+          when Prism::ConstantReadNode, Prism::ConstantPathNode
+            MethodDef.new(node.name.to_s, receiver.slice)
+          else
+            MethodDef.new(node.name.to_s, nil)
+          end
         end
       end
 

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -24,6 +24,7 @@ module RubyLsp
       def initialize(global_state, item)
         super()
         @index = global_state.index #: RubyIndexer::Index
+        @graph = global_state.graph #: Rubydex::Graph
         @item = item
       end
 
@@ -40,7 +41,7 @@ module RubyLsp
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the
         # `label` for the text edit instead
         label = @item[:label].dup
-        return keyword_resolve(@item) if @item.dig(:data, :keyword)
+        return keyword_resolve if @item.dig(:data, :keyword)
 
         entries = @index[label] || []
 
@@ -80,29 +81,24 @@ module RubyLsp
 
       private
 
-      #: (Hash[Symbol, untyped] item) -> Hash[Symbol, untyped]
-      def keyword_resolve(item)
-        keyword = item[:label]
-        content = KEYWORD_DOCS[keyword]
-
-        if content
-          doc_uri = URI::Generic.from_path(path: File.join(STATIC_DOCS_PATH, "#{keyword}.md"))
+      #: () -> Hash[Symbol, untyped]
+      def keyword_resolve
+        keyword = @graph.keyword(@item[:label])
 
+        if keyword
           @item[:documentation] = Interface::MarkupContent.new(
             kind: "markdown",
             value: <<~MARKDOWN.chomp,
               ```ruby
-              #{keyword}
+              #{keyword.name}
               ```
 
-              [Read more](#{doc_uri})
-
-              #{content}
+              #{keyword.documentation}
             MARKDOWN
           )
         end
 
-        item
+        @item
       end
     end
   end

data/lib/ruby_lsp/requests/discover_tests.rb

@@ -19,55 +19,19 @@ module RubyLsp
         @document = document
         @dispatcher = dispatcher
         @response_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
-        @index = global_state.index #: RubyIndexer::Index
       end
 
       # @override
       #: -> Array[Support::TestItem]
       def perform
-        uri = @document.uri
+        Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+        Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
 
-        # We normally only index test files once they are opened in the editor to save memory and avoid doing
-        # unnecessary work. If the file is already opened and we already indexed it, then we can just discover the tests
-        # straight away.
-        #
-        # However, if the user navigates to a specific test file from the explorer with nothing opened in the UI, then
-        # we will not have indexed the test file yet and trying to linearize the ancestor of the class will fail. In
-        # this case, we have to instantiate the indexer listener first, so that we insert classes, modules and methods
-        # in the index first and then discover the tests, all in the same traversal.
-        if @index.entries_for(uri.to_s)
-          Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-          Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-
-          Addon.addons.each do |addon|
-            addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
-          end
-
-          @dispatcher.visit(@document.ast)
-        else
-          @global_state.synchronize do
-            RubyIndexer::DeclarationListener.new(
-              @index,
-              @dispatcher,
-              @document.parse_result,
-              uri,
-              collect_comments: true,
-            )
-
-            Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-            Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-
-            Addon.addons.each do |addon|
-              addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
-            end
-
-            # Dispatch the events both for indexing the test file and discovering the tests. The order here is
-            # important because we need the index to be aware of the existing classes/modules/methods before the test
-            # listeners can do their work
-            @dispatcher.visit(@document.ast)
-          end
+        Addon.addons.each do |addon|
+          addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
         end
 
+        @dispatcher.visit(@document.ast)
         @response_builder.response
       end
     end

data/lib/ruby_lsp/requests/hover.rb

@@ -26,7 +26,6 @@ module RubyLsp
         node_context = RubyDocument.locate(
           document.ast,
           char_position,
-          node_types: Listeners::Hover::ALLOWED_TARGETS,
           code_units_cache: document.code_units_cache,
         )
         target = node_context.node
@@ -48,7 +47,7 @@ module RubyLsp
         @target = target #: Prism::Node?
         uri = document.uri
         @response_builder = ResponseBuilders::Hover.new #: ResponseBuilders::Hover
-        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level)
+        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level, position)
         Addon.addons.each do |addon|
           addon.create_hover_listener(@response_builder, node_context, dispatcher)
         end
@@ -77,9 +76,7 @@ module RubyLsp
 
       #: (Prism::Node? parent, Prism::Node? target) -> bool
       def should_refine_target?(parent, target)
-        (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-        !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
-          (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+        parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode)
       end
 
       #: (Hash[Symbol, untyped] position, Prism::Node? target) -> bool

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -5,9 +5,7 @@ module RubyLsp
   module Requests
     # The [prepare type hierarchy
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_prepareTypeHierarchy)
-    # displays the list of ancestors (supertypes) and descendants (subtypes) for the selected type.
-    #
-    # Currently only supports supertypes due to a limitation of the index.
+    # displays the list of direct ancestors (supertypes) and descendants (subtypes) for the selected type.
     class PrepareTypeHierarchy < Request
       include Support::Common
 
@@ -18,12 +16,12 @@ module RubyLsp
         end
       end
 
-      #: ((RubyDocument | ERBDocument) document, RubyIndexer::Index index, Hash[Symbol, untyped] position) -> void
-      def initialize(document, index, position)
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position) -> void
+      def initialize(document, global_state, position)
         super()
 
         @document = document
-        @index = index
+        @graph = global_state.graph #: Rubydex::Graph
         @position = position
       end
 
@@ -36,32 +34,78 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantWriteNode,
             Prism::ConstantPathNode,
+            Prism::SingletonClassNode,
           ],
         )
 
-        node = context.node
-        parent = context.parent
-        return unless node && parent
+        node = context.node #: as (Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantWriteNode | Prism::SingletonClassNode)?
+        return unless node
+
+        pair = name_and_nesting(node, context)
+        return unless pair
 
-        target = determine_target(node, parent, @position)
-        entries = @index.resolve(target.slice, context.nesting)
-        return unless entries
+        declaration = @graph.resolve_constant(pair.first, pair.last)
+        return unless declaration.is_a?(Rubydex::Namespace)
 
-        # While the spec allows for multiple entries, VSCode seems to only support one
-        # We'll just return the first one for now
-        first_entry = entries.first #: as !nil
-        range = range_from_location(first_entry.location)
+        primary = declaration.definitions.first
+        return unless primary
 
         [
-          Interface::TypeHierarchyItem.new(
-            name: first_entry.name,
-            kind: kind_for_entry(first_entry),
-            uri: first_entry.uri.to_s,
-            range: range,
-            selection_range: range,
+          primary.to_lsp_type_hierarchy_item(
+            declaration.name,
+            detail: declaration.lsp_type_hierarchy_detail,
           ),
         ]
       end
+
+      private
+
+      # Returns the `(name, nesting)` pair to pass to `Rubydex::Graph#resolve_constant`, covering three cases:
+      #
+      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantWriteNode | Prism::SingletonClassNode), NodeContext) -> [String, Array[String]]?
+      def name_and_nesting(node, context)
+        parent = context.parent
+        nesting = context.nesting
+
+        singleton_node = singleton_class_node_for(node, parent)
+        return singleton_lookup(singleton_node, nesting) if singleton_node
+
+        target = parent ? determine_target(node, parent, @position) : node
+        [target.slice, nesting]
+      end
+
+      # Ensures that we're returning the target of the singleton class block regardless of whether the cursor is on the
+      # `class` keyword or the constant reference for the target
+      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantWriteNode | Prism::SingletonClassNode), Prism::Node?) -> Prism::SingletonClassNode?
+      def singleton_class_node_for(node, parent)
+        return node if node.is_a?(Prism::SingletonClassNode)
+        return unless parent.is_a?(Prism::SingletonClassNode) && parent.expression == node
+
+        parent
+      end
+
+      # Builds the synthesized singleton class name (e.g. `Foo::<Foo>`) for a `class << X` block, together with the
+      # outer lexical nesting. `NodeContext` already appends a `<ClassName>` marker as the last element of the nesting
+      # whenever the cursor sits inside (or on) a `SingletonClassNode`, so we drop that marker to obtain the scope in
+      # which the singleton should be resolved.
+      #: (Prism::SingletonClassNode, Array[String]) -> [String, Array[String]]?
+      def singleton_lookup(singleton_node, nesting)
+        outer = nesting[0...-1] || []
+
+        case expression = singleton_node.expression
+        when Prism::SelfNode
+          name = nesting.last
+          return unless name
+
+          [name, outer]
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          name = constant_name(expression)
+          return unless name
+
+          unqualified = name.split("::").last #: as !nil
+          ["#{name}::<#{unqualified}>", outer]
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/references.rb

@@ -9,126 +9,226 @@ module RubyLsp
     class References < Request
       include Support::Common
 
+      MAX_NUMBER_OF_METHOD_CANDIDATES_WITHOUT_RECEIVER = 30
+
       #: (GlobalState global_state, Store store, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] params) -> void
       def initialize(global_state, store, document, params)
         super()
         @global_state = global_state
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
+        @graph = global_state.graph #: Rubydex::Graph
         @store = store
         @document = document
         @params = params
         @locations = [] #: Array[Interface::Location]
+        @char_position = 0 #: Integer
       end
 
       # @override
       #: -> Array[Interface::Location]
       def perform
-        position = @params[:position]
-        char_position, _ = @document.find_index_by_position(position)
+        include_declarations = @params.dig(:context, :includeDeclaration) || false
+        @char_position, _ = @document.find_index_by_position(@params[:position])
 
         node_context = RubyDocument.locate(
           @document.ast,
-          char_position,
+          @char_position,
           node_types: [
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::ConstantPathTargetNode,
+            Prism::ConstantAndWriteNode,
+            Prism::ConstantOperatorWriteNode,
+            Prism::ConstantOrWriteNode,
+            Prism::ConstantTargetNode,
+            Prism::ConstantWriteNode,
             Prism::InstanceVariableAndWriteNode,
             Prism::InstanceVariableOperatorWriteNode,
             Prism::InstanceVariableOrWriteNode,
             Prism::InstanceVariableReadNode,
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
+            Prism::ClassVariableAndWriteNode,
+            Prism::ClassVariableOperatorWriteNode,
+            Prism::ClassVariableOrWriteNode,
+            Prism::ClassVariableReadNode,
+            Prism::ClassVariableTargetNode,
+            Prism::ClassVariableWriteNode,
+            Prism::GlobalVariableAndWriteNode,
+            Prism::GlobalVariableOperatorWriteNode,
+            Prism::GlobalVariableOrWriteNode,
+            Prism::GlobalVariableReadNode,
+            Prism::GlobalVariableTargetNode,
+            Prism::GlobalVariableWriteNode,
             Prism::CallNode,
+            Prism::CallAndWriteNode,
+            Prism::CallOperatorWriteNode,
+            Prism::CallOrWriteNode,
             Prism::DefNode,
           ],
           code_units_cache: @document.code_units_cache,
         )
         target = node_context.node
-        parent = node_context.parent
         return @locations if !target || target.is_a?(Prism::ProgramNode)
 
-        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
-          target = determine_target(
-            target,
-            parent,
-            position,
-          )
+        case target
+        when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
+          name = constant_name(target)
+          handle_constant_references(name, node_context, include_declarations) if name
+        when Prism::ConstantTargetNode
+          handle_constant_references(target.name.to_s, node_context, include_declarations)
+        when Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantOrWriteNode,
+          Prism::ConstantWriteNode
+          if cursor_on_name?(target.name_loc)
+            handle_constant_references(target.name.to_s, node_context, include_declarations)
+          end
+        when Prism::InstanceVariableReadNode, Prism::InstanceVariableTargetNode,
+          Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
+          handle_variable_references(target.name.to_s, node_context, include_declarations)
+        when Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableWriteNode,
+          Prism::ClassVariableAndWriteNode, Prism::ClassVariableOperatorWriteNode,
+          Prism::ClassVariableOrWriteNode, Prism::ClassVariableWriteNode
+          if cursor_on_name?(target.name_loc)
+            handle_variable_references(target.name.to_s, node_context, include_declarations)
+          end
+        when Prism::GlobalVariableReadNode, Prism::GlobalVariableTargetNode
+          handle_global_variable_references(target.name.to_s, include_declarations)
+        when Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableWriteNode
+          if cursor_on_name?(target.name_loc)
+            handle_global_variable_references(target.name.to_s, include_declarations)
+          end
+        when Prism::CallNode
+          message_loc = target.message_loc
+          message = target.message
+          if message && message_loc && cursor_on_name?(message_loc)
+            resolve_method_references(message, node_context, include_declarations)
+          end
+        when Prism::CallAndWriteNode, Prism::CallOperatorWriteNode, Prism::CallOrWriteNode
+          message_loc = target.message_loc
+          if message_loc && cursor_on_name?(message_loc)
+            resolve_method_references(target.read_name.to_s, node_context, include_declarations)
+          end
+        when Prism::DefNode
+          handle_def_node_references(target, node_context, include_declarations) if cursor_on_name?(target.name_loc)
         end
 
-        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode,
+        @locations
+      end
 
-        reference_target = create_reference_target(target, node_context)
-        return @locations unless reference_target
+      private
 
-        Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
-          uri = URI::Generic.from_path(path: path)
-          # If the document is being managed by the client, then we should use whatever is present in the store instead
-          # of reading from disk
-          next if @store.key?(uri)
+      #: (String name, NodeContext node_context, bool include_declarations) -> void
+      def handle_constant_references(name, node_context, include_declarations)
+        declaration = @graph.resolve_constant(name, node_context.nesting)
+        return unless declaration
 
-          parse_result = Prism.parse_lex_file(path)
-          collect_references(reference_target, parse_result, uri)
-        rescue Errno::EISDIR, Errno::ENOENT
-          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
+        collect_references(declaration.references, [declaration], include_declarations)
+      end
+
+      #: (String message, NodeContext node_context, bool include_declarations) -> void
+      def resolve_method_references(message, node_context, include_declarations)
+        receiver_type = @type_inferrer.infer_receiver_type(node_context)
+
+        declaration = if receiver_type
+          owner = @graph[receiver_type.name]
+          owner.find_member("#{message}()") if owner.is_a?(Rubydex::Namespace)
         end
 
-        @store.each do |_uri, document|
-          collect_references(reference_target, document.parse_result, document.uri)
+        declarations = if receiver_type.nil? || (receiver_type.is_a?(TypeInferrer::GuessedType) && declaration.nil?)
+          @graph.search("##{message}()").take(MAX_NUMBER_OF_METHOD_CANDIDATES_WITHOUT_RECEIVER)
+        elsif declaration
+          [declaration]
+        else
+          []
         end
+        return if declarations.empty?
 
-        @locations
+        collect_references(method_references_for(message), declarations, include_declarations)
       end
 
-      private
+      # Handles instance and class variable references. Resolves the receiver type from the node context to locate
+      # the owning namespace, then looks up the member through the ancestor chain via `find_member`.
+      #: (String name, NodeContext node_context, bool include_declarations) -> void
+      def handle_variable_references(name, node_context, include_declarations)
+        type = @type_inferrer.infer_receiver_type(node_context)
+        return unless type
 
-      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode) target_node, NodeContext node_context) -> RubyIndexer::ReferenceFinder::Target?
-      def create_reference_target(target_node, node_context)
-        case target_node
-        when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
-          name = RubyIndexer::Index.constant_name(target_node)
-          return unless name
-
-          entries = @global_state.index.resolve(name, node_context.nesting)
-          return unless entries
-
-          fully_qualified_name = entries.first #: as !nil
-            .name
-          RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
-        when
-          Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode,
-          Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableReadNode,
-          Prism::InstanceVariableTargetNode,
-          Prism::InstanceVariableWriteNode
-          receiver_type = @global_state.type_inferrer.infer_receiver_type(node_context)
-          return unless receiver_type
-
-          ancestors = @global_state.index.linearized_ancestors_of(receiver_type.name)
-          RubyIndexer::ReferenceFinder::InstanceVariableTarget.new(target_node.name.to_s, ancestors)
-        when Prism::CallNode, Prism::DefNode
-          RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
-        end
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
+
+        declaration = owner.find_member(name)
+        return unless declaration
+
+        collect_references(declaration.references, [declaration], include_declarations)
       end
 
-      #: (RubyIndexer::ReferenceFinder::Target target, Prism::LexResult parse_result, URI::Generic uri) -> void
-      def collect_references(target, parse_result, uri)
-        dispatcher = Prism::Dispatcher.new
-        finder = RubyIndexer::ReferenceFinder.new(
-          target,
-          @global_state.index,
-          dispatcher,
-          uri,
-          include_declarations: @params.dig(:context, :includeDeclaration) || true,
-        )
-        dispatcher.visit(parse_result.value.first)
+      # Handles global variable references. Globals are keyed by their full name (including `$`) in the graph, so we
+      # can look them up directly without needing to resolve a receiver type.
+      #: (String name, bool include_declarations) -> void
+      def handle_global_variable_references(name, include_declarations)
+        declaration = @graph[name]
+        return unless declaration
+
+        collect_references(declaration.references, [declaration], include_declarations)
+      end
 
-        finder.references.each do |reference|
-          @locations << Interface::Location.new(
-            uri: uri.to_s,
-            range: range_from_location(reference.location),
-          )
+      #: (Prism::DefNode target, NodeContext node_context, bool include_declarations) -> void
+      def handle_def_node_references(target, node_context, include_declarations)
+        method_name = target.name.to_s
+
+        owner_type = @type_inferrer.infer_receiver_type(node_context)
+        return unless owner_type
+
+        owner = @graph[owner_type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
+
+        declaration = owner.find_member("#{method_name}()")
+        return unless declaration
+
+        collect_references(method_references_for(method_name), [declaration], include_declarations)
+      end
+
+      # Method references in Rubydex are not yet resolved to specific declarations, so we filter from the global
+      # method references by name
+      #: (String) -> Array[Rubydex::MethodReference]
+      def method_references_for(method_name)
+        @graph.method_references.select { |reference| reference.name == method_name }
+      end
+
+      #: (Enumerable[Rubydex::Reference] references, Array[Rubydex::Declaration] declarations, bool include_declarations) -> void
+      def collect_references(references, declarations, include_declarations)
+        references.each do |reference|
+          next if rubydex_internal_uri?(reference.location.uri)
+
+          @locations << reference.to_lsp_location
         end
+
+        return unless include_declarations
+
+        declarations.each do |declaration|
+          declaration.definitions.each do |definition|
+            next if rubydex_internal_uri?(definition.location.uri)
+
+            @locations << definition.to_lsp_selection_location
+          end
+        end
+      end
+
+      #: (String uri) -> bool
+      def rubydex_internal_uri?(uri)
+        URI(uri).scheme == "rubydex"
+      end
+
+      # Write, operator-write, and call-with-message nodes cover more than just the identifier —
+      # they span the whole assignment or call expression. We only resolve references when the
+      # cursor is positioned directly on the name itself, not on operators, values, or arguments.
+      #: (Prism::Location name_loc) -> bool
+      def cursor_on_name?(name_loc)
+        start = name_loc.cached_start_code_units_offset(@document.code_units_cache)
+        finish = name_loc.cached_end_code_units_offset(@document.code_units_cache)
+        (start...finish).cover?(@char_position)
       end
     end
   end