ruby-lsp 0.13.4 → 0.14.1

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -30,7 +30,6 @@ module RubyLsp
     # ```
     class DocumentSymbol < Request
       extend T::Sig
-      extend T::Generic
 
       class << self
         extend T::Sig
@@ -46,25 +45,20 @@ module RubyLsp
         end
       end
 
-      ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
-
       sig { params(dispatcher: Prism::Dispatcher).void }
       def initialize(dispatcher)
         super()
-        @listeners = T.let(
-          [Listeners::DocumentSymbol.new(dispatcher)],
-          T::Array[Listener[ResponseType]],
-        )
+        @response_builder = T.let(ResponseBuilders::DocumentSymbol.new, ResponseBuilders::DocumentSymbol)
+        Listeners::DocumentSymbol.new(@response_builder, dispatcher)
 
         Addon.addons.each do |addon|
-          addon_listener = addon.create_document_symbol_listener(dispatcher)
-          @listeners << addon_listener if addon_listener
+          addon.create_document_symbol_listener(@response_builder, dispatcher)
         end
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
       def perform
-        @listeners.flat_map(&:response).compact
+        @response_builder.response
       end
     end
   end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -19,7 +19,6 @@ module RubyLsp
     # ```
     class FoldingRanges < Request
       extend T::Sig
-      extend T::Generic
 
       class << self
         extend T::Sig
@@ -30,17 +29,23 @@ module RubyLsp
         end
       end
 
-      ResponseType = type_member { { fixed: T::Array[Interface::FoldingRange] } }
-
       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])
+        @response_builder = T.let(
+          ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange].new,
+          ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange],
+        )
+        @listener = T.let(
+          Listeners::FoldingRanges.new(@response_builder, comments, dispatcher),
+          Listeners::FoldingRanges,
+        )
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T::Array[Interface::FoldingRange]) }
       def perform
-        @listener.response
+        @listener.finalize_response!
+        @response_builder.response
       end
     end
   end

data/lib/ruby_lsp/requests/hover.rb

@@ -41,51 +41,45 @@ module RubyLsp
       end
       def initialize(document, index, position, dispatcher, typechecker_enabled)
         super()
-        target, parent, nesting = document.locate_node(
+        @target = T.let(nil, T.nilable(Prism::Node))
+        @target, parent, nesting = document.locate_node(
           position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
         )
 
         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
+            !Listeners::Hover::ALLOWED_TARGETS.include?(@target.class)) ||
+            (parent.is_a?(Prism::ConstantPathNode) && @target.is_a?(Prism::ConstantReadNode))
+          @target = parent
         end
 
-        @listeners = T.let([], T::Array[Listener[ResponseType]])
-
         # Don't need to instantiate any listeners if there's no target
-        return unless target
+        return unless @target
 
         uri = document.uri
-        @listeners = T.let(
-          [Listeners::Hover.new(uri, nesting, index, dispatcher, typechecker_enabled)],
-          T::Array[Listener[ResponseType]],
-        )
+        @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
+        Listeners::Hover.new(@response_builder, uri, nesting, index, dispatcher, typechecker_enabled)
         Addon.addons.each do |addon|
-          addon_listener = addon.create_hover_listener(nesting, index, dispatcher)
-          @listeners << addon_listener if addon_listener
+          addon.create_hover_listener(@response_builder, nesting, index, dispatcher)
         end
 
-        @target = T.let(target, Prism::Node)
         @dispatcher = dispatcher
       end
 
       sig { override.returns(ResponseType) }
       def perform
-        @dispatcher.dispatch_once(@target)
-        responses = @listeners.map(&:response).compact
-
-        first_response, *other_responses = responses
+        return unless @target
 
-        return unless first_response
+        @dispatcher.dispatch_once(@target)
 
-        # 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
+        return if @response_builder.empty?
 
-        first_response
+        Interface::Hover.new(
+          contents: Interface::MarkupContent.new(
+            kind: "markdown",
+            value: @response_builder.response,
+          ),
+        )
       end
     end
   end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -40,7 +40,6 @@ module RubyLsp
     # ```
     class InlayHints < Request
       extend T::Sig
-      extend T::Generic
 
       class << self
         extend T::Sig
@@ -51,8 +50,6 @@ module RubyLsp
         end
       end
 
-      ResponseType = type_member { { fixed: T::Array[Interface::InlayHint] } }
-
       sig do
         params(
           document: Document,
@@ -65,15 +62,17 @@ module RubyLsp
         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],
+
+        @response_builder = T.let(
+          ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint].new,
+          ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
         )
+        Listeners::InlayHints.new(@response_builder, start_line..end_line, hints_configuration, dispatcher)
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T::Array[Interface::InlayHint]) }
       def perform
-        @listener.response
+        @response_builder.response
       end
     end
   end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -38,8 +38,15 @@ module RubyLsp
         T::Array[Regexp],
       )
 
-      sig { params(document: Document, position: T::Hash[Symbol, T.untyped], trigger_character: String).void }
-      def initialize(document, position, trigger_character)
+      sig do
+        params(
+          document: Document,
+          position: T::Hash[Symbol, T.untyped],
+          trigger_character: String,
+          client_name: String,
+        ).void
+      end
+      def initialize(document, position, trigger_character, client_name)
         super()
         @document = document
         @lines = T.let(@document.source.lines, T::Array[String])
@@ -50,6 +57,7 @@ module RubyLsp
         @position = position
         @edits = T.let([], T::Array[Interface::TextEdit])
         @trigger_character = trigger_character
+        @client_name = client_name
       end
 
       sig { override.returns(T.all(T::Array[Interface::TextEdit], Object)) }
@@ -170,6 +178,8 @@ module RubyLsp
 
       sig { params(line: Integer, character: Integer).void }
       def move_cursor_to(line, character)
+        return if @client_name != "Visual Studio Code"
+
         position = Interface::Position.new(
           line: line,
           character: character,

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -22,9 +22,6 @@ module RubyLsp
     # ```
     class SemanticHighlighting < Request
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T::Array[Listeners::SemanticHighlighting::SemanticToken] } }
 
       class << self
         extend T::Sig
@@ -34,8 +31,8 @@ module RubyLsp
           Interface::SemanticTokensRegistrationOptions.new(
             document_selector: { scheme: "file", language: "ruby" },
             legend: Interface::SemanticTokensLegend.new(
-              token_types: Listeners::SemanticHighlighting::TOKEN_TYPES.keys,
-              token_modifiers: Listeners::SemanticHighlighting::TOKEN_MODIFIERS.keys,
+              token_types: ResponseBuilders::SemanticHighlighting::TOKEN_TYPES.keys,
+              token_modifiers: ResponseBuilders::SemanticHighlighting::TOKEN_MODIFIERS.keys,
             ),
             range: true,
             full: { delta: false },
@@ -46,12 +43,17 @@ module RubyLsp
       sig { params(dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
       def initialize(dispatcher, range: nil)
         super()
-        @listener = T.let(Listeners::SemanticHighlighting.new(dispatcher, range: range), Listener[ResponseType])
+        @response_builder = T.let(ResponseBuilders::SemanticHighlighting.new, ResponseBuilders::SemanticHighlighting)
+        Listeners::SemanticHighlighting.new(dispatcher, @response_builder, range: range)
+
+        Addon.addons.each do |addon|
+          addon.create_semantic_highlighting_listener(@response_builder, dispatcher)
+        end
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(Interface::SemanticTokens) }
       def perform
-        @listener.response
+        @response_builder.response
       end
     end
   end

data/lib/ruby_lsp/requests/signature_help.rb

@@ -26,7 +26,6 @@ module RubyLsp
     # ```
     class SignatureHelp < Request
       extend T::Sig
-      extend T::Generic
 
       class << self
         extend T::Sig
@@ -40,8 +39,6 @@ module RubyLsp
         end
       end
 
-      ResponseType = type_member { { fixed: T.nilable(T.any(Interface::SignatureHelp, T::Hash[Symbol, T.untyped])) } }
-
       sig do
         params(
           document: Document,
@@ -53,34 +50,72 @@ module RubyLsp
       end
       def initialize(document, index, position, context, dispatcher)
         super()
-        current_signature = context && context[:activeSignatureHelp]
         target, parent, nesting = document.locate_node(
-          { line: position[:line], character: position[:character] - 2 },
+          { line: position[:line], character: position[:character] },
           node_types: [Prism::CallNode],
         )
 
-        # If we're typing a nested method call (e.g.: `foo(bar)`), then we may end up locating `bar` as the target
-        # method call incorrectly. To correct that, we check if there's an active signature with the same name as the
-        # parent node and then replace the target
-        if current_signature && parent.is_a?(Prism::CallNode)
-          active_signature = current_signature[:activeSignature] || 0
-
-          if current_signature.dig(:signatures, active_signature, :label)&.start_with?(parent.message)
-            target = parent
-          end
-        end
+        target = adjust_for_nested_target(target, parent, position)
 
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
-        @listener = T.let(Listeners::SignatureHelp.new(nesting, index, dispatcher), Listener[ResponseType])
+        @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
+        Listeners::SignatureHelp.new(@response_builder, nesting, index, dispatcher)
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T.nilable(Interface::SignatureHelp)) }
       def perform
         return unless @target
 
         @dispatcher.dispatch_once(@target)
-        @listener.response
+        @response_builder.response
+      end
+
+      private
+
+      # Adjust the target of signature help in the case where we have nested method calls. This is necessary so that we
+      # select the right target in a situation like this:
+      #
+      # foo(another_method_call)
+      #
+      # In that case, we want to provide signature help for `foo` and not `another_method_call`.
+      sig do
+        params(
+          target: T.nilable(Prism::Node),
+          parent: T.nilable(Prism::Node),
+          position: T::Hash[Symbol, T.untyped],
+        ).returns(T.nilable(Prism::Node))
+      end
+      def adjust_for_nested_target(target, parent, position)
+        # If the parent node is not a method call, then make no adjustments
+        return target unless parent.is_a?(Prism::CallNode)
+        # If the parent is a method call, but the target isn't, then return the parent
+        return parent unless target.is_a?(Prism::CallNode)
+
+        # If both are method calls, we check the arguments of the inner method call. If there are no arguments, then
+        # we're providing signature help for the outer method call.
+        #
+        # If there are arguments, then we check if the arguments node covers the requested position. If it doesn't
+        # cover, then we're providing signature help for the outer method call.
+        arguments = target.arguments
+        arguments.nil? || !node_covers?(arguments, position) ? parent : target
+      end
+
+      sig { params(node: Prism::Node, position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      def node_covers?(node, position)
+        location = node.location
+        start_line = location.start_line - 1
+        start_character = location.start_column
+        end_line = location.end_line - 1
+        end_character = location.end_column
+
+        start_covered = start_line < position[:line] ||
+          (start_line == position[:line] && start_character <= position[:character])
+
+        end_covered = end_line > position[:line] ||
+          (end_line == position[:line] && end_character >= position[:character])
+
+        start_covered && end_covered
       end
     end
   end

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

@@ -86,9 +86,9 @@ module RubyLsp
           params(
             title: String,
             entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
-          ).returns(Interface::MarkupContent)
+          ).returns(T::Hash[Symbol, String])
         end
-        def markdown_from_index_entries(title, entries)
+        def categorized_markdown_from_index_entries(title, entries)
           markdown_title = "```ruby\n#{title}\n```"
           definitions = []
           content = +""
@@ -108,16 +108,44 @@ module RubyLsp
             content << "\n\n#{entry.comments.join("\n")}" unless entry.comments.empty?
           end
 
-          Interface::MarkupContent.new(
-            kind: "markdown",
-            value: <<~MARKDOWN.chomp,
-              #{markdown_title}
+          {
+            title: markdown_title,
+            links: "**Definitions**: #{definitions.join(" | ")}",
+            documentation: content,
+          }
+        end
 
-              **Definitions**: #{definitions.join(" | ")}
+        sig do
+          params(
+            title: String,
+            entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
+          ).returns(String)
+        end
+        def markdown_from_index_entries(title, entries)
+          categorized_markdown = categorized_markdown_from_index_entries(title, entries)
 
-              #{content}
-            MARKDOWN
-          )
+          <<~MARKDOWN.chomp
+            #{categorized_markdown[:title]}
+
+            #{categorized_markdown[:links]}
+
+            #{categorized_markdown[:documentation]}
+          MARKDOWN
+        end
+
+        sig do
+          params(
+            node: T.any(
+              Prism::ConstantPathNode,
+              Prism::ConstantReadNode,
+              Prism::ConstantPathTargetNode,
+            ),
+          ).returns(T.nilable(String))
+        end
+        def constant_name(node)
+          node.full_name
+        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+          nil
         end
       end
     end

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

@@ -63,7 +63,11 @@ module RubyLsp
     def detect_typechecker
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
-      direct_dependency?(/^sorbet/) || direct_dependency?(/^sorbet-static-and-runtime/)
+      Bundler.with_original_env do
+        Bundler.locked_gems.specs.any? { |spec| spec.name == "sorbet-static" }
+      end
+    rescue Bundler::GemfileNotFound
+      false
     end
 
     sig { returns(T::Array[String]) }

data/lib/ruby_lsp/requests.rb

@@ -50,7 +50,6 @@ module RubyLsp
     module Support
       autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"
       autoload :SelectionRange, "ruby_lsp/requests/support/selection_range"
-      autoload :SemanticTokenEncoder, "ruby_lsp/requests/support/semantic_token_encoder"
       autoload :Annotation, "ruby_lsp/requests/support/annotation"
       autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"

data/lib/ruby_lsp/response_builders/collection_response_builder.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module ResponseBuilders
+    class CollectionResponseBuilder < ResponseBuilder
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { upper: Object } }
+
+      sig { void }
+      def initialize
+        super
+        @items = T.let([], T::Array[ResponseType])
+      end
+
+      sig { params(item: ResponseType).void }
+      def <<(item)
+        @items << item
+      end
+
+      sig { override.returns(T::Array[ResponseType]) }
+      def response
+        @items
+      end
+    end
+  end
+end

data/lib/ruby_lsp/response_builders/document_symbol.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module ResponseBuilders
+    class DocumentSymbol < ResponseBuilder
+      ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
+
+      class SymbolHierarchyRoot
+        extend T::Sig
+
+        sig { returns(T::Array[Interface::DocumentSymbol]) }
+        attr_reader :children
+
+        sig { void }
+        def initialize
+          @children = T.let([], T::Array[Interface::DocumentSymbol])
+        end
+      end
+
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super
+        @stack = T.let(
+          [SymbolHierarchyRoot.new],
+          T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
+        )
+      end
+
+      sig { params(symbol: Interface::DocumentSymbol).void }
+      def push(symbol)
+        @stack << symbol
+      end
+
+      alias_method(:<<, :push)
+
+      sig { returns(T.nilable(Interface::DocumentSymbol)) }
+      def pop
+        if @stack.size > 1
+          T.cast(@stack.pop, Interface::DocumentSymbol)
+        end
+      end
+
+      sig { returns(T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)) }
+      def last
+        T.must(@stack.last)
+      end
+
+      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
+      def response
+        T.must(@stack.first).children
+      end
+    end
+  end
+end

data/lib/ruby_lsp/response_builders/hover.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module ResponseBuilders
+    class Hover < ResponseBuilder
+      ResponseType = type_member { { fixed: String } }
+
+      extend T::Sig
+      extend T::Generic
+
+      sig { void }
+      def initialize
+        super
+
+        @response = T.let(
+          {
+            title: +"",
+            links: +"",
+            documentation: +"",
+          },
+          T::Hash[Symbol, String],
+        )
+      end
+
+      sig { params(content: String, category: Symbol).void }
+      def push(content, category:)
+        hover_content = @response[category]
+        if hover_content
+          hover_content << content + "\n"
+        end
+      end
+
+      sig { returns(T::Boolean) }
+      def empty?
+        @response.values.all?(&:empty?)
+      end
+
+      sig { override.returns(ResponseType) }
+      def response
+        result = T.must(@response[:title])
+        result << "\n" << @response[:links] if @response[:links]
+        result << "\n" << @response[:documentation] if @response[:documentation]
+
+        result.strip
+      end
+    end
+  end
+end

data/lib/ruby_lsp/response_builders/response_builder.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module ResponseBuilders
+    class ResponseBuilder
+      extend T::Sig
+      extend T::Generic
+
+      abstract!
+
+      sig { abstract.returns(T.anything) }
+      def response; end
+    end
+  end
+end