ruby-lsp 0.17.3 → 0.17.5

data/lib/ruby_indexer/test/instance_variables_test.rb

@@ -20,7 +20,9 @@ module RubyIndexer
       assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
 
       entry = T.must(@index["@a"]&.first)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo::Bar", owner.name)
     end
 
     def test_instance_variable_and_write
@@ -38,7 +40,9 @@ module RubyIndexer
       assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
 
       entry = T.must(@index["@a"]&.first)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo::Bar", owner.name)
     end
 
     def test_instance_variable_operator_write
@@ -56,7 +60,9 @@ module RubyIndexer
       assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
 
       entry = T.must(@index["@a"]&.first)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo::Bar", owner.name)
     end
 
     def test_instance_variable_or_write
@@ -74,7 +80,9 @@ module RubyIndexer
       assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
 
       entry = T.must(@index["@a"]&.first)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo::Bar", owner.name)
     end
 
     def test_instance_variable_target
@@ -93,10 +101,14 @@ module RubyIndexer
       assert_entry("@b", Entry::InstanceVariable, "/fake/path/foo.rb:4-10:4-12")
 
       entry = T.must(@index["@a"]&.first)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo::Bar", owner.name)
 
       entry = T.must(@index["@b"]&.first)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo::Bar", owner.name)
     end
 
     def test_empty_name_instance_variables
@@ -118,6 +130,14 @@ module RubyIndexer
         module Foo
           class Bar
             @a = 123
+
+            class << self
+              def hello
+                @b = 123
+              end
+
+              @c = 123
+            end
           end
         end
       RUBY
@@ -125,7 +145,64 @@ module RubyIndexer
       assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:2-4:2-6")
 
       entry = T.must(@index["@a"]&.first)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::SingletonClass, owner)
+      assert_equal("Foo::Bar::<Class:Bar>", owner.name)
+
+      assert_entry("@b", Entry::InstanceVariable, "/fake/path/foo.rb:6-8:6-10")
+
+      entry = T.must(@index["@b"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::SingletonClass, owner)
+      assert_equal("Foo::Bar::<Class:Bar>", owner.name)
+
+      assert_entry("@c", Entry::InstanceVariable, "/fake/path/foo.rb:9-6:9-8")
+
+      entry = T.must(@index["@c"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::SingletonClass, owner)
+      assert_equal("Foo::Bar::<Class:Bar>::<Class:<Class:Bar>>", owner.name)
+    end
+
+    def test_top_level_instance_variables
+      index(<<~RUBY)
+        @a = 123
+      RUBY
+
+      entry = T.must(@index["@a"]&.first)
+      assert_nil(entry.owner)
+    end
+
+    def test_class_instance_variables_inside_self_method
+      index(<<~RUBY)
+        class Foo
+          def self.bar
+            @a = 123
+          end
+        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
+
+    def test_instance_variable_inside_dynamic_method_declaration
+      index(<<~RUBY)
+        class Foo
+          def something.bar
+            @a = 123
+          end
+        end
+      RUBY
+
+      # If the surrounding method is beind defined on any dynamic value that isn't `self`, then we attribute the
+      # instance variable to the wrong owner since there's no way to understand that statically
+      entry = T.must(@index["@a"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
     end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -13,7 +13,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
     end
 
     def test_conditional_method
@@ -24,7 +24,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
     end
 
     def test_singleton_method_using_self_receiver
@@ -35,7 +35,12 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::SingletonMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
+
+      entry = T.must(@index["bar"].first)
+      owner = T.must(entry.owner)
+      assert_equal("Foo::<Class:Foo>", owner.name)
+      assert_instance_of(Entry::SingletonClass, owner)
     end
 
     def test_singleton_method_using_other_receiver_is_not_indexed
@@ -83,9 +88,9 @@ module RubyIndexer
         def baz; end
       RUBY
 
-      assert_entry("foo", Entry::InstanceMethod, "/fake/path/foo.rb:0-8:1-3", visibility: Entry::Visibility::PRIVATE)
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:3-0:3-12", visibility: Entry::Visibility::PUBLIC)
-      assert_entry("baz", Entry::InstanceMethod, "/fake/path/foo.rb:7-0:7-12", visibility: Entry::Visibility::PROTECTED)
+      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)
     end
 
     def test_visibility_tracking_with_nested_class_or_modules
@@ -103,9 +108,9 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("foo", Entry::InstanceMethod, "/fake/path/foo.rb:3-2:3-14", visibility: Entry::Visibility::PRIVATE)
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:6-4:6-16", visibility: Entry::Visibility::PUBLIC)
-      assert_entry("baz", Entry::InstanceMethod, "/fake/path/foo.rb:9-2:9-14", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:3-2:3-14", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:6-4:6-16", visibility: Entry::Visibility::PUBLIC)
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:9-2:9-14", visibility: Entry::Visibility::PRIVATE)
     end
 
     def test_method_with_parameters
@@ -116,7 +121,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_equal(1, entry.parameters.length)
       parameter = entry.parameters.first
@@ -132,7 +137,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_equal(1, entry.parameters.length)
       parameter = entry.parameters.first
@@ -148,7 +153,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_equal(1, entry.parameters.length)
       parameter = entry.parameters.first
@@ -164,7 +169,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_equal(2, entry.parameters.length)
       a, b = entry.parameters
@@ -184,7 +189,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_equal(2, entry.parameters.length)
       a, b = entry.parameters
@@ -209,7 +214,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_equal(2, entry.parameters.length)
       a, b = entry.parameters
@@ -246,7 +251,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_equal(1, entry.parameters.length)
       param = entry.parameters.first
@@ -287,7 +292,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_equal(2, entry.parameters.length)
       first, second = entry.parameters
@@ -307,7 +312,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
       assert_empty(entry.parameters)
     end
@@ -359,23 +364,23 @@ module RubyIndexer
     def test_properly_tracks_multiple_levels_of_nesting
       index(<<~RUBY)
         module Foo
-          def first; end
+          def first_method; end
 
           module Bar
-            def second; end
+            def second_method; end
           end
 
-          def third; end
+          def third_method; end
         end
       RUBY
 
-      entry = T.must(@index["first"]&.first)
+      entry = T.cast(@index["first_method"]&.first, Entry::Method)
       assert_equal("Foo", T.must(entry.owner).name)
 
-      entry = T.must(@index["second"]&.first)
+      entry = T.cast(@index["second_method"]&.first, Entry::Method)
       assert_equal("Foo::Bar", T.must(entry.owner).name)
 
-      entry = T.must(@index["third"]&.first)
+      entry = T.cast(@index["third_method"]&.first, Entry::Method)
       assert_equal("Foo", T.must(entry.owner).name)
     end
 
@@ -396,7 +401,52 @@ module RubyIndexer
       assert_entry("foo", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:2-15:2-19")
       assert_entry("bar", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:3-15:3-20")
       # Foo plus 3 valid aliases
-      assert_equal(4, @index.instance_variable_get(:@entries).length - @default_indexed_entries.length)
+      assert_equal(4, @index.length - @default_indexed_entries.length)
+    end
+
+    def test_singleton_methods
+      index(<<~RUBY)
+        class Foo
+          def self.bar; end
+
+          class << self
+            def baz; end
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:1-19")
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:4-4:4-16")
+
+      bar_owner = T.must(T.must(@index["bar"].first).owner)
+      baz_owner = T.must(T.must(@index["baz"].first).owner)
+
+      assert_instance_of(Entry::SingletonClass, bar_owner)
+      assert_instance_of(Entry::SingletonClass, baz_owner)
+
+      # Regardless of whether the method was added through `self.something` or `class << self`, the owner object must be
+      # the exact same
+      assert_same(bar_owner, baz_owner)
+    end
+
+    def test_name_location_points_to_method_identifier_location
+      index(<<~RUBY)
+        class Foo
+          def bar
+            a = 123
+            a + 456
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      refute_equal(entry.location, entry.name_location)
+
+      name_location = entry.name_location
+      assert_equal(2, name_location.start_line)
+      assert_equal(2, name_location.end_line)
+      assert_equal(6, name_location.start_column)
+      assert_equal(9, name_location.end_column)
     end
   end
 end

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -8,8 +8,9 @@ module RubyIndexer
     def test_index_core_classes
       entries = @index["Array"]
       refute_nil(entries)
-      assert_equal(1, entries.length)
-      entry = entries.first
+      # Array is a class but also an instance method on Kernel
+      assert_equal(2, entries.length)
+      entry = entries.find { |entry| entry.is_a?(RubyIndexer::Entry::Class) }
       assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
       assert_equal("array.rbs", entry.file_name)
       assert_equal("Object", entry.parent_class)
@@ -38,5 +39,40 @@ module RubyIndexer
       assert_equal(0, entry.location.start_column)
       assert_operator(entry.location.end_column, :>, 0)
     end
+
+    def test_index_methods
+      entries = @index["initialize"]
+      refute_nil(entries)
+      entry = entries.find { |entry| entry.owner.name == "Array" }
+      assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
+      assert_equal("array.rbs", entry.file_name)
+      assert_equal(Entry::Visibility::PUBLIC, entry.visibility)
+
+      # Using fixed positions would be fragile, so let's just check some basics.
+      assert_operator(entry.location.start_line, :>, 0)
+      assert_operator(entry.location.end_line, :>, entry.location.start_line)
+      assert_equal(2, entry.location.start_column)
+      assert_operator(entry.location.end_column, :>, 0)
+    end
+
+    def test_attaches_correct_owner_to_singleton_methods
+      entries = @index["basename"]
+      refute_nil(entries)
+
+      owner = entries.first.owner
+      assert_instance_of(Entry::SingletonClass, owner)
+      assert_equal("File::<Class:File>", owner.name)
+    end
+
+    def test_location_and_name_location_are_the_same
+      # NOTE: RBS does not store the name location for classes, modules or methods. This behaviour is not exactly what
+      # we would like, but for now we assign the same location to both
+
+      entries = @index["Array"]
+      refute_nil(entries)
+      entry = entries.find { |entry| entry.is_a?(Entry::Class) }
+
+      assert_same(entry.location, entry.name_location)
+    end
   end
 end

data/lib/ruby_indexer/test/test_case.rb

@@ -40,16 +40,12 @@ module RubyIndexer
       assert_nil(entries, "Expected #{expected_name} to not be indexed")
     end
 
-    def assert_no_entries
-      assert_empty(@index.instance_variable_get(:@entries), "Expected nothing to be indexed")
-    end
-
     def assert_no_indexed_entries
       assert_equal(@default_indexed_entries, @index.instance_variable_get(:@entries))
     end
 
     def assert_no_entry(entry)
-      refute(@index.instance_variable_get(:@entries).key?(entry), "Expected '#{entry}' to not be indexed")
+      refute(@index.indexed?(entry), "Expected '#{entry}' to not be indexed")
     end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -72,6 +72,15 @@ module RubyLsp
           addon.add_error(e)
         end
       end
+
+      # Intended for use by tests for addons
+      sig { params(addon_name: String).returns(Addon) }
+      def get(addon_name)
+        addon = addons.find { |addon| addon.name == addon_name }
+        raise "Could not find addon '#{addon_name}'" unless addon
+
+        addon
+      end
     end
 
     sig { void }
@@ -157,7 +166,10 @@ module RubyLsp
     # Creates a new Definition listener. This method is invoked on every Definition request
     sig do
       overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+        response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
+          Interface::Location,
+          Interface::LocationLink,
+        )],
         uri: URI::Generic,
         node_context: NodeContext,
         dispatcher: Prism::Dispatcher,

data/lib/ruby_lsp/document.rb

@@ -3,6 +3,13 @@
 
 module RubyLsp
   class Document
+    class LanguageId < T::Enum
+      enums do
+        Ruby = new("ruby")
+        ERB = new("erb")
+      end
+    end
+
     extend T::Sig
     extend T::Helpers
 
@@ -34,21 +41,14 @@ module RubyLsp
       @parse_result = T.let(parse, Prism::ParseResult)
     end
 
-    sig { returns(Prism::ProgramNode) }
-    def tree
-      @parse_result.value
-    end
-
-    sig { returns(T::Array[Prism::Comment]) }
-    def comments
-      @parse_result.comments
-    end
-
     sig { params(other: Document).returns(T::Boolean) }
     def ==(other)
-      @source == other.source
+      self.class == other.class && uri == other.uri && @source == other.source
     end
 
+    sig { abstract.returns(LanguageId) }
+    def language_id; end
+
     # TODO: remove this method once all nonpositional requests have been migrated to the listener pattern
     sig do
       type_parameters(:T)
@@ -96,10 +96,8 @@ module RubyLsp
     sig { abstract.returns(Prism::ParseResult) }
     def parse; end
 
-    sig { returns(T::Boolean) }
-    def syntax_error?
-      @parse_result.failure?
-    end
+    sig { abstract.returns(T::Boolean) }
+    def syntax_error?; end
 
     sig { returns(Scanner) }
     def create_scanner
@@ -127,7 +125,10 @@ module RubyLsp
       queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
       closest = node
       parent = T.let(nil, T.nilable(Prism::Node))
-      nesting = T.let([], T::Array[T.any(Prism::ClassNode, Prism::ModuleNode)])
+      nesting_nodes = T.let(
+        [],
+        T::Array[T.any(Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode)],
+      )
       call_node = T.let(nil, T.nilable(Prism::CallNode))
 
       until queue.empty?
@@ -151,13 +152,18 @@ module RubyLsp
 
         # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level and
         # need to pop the stack
-        previous_level = nesting.last
-        nesting.pop if previous_level && loc.start_offset > previous_level.location.end_offset
+        previous_level = nesting_nodes.last
+        nesting_nodes.pop if previous_level && loc.start_offset > previous_level.location.end_offset
 
         # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
         # target when it is a constant
-        if candidate.is_a?(Prism::ClassNode) || candidate.is_a?(Prism::ModuleNode)
-          nesting << candidate
+        case candidate
+        when Prism::ClassNode, Prism::ModuleNode
+          nesting_nodes << candidate
+        when Prism::SingletonClassNode
+          nesting_nodes << candidate
+        when Prism::DefNode
+          nesting_nodes << candidate
         end
 
         if candidate.is_a?(Prism::CallNode)
@@ -189,11 +195,32 @@ module RubyLsp
       # The correct target is `Foo::Bar` with an empty nesting. `Foo::Bar` should not appear in the nesting stack, even
       # though the class/module node does indeed enclose the target, because it would lead to incorrect behavior
       if closest.is_a?(Prism::ConstantReadNode) || closest.is_a?(Prism::ConstantPathNode)
-        last_level = nesting.last
-        nesting.pop if last_level && last_level.constant_path == closest
+        last_level = nesting_nodes.last
+
+        if (last_level.is_a?(Prism::ModuleNode) || last_level.is_a?(Prism::ClassNode)) &&
+            last_level.constant_path == closest
+          nesting_nodes.pop
+        end
+      end
+
+      nesting = []
+      surrounding_method = T.let(nil, T.nilable(String))
+
+      nesting_nodes.each do |node|
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          nesting << node.constant_path.slice
+        when Prism::SingletonClassNode
+          nesting << "<Class:#{nesting.last}>"
+        when Prism::DefNode
+          surrounding_method = node.name.to_s
+          next unless node.receiver.is_a?(Prism::SelfNode)
+
+          nesting << "<Class:#{nesting.last}>"
+        end
       end
 
-      NodeContext.new(closest, parent, nesting.map { |n| n.constant_path.location.slice }, call_node)
+      NodeContext.new(closest, parent, nesting, call_node, surrounding_method)
     end
 
     sig { returns(T::Boolean) }