ruby-lsp 0.27.0.beta1 → 0.27.0.beta3

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,
@@ -219,7 +220,7 @@ module RubyLsp
         name = node.name.to_s
         return unless name.start_with?("test_")
 
-        current_group_name = RubyIndexer::Index.actual_nesting(@nesting, nil).join("::")
+        current_group_name = calc_fully_qualified_name(nil)
         parent = @parent_stack.last
         return unless parent.is_a?(Requests::Support::TestItem)
 
@@ -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

data/lib/ruby_lsp/node_context.rb

@@ -5,6 +5,21 @@ module RubyLsp
   # This class allows listeners to access contextual information about a node in the AST, such as its parent,
   # its namespace nesting, and the surrounding CallNode (e.g. a method call).
   class NodeContext
+    # Represents the surrounding method definition context, tracking both the method name and its receiver
+    class MethodDef
+      #: String
+      attr_reader :name
+
+      #: String?
+      attr_reader :receiver
+
+      #: (String name, String? receiver) -> void
+      def initialize(name, receiver)
+        @name = name
+        @receiver = receiver
+      end
+    end
+
     #: Prism::Node?
     attr_reader :node, :parent
 
@@ -14,7 +29,7 @@ module RubyLsp
     #: Prism::CallNode?
     attr_reader :call_node
 
-    #: String?
+    #: MethodDef?
     attr_reader :surrounding_method
 
     #: (Prism::Node? node, Prism::Node? parent, Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nesting_nodes, Prism::CallNode? call_node) -> void
@@ -26,7 +41,7 @@ module RubyLsp
 
       nesting, surrounding_method = handle_nesting_nodes(nesting_nodes)
       @nesting = nesting #: Array[String]
-      @surrounding_method = surrounding_method #: String?
+      @surrounding_method = surrounding_method #: MethodDef?
     end
 
     #: -> String
@@ -52,10 +67,10 @@ module RubyLsp
 
     private
 
-    #: (Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nodes) -> [Array[String], String?]
+    #: (Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nodes) -> [Array[String], MethodDef?]
     def handle_nesting_nodes(nodes)
       nesting = []
-      surrounding_method = nil #: String?
+      surrounding_method = nil #: MethodDef?
 
       @nesting_nodes.each do |node|
         case node
@@ -64,10 +79,18 @@ module RubyLsp
         when Prism::SingletonClassNode
           nesting << "<#{nesting.flat_map { |n| n.split("::") }.last}>"
         when Prism::DefNode
-          surrounding_method = node.name.to_s
-          next unless node.receiver.is_a?(Prism::SelfNode)
-
-          nesting << "<#{nesting.flat_map { |n| n.split("::") }.last}>"
+          receiver = node.receiver
+
+          surrounding_method = case receiver
+          when nil
+            MethodDef.new(node.name.to_s, "none")
+          when Prism::SelfNode
+            MethodDef.new(node.name.to_s, "self")
+          when Prism::ConstantReadNode, Prism::ConstantPathNode
+            MethodDef.new(node.name.to_s, receiver.slice)
+          else
+            MethodDef.new(node.name.to_s, nil)
+          end
         end
       end
 

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -16,6 +16,12 @@ module RubyLsp
     class CompletionResolve < Request
       include Requests::Support::Common
 
+      METHOD_KINDS = [
+        Constant::CompletionItemKind::METHOD,
+        Constant::CompletionItemKind::CONSTRUCTOR,
+        Constant::CompletionItemKind::FUNCTION,
+      ].freeze #: Array[Integer]
+
       # set a limit on the number of documentation entries returned, to avoid rendering performance issues
       # https://github.com/Shopify/ruby-lsp/pull/1798
       MAX_DOCUMENTATION_ENTRIES = 10
@@ -23,7 +29,7 @@ module RubyLsp
       #: (GlobalState global_state, Hash[Symbol, untyped] item) -> void
       def initialize(global_state, item)
         super()
-        @index = global_state.index #: RubyIndexer::Index
+        @graph = global_state.graph #: Rubydex::Graph
         @item = item
       end
 
@@ -31,6 +37,8 @@ module RubyLsp
       #: -> Hash[Symbol, untyped]
       def perform
         return @item if @item.dig(:data, :skip_resolve)
+        return keyword_resolve if @item.dig(:data, :keyword)
+        return @item if @item[:kind] == Constant::CompletionItemKind::FILE
 
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
@@ -39,70 +47,78 @@ module RubyLsp
         #
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the
         # `label` for the text edit instead
-        label = @item[:label].dup
-        return keyword_resolve(@item) if @item.dig(:data, :keyword)
-
-        entries = @index[label] || []
-
-        owner_name = @item.dig(:data, :owner_name)
-
-        if owner_name
-          entries = entries.select do |entry|
-            (entry.is_a?(RubyIndexer::Entry::Member) || entry.is_a?(RubyIndexer::Entry::InstanceVariable) ||
-            entry.is_a?(RubyIndexer::Entry::MethodAlias) || entry.is_a?(RubyIndexer::Entry::ClassVariable)) &&
-              entry.owner&.name == owner_name
-          end
-        end
+        declaration = resolve_declaration
+        return @item unless declaration
 
-        first_entry = entries.first #: as !nil
+        guessed_type = @item.dig(:data, :guessed_type)
+        title = @item[:label].dup
 
-        if first_entry.is_a?(RubyIndexer::Entry::Member)
-          label = +"#{label}#{first_entry.decorated_parameters}"
-          label << first_entry.formatted_signatures
+        if declaration.is_a?(Rubydex::Method)
+          title << declaration.decorated_parameters
+          title << declaration.formatted_signatures
         end
 
-        guessed_type = @item.dig(:data, :guessed_type)
-
         extra_links = if guessed_type
-          label << "\n\nGuessed receiver: #{guessed_type}"
+          title << "\n\nGuessed receiver: #{guessed_type}"
           "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
         end
 
-        unless @item[:kind] == Constant::CompletionItemKind::FILE
-          @item[:documentation] = Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
-          )
-        end
+        @item[:documentation] = Interface::MarkupContent.new(
+          kind: "markdown",
+          value: markdown_from_definitions(
+            title,
+            declaration.definitions,
+            MAX_DOCUMENTATION_ENTRIES,
+            extra_links: extra_links,
+          ),
+        )
 
         @item
       end
 
       private
 
-      #: (Hash[Symbol, untyped] item) -> Hash[Symbol, untyped]
-      def keyword_resolve(item)
-        keyword = item[:label]
-        content = KEYWORD_DOCS[keyword]
+      # Find the Rubydex declaration that matches the completion item. Constants are looked up by their fully qualified
+      # name (set when the completion was produced); members (methods, instance/class variables) are resolved by walking
+      # the owner namespace and its ancestors so that inherited and aliased members are surfaced correctly.
+      #: -> Rubydex::Declaration?
+      def resolve_declaration
+        data = @item[:data] || {}
+
+        if (fully_qualified_name = data[:fully_qualified_name])
+          @graph[fully_qualified_name]
+        elsif (owner_name = data[:owner_name])
+          owner = @graph[owner_name]
+          return unless owner.is_a?(Rubydex::Namespace)
+
+          member_name = if METHOD_KINDS.include?(@item[:kind])
+            "#{@item[:label]}()"
+          else
+            @item[:label]
+          end
+
+          owner.find_member(member_name)
+        end
+      end
 
-        if content
-          doc_uri = URI::Generic.from_path(path: File.join(STATIC_DOCS_PATH, "#{keyword}.md"))
+      #: -> Hash[Symbol, untyped]
+      def keyword_resolve
+        keyword = @graph.keyword(@item[:label])
 
+        if keyword
           @item[:documentation] = Interface::MarkupContent.new(
             kind: "markdown",
             value: <<~MARKDOWN.chomp,
               ```ruby
-              #{keyword}
+              #{keyword.name}
               ```
 
-              [Read more](#{doc_uri})
-
-              #{content}
+              #{keyword.documentation}
             MARKDOWN
           )
         end
 
-        item
+        @item
       end
     end
   end

data/lib/ruby_lsp/requests/discover_tests.rb

@@ -19,55 +19,19 @@ module RubyLsp
         @document = document
         @dispatcher = dispatcher
         @response_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
-        @index = global_state.index #: RubyIndexer::Index
       end
 
       # @override
       #: -> Array[Support::TestItem]
       def perform
-        uri = @document.uri
+        Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+        Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
 
-        # We normally only index test files once they are opened in the editor to save memory and avoid doing
-        # unnecessary work. If the file is already opened and we already indexed it, then we can just discover the tests
-        # straight away.
-        #
-        # However, if the user navigates to a specific test file from the explorer with nothing opened in the UI, then
-        # we will not have indexed the test file yet and trying to linearize the ancestor of the class will fail. In
-        # this case, we have to instantiate the indexer listener first, so that we insert classes, modules and methods
-        # in the index first and then discover the tests, all in the same traversal.
-        if @index.entries_for(uri.to_s)
-          Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-          Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-
-          Addon.addons.each do |addon|
-            addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
-          end
-
-          @dispatcher.visit(@document.ast)
-        else
-          @global_state.synchronize do
-            RubyIndexer::DeclarationListener.new(
-              @index,
-              @dispatcher,
-              @document.parse_result,
-              uri,
-              collect_comments: true,
-            )
-
-            Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-            Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-
-            Addon.addons.each do |addon|
-              addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
-            end
-
-            # Dispatch the events both for indexing the test file and discovering the tests. The order here is
-            # important because we need the index to be aware of the existing classes/modules/methods before the test
-            # listeners can do their work
-            @dispatcher.visit(@document.ast)
-          end
+        Addon.addons.each do |addon|
+          addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
         end
 
+        @dispatcher.visit(@document.ast)
         @response_builder.response
       end
     end

data/lib/ruby_lsp/requests/hover.rb

@@ -26,7 +26,6 @@ module RubyLsp
         node_context = RubyDocument.locate(
           document.ast,
           char_position,
-          node_types: Listeners::Hover::ALLOWED_TARGETS,
           code_units_cache: document.code_units_cache,
         )
         target = node_context.node
@@ -48,7 +47,7 @@ module RubyLsp
         @target = target #: Prism::Node?
         uri = document.uri
         @response_builder = ResponseBuilders::Hover.new #: ResponseBuilders::Hover
-        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level)
+        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level, position)
         Addon.addons.each do |addon|
           addon.create_hover_listener(@response_builder, node_context, dispatcher)
         end
@@ -77,9 +76,7 @@ module RubyLsp
 
       #: (Prism::Node? parent, Prism::Node? target) -> bool
       def should_refine_target?(parent, target)
-        (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-        !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
-          (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+        parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode)
       end
 
       #: (Hash[Symbol, untyped] position, Prism::Node? target) -> bool

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -5,9 +5,7 @@ module RubyLsp
   module Requests
     # The [prepare type hierarchy
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_prepareTypeHierarchy)
-    # displays the list of ancestors (supertypes) and descendants (subtypes) for the selected type.
-    #
-    # Currently only supports supertypes due to a limitation of the index.
+    # displays the list of direct ancestors (supertypes) and descendants (subtypes) for the selected type.
     class PrepareTypeHierarchy < Request
       include Support::Common
 
@@ -18,12 +16,12 @@ module RubyLsp
         end
       end
 
-      #: ((RubyDocument | ERBDocument) document, RubyIndexer::Index index, Hash[Symbol, untyped] position) -> void
-      def initialize(document, index, position)
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position) -> void
+      def initialize(document, global_state, position)
         super()
 
         @document = document
-        @index = index
+        @graph = global_state.graph #: Rubydex::Graph
         @position = position
       end
 
@@ -36,32 +34,78 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantWriteNode,
             Prism::ConstantPathNode,
+            Prism::SingletonClassNode,
           ],
         )
 
-        node = context.node
-        parent = context.parent
-        return unless node && parent
+        node = context.node #: as (Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantWriteNode | Prism::SingletonClassNode)?
+        return unless node
+
+        pair = name_and_nesting(node, context)
+        return unless pair
 
-        target = determine_target(node, parent, @position)
-        entries = @index.resolve(target.slice, context.nesting)
-        return unless entries
+        declaration = @graph.resolve_constant(pair.first, pair.last)
+        return unless declaration.is_a?(Rubydex::Namespace)
 
-        # While the spec allows for multiple entries, VSCode seems to only support one
-        # We'll just return the first one for now
-        first_entry = entries.first #: as !nil
-        range = range_from_location(first_entry.location)
+        primary = declaration.definitions.first
+        return unless primary
 
         [
-          Interface::TypeHierarchyItem.new(
-            name: first_entry.name,
-            kind: kind_for_entry(first_entry),
-            uri: first_entry.uri.to_s,
-            range: range,
-            selection_range: range,
+          primary.to_lsp_type_hierarchy_item(
+            declaration.name,
+            detail: declaration.lsp_type_hierarchy_detail,
           ),
         ]
       end
+
+      private
+
+      # Returns the `(name, nesting)` pair to pass to `Rubydex::Graph#resolve_constant`, covering three cases:
+      #
+      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantWriteNode | Prism::SingletonClassNode), NodeContext) -> [String, Array[String]]?
+      def name_and_nesting(node, context)
+        parent = context.parent
+        nesting = context.nesting
+
+        singleton_node = singleton_class_node_for(node, parent)
+        return singleton_lookup(singleton_node, nesting) if singleton_node
+
+        target = parent ? determine_target(node, parent, @position) : node
+        [target.slice, nesting]
+      end
+
+      # Ensures that we're returning the target of the singleton class block regardless of whether the cursor is on the
+      # `class` keyword or the constant reference for the target
+      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantWriteNode | Prism::SingletonClassNode), Prism::Node?) -> Prism::SingletonClassNode?
+      def singleton_class_node_for(node, parent)
+        return node if node.is_a?(Prism::SingletonClassNode)
+        return unless parent.is_a?(Prism::SingletonClassNode) && parent.expression == node
+
+        parent
+      end
+
+      # Builds the synthesized singleton class name (e.g. `Foo::<Foo>`) for a `class << X` block, together with the
+      # outer lexical nesting. `NodeContext` already appends a `<ClassName>` marker as the last element of the nesting
+      # whenever the cursor sits inside (or on) a `SingletonClassNode`, so we drop that marker to obtain the scope in
+      # which the singleton should be resolved.
+      #: (Prism::SingletonClassNode, Array[String]) -> [String, Array[String]]?
+      def singleton_lookup(singleton_node, nesting)
+        outer = nesting[0...-1] || []
+
+        case expression = singleton_node.expression
+        when Prism::SelfNode
+          name = nesting.last
+          return unless name
+
+          [name, outer]
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          name = constant_name(expression)
+          return unless name
+
+          unqualified = name.split("::").last #: as !nil
+          ["#{name}::<#{unqualified}>", outer]
+        end
+      end
     end
   end
 end