ruby-lsp 0.23.23 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2079a33c4ec7e87a6b90bcb3cc11eca81e0d2a9c6d591c2fc14b07234b56c60b
-  data.tar.gz: 2837a0acd68b11e065236fb3190baee2e358520694710676fe214e125ae74902
+  metadata.gz: 3e8b51ca9a97aa0e855fbf1109f07733aae195eb25dba844f79840665b36ac9a
+  data.tar.gz: 79d5c3af7ba9fb03c2da197b4213a861e366b7be5a60e677ac6ca9ae8269dbea
 SHA512:
-  metadata.gz: fd82d565032cf65414ea926313dfbb7be1c5a21c1d49f9191ed6b9d3c6f4d28458db21f78f14d37af03b84223dc40e4d8cb4c24a1a4a754359757048d84e930a
-  data.tar.gz: 48c1dd2271b23e585c37a941db30729d727ceaffb7c12c1b3f806a138834192b9073df72c83bec48a7015bad7d2b109e08f591dc0a69767c39a30c8a6bd96c94
+  metadata.gz: 8cb30f7427f02460320becb1b883c502ea0fbfd48f5148192e1339350e94836ed6ba825df4b4b0fe0ff8d32325d6196af6a26ef94d566e4e32ecd235d66ed821
+  data.tar.gz: 68d5712e3ae16ecaa602eeccadcab5108d89cce1f1a282b82bd3244b3111131442ee6feda63b1e7049027624c07be25e5f3ae39a00b9df25130f12f43c2dac80

data/VERSION

@@ -1 +1 @@
-0.23.23
+0.26.0

data/exe/ruby-lsp

@@ -88,13 +88,17 @@ if ENV["BUNDLE_GEMFILE"].nil?
   exit exec(env, "#{base_command} exec ruby-lsp #{original_args.join(" ")}".strip)
 end
 
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
-require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -147,8 +151,10 @@ if options[:doctor]
   return
 end
 
+server = RubyLsp::Server.new
+
 # Ensure all output goes out stderr by default to allow puts/p/pp to work
 # without specifying output device.
 $> = $stderr
 
-RubyLsp::Server.new.start
+server.start

data/exe/ruby-lsp-check

@@ -3,13 +3,9 @@
 
 # This executable checks if all automatic LSP requests run successfully on every Ruby file under the current directory
 
-require "ruby_lsp/load_sorbet"
-
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 files = Dir.glob("#{Dir.pwd}/**/*.rb")
 
 puts "Verifying that all automatic LSP requests execute successfully. This may take a while..."

data/exe/ruby-lsp-launcher

@@ -6,6 +6,13 @@
 # composed bundle
 # !!!!!!!
 
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
 setup_error = nil
 install_error = nil
 reboot = false
@@ -28,7 +35,6 @@ else
   # Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
   # Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
   # to ensure that we're setting up the bundle in the right place
-  $stdin.binmode
   headers = $stdin.gets("\r\n\r\n")
   content_length = headers[/Content-Length: (\d+)/i, 1].to_i
   $stdin.read(content_length)
@@ -83,8 +89,13 @@ begin
     # This Marshal load can only happen after requiring Bundler because it will load a custom error class from Bundler
     # itself. If we try to load before requiring, the class will not be defined and loading will fail
     error_path = File.join(".ruby-lsp", "install_error")
-    install_error = if File.exist?(error_path)
-      Marshal.load(File.read(error_path))
+    install_error = begin
+      Marshal.load(File.read(error_path)) if File.exist?(error_path)
+    rescue ArgumentError
+      # The class we tried to load is not defined. This might happen when the user upgrades Bundler and new error
+      # classes are introduced or removed
+      File.delete(error_path)
+      nil
     end
 
     Bundler.setup
@@ -120,11 +131,8 @@ end
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already
 # configured the load path using the version of the Ruby LSP present in the composed bundle. Do not push any Ruby LSP
 # paths into the load path manually or we may end up requiring the wrong version of the gem
-require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 if ARGV.include?("--debug")
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -138,22 +146,28 @@ if ARGV.include?("--debug")
   end
 end
 
-# Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
-$> = $stderr
-
 initialize_request = JSON.parse(raw_initialize, symbolize_names: true) if raw_initialize
 
 begin
-  RubyLsp::Server.new(
+  server = RubyLsp::Server.new(
     install_error: install_error,
     setup_error: setup_error,
     initialize_request: initialize_request,
-  ).start
+  )
+
+  # Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+  $> = $stderr
+
+  server.start
 rescue ArgumentError
   # If the launcher is booting an outdated version of the server, then the initializer doesn't accept a keyword splat
   # and we already read the initialize request from the stdin pipe. In this case, we need to process the initialize
   # request manually and then start the main loop
   server = RubyLsp::Server.new
+
+  # Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+  $> = $stderr
+
   server.process_message(initialize_request)
   server.start
 end

data/exe/ruby-lsp-test-exec

@@ -1,18 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Append to RUBYOPT the necessary requires to hook our custom test reporters so that results are automatically
-# reflected in the test explorer
-rubyopt = [
-  *ENV["RUBYOPT"],
-  "-rbundler/setup",
-  "-r#{File.expand_path("../lib/ruby_lsp/test_reporters/minitest_reporter", __dir__)}",
-  "-r#{File.expand_path("../lib/ruby_lsp/test_reporters/test_unit_reporter", __dir__)}",
-].join(" ")
-
-# Replace this process with whatever command was passed. We only want to set RUBYOPT.
-# The way you use this executable is by prefixing your test command with `ruby-lsp-test-exec`, like so:
-#  ruby-lsp-test-exec bundle exec ruby -Itest test/example_test.rb
-#  ruby-lsp-test-exec bundle exec ruby -Ispec spec/example_spec.rb
-#  ruby-lsp-test-exec bundle exec rspec spec/example_spec.rb
-exec({ "RUBYOPT" => rubyopt }, *ARGV)
+# This executable will be removed thanks to the changes in https://github.com/Shopify/ruby-lsp/pull/3661.
+# Remove this a few months after extension updates have rolled out
+exec(*ARGV)

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "rubocop"
-require "sorbet-runtime"
 
 module RuboCop
   module Cop

data/lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "rubocop"
-require "sorbet-runtime"
 
 module RuboCop
   module Cop

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -9,7 +9,7 @@ module RubyIndexer
     #: Array[String]
     attr_reader :indexing_errors
 
-    #: (Index index, Prism::Dispatcher dispatcher, Prism::ParseResult parse_result, URI::Generic uri, ?collect_comments: bool) -> void
+    #: (Index index, Prism::Dispatcher dispatcher, Prism::ParseLexResult | Prism::ParseResult parse_result, URI::Generic uri, ?collect_comments: bool) -> void
     def initialize(index, dispatcher, parse_result, uri, collect_comments: false)
       @index = index
       @uri = uri
@@ -260,6 +260,9 @@ module RubyIndexer
         handle_attribute(node, reader: false, writer: true)
       when :attr_accessor
         handle_attribute(node, reader: true, writer: true)
+      when :attr
+        has_writer = node.arguments&.arguments&.last&.is_a?(Prism::TrueNode) || false
+        handle_attribute(node, reader: true, writer: has_writer)
       when :alias_method
         handle_alias_method(node)
       when :include, :prepend, :extend
@@ -726,6 +729,9 @@ module RubyIndexer
         comment = @comments_by_line[line]
         break unless comment
 
+        # a trailing comment from a previous line is not a comment for this node
+        break if comment.trailing?
+
         comment_content = comment.location.slice
 
         # invalid encodings would raise an "invalid byte sequence" exception

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -2,11 +2,8 @@
 # frozen_string_literal: true
 
 module RubyIndexer
+  # @abstract
   class Enhancement
-    extend T::Helpers
-
-    abstract!
-
     @enhancements = [] #: Array[Class[Enhancement]]
 
     class << self

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -98,11 +98,8 @@ module RubyIndexer
       end
     end
 
+    # @abstract
     class ModuleOperation
-      extend T::Helpers
-
-      abstract!
-
       #: String
       attr_reader :module_name
 
@@ -115,11 +112,8 @@ module RubyIndexer
     class Include < ModuleOperation; end
     class Prepend < ModuleOperation; end
 
+    # @abstract
     class Namespace < Entry
-      extend T::Helpers
-
-      abstract!
-
       #: Array[String]
       attr_reader :nesting
 
@@ -191,11 +185,8 @@ module RubyIndexer
     class Constant < Entry
     end
 
+    # @abstract
     class Parameter
-      extend T::Helpers
-
-      abstract!
-
       # Name includes just the name of the parameter, excluding symbols like splats
       #: Symbol
       attr_reader :name
@@ -289,12 +280,8 @@ module RubyIndexer
       end
     end
 
+    # @abstract
     class Member < Entry
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
       #: Entry::Namespace?
       attr_reader :owner
 
@@ -305,8 +292,11 @@ module RubyIndexer
         @owner = owner
       end
 
-      sig { abstract.returns(T::Array[Entry::Signature]) }
-      def signatures; end
+      # @abstract
+      #: -> Array[Signature]
+      def signatures
+        raise AbstractMethodInvokedError
+      end
 
       #: -> String
       def decorated_parameters
@@ -343,6 +333,7 @@ module RubyIndexer
     end
 
     class Method < Member
+      # @override
       #: Array[Signature]
       attr_reader :signatures
 

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -266,7 +266,7 @@ module RubyIndexer
     def constant_completion_candidates(name, nesting)
       # If we have a top level reference, then we don't need to include completions inside the current nesting
       if name.start_with?("::")
-        return @entries_tree.search(name.delete_prefix("::")) #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]] # rubocop:disable Layout/LineLength
+        return @entries_tree.search(name.delete_prefix("::")) #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
       end
 
       # Otherwise, we have to include every possible constant the user might be referring to. This is essentially the
@@ -291,8 +291,17 @@ module RubyIndexer
 
       # Top level constants
       entries.concat(@entries_tree.search(name))
+
+      # Filter only constants since methods may have names that look like constants
+      entries.each do |definitions|
+        definitions.select! do |entry|
+          entry.is_a?(Entry::Constant) || entry.is_a?(Entry::ConstantAlias) ||
+            entry.is_a?(Entry::Namespace) || entry.is_a?(Entry::UnresolvedConstantAlias)
+        end
+      end
+
       entries.uniq!
-      entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]] # rubocop:disable Layout/LineLength
+      entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
     end
 
     # Resolve a constant to its declaration based on its name and the nesting where the reference was found. Parameter
@@ -818,11 +827,22 @@ module RubyIndexer
     )
       # Find the first class entry that has a parent class. Notice that if the developer makes a mistake and inherits
       # from two different classes in different files, we simply ignore it
-      superclass = if singleton_levels > 0
-        self[attached_class_name]&.find { |n| n.is_a?(Entry::Class) && n.parent_class }
-      else
-        namespace_entries.find { |n| n.is_a?(Entry::Class) && n.parent_class }
-      end #: as Entry::Class?
+      possible_parents = singleton_levels > 0 ? self[attached_class_name] : namespace_entries
+      superclass = nil #: Entry::Class?
+
+      possible_parents&.each do |n|
+        # Ignore non class entries
+        next unless n.is_a?(Entry::Class)
+
+        parent_class = n.parent_class
+        next unless parent_class
+
+        # Always set the superclass, but break early if we found one that isn't `::Object` (meaning we found an explicit
+        # parent class and not the implicit default). Note that when setting different parents to the same class, which
+        # is invalid, we pick whatever is the first one we find
+        superclass = n
+        break if parent_class != "::Object"
+      end
 
       if superclass
         # If the user makes a mistake and creates a class that inherits from itself, this method would throw a stack

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

@@ -3,11 +3,8 @@
 
 module RubyIndexer
   class ReferenceFinder
-    class Target
-      extend T::Helpers
-
-      abstract!
-    end
+    # @abstract
+    class Target; end
 
     class ConstTarget < Target
       #: String
@@ -35,10 +32,14 @@ module RubyIndexer
       #: String
       attr_reader :name
 
-      #: (String name) -> void
-      def initialize(name)
+      #: Array[String]
+      attr_reader :owner_ancestors
+
+      #: (String name, Array[String] owner_ancestors) -> void
+      def initialize(name, owner_ancestors)
         super()
         @name = name
+        @owner_ancestors = owner_ancestors
       end
     end
 
@@ -325,7 +326,10 @@ module RubyIndexer
     def collect_instance_variable_references(name, location, declaration)
       return unless @target.is_a?(InstanceVariableTarget) && name == @target.name
 
-      @references << Reference.new(name, location, declaration: declaration)
+      receiver_type = Index.actual_nesting(@stack, nil).join("::")
+      if @target.owner_ancestors.include?(receiver_type)
+        @references << Reference.new(name, location, declaration: declaration)
+      end
     end
   end
 end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -20,7 +20,7 @@ module RubyIndexer
       assert(uris.none? { |uri| uri.full_path.include?("test/fixtures") })
       assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("minitest-reporters").to_s) })
       assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("ansi").to_s) })
-      assert(uris.any? { |uri| uri.full_path.include?(bundle_path.join("sorbet-runtime").to_s) })
+      assert(uris.any? { |uri| uri.full_path.include?(bundle_path.join("prism").to_s) })
       assert(uris.none? { |uri| uri.full_path == __FILE__ })
     end
 
@@ -59,7 +59,6 @@ module RubyIndexer
 
       assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
       assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
-      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/erb.rb")
     end
 
     def test_indexable_uris_includes_project_files

data/lib/ruby_indexer/test/index_test.rb

@@ -728,6 +728,30 @@ module RubyIndexer
       assert_equal(["A", "ALIAS"], @index.linearized_ancestors_of("A"))
     end
 
+    def test_linearizing_ancestors_for_classes_with_overridden_parents
+      index(<<~RUBY)
+        # Find the re-open of a class first, without specifying a parent
+        class Child
+        end
+
+        # Now, find the actual definition of the class, which includes a parent
+        class Parent; end
+        class Child < Parent
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Child",
+          "Parent",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Child"),
+      )
+    end
+
     def test_resolving_an_inherited_method
       index(<<~RUBY)
         module Foo
@@ -1959,6 +1983,18 @@ module RubyIndexer
       assert_equal(["XQRK"], result.map { |entries| entries.first&.name })
     end
 
+    def test_constant_completion_does_not_confuse_uppercase_methods
+      index(<<~RUBY)
+        class Foo
+          def Qux
+          end
+        end
+      RUBY
+
+      candidates = @index.constant_completion_candidates("Q", [])
+      refute_includes(candidates.flat_map { |entries| entries.map(&:name) }, "Qux")
+    end
+
     def test_constant_completion_candidates_for_empty_name
       index(<<~RUBY)
         module Foo

data/lib/ruby_indexer/test/instance_variables_test.rb

@@ -236,5 +236,29 @@ module RubyIndexer
       assert_instance_of(Entry::SingletonClass, owner)
       assert_equal("Foo::<Class:Foo>", owner&.name)
     end
+
+    def test_class_instance_variable_comments
+      index(<<~RUBY)
+          class Foo
+            # Documentation for @a
+            @a = "Hello" #: String
+            @b = "World" # trailing comment
+            @c = "!"
+          end
+        end
+      RUBY
+
+      assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:2-4:2-6")
+      entry = @index["@a"]&.first #: as Entry::InstanceVariable
+      assert_equal("Documentation for @a", entry.comments)
+
+      assert_entry("@b", Entry::InstanceVariable, "/fake/path/foo.rb:3-4:3-6")
+      entry = @index["@b"]&.first #: as Entry::InstanceVariable
+      assert_empty(entry.comments)
+
+      assert_entry("@c", Entry::InstanceVariable, "/fake/path/foo.rb:4-4:4-6")
+      entry = @index["@c"]&.first #: as Entry::InstanceVariable
+      assert_empty(entry.comments)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -950,6 +950,23 @@ module RubyIndexer
       assert_predicate(entry, :public?)
     end
 
+    def test_handling_attr
+      index(<<~RUBY)
+        class Foo
+          attr :bar
+          attr :baz, true
+          attr :qux, false
+        end
+      RUBY
+
+      assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:1-8:1-11")
+      assert_no_entry("bar=")
+      assert_entry("baz", Entry::Accessor, "/fake/path/foo.rb:2-8:2-11")
+      assert_entry("baz=", Entry::Accessor, "/fake/path/foo.rb:2-8:2-11")
+      assert_entry("qux", Entry::Accessor, "/fake/path/foo.rb:3-8:3-11")
+      assert_no_entry("qux=")
+    end
+
     private
 
     #: (Entry::Method entry, String call_string) -> void

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -232,8 +232,8 @@ module RubyIndexer
       signatures = entry.signatures
       assert_equal(2, signatures.length)
 
-      # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ] # rubocop:disable Layout/LineLength
-      #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]? # rubocop:disable Layout/LineLength
+      # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ]
+      #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]?
 
       parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:read_array, :write_array, :error_array], parameters.map(&:name))

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -216,22 +216,43 @@ 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)
+    def test_finds_instance_variable_references
+      refs = find_instance_variable_references("@name", ["Foo"], <<~RUBY)
         class Foo
-          def foo
-            @foo
+          def initialize
+            @name = "foo"
+          end
+          def name
+            @name
+          end
+          def name_capital
+            @name[0]
+          end
+        end
+
+        class Bar
+          def initialize
+            @name = "foo"
+          end
+          def name
+            @name
           end
         end
       RUBY
-      assert_equal(1, refs.size)
+      assert_equal(3, refs.size)
 
-      assert_equal("@foo", refs[0].name)
+      assert_equal("@name", refs[0].name)
       assert_equal(3, refs[0].location.start_line)
+
+      assert_equal("@name", refs[1].name)
+      assert_equal(6, refs[1].location.start_line)
+
+      assert_equal("@name", refs[2].name)
+      assert_equal(9, refs[2].location.start_line)
     end
 
     def test_finds_instance_variable_write_references
-      refs = find_instance_variable_references("@foo", <<~RUBY)
+      refs = find_instance_variable_references("@foo", ["Foo"], <<~RUBY)
         class Foo
           def write
             @foo = 1
@@ -252,26 +273,70 @@ module RubyIndexer
       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 test_finds_instance_variable_references_in_owner_ancestors
+      refs = find_instance_variable_references("@name", ["Foo", "Base", "Top", "Parent"], <<~RUBY)
+        module Base
+          def change_name(name)
+            @name = name
+          end
           def name
+            @name
+          end
+
+          module ::Top
+            def name
+              @name
+            end
+          end
+        end
+
+        class Parent
+          def initialize
+            @name = "parent"
+          end
+          def name_capital
+            @name[0]
+          end
+        end
+
+        class Foo < Parent
+          include Base
+          def initialize
             @name = "foo"
           end
+          def name
+            @name
+          end
         end
+
         class Bar
           def name
             @name = "bar"
           end
         end
       RUBY
-      assert_equal(2, refs.size)
+      assert_equal(7, 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)
+      assert_equal(6, refs[1].location.start_line)
+
+      assert_equal("@name", refs[2].name)
+      assert_equal(11, refs[2].location.start_line)
+
+      assert_equal("@name", refs[3].name)
+      assert_equal(18, refs[3].location.start_line)
+
+      assert_equal("@name", refs[4].name)
+      assert_equal(21, refs[4].location.start_line)
+
+      assert_equal("@name", refs[5].name)
+      assert_equal(28, refs[5].location.start_line)
+
+      assert_equal("@name", refs[6].name)
+      assert_equal(31, refs[6].location.start_line)
     end
 
     def test_accounts_for_reopened_classes
@@ -310,8 +375,8 @@ module RubyIndexer
       find_references(target, source)
     end
 
-    def find_instance_variable_references(instance_variable_name, source)
-      target = ReferenceFinder::InstanceVariableTarget.new(instance_variable_name)
+    def find_instance_variable_references(instance_variable_name, owner_ancestors, source)
+      target = ReferenceFinder::InstanceVariableTarget.new(instance_variable_name, owner_ancestors)
       find_references(target, source)
     end