ruby-lsp 0.26.9 → 0.27.0.beta2

data/lib/ruby_lsp/listeners/hover.rb

@@ -6,91 +6,95 @@ module RubyLsp
     class Hover
       include Requests::Support::Common
 
-      ALLOWED_TARGETS = [
-        Prism::BreakNode,
-        Prism::CallNode,
-        Prism::ConstantReadNode,
-        Prism::ConstantWriteNode,
-        Prism::ConstantPathNode,
-        Prism::GlobalVariableAndWriteNode,
-        Prism::GlobalVariableOperatorWriteNode,
-        Prism::GlobalVariableOrWriteNode,
-        Prism::GlobalVariableReadNode,
-        Prism::GlobalVariableTargetNode,
-        Prism::GlobalVariableWriteNode,
-        Prism::InstanceVariableReadNode,
-        Prism::InstanceVariableAndWriteNode,
-        Prism::InstanceVariableOperatorWriteNode,
-        Prism::InstanceVariableOrWriteNode,
-        Prism::InstanceVariableTargetNode,
-        Prism::InstanceVariableWriteNode,
-        Prism::SymbolNode,
-        Prism::StringNode,
-        Prism::InterpolatedStringNode,
-        Prism::SuperNode,
-        Prism::ForwardingSuperNode,
-        Prism::YieldNode,
-        Prism::ClassVariableAndWriteNode,
-        Prism::ClassVariableOperatorWriteNode,
-        Prism::ClassVariableOrWriteNode,
-        Prism::ClassVariableReadNode,
-        Prism::ClassVariableTargetNode,
-        Prism::ClassVariableWriteNode,
-      ] #: Array[singleton(Prism::Node)]
-
       ALLOWED_REMOTE_PROVIDERS = [
         "https://github.com",
         "https://gitlab.com",
       ].freeze #: Array[String]
 
-      #: (ResponseBuilders::Hover response_builder, GlobalState global_state, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
-      def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
+      #: (ResponseBuilders::Hover response_builder, GlobalState global_state, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level, Hash[Symbol, untyped] position) -> void
+      def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level, position) # 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
         @path = uri.to_standardized_path #: String?
         @node_context = node_context
         @sorbet_level = sorbet_level
+        @position = position
 
         dispatcher.register(
           self,
+          :on_alias_global_variable_node_enter,
+          :on_alias_method_node_enter,
+          :on_and_node_enter,
+          :on_begin_node_enter,
+          :on_block_node_enter,
           :on_break_node_enter,
+          :on_call_node_enter,
+          :on_case_match_node_enter,
+          :on_case_node_enter,
+          :on_class_node_enter,
+          :on_singleton_class_node_enter,
+          :on_lambda_node_enter,
+          :on_class_variable_and_write_node_enter,
+          :on_class_variable_operator_write_node_enter,
+          :on_class_variable_or_write_node_enter,
+          :on_class_variable_read_node_enter,
+          :on_class_variable_target_node_enter,
+          :on_class_variable_write_node_enter,
+          :on_constant_path_node_enter,
           :on_constant_read_node_enter,
           :on_constant_write_node_enter,
-          :on_constant_path_node_enter,
-          :on_call_node_enter,
+          :on_def_node_enter,
+          :on_defined_node_enter,
+          :on_else_node_enter,
+          :on_ensure_node_enter,
+          :on_false_node_enter,
+          :on_for_node_enter,
+          :on_forwarding_super_node_enter,
           :on_global_variable_and_write_node_enter,
           :on_global_variable_operator_write_node_enter,
           :on_global_variable_or_write_node_enter,
           :on_global_variable_read_node_enter,
           :on_global_variable_target_node_enter,
           :on_global_variable_write_node_enter,
-          :on_instance_variable_read_node_enter,
-          :on_instance_variable_write_node_enter,
+          :on_if_node_enter,
+          :on_in_node_enter,
           :on_instance_variable_and_write_node_enter,
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
+          :on_instance_variable_read_node_enter,
           :on_instance_variable_target_node_enter,
-          :on_super_node_enter,
-          :on_forwarding_super_node_enter,
-          :on_string_node_enter,
+          :on_instance_variable_write_node_enter,
           :on_interpolated_string_node_enter,
+          :on_module_node_enter,
+          :on_next_node_enter,
+          :on_nil_node_enter,
+          :on_or_node_enter,
+          :on_post_execution_node_enter,
+          :on_pre_execution_node_enter,
+          :on_redo_node_enter,
+          :on_rescue_modifier_node_enter,
+          :on_rescue_node_enter,
+          :on_retry_node_enter,
+          :on_return_node_enter,
+          :on_self_node_enter,
+          :on_source_encoding_node_enter,
+          :on_source_file_node_enter,
+          :on_source_line_node_enter,
+          :on_string_node_enter,
+          :on_super_node_enter,
+          :on_true_node_enter,
+          :on_undef_node_enter,
+          :on_unless_node_enter,
+          :on_until_node_enter,
+          :on_when_node_enter,
+          :on_while_node_enter,
           :on_yield_node_enter,
-          :on_class_variable_and_write_node_enter,
-          :on_class_variable_operator_write_node_enter,
-          :on_class_variable_or_write_node_enter,
-          :on_class_variable_read_node_enter,
-          :on_class_variable_target_node_enter,
-          :on_class_variable_write_node_enter,
         )
       end
 
-      #: (Prism::BreakNode node) -> void
-      def on_break_node_enter(node)
-        handle_keyword_documentation(node.keyword)
-      end
-
       #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         if @path && File.basename(@path) == GEMFILE_NAME
@@ -143,6 +147,12 @@ module RubyLsp
         message = node.message
         return unless message
 
+        # `not x` is parsed as a call to `!` whose message_loc slices to "not"
+        if node.name == :! && message == "not"
+          handle_keyword_documentation("not")
+          return
+        end
+
         handle_method_hover(message)
       end
 
@@ -178,77 +188,208 @@ 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
       def on_super_node_enter(node)
-        handle_super_node_hover
+        handle_super_node_hover(node.keyword_loc)
       end
 
       #: (Prism::ForwardingSuperNode node) -> void
       def on_forwarding_super_node_enter(node)
-        handle_super_node_hover
+        handle_super_node_hover(node.location)
+      end
+
+      #: (Prism::AliasGlobalVariableNode) -> void
+      def on_alias_global_variable_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::AliasMethodNode) -> void
+      def on_alias_method_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::AndNode) -> void
+      def on_and_node_enter(node) = handle_keyword_at_location(node.operator_loc)
+
+      #: (Prism::BeginNode) -> void
+      def on_begin_node_enter(node) = handle_keyword_at_location(node.begin_keyword_loc, node.end_keyword_loc)
+
+      #: (Prism::BlockNode) -> void
+      def on_block_node_enter(node) = handle_keyword_at_location(node.opening_loc, node.closing_loc)
+
+      #: (Prism::BreakNode) -> void
+      def on_break_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::CaseMatchNode) -> void
+      def on_case_match_node_enter(node) = handle_keyword_at_location(node.case_keyword_loc, node.end_keyword_loc)
+
+      #: (Prism::CaseNode) -> void
+      def on_case_node_enter(node) = handle_keyword_at_location(node.case_keyword_loc, node.end_keyword_loc)
+
+      #: (Prism::ClassNode) -> void
+      def on_class_node_enter(node) = handle_keyword_at_location(node.class_keyword_loc, node.end_keyword_loc)
+
+      #: (Prism::SingletonClassNode) -> void
+      def on_singleton_class_node_enter(node)
+        handle_keyword_at_location(node.class_keyword_loc, node.end_keyword_loc)
+      end
+
+      #: (Prism::LambdaNode) -> void
+      def on_lambda_node_enter(node) = handle_keyword_at_location(node.opening_loc, node.closing_loc)
+
+      #: (Prism::DefNode) -> void
+      def on_def_node_enter(node) = handle_keyword_at_location(node.def_keyword_loc, node.end_keyword_loc)
+
+      #: (Prism::DefinedNode) -> void
+      def on_defined_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::ElseNode) -> void
+      def on_else_node_enter(node) = handle_keyword_at_location(node.else_keyword_loc, node.end_keyword_loc)
+
+      #: (Prism::EnsureNode) -> void
+      def on_ensure_node_enter(node) = handle_keyword_at_location(node.ensure_keyword_loc, node.end_keyword_loc)
+
+      #: (Prism::FalseNode) -> void
+      def on_false_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::ForNode) -> void
+      def on_for_node_enter(node)
+        handle_keyword_at_location(
+          node.for_keyword_loc,
+          node.in_keyword_loc,
+          node.do_keyword_loc,
+          node.end_keyword_loc,
+        )
       end
 
-      #: (Prism::YieldNode node) -> void
-      def on_yield_node_enter(node)
-        handle_keyword_documentation(node.keyword)
+      #: (Prism::IfNode) -> void
+      def on_if_node_enter(node)
+        handle_keyword_at_location(node.if_keyword_loc, node.then_keyword_loc, node.end_keyword_loc)
+      end
+
+      #: (Prism::InNode) -> void
+      def on_in_node_enter(node) = handle_keyword_at_location(node.in_loc, node.then_loc)
+
+      #: (Prism::ModuleNode) -> void
+      def on_module_node_enter(node) = handle_keyword_at_location(node.module_keyword_loc, node.end_keyword_loc)
+
+      #: (Prism::NextNode) -> void
+      def on_next_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::NilNode) -> void
+      def on_nil_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::OrNode) -> void
+      def on_or_node_enter(node) = handle_keyword_at_location(node.operator_loc)
+
+      #: (Prism::PostExecutionNode) -> void
+      def on_post_execution_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::PreExecutionNode) -> void
+      def on_pre_execution_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::RedoNode) -> void
+      def on_redo_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::RescueModifierNode) -> void
+      def on_rescue_modifier_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::RescueNode) -> void
+      def on_rescue_node_enter(node) = handle_keyword_at_location(node.keyword_loc, node.then_keyword_loc)
+
+      #: (Prism::RetryNode) -> void
+      def on_retry_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::ReturnNode) -> void
+      def on_return_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::SelfNode) -> void
+      def on_self_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::SourceEncodingNode) -> void
+      def on_source_encoding_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::SourceFileNode) -> void
+      def on_source_file_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::SourceLineNode) -> void
+      def on_source_line_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::TrueNode) -> void
+      def on_true_node_enter(node) = handle_keyword_at_location(node.location)
+
+      #: (Prism::UndefNode) -> void
+      def on_undef_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
+      #: (Prism::UnlessNode) -> void
+      def on_unless_node_enter(node)
+        handle_keyword_at_location(node.keyword_loc, node.then_keyword_loc, node.end_keyword_loc)
       end
 
+      #: (Prism::UntilNode) -> void
+      def on_until_node_enter(node) = handle_keyword_at_location(node.keyword_loc, node.do_keyword_loc, node.closing_loc)
+
+      #: (Prism::WhenNode) -> void
+      def on_when_node_enter(node) = handle_keyword_at_location(node.keyword_loc, node.then_keyword_loc)
+
+      #: (Prism::WhileNode) -> void
+      def on_while_node_enter(node) = handle_keyword_at_location(node.keyword_loc, node.do_keyword_loc, node.closing_loc)
+
+      #: (Prism::YieldNode) -> void
+      def on_yield_node_enter(node) = handle_keyword_at_location(node.keyword_loc)
+
       #: (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
@@ -278,27 +419,37 @@ module RubyLsp
         end
       end
 
-      #: (String keyword) -> void
-      def handle_keyword_documentation(keyword)
-        content = KEYWORD_DOCS[keyword]
-        return unless content
+      #: (String) -> void
+      def handle_keyword_documentation(name)
+        keyword = @graph.keyword(name)
+        return unless keyword
 
-        doc_uri = URI::Generic.from_path(path: File.join(STATIC_DOCS_PATH, "#{keyword}.md"))
-
-        @response_builder.push("```ruby\n#{keyword}\n```", category: :title)
-        @response_builder.push("[Read more](#{doc_uri})", category: :links)
-        @response_builder.push(content, category: :documentation)
+        @response_builder.push("```ruby\n#{keyword.name}\n```", category: :title)
+        @response_builder.push(keyword.documentation, category: :documentation)
       end
 
-      #: -> void
-      def handle_super_node_hover
-        # Sorbet can handle super hover on typed true or higher
-        return if @sorbet_level.true_or_higher?
+      # Push keyword documentation when the cursor is on one of the provided locations. The keyword name is taken from
+      # the covering location's slice so that operator forms (`&&`, `||`, `{`, `}`, ternary `? :`) yield no hover —
+      # their slice is not a keyword in the Rubydex graph.
+      #
+      #: (*Prism::Location?) -> void
+      def handle_keyword_at_location(*locations)
+        loc = locations.find { |l| l && covers_position?(l, @position) }
+        return unless loc
+
+        handle_keyword_documentation(loc.slice)
+      end
 
-        surrounding_method = @node_context.surrounding_method
-        return unless surrounding_method
+      #: (Prism::Location keyword_location) -> void
+      def handle_super_node_hover(keyword_location)
+        # Sorbet can handle the inherited-method hover on typed true or higher, but it does not surface keyword docs, so
+        # we still push those
+        unless @sorbet_level.true_or_higher?
+          surrounding_method = @node_context.surrounding_method
+          handle_method_hover(surrounding_method.name, inherited_only: true) if surrounding_method
+        end
 
-        handle_method_hover(surrounding_method, inherited_only: true)
+        handle_keyword_at_location(keyword_location)
       end
 
       #: (String message, ?inherited_only: bool) -> void
@@ -324,62 +475,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/spec_style.rb

@@ -34,7 +34,7 @@ module RubyLsp
       #: (Prism::ClassNode) -> void
       def on_class_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         with_test_ancestor_tracking(node) do |name, ancestors|
-          @spec_group_id_stack << (ancestors.include?("Minitest::Spec") ? ClassGroup.new(name) : nil)
+          @spec_group_id_stack << (spec_group?(ancestors, name) ? ClassGroup.new(name) : nil)
         end
       end
 
@@ -81,6 +81,11 @@ module RubyLsp
 
       private
 
+      #: (Array[String], String) -> bool
+      def spec_group?(ancestors, fully_qualified_name)
+        fully_qualified_name != "Minitest::Spec" && ancestors.include?("Minitest::Spec")
+      end
+
       #: (Prism::CallNode) -> void
       def handle_describe(node)
         # Describes will include the nesting of all classes and all outer describes as part of its ID, unlike classes

data/lib/ruby_lsp/listeners/test_discovery.rb

@@ -13,7 +13,7 @@ module RubyLsp
       def initialize(response_builder, global_state, uri)
         @response_builder = response_builder
         @uri = uri
-        @index = global_state.index #: RubyIndexer::Index
+        @graph = global_state.graph #: Rubydex::Graph
         @visibility_stack = [:public] #: Array[Symbol]
         @nesting = [] #: Array[String]
       end
@@ -64,22 +64,29 @@ module RubyLsp
         superclass = node.superclass
 
         begin
-          ancestors = @index.linearized_ancestors_of(fully_qualified_name)
-          # If the project has no bundle and a test class inherits from `Minitest::Test`, the linearized ancestors will
-          # not include the parent class because we never indexed it in the first place. Here we add the superclass
-          # directly, so that we can support running tests in projects without a bundle
-          return ancestors if ancestors.length > 1
-
-          # If all we found is the class itself, then manually include the parent class
-          if ancestors.first == fully_qualified_name && superclass
-            return [*ancestors, superclass.slice]
+          declaration = @graph[fully_qualified_name]
+
+          unless declaration.is_a?(Rubydex::Namespace)
+            # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
+            # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
+            return [superclass&.slice].compact
+          end
+
+          ancestors = declaration.ancestors.map(&:name)
+          superclass_ref = declaration.definitions
+            .filter_map { |d| d.superclass if d.is_a?(Rubydex::ClassDefinition) }
+            .find { |ref| !ref.is_a?(Rubydex::ResolvedConstantReference) || ref.declaration.name != "Object" }
+
+          # If we couldn't resolve the parent class, then artificially inject it into the ancestors
+          if superclass_ref.is_a?(Rubydex::UnresolvedConstantReference) && superclass
+            insert_index = ancestors.index(fully_qualified_name) #: as !nil
+            insert_index += 1
+            ancestors.insert(insert_index, superclass.slice)
+            return ancestors
           end
 
+          # If the parent class is properly resolved or if there isn't one, then just use the ancestors
           ancestors
-        rescue RubyIndexer::Index::NonExistingNamespaceError
-          # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
-          # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
-          [superclass&.slice].compact
         end
       end
 

data/lib/ruby_lsp/listeners/test_style.rb

@@ -174,9 +174,10 @@ module RubyLsp
       #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         with_test_ancestor_tracking(node) do |name, ancestors|
-          @framework = :test_unit if ancestors.include?("Test::Unit::TestCase")
+          is_test_unit = test_unit_group?(ancestors, name)
+          @framework = :test_unit if is_test_unit
 
-          if @framework == :test_unit || non_declarative_minitest?(ancestors, name)
+          if is_test_unit || non_declarative_minitest?(ancestors, name)
             test_item = Requests::Support::TestItem.new(
               name,
               name,
@@ -259,17 +260,28 @@ module RubyLsp
         @parent_stack[index] #: as Requests::Support::TestItem | ResponseBuilders::TestCollection
       end
 
-      #: (Array[String] attached_ancestors, String fully_qualified_name) -> bool
+      #: (Array[String], String) -> bool
+      def test_unit_group?(ancestors, fully_qualified_name)
+        fully_qualified_name != "Test::Unit::TestCase" && ancestors.include?("Test::Unit::TestCase")
+      end
+
+      #: (Array[String], String) -> bool
       def non_declarative_minitest?(attached_ancestors, fully_qualified_name)
+        return false if ["Minitest::Spec", "Minitest::Test", "ActiveSupport::TestCase"].include?(fully_qualified_name)
         return false unless attached_ancestors.include?("Minitest::Test")
 
         # 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}>"
-        !@index.linearized_ancestors_of(singleton_name).include?("ActiveSupport::Testing::Declarative")
-      rescue RubyIndexer::Index::NonExistingNamespaceError
-        true
+
+        declaration = @graph[fully_qualified_name]
+        # If we don't find the fully qualified name in the graph, it means there's a dynamic portion in the test class
+        # definition. In that case, if the ancestors did include `Minitest::Test`, we always assume it's a test
+        return true unless declaration.is_a?(Rubydex::Namespace)
+
+        singleton = declaration.singleton_class
+        return !singleton.ancestors.map(&:name).include?("ActiveSupport::Testing::Declarative") if singleton
+
+        !attached_ancestors.include?("ActiveSupport::TestCase")
       end
     end
   end