ruby-lsp 0.14.5 → 0.15.0

data/lib/ruby_lsp/requests/definition.rb

@@ -31,13 +31,13 @@ module RubyLsp
       sig do
         params(
           document: Document,
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(document, index, position, dispatcher, typechecker_enabled)
+      def initialize(document, global_state, position, dispatcher, typechecker_enabled)
         super()
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::Location].new,
@@ -49,12 +49,25 @@ module RubyLsp
           node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
         )
 
-        target = parent if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          target = determine_target(
+            target,
+            parent,
+            position,
+          )
+        end
 
-        Listeners::Definition.new(@response_builder, document.uri, nesting, index, dispatcher, typechecker_enabled)
+        Listeners::Definition.new(
+          @response_builder,
+          global_state,
+          document.uri,
+          nesting,
+          dispatcher,
+          typechecker_enabled,
+        )
 
         Addon.addons.each do |addon|
-          addon.create_definition_listener(@response_builder, document.uri, nesting, index, dispatcher)
+          addon.create_definition_listener(@response_builder, global_state, document.uri, nesting, dispatcher)
         end
 
         @target = T.let(target, T.nilable(Prism::Node))

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -45,11 +45,11 @@ module RubyLsp
         end
       end
 
-      sig { params(dispatcher: Prism::Dispatcher).void }
-      def initialize(dispatcher)
+      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
+      def initialize(uri, dispatcher)
         super()
         @response_builder = T.let(ResponseBuilders::DocumentSymbol.new, ResponseBuilders::DocumentSymbol)
-        Listeners::DocumentSymbol.new(@response_builder, dispatcher)
+        Listeners::DocumentSymbol.new(@response_builder, uri, dispatcher)
 
         Addon.addons.each do |addon|
           addon.create_document_symbol_listener(@response_builder, dispatcher)

data/lib/ruby_lsp/requests/hover.rb

@@ -33,13 +33,13 @@ module RubyLsp
       sig do
         params(
           document: Document,
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(document, index, position, dispatcher, typechecker_enabled)
+      def initialize(document, global_state, position, dispatcher, typechecker_enabled)
         super()
         @target = T.let(nil, T.nilable(Prism::Node))
         @target, parent, nesting = document.locate_node(
@@ -50,7 +50,11 @@ module RubyLsp
         if (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
             !Listeners::Hover::ALLOWED_TARGETS.include?(@target.class)) ||
             (parent.is_a?(Prism::ConstantPathNode) && @target.is_a?(Prism::ConstantReadNode))
-          @target = parent
+          @target = determine_target(
+            T.must(@target),
+            T.must(parent),
+            position,
+          )
         end
 
         # Don't need to instantiate any listeners if there's no target
@@ -58,9 +62,9 @@ module RubyLsp
 
         uri = document.uri
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
-        Listeners::Hover.new(@response_builder, uri, nesting, index, dispatcher, typechecker_enabled)
+        Listeners::Hover.new(@response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled)
         Addon.addons.each do |addon|
-          addon.create_hover_listener(@response_builder, nesting, index, dispatcher)
+          addon.create_hover_listener(@response_builder, global_state, nesting, dispatcher)
         end
 
         @dispatcher = dispatcher

data/lib/ruby_lsp/requests/request.rb

@@ -12,6 +12,57 @@ module RubyLsp
 
       sig { abstract.returns(T.anything) }
       def perform; end
+
+      private
+
+      # Checks if a location covers a position
+      sig { params(location: Prism::Location, position: T.untyped).returns(T::Boolean) }
+      def cover?(location, position)
+        start_covered =
+          location.start_line - 1 < position[:line] ||
+          (
+            location.start_line - 1 == position[:line] &&
+              location.start_column <= position[:character]
+          )
+        end_covered =
+          location.end_line - 1 > position[:line] ||
+          (
+            location.end_line - 1 == position[:line] &&
+              location.end_column >= position[:character]
+          )
+        start_covered && end_covered
+      end
+
+      # Based on a constant node target, a constant path node parent and a position, this method will find the exact
+      # portion of the constant path that matches the requested position, for higher precision in hover and
+      # definition. For example:
+      #
+      # ```ruby
+      # Foo::Bar::Baz
+      #  #        ^ Going to definition here should go to Foo::Bar::Baz
+      #  #   ^ Going to definition here should go to Foo::Bar
+      # #^ Going to definition here should go to Foo
+      # ```
+      sig do
+        params(
+          target: Prism::Node,
+          parent: Prism::Node,
+          position: T::Hash[Symbol, Integer],
+        ).returns(Prism::Node)
+      end
+      def determine_target(target, parent, position)
+        return target unless parent.is_a?(Prism::ConstantPathNode)
+
+        target = T.let(parent, Prism::Node)
+        parent = T.let(T.cast(target, Prism::ConstantPathNode).parent, T.nilable(Prism::Node))
+
+        while parent && cover?(parent.location, position)
+          target = parent
+          parent = target.is_a?(Prism::ConstantPathNode) ? target.parent : nil
+        end
+
+        target
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/signature_help.rb

@@ -42,13 +42,14 @@ module RubyLsp
       sig do
         params(
           document: Document,
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           context: T.nilable(T::Hash[Symbol, T.untyped]),
           dispatcher: Prism::Dispatcher,
+          typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(document, index, position, context, dispatcher)
+      def initialize(document, global_state, position, context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
         super()
         target, parent, nesting = document.locate_node(
           { line: position[:line], character: position[:character] },
@@ -60,7 +61,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
-        Listeners::SignatureHelp.new(@response_builder, nesting, index, dispatcher)
+        Listeners::SignatureHelp.new(@response_builder, global_state, nesting, dispatcher, typechecker_enabled)
       end
 
       sig { override.returns(T.nilable(Interface::SignatureHelp)) }

data/lib/ruby_lsp/requests/support/common.rb

@@ -86,13 +86,16 @@ module RubyLsp
           params(
             title: String,
             entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
+            max_entries: T.nilable(Integer),
           ).returns(T::Hash[Symbol, String])
         end
-        def categorized_markdown_from_index_entries(title, entries)
+        def categorized_markdown_from_index_entries(title, entries, max_entries = nil)
           markdown_title = "```ruby\n#{title}\n```"
           definitions = []
           content = +""
-          Array(entries).each do |entry|
+          entries = Array(entries)
+          entries_to_format = max_entries ? entries.take(max_entries) : entries
+          entries_to_format.each do |entry|
             loc = entry.location
 
             # We always handle locations as zero based. However, for file links in Markdown we need them to be one
@@ -108,9 +111,16 @@ module RubyLsp
             content << "\n\n#{entry.comments.join("\n")}" unless entry.comments.empty?
           end
 
+          additional_entries_text = if max_entries && entries.length > max_entries
+            additional = entries.length - max_entries
+            " | #{additional} other#{additional > 1 ? "s" : ""}"
+          else
+            ""
+          end
+
           {
             title: markdown_title,
-            links: "**Definitions**: #{definitions.join(" | ")}",
+            links: "**Definitions**: #{definitions.join(" | ")}#{additional_entries_text}",
             documentation: content,
           }
         end
@@ -119,10 +129,11 @@ module RubyLsp
           params(
             title: String,
             entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
+            max_entries: T.nilable(Integer),
           ).returns(String)
         end
-        def markdown_from_index_entries(title, entries)
-          categorized_markdown = categorized_markdown_from_index_entries(title, entries)
+        def markdown_from_index_entries(title, entries, max_entries = nil)
+          categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
 
           <<~MARKDOWN.chomp
             #{categorized_markdown[:title]}
@@ -147,6 +158,15 @@ module RubyLsp
         rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
           nil
         end
+
+        sig { params(node: T.any(Prism::ModuleNode, Prism::ClassNode)).returns(T.nilable(String)) }
+        def namespace_constant_name(node)
+          path = node.constant_path
+          case path
+          when Prism::ConstantPathNode, Prism::ConstantReadNode, Prism::ConstantPathTargetNode
+            constant_name(path)
+          end
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -92,6 +92,10 @@ module RubyLsp
           @options[:stdin] = contents
 
           super([path])
+
+          # RuboCop rescues interrupts and then sets the `@aborting` variable to true. We don't want them to be rescued,
+          # so here we re-raise in case RuboCop received an interrupt.
+          raise Interrupt if aborting?
         rescue RuboCop::Runner::InfiniteCorrectionLoop => error
           raise Formatting::Error, error.message
         rescue RuboCop::ValidationError => error

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -22,11 +22,12 @@ module RubyLsp
       extend T::Sig
       include Support::Common
 
-      sig { params(query: T.nilable(String), index: RubyIndexer::Index).void }
-      def initialize(query, index)
+      sig { params(global_state: GlobalState, query: T.nilable(String)).void }
+      def initialize(global_state, query)
         super()
+        @global_state = global_state
         @query = query
-        @index = index
+        @index = T.let(global_state.index, RubyIndexer::Index)
       end
 
       sig { override.returns(T::Array[Interface::WorkspaceSymbol]) }
@@ -35,7 +36,7 @@ module RubyLsp
           # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
           # we still return entries defined in gems to allow developers to jump directly to the source
           file_path = entry.file_path
-          next if DependencyDetector.instance.typechecker && not_in_dependencies?(file_path)
+          next if @global_state.typechecker && not_in_dependencies?(file_path)
 
           # We should never show private symbols when searching the entire workspace
           next if entry.visibility == :private

data/lib/ruby_lsp/requests.rb

@@ -18,6 +18,7 @@ module RubyLsp
   # - [DocumentHighlight](rdoc-ref:RubyLsp::Requests::DocumentHighlight)
   # - [InlayHint](rdoc-ref:RubyLsp::Requests::InlayHints)
   # - [Completion](rdoc-ref:RubyLsp::Requests::Completion)
+  # - [CompletionResolve](rdoc-ref:RubyLsp::Requests::CompletionResolve)
   # - [CodeLens](rdoc-ref:RubyLsp::Requests::CodeLens)
   # - [Definition](rdoc-ref:RubyLsp::Requests::Definition)
   # - [ShowSyntaxTree](rdoc-ref:RubyLsp::Requests::ShowSyntaxTree)
@@ -40,6 +41,7 @@ module RubyLsp
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
     autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
     autoload :Completion, "ruby_lsp/requests/completion"
+    autoload :CompletionResolve, "ruby_lsp/requests/completion_resolve"
     autoload :CodeLens, "ruby_lsp/requests/code_lens"
     autoload :Definition, "ruby_lsp/requests/definition"
     autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"