ruby-lsp 0.22.1 → 0.23.10

data/lib/ruby_indexer/test/index_test.rb

@@ -6,11 +6,11 @@ require_relative "test_case"
 module RubyIndexer
   class IndexTest < TestCase
     def test_deleting_one_entry_for_a_class
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
-      @index.index_single(IndexablePath.new(nil, "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/other_foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -18,13 +18,13 @@ module RubyIndexer
       entries = @index["Foo"]
       assert_equal(2, entries.length)
 
-      @index.delete(IndexablePath.new(nil, "/fake/path/other_foo.rb"))
+      @index.delete(URI::Generic.from_path(path: "/fake/path/other_foo.rb"))
       entries = @index["Foo"]
       assert_equal(1, entries.length)
     end
 
     def test_deleting_all_entries_for_a_class
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -32,13 +32,13 @@ module RubyIndexer
       entries = @index["Foo"]
       assert_equal(1, entries.length)
 
-      @index.delete(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      @index.delete(URI::Generic.from_path(path: "/fake/path/foo.rb"))
       entries = @index["Foo"]
       assert_nil(entries)
     end
 
     def test_index_resolve
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -72,7 +72,7 @@ module RubyIndexer
     end
 
     def test_accessing_with_colon_colon_prefix
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -92,7 +92,7 @@ module RubyIndexer
     end
 
     def test_fuzzy_search
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Zws; end
 
         module Qtl
@@ -120,18 +120,22 @@ module RubyIndexer
     end
 
     def test_index_single_ignores_directories
-      FileUtils.mkdir("lib/this_is_a_dir.rb")
-      @index.index_single(IndexablePath.new(nil, "lib/this_is_a_dir.rb"))
-    ensure
-      FileUtils.rm_r("lib/this_is_a_dir.rb")
+      path = "#{Dir.pwd}/lib/this_is_a_dir.rb"
+      FileUtils.mkdir(path)
+
+      begin
+        @index.index_file(URI::Generic.from_path(path: path))
+      ensure
+        FileUtils.rm_r(path)
+      end
     end
 
     def test_searching_for_require_paths
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo
         end
       RUBY
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/other_foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -140,11 +144,11 @@ module RubyIndexer
     end
 
     def test_searching_for_entries_based_on_prefix
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo::Bizw
         end
       RUBY
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/other_foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo::Bizw
         end
 
@@ -160,7 +164,7 @@ module RubyIndexer
     end
 
     def test_resolve_normalizes_top_level_names
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -180,7 +184,7 @@ module RubyIndexer
     end
 
     def test_resolving_aliases_to_non_existing_constants_with_conflicting_names
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Bar
         end
 
@@ -343,18 +347,18 @@ module RubyIndexer
         raise "Prism fixtures not found. Run `git submodule update --init` to fetch them."
       end
 
-      fixtures = Dir.glob("test/fixtures/prism/test/prism/fixtures/**/*.txt")
+      fixtures = Dir.glob("#{Dir.pwd}/test/fixtures/prism/test/prism/fixtures/**/*.txt")
 
       fixtures.each do |fixture|
-        indexable_path = IndexablePath.new("", fixture)
-        @index.index_single(indexable_path)
+        uri = URI::Generic.from_path(path: fixture)
+        @index.index_file(uri)
       end
 
       refute_empty(@index)
     end
 
     def test_index_single_does_not_fail_for_non_existing_file
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      @index.index_file(URI::Generic.from_path(path: "/fake/path/foo.rb"))
       entries_after_indexing = @index.names
       assert_equal(@default_indexed_entries.keys, entries_after_indexing)
     end
@@ -782,8 +786,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -796,7 +800,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           assert_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -816,8 +820,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -833,7 +837,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           refute_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -852,8 +856,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -866,7 +870,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           assert_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -1300,7 +1304,7 @@ module RubyIndexer
     end
 
     def test_resolving_method_inside_singleton_context
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             class << self
@@ -1321,7 +1325,7 @@ module RubyIndexer
     end
 
     def test_resolving_constants_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             CONST = 3
@@ -1346,7 +1350,7 @@ module RubyIndexer
     end
 
     def test_resolving_instance_variables_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             @a = 123
@@ -1376,7 +1380,7 @@ module RubyIndexer
     end
 
     def test_instance_variable_completion_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             @a = 123
@@ -1557,6 +1561,23 @@ module RubyIndexer
       assert_equal("Foo::Bar", entry.name)
     end
 
+    def test_first_unqualified_const_prefers_exact_matches
+      index(<<~RUBY)
+        module Foo
+          class ParseResultType
+          end
+        end
+
+        module Namespace
+          class Type
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.first_unqualified_const("Type")&.first)
+      assert_equal("Namespace::Type", entry.name)
+    end
+
     def test_completion_does_not_duplicate_overridden_methods
       index(<<~RUBY)
         class Foo
@@ -1622,7 +1643,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors_of_singleton_when_class_has_parent
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo; end
 
         class Bar < Foo
@@ -1673,7 +1694,7 @@ module RubyIndexer
     end
 
     def test_extend_self
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           def bar
           end
@@ -1705,7 +1726,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module First
         end
 
@@ -1746,7 +1767,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors_when_class_has_parent
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo; end
 
         class Bar < Foo
@@ -1776,7 +1797,7 @@ module RubyIndexer
     end
 
     def test_linearizing_a_module_singleton_class
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module A; end
       RUBY
 
@@ -1885,13 +1906,13 @@ module RubyIndexer
         end
       RUBY
 
-      entries = @index.entries_for("/fake/path/foo.rb", Entry)
+      entries = @index.entries_for("file:///fake/path/foo.rb", Entry)
       assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
 
-      entries = @index.entries_for("/fake/path/foo.rb", RubyIndexer::Entry::Namespace)
+      entries = @index.entries_for("file:///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")
+      entries = @index.entries_for("file:///fake/path/foo.rb")
       assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
     end
 
@@ -2057,10 +2078,88 @@ module RubyIndexer
     end
 
     def test_prevents_multiple_calls_to_index_all
-      # For this test class, `index_all` is already called once in `setup`.
+      @index.index_all
+
       assert_raises(Index::IndexNotEmptyError) do
         @index.index_all
       end
     end
+
+    def test_index_can_handle_entries_from_untitled_scheme
+      uri = URI("untitled:Untitled-1")
+
+      index(<<~RUBY, uri: uri)
+        class Foo
+        end
+      RUBY
+
+      entry = @index["Foo"]&.first
+      refute_nil(entry, "Expected indexer to be able to handle unsaved URIs")
+      assert_equal("untitled:Untitled-1", entry.uri.to_s)
+      assert_equal("Untitled-1", entry.file_name)
+      assert_nil(entry.file_path)
+
+      @index.handle_change(uri, <<~RUBY)
+        # I added this comment!
+        class Foo
+        end
+      RUBY
+
+      entry = @index["Foo"]&.first
+      refute_nil(entry, "Expected indexer to be able to handle unsaved URIs")
+      assert_equal("I added this comment!", entry.comments)
+    end
+
+    def test_instance_variable_completion_returns_class_variables_too
+      index(<<~RUBY)
+        class Parent
+          @@abc = 123
+        end
+
+        class Child < Parent
+          @@adf = 123
+
+          def self.do
+          end
+        end
+      RUBY
+
+      abc, adf = @index.instance_variable_completion_candidates("@", "Child::<Class:Child>")
+
+      refute_nil(abc)
+      refute_nil(adf)
+
+      assert_equal("@@abc", abc.name)
+      assert_equal("@@adf", adf.name)
+    end
+
+    def test_class_variable_completion_from_singleton_context
+      index(<<~RUBY)
+        class Foo
+          @@hello = 123
+
+          def self.do
+          end
+        end
+      RUBY
+
+      candidates = @index.class_variable_completion_candidates("@@", "Foo::<Class:Foo>")
+      refute_empty(candidates)
+
+      assert_equal("@@hello", candidates.first&.name)
+    end
+
+    def test_resolve_class_variable_in_singleton_context
+      index(<<~RUBY)
+        class Foo
+          @@hello = 123
+        end
+      RUBY
+
+      candidates = @index.resolve_class_variable("@@hello", "Foo::<Class:Foo>")
+      refute_empty(candidates)
+
+      assert_equal("@@hello", candidates.first&.name)
+    end
   end
 end

data/lib/ruby_indexer/test/instance_variables_test.rb

@@ -216,5 +216,25 @@ module RubyIndexer
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
+
+    def test_module_function_does_not_impact_instance_variables
+      # One possible way of implementing `module_function` would be to push a fake singleton class to the stack, so that
+      # methods are inserted into it. However, that would be incorrect because it would then bind instance variables to
+      # the wrong type. This test is here to prevent that from happening.
+      index(<<~RUBY)
+        module Foo
+          module_function
+
+          def something; end
+
+          @a = 123
+        end
+      RUBY
+
+      entry = T.must(@index["@a"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::SingletonClass, owner)
+      assert_equal("Foo::<Class:Foo>", owner.name)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -88,19 +88,21 @@ module RubyIndexer
 
     def test_visibility_tracking
       index(<<~RUBY)
-        private def foo
-        end
+        class Foo
+          private def foo
+          end
 
-        def bar; end
+          def bar; end
 
-        protected
+          protected
 
-        def baz; end
+          def baz; end
+        end
       RUBY
 
-      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)
+      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:1-10:2-5", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:4-2:4-14", visibility: Entry::Visibility::PUBLIC)
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:8-2:8-14", visibility: Entry::Visibility::PROTECTED)
     end
 
     def test_visibility_tracking_with_nested_class_or_modules
@@ -846,6 +848,82 @@ module RubyIndexer
       assert_signature_matches(entry, "baz(1)")
     end
 
+    def test_module_function_with_no_arguments
+      index(<<~RUBY)
+        module Foo
+          def bar; end
+
+          module_function
+
+          def baz; end
+          attr_reader :attribute
+
+          public
+
+          def qux; end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_predicate(entry, :public?)
+      assert_equal("Foo", T.must(entry.owner).name)
+
+      instance_baz, singleton_baz = T.must(@index["baz"])
+      assert_predicate(instance_baz, :private?)
+      assert_equal("Foo", T.must(instance_baz.owner).name)
+
+      assert_predicate(singleton_baz, :public?)
+      assert_equal("Foo::<Class:Foo>", T.must(singleton_baz.owner).name)
+
+      # After invoking `public`, the state of `module_function` is reset
+      instance_qux, singleton_qux = T.must(@index["qux"])
+      assert_nil(singleton_qux)
+      assert_predicate(instance_qux, :public?)
+      assert_equal("Foo", T.must(instance_baz.owner).name)
+
+      # Attributes are not turned into class methods, they do become private
+      instance_attribute, singleton_attribute = @index["attribute"]
+      assert_nil(singleton_attribute)
+      assert_equal("Foo", T.must(instance_attribute.owner).name)
+      assert_predicate(instance_attribute, :private?)
+    end
+
+    def test_module_function_does_nothing_in_classes
+      # Invoking `module_function` in a class raises an error. We simply ignore it
+      index(<<~RUBY)
+        class Foo
+          def bar; end
+
+          module_function
+
+          def baz; end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_predicate(entry, :public?)
+      assert_equal("Foo", T.must(entry.owner).name)
+
+      entry = T.must(@index["baz"].first)
+      assert_predicate(entry, :public?)
+      assert_equal("Foo", T.must(entry.owner).name)
+    end
+
+    def test_making_several_class_methods_private
+      index(<<~RUBY)
+        class Foo
+          def self.bar; end
+          def self.baz; end
+          def self.qux; end
+
+          private_class_method :bar, :baz, :qux
+
+          def initialize
+          end
+        end
+      RUBY
+    end
+
     private
 
     sig { params(entry: Entry::Method, call_string: String).void }

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -377,7 +377,7 @@ module RubyIndexer
       _, _, declarations = RBS::Parser.parse_signature(buffer)
       index = RubyIndexer::Index.new
       indexer = RubyIndexer::RBSIndexer.new(index)
-      pathname = Pathname.new("file.rbs")
+      pathname = Pathname.new("/file.rbs")
       indexer.process_signature(pathname, declarations)
       entry = T.must(index[method_name]).first
       T.cast(entry, Entry::Method).signatures

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -216,6 +216,88 @@ module RubyIndexer
       assert_equal(11, refs[2].location.start_line)
     end
 
+    def test_finds_instance_variable_read_references
+      refs = find_instance_variable_references("@foo", <<~RUBY)
+        class Foo
+          def foo
+            @foo
+          end
+        end
+      RUBY
+      assert_equal(1, refs.size)
+
+      assert_equal("@foo", refs[0].name)
+      assert_equal(3, refs[0].location.start_line)
+    end
+
+    def test_finds_instance_variable_write_references
+      refs = find_instance_variable_references("@foo", <<~RUBY)
+        class Foo
+          def write
+            @foo = 1
+            @foo &&= 2
+            @foo ||= 3
+            @foo += 4
+            @foo, @bar = []
+          end
+        end
+      RUBY
+      assert_equal(5, refs.size)
+
+      assert_equal(["@foo"], refs.map(&:name).uniq)
+      assert_equal(3, refs[0].location.start_line)
+      assert_equal(4, refs[1].location.start_line)
+      assert_equal(5, refs[2].location.start_line)
+      assert_equal(6, refs[3].location.start_line)
+      assert_equal(7, refs[4].location.start_line)
+    end
+
+    def test_finds_instance_variable_references_ignore_context
+      refs = find_instance_variable_references("@name", <<~RUBY)
+        class Foo
+          def name
+            @name = "foo"
+          end
+        end
+        class Bar
+          def name
+            @name = "bar"
+          end
+        end
+      RUBY
+      assert_equal(2, refs.size)
+
+      assert_equal("@name", refs[0].name)
+      assert_equal(3, refs[0].location.start_line)
+
+      assert_equal("@name", refs[1].name)
+      assert_equal(8, refs[1].location.start_line)
+    end
+
+    def test_accounts_for_reopened_classes
+      refs = find_const_references("Foo", <<~RUBY)
+        class Foo
+        end
+        class Foo
+          class Bar
+          end
+        end
+
+        Foo.new
+      RUBY
+
+      assert_equal(3, refs.size)
+
+      assert_equal("Foo", refs[0].name)
+      assert_equal(1, refs[0].location.start_line)
+
+      assert_equal("Foo", refs[1].name)
+      assert_equal(3, refs[1].location.start_line)
+
+      assert_equal("Foo", refs[2].name)
+      assert_equal(8, refs[2].location.start_line)
+    end
+
     private
 
     def find_const_references(const_name, source)
@@ -228,13 +310,19 @@ module RubyIndexer
       find_references(target, source)
     end
 
+    def find_instance_variable_references(instance_variable_name, source)
+      target = ReferenceFinder::InstanceVariableTarget.new(instance_variable_name)
+      find_references(target, source)
+    end
+
     def find_references(target, source)
       file_path = "/fake.rb"
+      uri = URI::Generic.from_path(path: file_path)
       index = Index.new
-      index.index_single(IndexablePath.new(nil, file_path), source)
+      index.index_single(uri, source)
       parse_result = Prism.parse(source)
       dispatcher = Prism::Dispatcher.new
-      finder = ReferenceFinder.new(target, index, dispatcher)
+      finder = ReferenceFinder.new(target, index, dispatcher, uri)
       dispatcher.visit(parse_result.value)
       finder.references
     end

data/lib/ruby_indexer/test/test_case.rb

@@ -13,8 +13,8 @@ module RubyIndexer
 
     private
 
-    def index(source)
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), source)
+    def index(source, uri: URI::Generic.from_path(path: "/fake/path/foo.rb"))
+      @index.index_single(uri, source)
     end
 
     def assert_entry(expected_name, type, expected_location, visibility: nil)