ruby-lsp 0.26.9 → 0.27.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b12b079fa54de3410e0d0ab2db9bf2241c6413c3c61d3ead21d4bbcc9b4e7d6
-  data.tar.gz: dede13048ef29f79079271c7d20d505160f8fe24d495863e08be96c95207c6bf
+  metadata.gz: 4e5c88483f280d13f2691e131a16e35df07df898e8f380071d077479cd24133e
+  data.tar.gz: 7630ce8844fcb532ca63c77e299b692471b145530a623dcbc78ecbb50ce08596
 SHA512:
-  metadata.gz: 922edf8dadc38fa037d2c157c8e0b9bbbd3c759931ac6cda3070b615a3039597028672e8632507e80689f6a8f6cc793e7a1006a49bba28d72489f541e75f2fc3
-  data.tar.gz: 046d2d369c16a743f71750a9a6dfed945d8e21b43bb58ad357ce1098fd731dc4e7060ffebcc96e1b78a43a3b2571ac9e31d94dc6c25c380478cb54a979c0f461
+  metadata.gz: 7757882e6e441d49705a389bad6b0b617b7f9a26fb1e5f34ebd3fc93eeb8921b31a703253cff79ed123ae411333fc7d91f0555ae162cafee1d10adfb13b76cf4
+  data.tar.gz: c215743ab00113e4dd3186732faabd462fef6a3be425f1c76bb65b045846effd7db0673478244218f1087e3fa9ca96f8668c86970def65bf2e5fbb4ea0728a8d

data/VERSION

@@ -1 +1 @@
-0.26.9
+0.27.0.beta1

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

@@ -129,7 +129,7 @@ module RubyIndexer
 
       if current_owner
         expression = node.expression
-        name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{last_name_in_stack}>" : "<Class:#{expression.slice}>")
+        name = (expression.is_a?(Prism::SelfNode) ? "<#{last_name_in_stack}>" : "<#{expression.slice}>")
         real_nesting = Index.actual_nesting(@stack, name)
 
         existing_entries = @index[real_nesting.join("::")] #: as Array[Entry::SingletonClass]?
@@ -577,7 +577,7 @@ module RubyIndexer
 
       # set the class variable's owner to the attached context when defined within a singleton scope.
       if owner.is_a?(Entry::SingletonClass)
-        owner = @owner_stack.reverse.find { |entry| !entry.name.include?("<Class:") }
+        owner = @owner_stack.reverse.find { |entry| !entry.name.include?("<") }
       end
 
       @index.add(Entry::ClassVariable.new(

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

@@ -507,7 +507,7 @@ module RubyIndexer
       singleton_levels = 0
 
       parts.reverse_each do |part|
-        break unless part.include?("<Class:")
+        break unless part.start_with?("<")
 
         singleton_levels += 1
         parts.pop
@@ -551,7 +551,7 @@ module RubyIndexer
 
       if nesting.any?
         singleton_levels.times do
-          nesting << "<Class:#{nesting.last}>"
+          nesting << "<#{nesting.last}>"
         end
       end
 
@@ -616,7 +616,7 @@ module RubyIndexer
       if class_variables.any?
         name_parts = owner_name.split("::")
 
-        if name_parts.last&.start_with?("<Class:")
+        if name_parts.last&.start_with?("<")
           attached_name = name_parts[0..-2] #: as !nil
             .join("::")
           attached_ancestors = linearized_ancestors_of(attached_name)
@@ -707,7 +707,7 @@ module RubyIndexer
     #: (String name) -> Entry::SingletonClass
     def existing_or_new_singleton_class(name)
       *_namespace, unqualified_name = name.split("::")
-      full_singleton_name = "#{name}::<Class:#{unqualified_name}>"
+      full_singleton_name = "#{name}::<#{unqualified_name}>"
       singleton = self[full_singleton_name]&.first #: as Entry::SingletonClass?
 
       unless singleton
@@ -744,7 +744,7 @@ module RubyIndexer
     def linearized_attached_ancestors(name)
       name_parts = name.split("::")
 
-      if name_parts.last&.start_with?("<Class:")
+      if name_parts.last&.start_with?("<")
         attached_name = name_parts[0..-2] #: as !nil
           .join("::")
         linearized_ancestors_of(attached_name)
@@ -866,7 +866,7 @@ module RubyIndexer
 
           parent_name_parts = parent_class_name.split("::")
           singleton_levels.times do
-            parent_name_parts << "<Class:#{parent_name_parts.last}>"
+            parent_name_parts << "<#{parent_name_parts.last}>"
           end
 
           ancestors.concat(linearized_ancestors_of(parent_name_parts.join("::")))
@@ -878,7 +878,7 @@ module RubyIndexer
           class_class_name_parts = ["Class"]
 
           (singleton_levels - 1).times do
-            class_class_name_parts << "<Class:#{class_class_name_parts.last}>"
+            class_class_name_parts << "<#{class_class_name_parts.last}>"
           end
 
           ancestors.concat(linearized_ancestors_of(class_class_name_parts.join("::")))
@@ -892,7 +892,7 @@ module RubyIndexer
           module_class_name_parts = ["Module"]
 
           (singleton_levels - 1).times do
-            module_class_name_parts << "<Class:#{module_class_name_parts.last}>"
+            module_class_name_parts << "<#{module_class_name_parts.last}>"
           end
 
           ancestors.concat(linearized_ancestors_of(module_class_name_parts.join("::")))

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

@@ -134,7 +134,7 @@ module RubyIndexer
       expression = node.expression
       return unless expression.is_a?(Prism::SelfNode)
 
-      @stack << "<Class:#{@stack.last}>"
+      @stack << "<#{@stack.last}>"
     end
 
     #: (Prism::SingletonClassNode node) -> void
@@ -239,7 +239,7 @@ module RubyIndexer
       end
 
       if node.receiver.is_a?(Prism::SelfNode)
-        @stack << "<Class:#{@stack.last}>"
+        @stack << "<#{@stack.last}>"
       end
     end
 

data/lib/ruby_lsp/global_state.rb

@@ -30,6 +30,9 @@ module RubyLsp
     #: RubyIndexer::Index
     attr_reader :index
 
+    #: Rubydex::Graph
+    attr_reader :graph
+
     #: Encoding
     attr_reader :encoding
 
@@ -58,8 +61,9 @@ module RubyLsp
       @test_library = "minitest" #: String
       @has_type_checker = true #: bool
       @index = RubyIndexer::Index.new #: RubyIndexer::Index
+      @graph = Rubydex::Graph.new #: Rubydex::Graph
       @supported_formatters = {} #: Hash[String, Requests::Support::Formatter]
-      @type_inferrer = TypeInferrer.new(@index) #: TypeInferrer
+      @type_inferrer = TypeInferrer.new(@graph) #: TypeInferrer
       @addon_settings = {} #: Hash[String, untyped]
       @top_level_bundle = begin
         Bundler.with_original_env { Bundler.default_gemfile }
@@ -117,6 +121,7 @@ module RubyLsp
       all_dependencies = gather_direct_and_indirect_dependencies
       workspace_uri = options.dig(:workspaceFolders, 0, :uri)
       @workspace_uri = URI(workspace_uri) if workspace_uri
+      @graph.workspace_path = workspace_path
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
       rubocop_has_addon = defined?(::RuboCop::Version::STRING) &&
@@ -189,12 +194,16 @@ module RubyLsp
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
+        @graph.encoding = "utf16"
         Encoding::UTF_16LE
       elsif encodings.include?(Constant::PositionEncodingKind::UTF8)
+        @graph.encoding = "utf8"
         Encoding::UTF_8
       elsif encodings.include?(Constant::PositionEncodingKind::UTF16)
+        @graph.encoding = "utf16"
         Encoding::UTF_16LE
       else
+        @graph.encoding = "utf32"
         Encoding::UTF_32
       end
       @index.configuration.encoding = @encoding

data/lib/ruby_lsp/internal.rb

@@ -20,6 +20,7 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.5")
 end
 require "set"
 require "strscan"
+require "rubydex"
 require "prism"
 require "prism/visitor"
 require "language_server-protocol"
@@ -30,6 +31,10 @@ require "securerandom"
 require "shellwords"
 require "set"
 
+# Rubydex LSP additions
+require "ruby_lsp/rubydex/definition"
+require "ruby_lsp/rubydex/reference"
+
 require "ruby-lsp"
 require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"

data/lib/ruby_lsp/listeners/definition.rb

@@ -12,7 +12,7 @@ module RubyLsp
       def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
-        @index = global_state.index #: RubyIndexer::Index
+        @graph = global_state.graph #: Rubydex::Graph
         @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @language_id = language_id
         @uri = uri
@@ -109,7 +109,7 @@ module RubyLsp
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
-        find_in_index(name)
+        handle_constant_definition(name)
       end
 
       #: (Prism::ConstantReadNode node) -> void
@@ -117,7 +117,7 @@ module RubyLsp
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
-        find_in_index(name)
+        handle_constant_definition(name)
       end
 
       #: (Prism::GlobalVariableAndWriteNode node) -> void
@@ -152,32 +152,32 @@ module RubyLsp
 
       #: (Prism::InstanceVariableReadNode node) -> void
       def on_instance_variable_read_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableWriteNode node) -> void
       def on_instance_variable_write_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableAndWriteNode node) -> void
       def on_instance_variable_and_write_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableOperatorWriteNode node) -> void
       def on_instance_variable_operator_write_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableOrWriteNode node) -> void
       def on_instance_variable_or_write_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableTargetNode node) -> void
       def on_instance_variable_target_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::SuperNode node) -> void
@@ -192,32 +192,32 @@ module RubyLsp
 
       #: (Prism::ClassVariableAndWriteNode node) -> void
       def on_class_variable_and_write_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableOperatorWriteNode node) -> void
       def on_class_variable_operator_write_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableOrWriteNode node) -> void
       def on_class_variable_or_write_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableTargetNode node) -> void
       def on_class_variable_target_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableReadNode node) -> void
       def on_class_variable_read_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableWriteNode node) -> void
       def on_class_variable_write_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       private
@@ -257,93 +257,63 @@ module RubyLsp
 
       #: (String name) -> void
       def handle_global_variable_definition(name)
-        entries = @index[name]
+        declaration = @graph[name]
+        return unless declaration
 
-        return unless entries
-
-        entries.each do |entry|
-          location = entry.location
-
-          @response_builder << Interface::Location.new(
-            uri: entry.uri.to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-            ),
-          )
-        end
-      end
-
-      #: (String name) -> void
-      def handle_class_variable_definition(name)
-        type = @type_inferrer.infer_receiver_type(@node_context)
-        return unless type
-
-        entries = @index.resolve_class_variable(name, type.name)
-        return unless entries
-
-        entries.each do |entry|
-          @response_builder << Interface::Location.new(
-            uri: entry.uri.to_s,
-            range: range_from_location(entry.location),
-          )
-        end
-      rescue RubyIndexer::Index::NonExistingNamespaceError
-        # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
+        declaration.definitions.each { |definition| @response_builder << definition.to_lsp_selection_location }
       end
 
+      # Handle class or instance variables. We collect all definitions across the ancestors of the type
+      #
       #: (String name) -> void
-      def handle_instance_variable_definition(name)
-        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
-        # to provide all features for them
+      def handle_variable_definition(name)
+        # Sorbet enforces that all variables be declared on typed strict or higher, which means it will be able to
+        # provide all features for them
         return if @sorbet_level.strict?
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        entries = @index.resolve_instance_variable(name, type.name)
-        return unless entries
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
 
-        entries.each do |entry|
-          location = entry.location
+        owner.ancestors.each do |ancestor|
+          member = ancestor.member(name)
+          next unless member
 
-          @response_builder << Interface::Location.new(
-            uri: entry.uri.to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-            ),
-          )
+          member.definitions.each { |definition| @response_builder << definition.to_lsp_selection_location }
         end
-      rescue RubyIndexer::Index::NonExistingNamespaceError
-        # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
       #: (String message, TypeInferrer::Type? receiver_type, ?inherited_only: bool) -> void
       def handle_method_definition(message, receiver_type, inherited_only: false)
-        methods = if receiver_type
-          @index.resolve_method(message, receiver_type.name, inherited_only: inherited_only)
+        declaration = if receiver_type
+          owner = @graph[receiver_type.name]
+          owner.find_member("#{message}()", only_inherited: inherited_only) if owner.is_a?(Rubydex::Namespace)
         end
 
-        # If the method doesn't have a receiver, or the guessed receiver doesn't have any matched candidates,
-        # then we provide a few candidates to jump to
-        # But we don't want to provide too many candidates, as it can be overwhelming
-        if receiver_type.nil? || (receiver_type.is_a?(TypeInferrer::GuessedType) && methods.nil?)
-          methods = @index[message]&.take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
+        # If the method doesn't have a receiver, or the guessed receiver doesn't have any matched candidates, then we
+        # provide a few candidates to jump to. However, we don't want to provide too many candidates, as it can be
+        # overwhelming
+        if receiver_type.nil? || (receiver_type.is_a?(TypeInferrer::GuessedType) && declaration.nil?)
+          declaration = @graph.search("##{message}()").take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
         end
 
-        return unless methods
+        return unless declaration
 
-        methods.each do |target_method|
-          uri = target_method.uri
-          full_path = uri.full_path
-          next if @sorbet_level.true_or_higher? && (!full_path || not_in_dependencies?(full_path))
+        Array(declaration).each do |decl|
+          decl.definitions.each do |definition|
+            location = definition.location
+            uri = URI(location.uri)
+            full_path = uri.full_path
+            next if @sorbet_level.true_or_higher? && (!full_path || not_in_dependencies?(full_path))
 
-          @response_builder << Interface::LocationLink.new(
-            target_uri: uri.to_s,
-            target_range: range_from_location(target_method.location),
-            target_selection_range: range_from_location(target_method.name_location),
-          )
+            @response_builder << Interface::LocationLink.new(
+              target_uri: uri.to_s,
+              target_range: definition.to_lsp_selection_range,
+              target_selection_range: definition.to_lsp_name_range || definition.to_lsp_selection_range,
+            )
+          end
         end
       end
 
@@ -351,12 +321,10 @@ module RubyLsp
       def handle_require_definition(node, message)
         case message
         when :require
-          entry = @index.search_require_paths(node.content).find do |uri|
-            uri.require_path == node.content
-          end
+          document = @graph.resolve_require_path(node.content, $LOAD_PATH)
 
-          if entry
-            candidate = entry.full_path
+          if document
+            candidate = URI(document.uri).full_path
 
             if candidate
               @response_builder << Interface::Location.new(
@@ -392,35 +360,33 @@ module RubyLsp
         constant_name = argument.value
         return unless constant_name
 
-        find_in_index(constant_name)
+        handle_constant_definition(constant_name)
       end
 
       #: (String value) -> void
-      def find_in_index(value)
-        entries = @index.resolve(value, @node_context.nesting)
-        return unless entries
+      def handle_constant_definition(value)
+        declaration = @graph.resolve_constant(value, @node_context.nesting)
+        return unless declaration
 
+        # [RUBYDEX] TODO: temporarily commented out until we have the visibility API
+        #
         # We should only allow jumping to the definition of private constants if the constant is defined in the same
         # namespace as the reference
-        first_entry = entries.first #: as !nil
-        return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{value}"
+        #
+        # return if declaration.private? && declaration.name != "#{@node_context.fully_qualified_name}::#{value}"
 
-        entries.each do |entry|
+        declaration.definitions.each do |definition|
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
           # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
           # ignore
-          uri = entry.uri
+          uri = URI(definition.location.uri)
           full_path = uri.full_path
 
           if !@sorbet_level.ignore? && (!full_path || not_in_dependencies?(full_path))
             next
           end
 
-          @response_builder << Interface::LocationLink.new(
-            target_uri: uri.to_s,
-            target_range: range_from_location(entry.location),
-            target_selection_range: range_from_location(entry.name_location),
-          )
+          @response_builder << definition.to_lsp_location_link
         end
       end
     end

data/lib/ruby_lsp/listeners/hover.rb

@@ -48,6 +48,7 @@ module RubyLsp
         @response_builder = response_builder
         @global_state = global_state
         @index = global_state.index #: RubyIndexer::Index
+        @graph = global_state.graph #: Rubydex::Graph
         @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @path = uri.to_standardized_path #: String?
         @node_context = node_context
@@ -178,32 +179,32 @@ module RubyLsp
 
       #: (Prism::InstanceVariableReadNode node) -> void
       def on_instance_variable_read_node_enter(node)
-        handle_instance_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableWriteNode node) -> void
       def on_instance_variable_write_node_enter(node)
-        handle_instance_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableAndWriteNode node) -> void
       def on_instance_variable_and_write_node_enter(node)
-        handle_instance_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableOperatorWriteNode node) -> void
       def on_instance_variable_operator_write_node_enter(node)
-        handle_instance_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableOrWriteNode node) -> void
       def on_instance_variable_or_write_node_enter(node)
-        handle_instance_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableTargetNode node) -> void
       def on_instance_variable_target_node_enter(node)
-        handle_instance_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::SuperNode node) -> void
@@ -223,32 +224,32 @@ module RubyLsp
 
       #: (Prism::ClassVariableAndWriteNode node) -> void
       def on_class_variable_and_write_node_enter(node)
-        handle_class_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::ClassVariableOperatorWriteNode node) -> void
       def on_class_variable_operator_write_node_enter(node)
-        handle_class_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::ClassVariableOrWriteNode node) -> void
       def on_class_variable_or_write_node_enter(node)
-        handle_class_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::ClassVariableTargetNode node) -> void
       def on_class_variable_target_node_enter(node)
-        handle_class_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::ClassVariableReadNode node) -> void
       def on_class_variable_read_node_enter(node)
-        handle_class_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       #: (Prism::ClassVariableWriteNode node) -> void
       def on_class_variable_write_node_enter(node)
-        handle_class_variable_hover(node.name.to_s)
+        handle_variable_hover(node.name.to_s)
       end
 
       private
@@ -324,62 +325,46 @@ module RubyLsp
         end
       end
 
-      #: (String name) -> void
-      def handle_instance_variable_hover(name)
-        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
-        # to provide all features for them
-        return if @sorbet_level.strict?
-
-        type = @type_inferrer.infer_receiver_type(@node_context)
-        return unless type
-
-        entries = @index.resolve_instance_variable(name, type.name)
-        return unless entries
-
-        categorized_markdown_from_index_entries(name, entries).each do |category, content|
-          @response_builder.push(content, category: category)
-        end
-      rescue RubyIndexer::Index::NonExistingNamespaceError
-        # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
-      end
-
       #: (String name) -> void
       def handle_global_variable_hover(name)
-        entries = @index[name]
-        return unless entries
+        declaration = @graph[name]
+        return unless declaration
 
-        categorized_markdown_from_index_entries(name, entries).each do |category, content|
+        categorized_markdown_from_definitions(name, declaration.definitions).each do |category, content|
           @response_builder.push(content, category: category)
         end
       end
 
+      # Handle class or instance variables. We collect all definitions across the ancestors of the type
+      #
       #: (String name) -> void
-      def handle_class_variable_hover(name)
+      def handle_variable_hover(name)
+        # Sorbet enforces that all variables be declared on typed strict or higher, which means it will be able to
+        # provide all features for them
+        return if @sorbet_level.strict?
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        entries = @index.resolve_class_variable(name, type.name)
-        return unless entries
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
 
-        categorized_markdown_from_index_entries(name, entries).each do |category, content|
-          @response_builder.push(content, category: category)
+        owner.ancestors.each do |ancestor|
+          member = ancestor.member(name)
+          next unless member
+
+          categorized_markdown_from_definitions(member.name, member.definitions).each do |category, content|
+            @response_builder.push(content, category: category)
+          end
         end
-      rescue RubyIndexer::Index::NonExistingNamespaceError
-        # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
       #: (String name, Prism::Location location) -> void
       def generate_hover(name, location)
-        entries = @index.resolve(name, @node_context.nesting)
-        return unless entries
-
-        # We should only show hover for private constants if the constant is defined in the same namespace as the
-        # reference
-        first_entry = entries.first #: as !nil
-        full_name = first_entry.name
-        return if first_entry.private? && full_name != "#{@node_context.fully_qualified_name}::#{name}"
+        declaration = @graph.resolve_constant(name, @node_context.nesting)
+        return unless declaration
 
-        categorized_markdown_from_index_entries(full_name, entries).each do |category, content|
+        categorized_markdown_from_definitions(declaration.name, declaration.definitions).each do |category, content|
           @response_builder.push(content, category: category)
         end
       end

data/lib/ruby_lsp/listeners/test_style.rb

@@ -266,7 +266,7 @@ module RubyLsp
         # We only support regular Minitest tests. The declarative syntax provided by ActiveSupport is handled by the
         # Rails add-on
         name_parts = fully_qualified_name.split("::")
-        singleton_name = "#{name_parts.join("::")}::<Class:#{name_parts.last}>"
+        singleton_name = "#{name_parts.join("::")}::<#{name_parts.last}>"
         !@index.linearized_ancestors_of(singleton_name).include?("ActiveSupport::Testing::Declarative")
       rescue RubyIndexer::Index::NonExistingNamespaceError
         true