ruby-lsp 0.18.3 → 0.19.1

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

@@ -0,0 +1,324 @@
+# typed: strict
+# frozen_string_literal: true
+
+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
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(Prism::Location) }
+      attr_reader :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 do
+      params(
+        target: Target,
+        index: RubyIndexer::Index,
+        dispatcher: Prism::Dispatcher,
+        include_declarations: T::Boolean,
+      ).void
+    end
+    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])
+
+      dispatcher.register(
+        self,
+        :on_class_node_enter,
+        :on_class_node_leave,
+        :on_module_node_enter,
+        :on_module_node_leave,
+        :on_singleton_class_node_enter,
+        :on_singleton_class_node_leave,
+        :on_def_node_enter,
+        :on_def_node_leave,
+        :on_multi_write_node_enter,
+        :on_constant_path_write_node_enter,
+        :on_constant_path_or_write_node_enter,
+        :on_constant_path_operator_write_node_enter,
+        :on_constant_path_and_write_node_enter,
+        :on_constant_or_write_node_enter,
+        :on_constant_path_node_enter,
+        :on_constant_read_node_enter,
+        :on_constant_write_node_enter,
+        :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 @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
+        @references << Reference.new(name, constant_path.location, declaration: true)
+      end
+
+      @stack << name
+    end
+
+    sig { params(node: Prism::ClassNode).void }
+    def on_class_node_leave(node)
+      @stack.pop
+    end
+
+    sig { params(node: Prism::ModuleNode).void }
+    def on_module_node_enter(node)
+      constant_path = node.constant_path
+      name = constant_path.slice
+      nesting = actual_nesting(name)
+
+      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
+        @references << Reference.new(name, constant_path.location, declaration: true)
+      end
+
+      @stack << name
+    end
+
+    sig { params(node: Prism::ModuleNode).void }
+    def on_module_node_leave(node)
+      @stack.pop
+    end
+
+    sig { params(node: Prism::SingletonClassNode).void }
+    def on_singleton_class_node_enter(node)
+      expression = node.expression
+      return unless expression.is_a?(Prism::SelfNode)
+
+      @stack << "<Class:#{@stack.last}>"
+    end
+
+    sig { params(node: Prism::SingletonClassNode).void }
+    def on_singleton_class_node_leave(node)
+      @stack.pop
+    end
+
+    sig { params(node: Prism::ConstantPathNode).void }
+    def on_constant_path_node_enter(node)
+      name = constant_name(node)
+      return unless name
+
+      collect_constant_references(name, node.location)
+    end
+
+    sig { params(node: Prism::ConstantReadNode).void }
+    def on_constant_read_node_enter(node)
+      name = constant_name(node)
+      return unless name
+
+      collect_constant_references(name, node.location)
+    end
+
+    sig { params(node: Prism::MultiWriteNode).void }
+    def on_multi_write_node_enter(node)
+      [*node.lefts, *node.rest, *node.rights].each do |target|
+        case target
+        when Prism::ConstantTargetNode, Prism::ConstantPathTargetNode
+          collect_constant_references(target.name.to_s, target.location)
+        end
+      end
+    end
+
+    sig { params(node: Prism::ConstantPathWriteNode).void }
+    def on_constant_path_write_node_enter(node)
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
+
+      name = constant_name(target)
+      return unless name
+
+      collect_constant_references(name, target.location)
+    end
+
+    sig { params(node: Prism::ConstantPathOrWriteNode).void }
+    def on_constant_path_or_write_node_enter(node)
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
+
+      name = constant_name(target)
+      return unless name
+
+      collect_constant_references(name, target.location)
+    end
+
+    sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+    def on_constant_path_operator_write_node_enter(node)
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
+
+      name = constant_name(target)
+      return unless name
+
+      collect_constant_references(name, target.location)
+    end
+
+    sig { params(node: Prism::ConstantPathAndWriteNode).void }
+    def on_constant_path_and_write_node_enter(node)
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
+
+      name = constant_name(target)
+      return unless name
+
+      collect_constant_references(name, target.location)
+    end
+
+    sig { params(node: Prism::ConstantWriteNode).void }
+    def on_constant_write_node_enter(node)
+      collect_constant_references(node.name.to_s, node.name_loc)
+    end
+
+    sig { params(node: Prism::ConstantOrWriteNode).void }
+    def on_constant_or_write_node_enter(node)
+      collect_constant_references(node.name.to_s, node.name_loc)
+    end
+
+    sig { params(node: Prism::ConstantAndWriteNode).void }
+    def on_constant_and_write_node_enter(node)
+      collect_constant_references(node.name.to_s, node.name_loc)
+    end
+
+    sig { params(node: Prism::ConstantOperatorWriteNode).void }
+    def on_constant_operator_write_node_enter(node)
+      collect_constant_references(node.name.to_s, node.name_loc)
+    end
+
+    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
+    end
+
+    sig { params(node: Prism::DefNode).void }
+    def on_def_node_leave(node)
+      if node.receiver.is_a?(Prism::SelfNode)
+        @stack.pop
+      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]) }
+    def actual_nesting(name)
+      nesting = @stack + [name]
+      corrected_nesting = []
+
+      nesting.reverse_each do |name|
+        corrected_nesting.prepend(name.delete_prefix("::"))
+
+        break if name.start_with?("::")
+      end
+
+      corrected_nesting
+    end
+
+    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 == @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, declaration: false)
+      end
+    end
+
+    sig do
+      params(
+        node: T.any(
+          Prism::ConstantPathNode,
+          Prism::ConstantReadNode,
+          Prism::ConstantPathTargetNode,
+        ),
+      ).returns(T.nilable(String))
+    end
+    def constant_name(node)
+      node.full_name
+    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+           Prism::ConstantPathNode::MissingNodesInConstantPathError
+      nil
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -6,6 +6,7 @@ require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
 require "ruby_indexer/lib/ruby_indexer/declaration_listener"
+require "ruby_indexer/lib/ruby_indexer/reference_finder"
 require "ruby_indexer/lib/ruby_indexer/enhancement"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -159,6 +159,17 @@ module RubyIndexer
       assert_entry("Foo::Bar", Entry::Module, "/fake/path/foo.rb:4-2:5-5")
     end
 
+    def test_nested_modules_and_classes_with_multibyte_characters
+      index(<<~RUBY)
+        module A動物
+          class Bねこ; end
+        end
+      RUBY
+
+      assert_entry("A動物", Entry::Module, "/fake/path/foo.rb:0-0:2-3")
+      assert_entry("A動物::Bねこ", Entry::Class, "/fake/path/foo.rb:1-2:1-16")
+    end
+
     def test_nested_modules_and_classes
       index(<<~RUBY)
         module Foo
@@ -619,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/constant_test.rb

@@ -21,6 +21,14 @@ module RubyIndexer
       assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:6-0:6-7")
     end
 
+    def test_constant_with_multibyte_characters
+      index(<<~RUBY)
+        CONST_💎 = "Ruby"
+      RUBY
+
+      assert_entry("CONST_💎", Entry::Constant, "/fake/path/foo.rb:0-0:0-16")
+    end
+
     def test_constant_or_writes
       index(<<~RUBY)
         FOO ||= 1

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -39,6 +39,7 @@ module RubyIndexer
               location,
               location,
               nil,
+              index.configuration.encoding,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
               Entry::Visibility::PUBLIC,
               owner,
@@ -121,6 +122,7 @@ module RubyIndexer
             location,
             location,
             nil,
+            index.configuration.encoding,
             [],
             Entry::Visibility::PUBLIC,
             owner,

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/instance_variables_test.rb

@@ -25,6 +25,18 @@ module RubyIndexer
       assert_equal("Foo::Bar", owner.name)
     end
 
+    def test_instance_variable_with_multibyte_characters
+      index(<<~RUBY)
+        class Foo
+          def initialize
+            @あ = 1
+          end
+        end
+      RUBY
+
+      assert_entry("@あ", Entry::InstanceVariable, "/fake/path/foo.rb:2-4:2-6")
+    end
+
     def test_instance_variable_and_write
       index(<<~RUBY)
         module Foo

data/lib/ruby_indexer/test/method_test.rb

@@ -27,6 +27,16 @@ module RubyIndexer
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
     end
 
+    def test_method_with_multibyte_characters
+      index(<<~RUBY)
+        class Foo
+          def こんにちは; end
+        end
+      RUBY
+
+      assert_entry("こんにちは", Entry::Method, "/fake/path/foo.rb:1-2:1-16")
+    end
+
     def test_singleton_method_using_self_receiver
       index(<<~RUBY)
         class Foo

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)
@@ -348,6 +362,14 @@ module RubyIndexer
       assert_includes(entry.comments, "Returns `true` if any element of `self` meets a given criterion.")
     end
 
+    def test_indexing_untyped_functions
+      entries = @index.resolve_method("call", "Method")
+
+      parameters = entries.first.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      assert_instance_of(Entry::ForwardingParameter, parameters.first)
+    end
+
     private
 
     def parse_rbs_methods(rbs, method_name)