pink_spoon 0.1.0

data/lib/ruby_lsp/pink_spoon/definition_listener.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module PinkSpoon
+    # Fired on every textDocument/definition request.
+    # Resolves the call under the cursor, looks up the RBI definition location,
+    # and pushes an Interface::Location into the response.
+    class DefinitionListener
+      def initialize(response_builder, uri, node_context, dispatcher, resolver, rbi_index, doc_extractor = nil)
+        @response_builder = response_builder
+        @uri              = uri
+        @node_context     = node_context
+        @resolver         = resolver
+        @rbi_index        = rbi_index
+        @doc_extractor    = doc_extractor
+
+        dispatcher.register(
+          self,
+          :on_call_node_enter,
+          :on_local_variable_read_node_enter,
+          :on_constant_read_node_enter,
+          :on_constant_path_node_enter,
+          :on_instance_variable_read_node_enter,
+          :on_forwarding_super_node_enter,
+          :on_super_node_enter,
+          :on_symbol_node_enter,
+          :on_def_node_enter,
+        )
+      end
+
+      def on_call_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        nesting      = @node_context.instance_variable_get(:@nesting_nodes)
+        program_node = nesting&.find { |n| n.is_a?(Prism::ProgramNode) }
+        return unless program_node
+
+        resolved = @resolver.resolve_from_call(node, program_node, nesting)
+
+        location = if resolved
+          source_location(resolved) || rbi_location(resolved)
+        end
+
+        # Bare call (no explicit receiver): try two more strategies.
+        if location.nil? && node.receiver.nil?
+          method_name = node.name.to_s
+          location    = nesting_location(method_name, nesting) ||
+                        current_file_location(method_name)
+        end
+
+        # Fallback: ruby-lsp resolves LocalVariableReadNode receivers up to the
+        # parent CallNode (LocalVariableReadNode is not in the definition node_types
+        # list). If method resolution failed, navigate to the receiver variable's
+        # declaration instead — that is almost certainly what the user clicked on.
+        if location.nil? && node.receiver
+          location = receiver_variable_location(node.receiver)
+        end
+
+        return unless location
+
+        push_location(location[:file], location[:line])
+      end
+
+      def on_constant_read_node_enter(node)
+        return unless node.equal?(@node_context.node)
+        goto_constant(node.name.to_s)
+      end
+
+      def on_constant_path_node_enter(node)
+        return unless node.equal?(@node_context.node)
+        goto_constant(node.slice.delete_prefix("::"))
+      end
+
+      # Symbol go-to-def: :method_name → def method_name
+      def on_symbol_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        method_name = node.value
+        return unless method_name && !method_name.empty?
+
+        loc = current_file_location(method_name)
+        return push_location(loc[:file], loc[:line]) if loc
+
+        loc = @doc_extractor&.find_source(
+          guess_type_from_nesting(@node_context.instance_variable_get(:@nesting_nodes)),
+          method_name
+        )
+        push_location(loc[:file], loc[:line]) if loc
+      rescue
+        nil
+      end
+
+      # Hover on def: cursor on the method name in a definition
+      def on_def_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        nesting    = @node_context.instance_variable_get(:@nesting_nodes)
+        class_node = nesting&.reverse&.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+        return unless class_node
+
+        type = class_node.constant_path.slice.delete_prefix("::")
+        loc  = source_location({ type: type, method: node.name.to_s })
+        push_location(loc[:file], loc[:line]) if loc
+      rescue
+        nil
+      end
+
+      def on_forwarding_super_node_enter(node)
+        return unless node.equal?(@node_context.node)
+        navigate_super(node)
+      end
+
+      def on_super_node_enter(node)
+        return unless node.equal?(@node_context.node)
+        navigate_super(node)
+      end
+
+      def on_instance_variable_read_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        file = @uri.to_s.delete_prefix("file://")
+        return unless file && File.exist?(file)
+
+        ivar_name = node.name.to_s
+        read_line = node.location.start_line
+
+        result = Prism.parse_file(file)
+        finder = IvarAssignmentFinder.new(ivar_name, read_line)
+        finder.visit(result.value)
+
+        if finder.line
+          push_location(file, finder.line)
+          return
+        end
+
+        # Not found in current file — walk the parent class chain.
+        nesting    = @node_context.instance_variable_get(:@nesting_nodes)
+        class_node = nesting&.reverse&.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+        return unless class_node
+
+        current_type = class_node.constant_path.slice.delete_prefix("::")
+        @rbi_index.mixins_for(current_type).each do |parent_type|
+          loc = @doc_extractor&.find_ivar_in_type(parent_type, ivar_name)
+          if loc
+            push_location(loc[:file], loc[:line])
+            return
+          end
+        end
+      rescue
+        nil
+      end
+
+      private
+
+      def navigate_super(node)
+        nesting      = @node_context.instance_variable_get(:@nesting_nodes)
+        program_node = nesting&.find { |n| n.is_a?(Prism::ProgramNode) }
+        return unless program_node
+
+        class_node = nesting.reverse.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+        return unless class_node
+
+        current_type = class_node.constant_path.slice.delete_prefix("::")
+        method_name  = EnclosingMethodFinder.new(node.location.start_line).find(program_node)
+        return unless method_name
+
+        @rbi_index.mixins_for(current_type).each do |parent_type|
+          resolved = { type: parent_type, method: method_name }
+          location = rbi_location(resolved) || source_location(resolved)
+          if location
+            push_location(location[:file], location[:line])
+            return
+          end
+        end
+      end
+
+      # When go-to-def is clicked on a local variable or ivar that is the
+      # receiver of a method call, navigate to where that variable is declared.
+      def receiver_variable_location(receiver)
+        file = @uri.to_s.delete_prefix("file://")
+        return nil unless file && File.exist?(file)
+
+        result = Prism.parse_file(file)
+
+        case receiver
+        when Prism::LocalVariableReadNode
+          finder = LocalVariableDefinitionFinder.new(
+            receiver.name.to_s,
+            receiver.location.start_line,
+          )
+          finder.visit(result.value)
+          { file: file, line: finder.line } if finder.line
+
+        when Prism::InstanceVariableReadNode
+          finder = IvarAssignmentFinder.new(
+            receiver.name.to_s,
+            receiver.location.start_line,
+          )
+          finder.visit(result.value)
+          { file: file, line: finder.line } if finder.line
+        end
+      rescue
+        nil
+      end
+
+      def guess_type_from_nesting(nesting)
+        class_node = nesting&.reverse&.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+        class_node&.constant_path&.slice&.delete_prefix("::")
+      end
+
+      def goto_constant(type)
+        location = @doc_extractor&.find_constant_source(type)
+        return unless location
+        push_location(location[:file], location[:line])
+      end
+
+      def rbi_location(resolved)
+        @rbi_index.rbi_location_for(resolved[:type], resolved[:method])
+      end
+
+      def source_location(resolved)
+        @doc_extractor&.find_source(resolved[:type], resolved[:method])
+      end
+
+      # Infer the type from the innermost enclosing class/module in the nesting
+      # and look the method up in the RBI index or gem source.
+      def nesting_location(method_name, nesting)
+        return nil unless nesting
+
+        class_node = nesting.reverse.find do |n|
+          n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode)
+        end
+        return nil unless class_node
+
+        type     = class_node.constant_path.slice.delete_prefix("::")
+        resolved = { type: type, method: method_name }
+
+        rbi_location(resolved) || source_location(resolved)
+      end
+
+      # Handles go-to-definition for real local variables (entry = ..., |entry|, etc).
+      def on_local_variable_read_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        file = @uri.to_s.delete_prefix("file://")
+        return unless file && File.exist?(file)
+
+        var_name  = node.name.to_s
+        read_line = node.location.start_line
+
+        result = Prism.parse_file(file)
+        finder = LocalVariableDefinitionFinder.new(var_name, read_line)
+        finder.visit(result.value)
+        line = finder.line
+        return unless line
+
+        push_location(file, line)
+      rescue
+        nil
+      end
+
+      # Last resort: scan the file the user is currently editing.
+      # Matches def, let(:name), let!(:name), subject(:name), subject!(:name).
+      def current_file_location(method_name)
+        file = @uri.to_s.delete_prefix("file://")
+        return nil unless file && File.exist?(file)
+
+        e       = Regexp.escape(method_name)
+        def_re  = /\bdef\s+(?:self\.)?#{e}(?=[\s\(;]|\z)/
+        let_re  = /\blet[!]?\s*\(\s*:#{e}\b/
+        subj_re = /\bsubject[!]?\s*\(\s*:#{e}\b/
+
+        File.foreach(file).with_index(1) do |raw, i|
+          return { file: file, line: i } if raw.match?(def_re) || raw.match?(let_re) || raw.match?(subj_re)
+        end
+
+        nil
+      rescue
+        nil
+      end
+
+      def push_location(file, line)
+        line_lsp = line - 1
+        @response_builder << Interface::Location.new(
+          uri:   "file://#{file}",
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: line_lsp, character: 0),
+            end:   Interface::Position.new(line: line_lsp, character: 0),
+          ),
+        )
+      end
+
+      # Finds the line where a local variable was last assigned before
+      # a given line. Handles plain writes, block params, and method params.
+      class LocalVariableDefinitionFinder < Prism::Visitor
+        attr_reader :line
+
+        def initialize(var_name, before_line)
+          @var_name    = var_name
+          @before_line = before_line
+          @candidates  = []
+        end
+
+        def line
+          @candidates.last
+        end
+
+        def visit_local_variable_write_node(node)
+          record(node)
+          super
+        end
+
+        def visit_local_variable_operator_write_node(node)
+          record(node)
+          super
+        end
+
+        def visit_local_variable_or_write_node(node)
+          record(node)
+          super
+        end
+
+        def visit_local_variable_and_write_node(node)
+          record(node)
+          super
+        end
+
+        # Method parameters: def foo(entry)
+        def visit_required_parameter_node(node)
+          record(node)
+          super
+        end
+
+        def visit_optional_parameter_node(node)
+          record(node)
+          super
+        end
+
+        # Block parameters: do |entry|
+        def visit_block_parameter_node(node)
+          record(node)
+          super
+        end
+
+        def visit_required_keyword_parameter_node(node)
+          record(node)
+          super
+        end
+
+        def visit_optional_keyword_parameter_node(node)
+          record(node)
+          super
+        end
+
+        private
+
+        def record(node)
+          return unless node.name.to_s == @var_name
+          line_no = node.location.start_line
+          @candidates << line_no if line_no <= @before_line
+        end
+      end
+
+      # Finds the name of the innermost method def that contains a target line.
+      class EnclosingMethodFinder < Prism::Visitor
+        def initialize(target_line)
+          @target_line = target_line
+          @best_name   = nil
+          @best_span   = nil
+        end
+
+        def find(ast)
+          visit(ast)
+          @best_name
+        end
+
+        def visit_def_node(node)
+          loc = node.location
+          return super unless @target_line >= loc.start_line && @target_line <= loc.end_line
+
+          span = loc.end_line - loc.start_line
+          if @best_span.nil? || span < @best_span
+            @best_span = span
+            @best_name = node.name.to_s
+          end
+          super
+        end
+      end
+
+      # Finds the nearest instance variable write (@ivar = ...) before a given line.
+      class IvarAssignmentFinder < Prism::Visitor
+        def initialize(ivar_name, before_line)
+          @ivar_name   = ivar_name
+          @before_line = before_line
+          @candidates  = []
+        end
+
+        def line
+          @candidates.last
+        end
+
+        def visit_instance_variable_write_node(node)
+          if node.name.to_s == @ivar_name && node.location.start_line <= @before_line
+            @candidates << node.location.start_line
+          end
+          super
+        end
+
+        def visit_instance_variable_operator_write_node(node)
+          if node.name.to_s == @ivar_name && node.location.start_line <= @before_line
+            @candidates << node.location.start_line
+          end
+          super
+        end
+
+        def visit_instance_variable_or_write_node(node)
+          if node.name.to_s == @ivar_name && node.location.start_line <= @before_line
+            @candidates << node.location.start_line
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/pink_spoon/hover_listener.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module PinkSpoon
+    # Fired on every textDocument/hover request.
+    # Registers for two node types:
+    #   on_program_node_enter — captures the root AST so AssignmentFinder can
+    #                           scan the whole file for constant assignments.
+    #   on_call_node_enter    — resolves the receiver type for the call under
+    #                           the cursor and pushes a sig string into the
+    #                           hover panel.
+    class HoverListener
+      def initialize(response_builder, node_context, dispatcher, resolver, rbi_index, doc_extractor = nil)
+        @response_builder = response_builder
+        @node_context     = node_context
+        @resolver         = resolver
+        @rbi_index        = rbi_index
+        @doc_extractor    = doc_extractor
+
+        dispatcher.register(
+          self,
+          :on_call_node_enter,
+          :on_constant_read_node_enter,
+          :on_constant_path_node_enter,
+          :on_instance_variable_read_node_enter,
+        )
+      end
+
+      def on_constant_read_node_enter(node)
+        return unless node.equal?(@node_context.node)
+        serve_constant_hover(node.name.to_s)
+      end
+
+      def on_constant_path_node_enter(node)
+        return unless node.equal?(@node_context.node)
+        serve_constant_hover(node.slice.delete_prefix("::"))
+      end
+
+      def on_instance_variable_read_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        nesting    = @node_context.instance_variable_get(:@nesting_nodes)
+        class_node = nesting&.reverse&.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+        return unless class_node
+
+        type     = class_node.constant_path.slice.delete_prefix("::")
+        accessor = node.name.to_s.delete_prefix("@")
+
+        content = @rbi_index.hover_content_for(type, accessor)
+        return unless content
+
+        @response_builder.push(content, category: :documentation)
+      end
+
+      def on_call_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        nesting      = @node_context.instance_variable_get(:@nesting_nodes)
+        program_node = nesting&.find { |n| n.is_a?(Prism::ProgramNode) }
+        return unless program_node
+
+        resolved = @resolver.resolve_from_call(node, program_node)
+        return unless resolved
+
+        rbi_content = @rbi_index.hover_content_for(resolved[:type], resolved[:method])
+        doc_content = @doc_extractor&.extract(resolved[:type], resolved[:method])
+
+        content = combine(rbi_content, doc_content)
+        return unless content
+
+        @response_builder.push(content, category: :documentation)
+      end
+
+      private
+
+      def serve_constant_hover(type)
+        return unless @doc_extractor
+
+        doc = @doc_extractor.extract_for_constant(type)
+        return unless doc
+
+        @response_builder.push("**`#{type}`**\n\n#{doc}", category: :documentation)
+      end
+
+      def combine(rbi, doc)
+        return nil unless rbi || doc
+        return rbi unless doc
+        return doc unless rbi
+
+        "#{rbi}\n\n---\n\n#{doc}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: pink_spoon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jānis Harbs
+bindir: bin
+cert_chain: []
+date: 2026-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.24'
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: Augments ruby-lsp hover and go-to-definition with type information from
+  sorbet/rbi/**/*.rbi. Drop it in your Gemfile and it just works.
+executables:
+- pink-spoon
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/install-addon
+- bin/pink-spoon
+- lib/pink_spoon.rb
+- lib/pink_spoon/constant_resolver.rb
+- lib/pink_spoon/definition_finder.rb
+- lib/pink_spoon/doc_extractor.rb
+- lib/pink_spoon/rbi_index.rb
+- lib/pink_spoon/server.rb
+- lib/pink_spoon/version.rb
+- lib/ruby_lsp/pink_spoon/addon.rb
+- lib/ruby_lsp/pink_spoon/code_lens_listener.rb
+- lib/ruby_lsp/pink_spoon/completion_listener.rb
+- lib/ruby_lsp/pink_spoon/definition_listener.rb
+- lib/ruby_lsp/pink_spoon/hover_listener.rb
+licenses: []
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: 'ruby-lsp addon: resolves types from Sorbet RBI files'
+test_files: []