ruby-lsp 0.13.2 → 0.13.4

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/folding_ranges"
+
 module RubyLsp
   module Requests
     # ![Folding ranges demo](../../folding_ranges.gif)
@@ -15,268 +17,30 @@ module RubyLsp
     #   puts "Hello"
     # end # <-- folding range end
     # ```
-    class FoldingRanges < Listener
+    class FoldingRanges < Request
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T::Array[Interface::FoldingRange] } }
-
-      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher).void }
-      def initialize(comments, dispatcher)
-        super(dispatcher)
-
-        @_response = T.let([], ResponseType)
-        @requires = T.let([], T::Array[Prism::CallNode])
-        @finalized_response = T.let(false, T::Boolean)
-        @comments = comments
+      class << self
+        extend T::Sig
 
-        dispatcher.register(
-          self,
-          :on_if_node_enter,
-          :on_in_node_enter,
-          :on_rescue_node_enter,
-          :on_when_node_enter,
-          :on_interpolated_string_node_enter,
-          :on_array_node_enter,
-          :on_block_node_enter,
-          :on_case_node_enter,
-          :on_case_match_node_enter,
-          :on_class_node_enter,
-          :on_module_node_enter,
-          :on_for_node_enter,
-          :on_hash_node_enter,
-          :on_singleton_class_node_enter,
-          :on_unless_node_enter,
-          :on_until_node_enter,
-          :on_while_node_enter,
-          :on_else_node_enter,
-          :on_ensure_node_enter,
-          :on_begin_node_enter,
-          :on_def_node_enter,
-          :on_call_node_enter,
-          :on_lambda_node_enter,
-        )
-      end
-
-      sig { override.returns(ResponseType) }
-      def _response
-        unless @finalized_response
-          push_comment_ranges
-          emit_requires_range
-          @finalized_response = true
+        sig { returns(Interface::FoldingRangeClientCapabilities) }
+        def provider
+          Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
         end
-
-        @_response
-      end
-
-      sig { params(node: Prism::IfNode).void }
-      def on_if_node_enter(node)
-        add_statements_range(node)
-      end
-
-      sig { params(node: Prism::InNode).void }
-      def on_in_node_enter(node)
-        add_statements_range(node)
-      end
-
-      sig { params(node: Prism::RescueNode).void }
-      def on_rescue_node_enter(node)
-        add_statements_range(node)
-      end
-
-      sig { params(node: Prism::WhenNode).void }
-      def on_when_node_enter(node)
-        add_statements_range(node)
-      end
-
-      sig { params(node: Prism::InterpolatedStringNode).void }
-      def on_interpolated_string_node_enter(node)
-        opening_loc = node.opening_loc || node.location
-        closing_loc = node.closing_loc || node.parts.last&.location || node.location
-
-        add_lines_range(opening_loc.start_line, closing_loc.start_line - 1)
       end
 
-      sig { params(node: Prism::ArrayNode).void }
-      def on_array_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::BlockNode).void }
-      def on_block_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::CaseNode).void }
-      def on_case_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::CaseMatchNode).void }
-      def on_case_match_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::ClassNode).void }
-      def on_class_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::ModuleNode).void }
-      def on_module_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::ForNode).void }
-      def on_for_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::HashNode).void }
-      def on_hash_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::SingletonClassNode).void }
-      def on_singleton_class_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::UnlessNode).void }
-      def on_unless_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::UntilNode).void }
-      def on_until_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::WhileNode).void }
-      def on_while_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::ElseNode).void }
-      def on_else_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::EnsureNode).void }
-      def on_ensure_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::BeginNode).void }
-      def on_begin_node_enter(node)
-        add_simple_range(node)
-      end
-
-      sig { params(node: Prism::DefNode).void }
-      def on_def_node_enter(node)
-        params = node.parameters
-        parameter_loc = params&.location
-        location = node.location
-
-        if params && parameter_loc.end_line > location.start_line
-          # Multiline parameters
-          add_lines_range(location.start_line, parameter_loc.end_line)
-          add_lines_range(parameter_loc.end_line + 1, location.end_line - 1)
-        else
-          add_lines_range(location.start_line, location.end_line - 1)
-        end
-      end
-
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_enter(node)
-        # If we find a require, don't visit the child nodes (prevent `super`), so that we can keep accumulating into
-        # the `@requires` array and then push the range whenever we find a node that isn't a CallNode
-        if require?(node)
-          @requires << node
-          return
-        end
-
-        location = node.location
-        add_lines_range(location.start_line, location.end_line - 1)
-      end
-
-      sig { params(node: Prism::LambdaNode).void }
-      def on_lambda_node_enter(node)
-        add_simple_range(node)
-      end
-
-      private
-
-      sig { void }
-      def push_comment_ranges
-        # Group comments that are on consecutive lines and then push ranges for each group that has at least 2 comments
-        @comments.chunk_while do |this, other|
-          this.location.end_line + 1 == other.location.start_line
-        end.each do |chunk|
-          next if chunk.length == 1
-
-          @_response << Interface::FoldingRange.new(
-            start_line: T.must(chunk.first).location.start_line - 1,
-            end_line: T.must(chunk.last).location.end_line - 1,
-            kind: "comment",
-          )
-        end
-      end
-
-      sig { void }
-      def emit_requires_range
-        if @requires.length > 1
-          @_response << Interface::FoldingRange.new(
-            start_line: T.must(@requires.first).location.start_line - 1,
-            end_line: T.must(@requires.last).location.end_line - 1,
-            kind: "imports",
-          )
-        end
-
-        @requires.clear
-      end
-
-      sig { params(node: Prism::CallNode).returns(T::Boolean) }
-      def require?(node)
-        message = node.message
-        return false unless message == "require" || message == "require_relative"
-
-        receiver = node.receiver
-        return false unless receiver.nil? || receiver.slice == "Kernel"
-
-        arguments = node.arguments&.arguments
-        return false unless arguments
-
-        arguments.length == 1 && arguments.first.is_a?(Prism::StringNode)
-      end
-
-      sig { params(node: T.any(Prism::IfNode, Prism::InNode, Prism::RescueNode, Prism::WhenNode)).void }
-      def add_statements_range(node)
-        statements = node.statements
-        return unless statements
-
-        body = statements.body
-        return if body.empty?
-
-        add_lines_range(node.location.start_line, T.must(body.last).location.end_line)
-      end
+      ResponseType = type_member { { fixed: T::Array[Interface::FoldingRange] } }
 
-      sig { params(node: Prism::Node).void }
-      def add_simple_range(node)
-        location = node.location
-        add_lines_range(location.start_line, location.end_line - 1)
+      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher).void }
+      def initialize(comments, dispatcher)
+        super()
+        @listener = T.let(Listeners::FoldingRanges.new(comments, dispatcher), Listener[ResponseType])
       end
 
-      sig { params(start_line: Integer, end_line: Integer).void }
-      def add_lines_range(start_line, end_line)
-        emit_requires_range
-        return if start_line >= end_line
-
-        @_response << Interface::FoldingRange.new(
-          start_line: start_line - 1,
-          end_line: end_line - 1,
-          kind: "region",
-        )
+      sig { override.returns(ResponseType) }
+      def perform
+        @listener.response
       end
     end
   end

data/lib/ruby_lsp/requests/formatting.rb

@@ -25,7 +25,7 @@ module RubyLsp
     # puts "Hello" # --> formatting: fixes the indentation on save
     # end
     # ```
-    class Formatting < BaseRequest
+    class Formatting < Request
       class Error < StandardError; end
       class InvalidFormatter < StandardError; end
 
@@ -55,14 +55,14 @@ module RubyLsp
 
       sig { params(document: Document, formatter: String).void }
       def initialize(document, formatter: "auto")
-        super(document)
-
+        super()
+        @document = document
         @uri = T.let(document.uri, URI::Generic)
         @formatter = formatter
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
-      def run
+      def perform
         return if @formatter == "none"
         return if @document.syntax_error?
 

data/lib/ruby_lsp/requests/hover.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/hover"
+
 module RubyLsp
   module Requests
     # ![Hover demo](../../hover.gif)
@@ -13,123 +15,77 @@ module RubyLsp
     # ```ruby
     # String # -> Hovering over the class reference will show all declaration locations and the documentation
     # ```
-    class Hover < ExtensibleListener
+    class Hover < Request
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
+      class << self
+        extend T::Sig
 
-      ALLOWED_TARGETS = T.let(
-        [
-          Prism::CallNode,
-          Prism::ConstantReadNode,
-          Prism::ConstantWriteNode,
-          Prism::ConstantPathNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
+        sig { returns(Interface::HoverClientCapabilities) }
+        def provider
+          Interface::HoverClientCapabilities.new(dynamic_registration: false)
+        end
+      end
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
 
       sig do
         params(
+          document: Document,
           index: RubyIndexer::Index,
-          nesting: T::Array[String],
+          position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
+          typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(index, nesting, dispatcher)
-        @index = index
-        @nesting = nesting
-        @_response = T.let(nil, ResponseType)
-
-        super(dispatcher)
-        dispatcher.register(
-          self,
-          :on_constant_read_node_enter,
-          :on_constant_write_node_enter,
-          :on_constant_path_node_enter,
-          :on_call_node_enter,
+      def initialize(document, index, position, dispatcher, typechecker_enabled)
+        super()
+        target, parent, nesting = document.locate_node(
+          position,
+          node_types: Listeners::Hover::ALLOWED_TARGETS,
         )
-      end
 
-      sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
-      def initialize_external_listener(addon)
-        addon.create_hover_listener(@nesting, @index, @dispatcher)
-      end
-
-      # Merges responses from other hover listeners
-      sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
-      def merge_response!(other)
-        other_response = other.response
-        return self unless other_response
-
-        if @_response.nil?
-          @_response = other.response
-        else
-          @_response.contents.value << "\n\n" << other_response.contents.value
+        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
         end
 
-        self
-      end
-
-      sig { params(node: Prism::ConstantReadNode).void }
-      def on_constant_read_node_enter(node)
-        return if DependencyDetector.instance.typechecker
-
-        generate_hover(node.slice, node.location)
-      end
+        @listeners = T.let([], T::Array[Listener[ResponseType]])
 
-      sig { params(node: Prism::ConstantWriteNode).void }
-      def on_constant_write_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        # Don't need to instantiate any listeners if there's no target
+        return unless target
 
-        generate_hover(node.name.to_s, node.name_loc)
-      end
-
-      sig { params(node: Prism::ConstantPathNode).void }
-      def on_constant_path_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        uri = document.uri
+        @listeners = T.let(
+          [Listeners::Hover.new(uri, nesting, index, dispatcher, typechecker_enabled)],
+          T::Array[Listener[ResponseType]],
+        )
+        Addon.addons.each do |addon|
+          addon_listener = addon.create_hover_listener(nesting, index, dispatcher)
+          @listeners << addon_listener if addon_listener
+        end
 
-        generate_hover(node.slice, node.location)
+        @target = T.let(target, Prism::Node)
+        @dispatcher = dispatcher
       end
 
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_enter(node)
-        return if DependencyDetector.instance.typechecker
-        return unless self_receiver?(node)
-
-        message = node.message
-        return unless message
-
-        target_method = @index.resolve_method(message, @nesting.join("::"))
-        return unless target_method
-
-        location = target_method.location
-
-        @_response = Interface::Hover.new(
-          range: range_from_location(location),
-          contents: markdown_from_index_entries(message, target_method),
-        )
-      end
+      sig { override.returns(ResponseType) }
+      def perform
+        @dispatcher.dispatch_once(@target)
+        responses = @listeners.map(&:response).compact
 
-      private
+        first_response, *other_responses = responses
 
-      sig { params(name: String, location: Prism::Location).void }
-      def generate_hover(name, location)
-        entries = @index.resolve(name, @nesting)
-        return unless entries
+        return unless first_response
 
-        # We should only show hover for private constants if the constant is defined in the same namespace as the
-        # reference
-        first_entry = T.must(entries.first)
-        return if first_entry.visibility == :private && first_entry.name != "#{@nesting.join("::")}::#{name}"
+        # TODO: other_responses should never be nil. Check Sorbet
+        T.must(other_responses).each do |other_response|
+          first_response.contents.value << "\n\n" << other_response.contents.value
+        end
 
-        @_response = Interface::Hover.new(
-          range: range_from_location(location),
-          contents: markdown_from_index_entries(name, entries),
-        )
+        first_response
       end
     end
   end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/inlay_hints"
+
 module RubyLsp
   module Requests
     # ![Inlay hint demo](../../inlay_hints.gif)
@@ -36,77 +38,42 @@ module RubyLsp
     #   a: "hello",
     # }
     # ```
-    class InlayHints < Listener
+    class InlayHints < Request
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T::Array[Interface::InlayHint] } }
+      class << self
+        extend T::Sig
 
-      RESCUE_STRING_LENGTH = T.let("rescue".length, Integer)
+        sig { returns(Interface::InlayHintOptions) }
+        def provider
+          Interface::InlayHintOptions.new(resolve_provider: false)
+        end
+      end
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      ResponseType = type_member { { fixed: T::Array[Interface::InlayHint] } }
 
       sig do
         params(
-          range: T::Range[Integer],
+          document: Document,
+          range: T::Hash[Symbol, T.untyped],
           hints_configuration: RequestConfig,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(range, hints_configuration, dispatcher)
-        super(dispatcher)
-
-        @_response = T.let([], ResponseType)
-        @range = range
-        @hints_configuration = hints_configuration
-
-        dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
-      end
-
-      sig { params(node: Prism::RescueNode).void }
-      def on_rescue_node_enter(node)
-        return unless @hints_configuration.enabled?(:implicitRescue)
-        return unless node.exceptions.empty?
-
-        loc = node.location
-        return unless visible?(node, @range)
-
-        @_response << Interface::InlayHint.new(
-          position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
-          label: "StandardError",
-          padding_left: true,
-          tooltip: "StandardError is implied in a bare rescue",
+      def initialize(document, range, hints_configuration, dispatcher)
+        super()
+        start_line = range.dig(:start, :line)
+        end_line = range.dig(:end, :line)
+        @listener = T.let(
+          Listeners::InlayHints.new(start_line..end_line, hints_configuration, dispatcher),
+          Listener[ResponseType],
         )
       end
 
-      sig { params(node: Prism::ImplicitNode).void }
-      def on_implicit_node_enter(node)
-        return unless @hints_configuration.enabled?(:implicitHashValue)
-        return unless visible?(node, @range)
-
-        node_value = node.value
-        loc = node.location
-        tooltip = ""
-        node_name = ""
-        case node_value
-        when Prism::CallNode
-          node_name = node_value.name
-          tooltip = "This is a method call. Method name: #{node_name}"
-        when Prism::ConstantReadNode
-          node_name = node_value.name
-          tooltip = "This is a constant: #{node_name}"
-        when Prism::LocalVariableReadNode
-          node_name = node_value.name
-          tooltip = "This is a local variable: #{node_name}"
-        end
-
-        @_response << Interface::InlayHint.new(
-          position: { line: loc.start_line - 1, character: loc.start_column + node_name.length + 1 },
-          label: node_name,
-          padding_left: true,
-          tooltip: tooltip,
-        )
+      sig { override.returns(ResponseType) }
+      def perform
+        @listener.response
       end
     end
   end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -15,9 +15,21 @@ module RubyLsp
     #   # <-- cursor ends up here
     # end # <-- end is automatically added
     # ```
-    class OnTypeFormatting < BaseRequest
+    class OnTypeFormatting < Request
       extend T::Sig
 
+      class << self
+        extend T::Sig
+
+        sig { returns(Interface::DocumentOnTypeFormattingOptions) }
+        def provider
+          Interface::DocumentOnTypeFormattingOptions.new(
+            first_trigger_character: "{",
+            more_trigger_character: ["\n", "|", "d"],
+          )
+        end
+      end
+
       END_REGEXES = T.let(
         [
           /\b(if|unless|for|while|class|module|until|def|case)\b.*/,
@@ -28,8 +40,8 @@ module RubyLsp
 
       sig { params(document: Document, position: T::Hash[Symbol, T.untyped], trigger_character: String).void }
       def initialize(document, position, trigger_character)
-        super(document)
-
+        super()
+        @document = document
         @lines = T.let(@document.source.lines, T::Array[String])
         line = @lines[[position[:line] - 1, 0].max]
 
@@ -41,7 +53,7 @@ module RubyLsp
       end
 
       sig { override.returns(T.all(T::Array[Interface::TextEdit], Object)) }
-      def run
+      def perform
         case @trigger_character
         when "{"
           handle_curly_brace if @document.syntax_error?

data/lib/ruby_lsp/requests/request.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # :nodoc:
+    class Request
+      extend T::Sig
+      extend T::Generic
+
+      abstract!
+
+      sig { abstract.returns(T.anything) }
+      def perform; end
+    end
+  end
+end

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -20,18 +20,19 @@ module RubyLsp
     #   puts "Hello, world!" # --> Cursor is on this line
     # end
     # ```
-    class SelectionRanges
+    class SelectionRanges < Request
       extend T::Sig
       include Support::Common
       sig { params(document: Document).void }
       def initialize(document)
+        super()
         @document = document
         @ranges = T.let([], T::Array[Support::SelectionRange])
         @stack = T.let([], T::Array[Support::SelectionRange])
       end
 
-      sig { returns(T.all(T::Array[Support::SelectionRange], Object)) }
-      def run
+      sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
+      def perform
         # [node, parent]
         queue = [[@document.tree, nil]]