ruby-lsp 0.27.0.beta1 → 0.27.0.beta3

data/lib/ruby_lsp/listeners/definition.rb

@@ -106,7 +106,7 @@ module RubyLsp
 
       #: (Prism::ConstantPathNode node) -> void
       def on_constant_path_node_enter(node)
-        name = RubyIndexer::Index.constant_name(node)
+        name = constant_name(node)
         return if name.nil?
 
         handle_constant_definition(name)
@@ -114,7 +114,7 @@ module RubyLsp
 
       #: (Prism::ConstantReadNode node) -> void
       def on_constant_read_node_enter(node)
-        name = RubyIndexer::Index.constant_name(node)
+        name = constant_name(node)
         return if name.nil?
 
         handle_constant_definition(name)
@@ -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,
         )
@@ -302,6 +302,9 @@ module RubyLsp
         return unless declaration
 
         Array(declaration).each do |decl|
+          next if decl.is_a?(Rubydex::Method) &&
+            !method_reachable_from_call_site?(decl, receiver_type, @graph, @node_context)
+
           decl.definitions.each do |definition|
             location = definition.location
             uri = URI(location.uri)
@@ -367,13 +370,7 @@ module RubyLsp
       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
-        #
-        # return if declaration.private? && declaration.name != "#{@node_context.fully_qualified_name}::#{value}"
+        return unless constant_reachable_from_call_site?(declaration, value, @node_context)
 
         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

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,92 +6,94 @@ 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
@@ -114,7 +116,7 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         return unless @sorbet_level.ignore?
 
-        name = RubyIndexer::Index.constant_name(node)
+        name = constant_name(node)
         return if name.nil?
 
         generate_hover(name, node.location)
@@ -131,7 +133,7 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return unless @sorbet_level.ignore?
 
-        name = RubyIndexer::Index.constant_name(node)
+        name = constant_name(node)
         return if name.nil?
 
         generate_hover(name, node.location)
@@ -144,6 +146,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 +217,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::YieldNode node) -> void
-      def on_yield_node_enter(node)
-        handle_keyword_documentation(node.keyword)
+      #: (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::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 +418,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
@@ -307,20 +456,22 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
-        return unless methods
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
 
-        first_method = methods.first #: as !nil
+        method = owner.find_member("#{message}()", only_inherited: inherited_only)
+        return unless method.is_a?(Rubydex::Method)
+        return unless method_reachable_from_call_site?(method, type, @graph, @node_context)
 
-        title = "#{message}#{first_method.decorated_parameters}"
-        title << first_method.formatted_signatures
+        title = +"#{message}#{method.decorated_parameters}"
+        title << method.formatted_signatures
 
         if type.is_a?(TypeInferrer::GuessedType)
           title << "\n\nGuessed receiver: #{type.name}"
           @response_builder.push("[Learn more about guessed types](#{GUESSED_TYPES_URL})\n", category: :links)
         end
 
-        categorized_markdown_from_index_entries(title, methods).each do |category, content|
+        categorized_markdown_from_definitions(title, method.definitions).each do |category, content|
           @response_builder.push(content, category: category)
         end
       end
@@ -363,6 +514,7 @@ module RubyLsp
       def generate_hover(name, location)
         declaration = @graph.resolve_constant(name, @node_context.nesting)
         return unless declaration
+        return unless constant_reachable_from_call_site?(declaration, name, @node_context)
 
         categorized_markdown_from_definitions(declaration.name, declaration.definitions).each do |category, content|
           @response_builder.push(content, category: category)

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -11,7 +11,7 @@ module RubyLsp
         @sorbet_level = sorbet_level
         @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
         @node_context = node_context
         dispatcher.register(self, :on_call_node_enter)
@@ -27,18 +27,17 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        methods = @index.resolve_method(message, type.name)
-        return unless methods
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
 
-        target_method = methods.first
-        return unless target_method
+        target_method = owner.find_member("#{message}()")
+        return unless target_method.is_a?(Rubydex::Method)
 
         signatures = target_method.signatures
 
-        # If the method doesn't have any parameters, there's no need to show signature help
+        # If the method doesn't have any signatures, there's nothing to show
         return if signatures.empty?
 
-        name = target_method.name
         title = +""
 
         extra_links = if type.is_a?(TypeInferrer::GuessedType)
@@ -49,7 +48,7 @@ module RubyLsp
         active_signature, active_parameter = determine_active_signature_and_parameter(node, signatures)
 
         signature_help = Interface::SignatureHelp.new(
-          signatures: generate_signatures(signatures, name, methods, title, extra_links),
+          signatures: generate_signatures(signatures, message, target_method, title, extra_links),
           active_signature: active_signature,
           active_parameter: active_parameter,
         )
@@ -58,7 +57,7 @@ module RubyLsp
 
       private
 
-      #: (Prism::CallNode node, Array[RubyIndexer::Entry::Signature] signatures) -> [Integer, Integer]
+      #: (Prism::CallNode node, Array[Rubydex::Signature] signatures) -> [Integer, Integer]
       def determine_active_signature_and_parameter(node, signatures)
         arguments_node = node.arguments
         arguments = arguments_node&.arguments || []
@@ -86,15 +85,15 @@ module RubyLsp
         [active_sig_index, active_parameter]
       end
 
-      #: (Array[RubyIndexer::Entry::Signature] signatures, String method_name, Array[RubyIndexer::Entry] methods, String title, String? extra_links) -> Array[Interface::SignatureInformation]
-      def generate_signatures(signatures, method_name, methods, title, extra_links)
+      #: (Array[Rubydex::Signature] signatures, String method_name, Rubydex::Method method, String title, String? extra_links) -> Array[Interface::SignatureInformation]
+      def generate_signatures(signatures, method_name, method, title, extra_links)
         signatures.map do |signature|
           Interface::SignatureInformation.new(
             label:  "#{method_name}(#{signature.format})",
             parameters: signature.parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
             documentation: Interface::MarkupContent.new(
               kind: "markdown",
-              value: markdown_from_index_entries(title, methods, extra_links: extra_links),
+              value: markdown_from_definitions(title, method.definitions, extra_links: extra_links),
             ),
           )
         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
@@ -56,7 +56,23 @@ module RubyLsp
 
       #: (String? name) -> String
       def calc_fully_qualified_name(name)
-        RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
+        parts = name ? @nesting + [name] : @nesting
+        return "" if parts.empty?
+
+        last = parts.last #: as !nil
+        rest = parts[0...-1] #: as !nil
+
+        resolved = @graph.resolve_constant(last, rest)
+        return resolved.name if resolved
+
+        # Fallback for unresolved constants (e.g. dynamic references): preserve top-level reset semantics by
+        # truncating at the first `::`-prefixed part when scanning from the innermost out.
+        corrected = []
+        parts.reverse_each do |part|
+          corrected.prepend(part.delete_prefix("::"))
+          break if part.start_with?("::")
+        end
+        corrected.join("::")
       end
 
       #: (Prism::ClassNode node, String fully_qualified_name) -> Array[String]
@@ -64,22 +80,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