ruby-lsp 0.17.2 → 0.17.4

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,24 +364,69 @@ 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
+
+    def test_keeps_track_of_aliases
+      index(<<~RUBY)
+        class Foo
+          alias whatever to_s
+          alias_method :foo, :to_a
+          alias_method "bar", "to_a"
+
+          # These two are not indexed because they are dynamic or incomplete
+          alias_method baz, :to_a
+          alias_method :baz
+        end
+      RUBY
+
+      assert_entry("whatever", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:1-8:1-16")
+      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)
+    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
   end
 end

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -0,0 +1,67 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class RBSIndexerTest < TestCase
+    def test_index_core_classes
+      entries = @index["Array"]
+      refute_nil(entries)
+      # 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)
+      assert_equal(1, entry.mixin_operations.length)
+      enumerable_include = entry.mixin_operations.first
+      assert_equal("Enumerable", enumerable_include.module_name)
+
+      # 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(0, entry.location.start_column)
+      assert_operator(entry.location.end_column, :>, 0)
+    end
+
+    def test_index_core_modules
+      entries = @index["Kernel"]
+      refute_nil(entries)
+      assert_equal(1, entries.length)
+      entry = entries.first
+      assert_match(%r{/gems/rbs-.*/core/kernel.rbs}, entry.file_path)
+      assert_equal("kernel.rbs", entry.file_name)
+
+      # 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(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
+  end
+end

data/lib/ruby_indexer/test/test_case.rb

@@ -7,6 +7,8 @@ module RubyIndexer
   class TestCase < Minitest::Test
     def setup
       @index = Index.new
+      RBSIndexer.new(@index).index_ruby_core
+      @default_indexed_entries = @index.instance_variable_get(:@entries).dup
     end
 
     private
@@ -17,6 +19,7 @@ module RubyIndexer
 
     def assert_entry(expected_name, type, expected_location, visibility: nil)
       entries = @index[expected_name]
+      refute_nil(entries, "Expected #{expected_name} to be indexed")
       refute_empty(entries, "Expected #{expected_name} to be indexed")
 
       entry = entries.first
@@ -41,6 +44,10 @@ module RubyIndexer
       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")
     end

data/lib/ruby_lsp/document.rb

@@ -127,7 +127,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 +154,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 +197,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) }

data/lib/ruby_lsp/global_state.rb

@@ -12,7 +12,7 @@ module RubyLsp
     attr_accessor :formatter
 
     sig { returns(T::Boolean) }
-    attr_reader :typechecker
+    attr_reader :has_type_checker
 
     sig { returns(RubyIndexer::Index) }
     attr_reader :index
@@ -23,6 +23,9 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_reader :supports_watching_files
 
+    sig { returns(TypeInferrer) }
+    attr_reader :type_inferrer
+
     sig { void }
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
@@ -31,8 +34,9 @@ module RubyLsp
       @formatter = T.let("auto", String)
       @linters = T.let([], T::Array[String])
       @test_library = T.let("minitest", String)
-      @typechecker = T.let(true, T::Boolean)
+      @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
+      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
       @supports_watching_files = T.let(false, T::Boolean)
     end
@@ -54,18 +58,19 @@ module RubyLsp
 
     sig { params(options: T::Hash[Symbol, T.untyped]).void }
     def apply_options(options)
-      dependencies = gather_dependencies
+      direct_dependencies = gather_direct_dependencies
+      all_dependencies = gather_direct_and_indirect_dependencies
       workspace_uri = options.dig(:workspaceFolders, 0, :uri)
       @workspace_uri = URI(workspace_uri) if workspace_uri
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
       @formatter = specified_formatter if specified_formatter
-      @formatter = detect_formatter(dependencies) if @formatter == "auto"
+      @formatter = detect_formatter(direct_dependencies, all_dependencies) if @formatter == "auto"
 
       specified_linters = options.dig(:initializationOptions, :linters)
-      @linters = specified_linters || detect_linters(dependencies)
-      @test_library = detect_test_library(dependencies)
-      @typechecker = detect_typechecker(dependencies)
+      @linters = specified_linters || detect_linters(direct_dependencies)
+      @test_library = detect_test_library(direct_dependencies)
+      @has_type_checker = detect_typechecker(direct_dependencies)
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
@@ -103,16 +108,18 @@ module RubyLsp
 
     private
 
-    sig { params(dependencies: T::Array[String]).returns(String) }
-    def detect_formatter(dependencies)
+    sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }
+    def detect_formatter(direct_dependencies, all_dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
-      if dependencies.any?(/^rubocop/)
-        "rubocop"
-      elsif dependencies.any?(/^syntax_tree$/)
-        "syntax_tree"
-      else
-        "none"
-      end
+      return "rubocop" if direct_dependencies.any?(/^rubocop/)
+
+      syntax_tree_is_direct_dependency = direct_dependencies.include?("syntax_tree")
+      return "syntax_tree" if syntax_tree_is_direct_dependency
+
+      rubocop_is_transitive_dependency = all_dependencies.include?("rubocop")
+      return "rubocop" if dot_rubocop_yml_present && rubocop_is_transitive_dependency
+
+      "none"
     end
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
@@ -132,7 +139,7 @@ module RubyLsp
       # by ruby-lsp-rails. A Rails app doesn't need to depend on the rails gem itself, individual components like
       # activestorage may be added to the gemfile so that other components aren't downloaded. Check for the presence
       #  of bin/rails to support these cases.
-      elsif File.exist?(File.join(workspace_path, "bin/rails"))
+      elsif bin_rails_present
         "rails"
       # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
       elsif dependencies.any?(/^minitest$/)
@@ -162,8 +169,18 @@ module RubyLsp
       false
     end
 
+    sig { returns(T::Boolean) }
+    def bin_rails_present
+      File.exist?(File.join(workspace_path, "bin/rails"))
+    end
+
+    sig { returns(T::Boolean) }
+    def dot_rubocop_yml_present
+      File.exist?(File.join(workspace_path, ".rubocop.yml"))
+    end
+
     sig { returns(T::Array[String]) }
-    def gather_dependencies
+    def gather_direct_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
       Bundler.locked_gems.dependencies.keys + gemspec_dependencies
     rescue Bundler::GemfileNotFound
@@ -176,5 +193,13 @@ module RubyLsp
         .grep(Bundler::Source::Gemspec)
         .flat_map { _1.gemspec&.dependencies&.map(&:name) }
     end
+
+    sig { returns(T::Array[String]) }
+    def gather_direct_and_indirect_dependencies
+      Bundler.with_original_env { Bundler.default_gemfile }
+      Bundler.locked_gems.specs.map(&:name)
+    rescue Bundler::GemfileNotFound
+      []
+    end
   end
 end

data/lib/ruby_lsp/internal.rb

@@ -18,6 +18,7 @@ require "set"
 require "prism"
 require "prism/visitor"
 require "language_server-protocol"
+require "rbs"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"
@@ -27,6 +28,7 @@ require "ruby_lsp/utils"
 require "ruby_lsp/parameter_scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
+require "ruby_lsp/type_inferrer"
 require "ruby_lsp/requests"
 require "ruby_lsp/response_builders"
 require "ruby_lsp/node_context"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -236,7 +236,7 @@ module RubyLsp
             # so there must be something to the left of the available path.
             group_stack = T.must(group_stack[last_dynamic_reference_index + 1..])
             if method_name
-              " --name " + "/::#{Shellwords.escape(group_stack.join("::") + "#" + method_name)}$/"
+              " --name " + "/::#{Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)}$/"
             else
               # When clicking on a CodeLens for `Test`, `(#|::)` will match all tests
               # that are registered on the class itself (matches after `#`) and all tests
@@ -245,7 +245,7 @@ module RubyLsp
             end
           elsif method_name
             # We know the entire path, do an exact match
-            " --name " + Shellwords.escape(group_stack.join("::") + "#" + method_name)
+            " --name " + Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)
           elsif spec_name
             " --name " + "/#{Shellwords.escape(spec_name)}/"
           else