ruby-lsp 0.27.0.beta1 → 0.27.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e5c88483f280d13f2691e131a16e35df07df898e8f380071d077479cd24133e
-  data.tar.gz: 7630ce8844fcb532ca63c77e299b692471b145530a623dcbc78ecbb50ce08596
+  metadata.gz: 11c508848c7c0db2c86807dd05b5de3a0cf33c8d69259cffd34865af8f50d93b
+  data.tar.gz: d030d7223e7714008fef42f5b8635b373cf42f88f60e3c22a878dd1e48ed2ee8
 SHA512:
-  metadata.gz: 7757882e6e441d49705a389bad6b0b617b7f9a26fb1e5f34ebd3fc93eeb8921b31a703253cff79ed123ae411333fc7d91f0555ae162cafee1d10adfb13b76cf4
-  data.tar.gz: c215743ab00113e4dd3186732faabd462fef6a3be425f1c76bb65b045846effd7db0673478244218f1087e3fa9ca96f8668c86970def65bf2e5fbb4ea0728a8d
+  metadata.gz: 23d4677fea98fe4723442e9162c9835ce9813eab354882c9b3cbd45deb4fc9cd81a91d1618cdb8e580c68eeaf840a45cc7271c031b2b4bf559d92a50d64755ec
+  data.tar.gz: 1e044d2758e1872a1a94df7f288e8e2ff4b1b4ca2a089db8958acf5830bacd8247086c1c0df167fe072a6586a8391332ceaaa1827add9280e9c42cd3ce96bdf2

data/VERSION

@@ -1 +1 @@
-0.27.0.beta1
+0.27.0.beta2

data/lib/ruby_indexer/ruby_indexer.rb

@@ -7,7 +7,6 @@ require "did_you_mean"
 require "ruby_indexer/lib/ruby_indexer/uri"
 require "ruby_indexer/lib/ruby_indexer/visibility_scope"
 require "ruby_indexer/lib/ruby_indexer/declaration_listener"
-require "ruby_indexer/lib/ruby_indexer/reference_finder"
 require "ruby_indexer/lib/ruby_indexer/enhancement"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"

data/lib/ruby_lsp/addon.rb

@@ -56,26 +56,9 @@ module RubyLsp
         addon_files = Gem.find_files("ruby_lsp/**/addon.rb")
 
         if include_project_addons
-          project_addons = Dir.glob("#{global_state.workspace_path}/**/ruby_lsp/**/addon.rb")
           bundle_path = Bundler.bundle_path.to_s
-          gems_dir = Bundler.bundle_path.join("gems")
-
-          # Create an array of rejection glob patterns to ignore add-ons already discovered through Gem.find_files if
-          # they are also copied inside the workspace for whatever reason. We received reports of projects having gems
-          # installed in vendor/bundle despite BUNDLE_PATH pointing elsewhere. Without this mechanism, we will
-          # double-require the same add-on, potentially for different versions of the same gem, which leads to incorrect
-          # behavior
-          reject_glob_patterns = addon_files.map do |path|
-            relative_gem_path = Pathname.new(path).relative_path_from(gems_dir)
-            first_part, *parts = relative_gem_path.to_s.split(File::SEPARATOR)
-            first_part&.gsub!(/-([0-9.]+)$/, "*")
-            "**/#{first_part}/#{parts.join("/")}"
-          end
-
-          project_addons.reject! do |path|
-            path.start_with?(bundle_path) ||
-              reject_glob_patterns.any? { |pattern| File.fnmatch?(pattern, path, File::Constants::FNM_PATHNAME) }
-          end
+          project_addons = Dir.glob("#{global_state.workspace_path}/**/ruby_lsp/**/addon.rb")
+          project_addons.reject! { |path| path.start_with?(bundle_path) || gem_installation_path?(path) }
 
           addon_files.concat(project_addons)
         end
@@ -162,6 +145,23 @@ module RubyLsp
             "Add-on is not compatible with this version of the Ruby LSP. Skipping its activation"
         end
       end
+
+      private
+
+      # Checks if a path appears to be inside a versioned gem installation directory (e.g., `rubocop-1.73.0/lib/...`) by
+      # looking for a directory segment matching `name-version` before the `lib` component
+      #
+      #: (String path) -> bool
+      def gem_installation_path?(path)
+        parts = path.split(%r{[/\\]})
+        lib_index = parts.rindex("lib")
+        return false unless lib_index
+
+        prefix = parts[0...lib_index] #: Array[String]?
+        return false unless prefix
+
+        prefix.any? { |part| part.match?(/-\d+(\.\d+)+$/) }
+      end
     end
 
     #: -> void

data/lib/ruby_lsp/global_state.rb

@@ -204,7 +204,7 @@ module RubyLsp
         Encoding::UTF_16LE
       else
         @graph.encoding = "utf32"
-        Encoding::UTF_32
+        Encoding::UTF_32LE
       end
       @index.configuration.encoding = @encoding
 

data/lib/ruby_lsp/internal.rb

@@ -32,6 +32,7 @@ require "shellwords"
 require "set"
 
 # Rubydex LSP additions
+require "ruby_lsp/rubydex/declaration"
 require "ruby_lsp/rubydex/definition"
 require "ruby_lsp/rubydex/reference"
 
@@ -39,7 +40,6 @@ require "ruby-lsp"
 require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
 require "ruby_lsp/utils"
-require "ruby_lsp/static_docs"
 require "ruby_lsp/scope"
 require "ruby_lsp/client_capabilities"
 require "ruby_lsp/global_state"

data/lib/ruby_lsp/listeners/definition.rb

@@ -249,7 +249,7 @@ module RubyLsp
         return unless surrounding_method
 
         handle_method_definition(
-          surrounding_method,
+          surrounding_method.name,
           @type_inferrer.infer_receiver_type(@node_context),
           inherited_only: true,
         )

data/lib/ruby_lsp/listeners/document_link.rb

@@ -21,6 +21,8 @@ module RubyLsp
 
             Gem::Specification.stubs.each do |stub|
               spec = stub.to_spec
+              next unless spec
+
               lookup[spec.name] = {}
               lookup[spec.name][spec.version.to_s] = {}
 
@@ -31,6 +33,8 @@ module RubyLsp
 
             Gem::Specification.default_stubs.each do |stub|
               spec = stub.to_spec
+              next unless spec
+
               lookup[spec.name] = {}
               lookup[spec.name][spec.version.to_s] = {}
               prefix_matchers = Regexp.union(spec.require_paths.map do |rp|

data/lib/ruby_lsp/listeners/hover.rb

@@ -6,45 +6,13 @@ 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
@@ -53,45 +21,80 @@ module RubyLsp
         @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
@@ -144,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
 
@@ -209,19 +218,150 @@ module RubyLsp
 
       #: (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::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::YieldNode node) -> void
-      def on_yield_node_enter(node)
-        handle_keyword_documentation(node.keyword)
+      #: (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_variable_hover(node.name.to_s)
@@ -279,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
 
-        surrounding_method = @node_context.surrounding_method
-        return unless surrounding_method
+        handle_keyword_documentation(loc.slice)
+      end
+
+      #: (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

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("::")}::<#{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