ruby-lsp 0.19.0 → 0.20.0

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

@@ -44,6 +44,8 @@ module RubyIndexer
       when RBS::AST::Declarations::Constant
         namespace_nesting = declaration.name.namespace.path.map(&:to_s)
         handle_constant(declaration, namespace_nesting, pathname.to_s)
+      when RBS::AST::Declarations::Global
+        handle_global_variable(declaration, pathname)
       else # rubocop:disable Style/EmptyElse
         # Other kinds not yet handled
       end
@@ -59,9 +61,9 @@ module RubyIndexer
       comments = comments_to_string(declaration)
       entry = if declaration.is_a?(RBS::AST::Declarations::Class)
         parent_class = declaration.super_class&.name&.name&.to_s
-        Entry::Class.new(nesting, file_path, location, location, comments, @index.configuration.encoding, parent_class)
+        Entry::Class.new(nesting, file_path, location, location, comments, parent_class)
       else
-        Entry::Module.new(nesting, file_path, location, location, comments, @index.configuration.encoding)
+        Entry::Module.new(nesting, file_path, location, location, comments)
       end
       add_declaration_mixins_to_entry(declaration, entry)
       @index.add(entry)
@@ -134,7 +136,6 @@ module RubyIndexer
         location,
         location,
         comments,
-        @index.configuration.encoding,
         signatures,
         visibility,
         real_owner,
@@ -267,7 +268,21 @@ module RubyIndexer
         file_path,
         to_ruby_indexer_location(declaration.location),
         comments_to_string(declaration),
-        @index.configuration.encoding,
+      ))
+    end
+
+    sig { params(declaration: RBS::AST::Declarations::Global, pathname: Pathname).void }
+    def handle_global_variable(declaration, pathname)
+      name = declaration.name.to_s
+      file_path = pathname.to_s
+      location = to_ruby_indexer_location(declaration.location)
+      comments = comments_to_string(declaration)
+
+      @index.add(Entry::GlobalVariable.new(
+        name,
+        file_path,
+        location,
+        comments,
       ))
     end
 
@@ -283,7 +298,6 @@ module RubyIndexer
         file_path,
         to_ruby_indexer_location(member.location),
         comments,
-        @index.configuration.encoding,
       )
 
       @index.add(entry)
@@ -294,6 +308,7 @@ module RubyIndexer
         RBS::AST::Declarations::Class,
         RBS::AST::Declarations::Module,
         RBS::AST::Declarations::Constant,
+        RBS::AST::Declarations::Global,
         RBS::AST::Members::MethodDefinition,
         RBS::AST::Members::Alias,
       )).returns(T.nilable(String))

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -5,6 +5,38 @@ module RubyIndexer
   class ReferenceFinder
     extend T::Sig
 
+    class Target
+      extend T::Helpers
+
+      abstract!
+    end
+
+    class ConstTarget < Target
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :fully_qualified_name
+
+      sig { params(fully_qualified_name: String).void }
+      def initialize(fully_qualified_name)
+        super()
+        @fully_qualified_name = fully_qualified_name
+      end
+    end
+
+    class MethodTarget < Target
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :method_name
+
+      sig { params(method_name: String).void }
+      def initialize(method_name)
+        super()
+        @method_name = method_name
+      end
+    end
+
     class Reference
       extend T::Sig
 
@@ -14,26 +46,29 @@ module RubyIndexer
       sig { returns(Prism::Location) }
       attr_reader :location
 
-      sig { params(name: String, location: Prism::Location).void }
-      def initialize(name, location)
+      sig { returns(T::Boolean) }
+      attr_reader :declaration
+
+      sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
+      def initialize(name, location, declaration:)
         @name = name
         @location = location
+        @declaration = declaration
       end
     end
 
-    sig { returns(T::Array[Reference]) }
-    attr_reader :references
-
     sig do
       params(
-        fully_qualified_name: String,
+        target: Target,
         index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
+        include_declarations: T::Boolean,
       ).void
     end
-    def initialize(fully_qualified_name, index, dispatcher)
-      @fully_qualified_name = fully_qualified_name
+    def initialize(target, index, dispatcher, include_declarations: true)
+      @target = target
       @index = index
+      @include_declarations = include_declarations
       @stack = T.let([], T::Array[String])
       @references = T.let([], T::Array[Reference])
 
@@ -59,17 +94,25 @@ module RubyIndexer
         :on_constant_or_write_node_enter,
         :on_constant_and_write_node_enter,
         :on_constant_operator_write_node_enter,
+        :on_call_node_enter,
       )
     end
 
+    sig { returns(T::Array[Reference]) }
+    def references
+      return @references if @include_declarations
+
+      @references.reject(&:declaration)
+    end
+
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_enter(node)
       constant_path = node.constant_path
       name = constant_path.slice
       nesting = actual_nesting(name)
 
-      if nesting.join("::") == @fully_qualified_name
-        @references << Reference.new(name, constant_path.location)
+      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
+        @references << Reference.new(name, constant_path.location, declaration: true)
       end
 
       @stack << name
@@ -86,8 +129,8 @@ module RubyIndexer
       name = constant_path.slice
       nesting = actual_nesting(name)
 
-      if nesting.join("::") == @fully_qualified_name
-        @references << Reference.new(name, constant_path.location)
+      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
+        @references << Reference.new(name, constant_path.location, declaration: true)
       end
 
       @stack << name
@@ -203,6 +246,10 @@ module RubyIndexer
 
     sig { params(node: Prism::DefNode).void }
     def on_def_node_enter(node)
+      if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
+        @references << Reference.new(name, node.name_loc, declaration: true)
+      end
+
       if node.receiver.is_a?(Prism::SelfNode)
         @stack << "<Class:#{@stack.last}>"
       end
@@ -215,6 +262,13 @@ module RubyIndexer
       end
     end
 
+    sig { params(node: Prism::CallNode).void }
+    def on_call_node_enter(node)
+      if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
+        @references << Reference.new(name, T.must(node.message_loc), declaration: false)
+      end
+    end
+
     private
 
     sig { params(name: String).returns(T::Array[String]) }
@@ -233,13 +287,21 @@ module RubyIndexer
 
     sig { params(name: String, location: Prism::Location).void }
     def collect_constant_references(name, location)
+      return unless @target.is_a?(ConstTarget)
+
       entries = @index.resolve(name, @stack)
       return unless entries
 
+      previous_reference = @references.last
+
       entries.each do |entry|
-        next unless entry.name == @fully_qualified_name
+        next unless entry.name == @target.fully_qualified_name
+
+        # When processing a class/module declaration, we eagerly handle the constant reference. To avoid duplicates,
+        # when we find the constant node defining the namespace, then we have to check if it wasn't already added
+        next if previous_reference&.location == location
 
-        @references << Reference.new(name, location)
+        @references << Reference.new(name, location, declaration: false)
       end
     end
 

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -630,5 +630,17 @@ module RubyIndexer
         its namespace nesting, and the surrounding CallNode (e.g. a method call).
       COMMENTS
     end
+
+    def test_lazy_comment_fetching_does_not_fail_if_file_gets_deleted
+      indexable = IndexablePath.new("#{Dir.pwd}/lib", "lib/ruby_lsp/does_not_exist.rb")
+
+      @index.index_single(indexable, <<~RUBY, collect_comments: false)
+        class Foo
+        end
+      RUBY
+
+      entry = @index["Foo"].first
+      assert_empty(entry.comments)
+    end
   end
 end

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -9,14 +9,14 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           return unless owner
           return unless node.name == :extend
 
           arguments = node.arguments&.arguments
           return unless arguments
 
-          location = node.location
+          location = Location.from_prism_location(node.location, code_units_cache)
 
           arguments.each do |node|
             next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
@@ -39,7 +39,6 @@ module RubyIndexer
               location,
               location,
               nil,
-              index.configuration.encoding,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
               Entry::Visibility::PUBLIC,
               owner,
@@ -102,7 +101,7 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           return unless owner
 
           name = node.name
@@ -114,7 +113,7 @@ module RubyIndexer
           association_name = arguments.first
           return unless association_name.is_a?(Prism::SymbolNode)
 
-          location = association_name.location
+          location = Location.from_prism_location(association_name.location, code_units_cache)
 
           index.add(Entry::Method.new(
             T.must(association_name.value),
@@ -122,7 +121,6 @@ module RubyIndexer
             location,
             location,
             nil,
-            index.configuration.encoding,
             [],
             Entry::Visibility::PUBLIC,
             owner,
@@ -166,7 +164,7 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           raise "Error"
         end
 

data/lib/ruby_indexer/test/global_variable_test.rb

@@ -0,0 +1,49 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class GlobalVariableTest < TestCase
+    def test_global_variable_and_write
+      index(<<~RUBY)
+        $foo &&= 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_operator_write
+      index(<<~RUBY)
+        $foo += 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_or_write
+      index(<<~RUBY)
+        $foo ||= 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_target_node
+      index(<<~RUBY)
+        $foo, $bar = 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+      assert_entry("$bar", Entry::GlobalVariable, "/fake/path/foo.rb:0-6:0-10")
+    end
+
+    def test_global_variable_write
+      index(<<~RUBY)
+        $foo = 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+  end
+end

data/lib/ruby_indexer/test/index_test.rb

@@ -1858,6 +1858,9 @@ module RubyIndexer
 
       entries = @index.entries_for("/fake/path/foo.rb", RubyIndexer::Entry::Namespace)
       assert_equal(["Foo", "Bar", "Bar::<Class:Bar>"], entries.map(&:name))
+
+      entries = @index.entries_for("/fake/path/foo.rb")
+      assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
     end
 
     def test_entries_for_returns_nil_if_no_matches

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -76,6 +76,20 @@ module RubyIndexer
       assert_operator(entry.location.end_column, :>, 0)
     end
 
+    def test_index_global_declaration
+      entries = @index["$DEBUG"]
+      refute_nil(entries)
+      assert_equal(1, entries.length)
+
+      entry = entries.first
+
+      assert_instance_of(Entry::GlobalVariable, entry)
+      assert_equal("$DEBUG", entry.name)
+      assert_match(%r{/gems/rbs-.*/core/global_variables.rbs}, entry.file_path)
+      assert_operator(entry.location.start_column, :<, entry.location.end_column)
+      assert_equal(entry.location.start_line, entry.location.end_line)
+    end
+
     def test_attaches_correct_owner_to_singleton_methods
       entries = @index["basename"]
       refute_nil(entries)

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -6,7 +6,7 @@ require "test_helper"
 module RubyIndexer
   class ReferenceFinderTest < Minitest::Test
     def test_finds_constant_references
-      refs = find_references("Foo::Bar", <<~RUBY)
+      refs = find_const_references("Foo::Bar", <<~RUBY)
         module Foo
           class Bar
           end
@@ -28,7 +28,7 @@ module RubyIndexer
     end
 
     def test_finds_constant_references_inside_singleton_contexts
-      refs = find_references("Foo::<Class:Foo>::Bar", <<~RUBY)
+      refs = find_const_references("Foo::<Class:Foo>::Bar", <<~RUBY)
         class Foo
           class << self
             class Bar
@@ -47,7 +47,7 @@ module RubyIndexer
     end
 
     def test_finds_top_level_constant_references
-      refs = find_references("Bar", <<~RUBY)
+      refs = find_const_references("Bar", <<~RUBY)
         class Bar
         end
 
@@ -70,17 +70,173 @@ module RubyIndexer
       assert_equal(8, refs[2].location.start_line)
     end
 
+    def test_finds_method_references
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def baz
+            foo
+          end
+        end
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(6, refs[1].location.start_line)
+    end
+
+    def test_does_not_mismatch_on_readers_and_writers
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def foo=(value)
+          end
+
+          def baz
+            self.foo = 1
+            self.foo
+          end
+        end
+      RUBY
+
+      # We want to match `foo` but not `foo=`
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(10, refs[1].location.start_line)
+    end
+
+    def test_matches_writers
+      refs = find_method_references("foo=", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def foo=(value)
+          end
+
+          def baz
+            self.foo = 1
+            self.foo
+          end
+        end
+      RUBY
+
+      # We want to match `foo=` but not `foo`
+      assert_equal(2, refs.size)
+
+      assert_equal("foo=", refs[0].name)
+      assert_equal(5, refs[0].location.start_line)
+
+      assert_equal("foo=", refs[1].name)
+      assert_equal(9, refs[1].location.start_line)
+    end
+
+    def test_find_inherited_methods
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+        end
+
+        class Baz < Bar
+          super.foo
+        end
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(7, refs[1].location.start_line)
+    end
+
+    def test_finds_methods_created_in_mixins
+      refs = find_method_references("foo", <<~RUBY)
+        module Mixin
+          def foo
+          end
+        end
+
+        class Bar
+          include Mixin
+        end
+
+        Bar.foo
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(10, refs[1].location.start_line)
+    end
+
+    def test_finds_singleton_methods
+      # The current implementation matches on both `Bar.foo` and `Bar#foo` even though they are different
+
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          class << self
+            def foo
+            end
+          end
+
+          def foo
+          end
+        end
+
+        Bar.foo
+      RUBY
+
+      assert_equal(3, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(3, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(7, refs[1].location.start_line)
+
+      assert_equal("foo", refs[2].name)
+      assert_equal(11, refs[2].location.start_line)
+    end
+
     private
 
-    def find_references(fully_qualified_name, source)
+    def find_const_references(const_name, source)
+      target = ReferenceFinder::ConstTarget.new(const_name)
+      find_references(target, source)
+    end
+
+    def find_method_references(method_name, source)
+      target = ReferenceFinder::MethodTarget.new(method_name)
+      find_references(target, source)
+    end
+
+    def find_references(target, source)
       file_path = "/fake.rb"
       index = Index.new
       index.index_single(IndexablePath.new(nil, file_path), source)
       parse_result = Prism.parse(source)
       dispatcher = Prism::Dispatcher.new
-      finder = ReferenceFinder.new(fully_qualified_name, index, dispatcher)
+      finder = ReferenceFinder.new(target, index, dispatcher)
       dispatcher.visit(parse_result.value)
-      finder.references.uniq(&:location)
+      finder.references
     end
   end
 end

data/lib/ruby_lsp/erb_document.rb

@@ -6,10 +6,18 @@ module RubyLsp
     extend T::Sig
     extend T::Generic
 
+    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+
     sig { returns(String) }
     attr_reader :host_language_source
 
-    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+    sig do
+      returns(T.any(
+        T.proc.params(arg0: Integer).returns(Integer),
+        Prism::CodeUnitsCache,
+      ))
+    end
+    attr_reader :code_units_cache
 
     sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
     def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
@@ -17,6 +25,10 @@ module RubyLsp
       # overrides this with the proper virtual host language source
       @host_language_source = T.let("", String)
       super
+      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
+        T.proc.params(arg0: Integer).returns(Integer),
+        Prism::CodeUnitsCache,
+      ))
     end
 
     sig { override.returns(T::Boolean) }
@@ -30,6 +42,7 @@ module RubyLsp
       # Use partial script to avoid syntax errors in ERB files where keywords may be used without the full context in
       # which they will be evaluated
       @parse_result = Prism.parse(scanner.ruby, partial_script: true)
+      @code_units_cache = @parse_result.code_units_cache(@encoding)
       true
     end
 
@@ -50,7 +63,12 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
-      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+      RubyDocument.locate(
+        @parse_result.value,
+        create_scanner.find_char_position(position),
+        code_units_cache: @code_units_cache,
+        node_types: node_types,
+      )
     end
 
     sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }

data/lib/ruby_lsp/internal.rb

@@ -75,10 +75,12 @@ require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"
 require "ruby_lsp/requests/prepare_type_hierarchy"
+require "ruby_lsp/requests/range_formatting"
+require "ruby_lsp/requests/references"
+require "ruby_lsp/requests/rename"
 require "ruby_lsp/requests/selection_ranges"
 require "ruby_lsp/requests/semantic_highlighting"
 require "ruby_lsp/requests/show_syntax_tree"
 require "ruby_lsp/requests/signature_help"
 require "ruby_lsp/requests/type_hierarchy_supertypes"
 require "ruby_lsp/requests/workspace_symbol"
-require "ruby_lsp/requests/rename"

data/lib/ruby_lsp/listeners/definition.rb

@@ -39,6 +39,7 @@ module RubyLsp
           :on_block_argument_node_enter,
           :on_constant_read_node_enter,
           :on_constant_path_node_enter,
+          :on_global_variable_read_node_enter,
           :on_instance_variable_read_node_enter,
           :on_instance_variable_write_node_enter,
           :on_instance_variable_and_write_node_enter,
@@ -120,6 +121,25 @@ module RubyLsp
         find_in_index(name)
       end
 
+      sig { params(node: Prism::GlobalVariableReadNode).void }
+      def on_global_variable_read_node_enter(node)
+        entries = @index[node.name.to_s]
+
+        return unless entries
+
+        entries.each do |entry|
+          location = entry.location
+
+          @response_builder << Interface::Location.new(
+            uri: URI::Generic.from_path(path: entry.file_path).to_s,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+            ),
+          )
+        end
+      end
+
       sig { params(node: Prism::InstanceVariableReadNode).void }
       def on_instance_variable_read_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)