ruby-lsp 0.13.4 → 0.14.1

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -3,56 +3,9 @@
 
 module RubyLsp
   module Listeners
-    class SemanticHighlighting < Listener
+    class SemanticHighlighting
+      include Requests::Support::Common
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T::Array[SemanticToken] } }
-
-      TOKEN_TYPES = T.let(
-        {
-          namespace: 0,
-          type: 1,
-          class: 2,
-          enum: 3,
-          interface: 4,
-          struct: 5,
-          typeParameter: 6,
-          parameter: 7,
-          variable: 8,
-          property: 9,
-          enumMember: 10,
-          event: 11,
-          function: 12,
-          method: 13,
-          macro: 14,
-          keyword: 15,
-          modifier: 16,
-          comment: 17,
-          string: 18,
-          number: 19,
-          regexp: 20,
-          operator: 21,
-          decorator: 22,
-        }.freeze,
-        T::Hash[Symbol, Integer],
-      )
-
-      TOKEN_MODIFIERS = T.let(
-        {
-          declaration: 0,
-          definition: 1,
-          readonly: 2,
-          static: 3,
-          deprecated: 4,
-          abstract: 5,
-          async: 6,
-          modification: 7,
-          documentation: 8,
-          default_library: 9,
-        }.freeze,
-        T::Hash[Symbol, Integer],
-      )
 
       SPECIAL_RUBY_METHODS = T.let(
         [
@@ -65,42 +18,20 @@ module RubyLsp
         T::Array[String],
       )
 
-      class SemanticToken
-        extend T::Sig
-
-        sig { returns(Prism::Location) }
-        attr_reader :location
-
-        sig { returns(Integer) }
-        attr_reader :length
-
-        sig { returns(Integer) }
-        attr_reader :type
-
-        sig { returns(T::Array[Integer]) }
-        attr_reader :modifier
-
-        sig { params(location: Prism::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
-        def initialize(location:, length:, type:, modifier:)
-          @location = location
-          @length = length
-          @type = type
-          @modifier = modifier
-        end
+      sig do
+        params(
+          dispatcher: Prism::Dispatcher,
+          response_builder: ResponseBuilders::SemanticHighlighting,
+          range: T.nilable(T::Range[Integer]),
+        ).void
       end
-
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
-
-      sig { params(dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
-      def initialize(dispatcher, range: nil)
-        super(dispatcher)
-
-        @_response = T.let([], ResponseType)
+      def initialize(dispatcher, response_builder, range: nil)
+        @response_builder = response_builder
         @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
         @current_scope = T.let(ParameterScope.new, ParameterScope)
         @inside_regex_capture = T.let(false, T::Boolean)
+        @inside_implicit_node = T.let(false, T::Boolean)
 
         dispatcher.register(
           self,
@@ -134,11 +65,14 @@ module RubyLsp
           :on_block_local_variable_node_enter,
           :on_match_write_node_enter,
           :on_match_write_node_leave,
+          :on_implicit_node_enter,
+          :on_implicit_node_leave,
         )
       end
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
+        return if @inside_implicit_node
         return unless visible?(node, @range)
 
         message = node.message
@@ -151,7 +85,7 @@ module RubyLsp
         return if special_method?(message)
 
         type = Requests::Support::Sorbet.annotation?(node) ? :type : :method
-        add_token(T.must(node.message_loc), type)
+        @response_builder.add_token(T.must(node.message_loc), type)
       end
 
       sig { params(node: Prism::MatchWriteNode).void }
@@ -171,48 +105,45 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
+        return if @inside_implicit_node
         return unless visible?(node, @range)
-        # When finding a module or class definition, we will have already pushed a token related to this constant. We
-        # need to look at the previous two tokens and if they match this locatione exactly, avoid pushing another token
-        # on top of the previous one
-        return if @_response.last(2).any? { |token| token.location == node.location }
 
-        add_token(node.location, :namespace)
+        @response_builder.add_token(node.location, :namespace)
       end
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, :namespace)
+        @response_builder.add_token(node.name_loc, :namespace)
       end
 
       sig { params(node: Prism::ConstantAndWriteNode).void }
       def on_constant_and_write_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, :namespace)
+        @response_builder.add_token(node.name_loc, :namespace)
       end
 
       sig { params(node: Prism::ConstantOperatorWriteNode).void }
       def on_constant_operator_write_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, :namespace)
+        @response_builder.add_token(node.name_loc, :namespace)
       end
 
       sig { params(node: Prism::ConstantOrWriteNode).void }
       def on_constant_or_write_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, :namespace)
+        @response_builder.add_token(node.name_loc, :namespace)
       end
 
       sig { params(node: Prism::ConstantTargetNode).void }
       def on_constant_target_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.location, :namespace)
+        @response_builder.add_token(node.location, :namespace)
       end
 
       sig { params(node: Prism::DefNode).void }
@@ -220,7 +151,7 @@ module RubyLsp
         @current_scope = ParameterScope.new(@current_scope)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, :method, [:declaration])
+        @response_builder.add_token(node.name_loc, :method, [:declaration])
       end
 
       sig { params(node: Prism::DefNode).void }
@@ -240,7 +171,7 @@ module RubyLsp
 
       sig { params(node: Prism::BlockLocalVariableNode).void }
       def on_block_local_variable_node_enter(node)
-        add_token(node.location, :variable)
+        @response_builder.add_token(node.location, :variable)
       end
 
       sig { params(node: Prism::BlockParameterNode).void }
@@ -255,7 +186,7 @@ module RubyLsp
         return unless visible?(node, @range)
 
         location = node.name_loc
-        add_token(location.copy(length: location.length - 1), :parameter)
+        @response_builder.add_token(location.copy(length: location.length - 1), :parameter)
       end
 
       sig { params(node: Prism::OptionalKeywordParameterNode).void }
@@ -264,7 +195,7 @@ module RubyLsp
         return unless visible?(node, @range)
 
         location = node.name_loc
-        add_token(location.copy(length: location.length - 1), :parameter)
+        @response_builder.add_token(location.copy(length: location.length - 1), :parameter)
       end
 
       sig { params(node: Prism::KeywordRestParameterNode).void }
@@ -274,7 +205,7 @@ module RubyLsp
         if name
           @current_scope << name.to_sym
 
-          add_token(T.must(node.name_loc), :parameter) if visible?(node, @range)
+          @response_builder.add_token(T.must(node.name_loc), :parameter) if visible?(node, @range)
         end
       end
 
@@ -283,7 +214,7 @@ module RubyLsp
         @current_scope << node.name
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, :parameter)
+        @response_builder.add_token(node.name_loc, :parameter)
       end
 
       sig { params(node: Prism::RequiredParameterNode).void }
@@ -291,7 +222,7 @@ module RubyLsp
         @current_scope << node.name
         return unless visible?(node, @range)
 
-        add_token(node.location, :parameter)
+        @response_builder.add_token(node.location, :parameter)
       end
 
       sig { params(node: Prism::RestParameterNode).void }
@@ -301,7 +232,7 @@ module RubyLsp
         if name
           @current_scope << name.to_sym
 
-          add_token(T.must(node.name_loc), :parameter) if visible?(node, @range)
+          @response_builder.add_token(T.must(node.name_loc), :parameter) if visible?(node, @range)
         end
       end
 
@@ -309,48 +240,49 @@ module RubyLsp
       def on_self_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.location, :variable, [:default_library])
+        @response_builder.add_token(node.location, :variable, [:default_library])
       end
 
       sig { params(node: Prism::LocalVariableWriteNode).void }
       def on_local_variable_write_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, @current_scope.type_for(node.name))
+        @response_builder.add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
       sig { params(node: Prism::LocalVariableReadNode).void }
       def on_local_variable_read_node_enter(node)
+        return if @inside_implicit_node
         return unless visible?(node, @range)
 
         # Numbered parameters
         if /_\d+/.match?(node.name)
-          add_token(node.location, :parameter)
+          @response_builder.add_token(node.location, :parameter)
           return
         end
 
-        add_token(node.location, @current_scope.type_for(node.name))
+        @response_builder.add_token(node.location, @current_scope.type_for(node.name))
       end
 
       sig { params(node: Prism::LocalVariableAndWriteNode).void }
       def on_local_variable_and_write_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, @current_scope.type_for(node.name))
+        @response_builder.add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
       sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
       def on_local_variable_operator_write_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, @current_scope.type_for(node.name))
+        @response_builder.add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
       sig { params(node: Prism::LocalVariableOrWriteNode).void }
       def on_local_variable_or_write_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.name_loc, @current_scope.type_for(node.name))
+        @response_builder.add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
       sig { params(node: Prism::LocalVariableTargetNode).void }
@@ -363,42 +295,40 @@ module RubyLsp
 
         return unless visible?(node, @range)
 
-        add_token(node.location, @current_scope.type_for(node.name))
+        @response_builder.add_token(node.location, @current_scope.type_for(node.name))
       end
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.constant_path.location, :class, [:declaration])
+        @response_builder.add_token(node.constant_path.location, :class, [:declaration])
 
         superclass = node.superclass
-        add_token(superclass.location, :class) if superclass
+        @response_builder.add_token(superclass.location, :class) if superclass
       end
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
         return unless visible?(node, @range)
 
-        add_token(node.constant_path.location, :namespace, [:declaration])
+        @response_builder.add_token(node.constant_path.location, :namespace, [:declaration])
       end
 
-      private
+      sig { params(node: Prism::ImplicitNode).void }
+      def on_implicit_node_enter(node)
+        return unless visible?(node, @range)
 
-      sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
-      def add_token(location, type, modifiers = [])
-        length = location.end_offset - location.start_offset
-        modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
-        @_response.push(
-          SemanticToken.new(
-            location: location,
-            length: length,
-            type: T.must(TOKEN_TYPES[type]),
-            modifier: modifiers_indices,
-          ),
-        )
+        @inside_implicit_node = true
       end
 
+      sig { params(node: Prism::ImplicitNode).void }
+      def on_implicit_node_leave(node)
+        @inside_implicit_node = false
+      end
+
+      private
+
       # Textmate provides highlighting for a subset of these special Ruby-specific methods.  We want to utilize that
       # highlighting, so we avoid making a semantic token for it.
       sig { params(method_name: String).returns(T::Boolean) }
@@ -422,7 +352,7 @@ module RubyLsp
           capture_name_offset = T.must(content.index("(?<#{name}>")) + 3
           local_var_loc = loc.copy(start_offset: loc.start_offset + capture_name_offset, length: name.length)
 
-          add_token(local_var_loc, @current_scope.type_for(name))
+          @response_builder.add_token(local_var_loc, @current_scope.type_for(name))
         end
       end
     end

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -3,28 +3,22 @@
 
 module RubyLsp
   module Listeners
-    class SignatureHelp < Listener
+    class SignatureHelp
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T.nilable(T.any(Interface::SignatureHelp, T::Hash[Symbol, T.untyped])) } }
-
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      include Requests::Support::Common
 
       sig do
         params(
+          response_builder: ResponseBuilders::SignatureHelp,
           nesting: T::Array[String],
           index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(nesting, index, dispatcher)
+      def initialize(response_builder, nesting, index, dispatcher)
+        @response_builder = response_builder
         @nesting = nesting
         @index = index
-        @_response = T.let(nil, ResponseType)
-
-        super(dispatcher)
         dispatcher.register(self, :on_call_node_enter)
       end
 
@@ -36,7 +30,10 @@ module RubyLsp
         message = node.message
         return unless message
 
-        target_method = @index.resolve_method(message, @nesting.join("::"))
+        methods = @index.resolve_method(message, @nesting.join("::"))
+        return unless methods
+
+        target_method = methods.first
         return unless target_method
 
         parameters = target_method.parameters
@@ -58,16 +55,20 @@ module RubyLsp
           active_parameter += 1
         end
 
-        @_response = Interface::SignatureHelp.new(
+        signature_help = Interface::SignatureHelp.new(
           signatures: [
             Interface::SignatureInformation.new(
               label: label,
               parameters: parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
-              documentation: markdown_from_index_entries("", target_method),
+              documentation: Interface::MarkupContent.new(
+                kind: "markdown",
+                value: markdown_from_index_entries("", methods),
+              ),
             ),
           ],
           active_parameter: active_parameter,
         )
+        @response_builder.replace(signature_help)
       end
     end
   end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -11,22 +11,17 @@ module RubyLsp
     #
     # The
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
-    # request informs the editor of runnable commands such as tests
-    #
-    # # Configuration
-    #
-    # To disable gem code lenses, set `rubyLsp.featuresConfiguration.codeLens.gemfileLinks` to `false`.
+    # request informs the editor of runnable commands such as testing and debugging
     #
     # # Example
     #
     # ```ruby
-    # # Run
+    # # Run | Run in Terminal | Debug
     # class Test < Minitest::Test
     # end
     # ```
     class CodeLens < Request
       extend T::Sig
-      extend T::Generic
 
       class << self
         extend T::Sig
@@ -37,31 +32,28 @@ module RubyLsp
         end
       end
 
-      ResponseType = type_member { { fixed: T::Array[Interface::CodeLens] } }
-
       sig do
         params(
           uri: URI::Generic,
-          lenses_configuration: RequestConfig,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(uri, lenses_configuration, dispatcher)
-        super()
-        @listeners = T.let(
-          [Listeners::CodeLens.new(uri, lenses_configuration, dispatcher)],
-          T::Array[Listener[ResponseType]],
+      def initialize(uri, dispatcher)
+        @response_builder = T.let(
+          ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens].new,
+          ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
         )
+        super()
+        Listeners::CodeLens.new(@response_builder, uri, dispatcher)
 
         Addon.addons.each do |addon|
-          addon_listener = addon.create_code_lens_listener(uri, dispatcher)
-          @listeners << addon_listener if addon_listener
+          addon.create_code_lens_listener(@response_builder, uri, dispatcher)
         end
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T::Array[Interface::CodeLens]) }
       def perform
-        @listeners.flat_map(&:response)
+        @response_builder.response
       end
     end
   end

data/lib/ruby_lsp/requests/completion.rb

@@ -26,7 +26,6 @@ module RubyLsp
     # ```
     class Completion < Request
       extend T::Sig
-      extend T::Generic
 
       class << self
         extend T::Sig
@@ -43,8 +42,6 @@ module RubyLsp
         end
       end
 
-      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
-
       sig do
         params(
           document: Document,
@@ -66,12 +63,13 @@ module RubyLsp
           char_position,
           node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
         )
-
-        @listener = T.let(
-          Listeners::Completion.new(index, nesting, typechecker_enabled, dispatcher),
-          Listener[ResponseType],
+        @response_builder = T.let(
+          ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,
+          ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
         )
 
+        Listeners::Completion.new(@response_builder, index, nesting, typechecker_enabled, dispatcher)
+
         return unless matched && parent
 
         @target = case matched
@@ -99,12 +97,12 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T::Array[Interface::CompletionItem]) }
       def perform
         return [] unless @target
 
         @dispatcher.dispatch_once(@target)
-        @listener.response
+        @response_builder.response
       end
     end
   end

data/lib/ruby_lsp/requests/definition.rb

@@ -28,8 +28,6 @@ module RubyLsp
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T.nilable(T.any(T::Array[Interface::Location], Interface::Location)) } }
-
       sig do
         params(
           document: Document,
@@ -41,6 +39,11 @@ module RubyLsp
       end
       def initialize(document, index, position, dispatcher, typechecker_enabled)
         super()
+        @response_builder = T.let(
+          ResponseBuilders::CollectionResponseBuilder[Interface::Location].new,
+          ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+        )
+
         target, parent, nesting = document.locate_node(
           position,
           node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
@@ -48,35 +51,20 @@ module RubyLsp
 
         target = parent if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
 
-        @listeners = T.let(
-          [Listeners::Definition.new(document.uri, nesting, index, dispatcher, typechecker_enabled)],
-          T::Array[Listener[T.nilable(T.any(T::Array[Interface::Location], Interface::Location))]],
-        )
+        Listeners::Definition.new(@response_builder, document.uri, nesting, index, dispatcher, typechecker_enabled)
+
         Addon.addons.each do |addon|
-          addon_listener = addon.create_definition_listener(document.uri, nesting, index, dispatcher)
-          @listeners << addon_listener if addon_listener
+          addon.create_definition_listener(@response_builder, document.uri, nesting, index, dispatcher)
         end
 
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T::Array[Interface::Location]) }
       def perform
         @dispatcher.dispatch_once(@target)
-        result = []
-
-        @listeners.each do |listener|
-          res = listener.response
-          case res
-          when Interface::Location
-            result << res
-          when Array
-            result.concat(res)
-          end
-        end
-
-        result if result.any?
+        @response_builder.response
       end
     end
   end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -27,8 +27,6 @@ module RubyLsp
     class DocumentHighlight < Request
       extend T::Sig
 
-      ResponseType = type_member { { fixed: T::Array[Interface::DocumentHighlight] } }
-
       sig do
         params(
           document: Document,
@@ -39,12 +37,16 @@ module RubyLsp
       def initialize(document, position, dispatcher)
         super()
         target, parent = document.locate_node(position)
-        @listener = T.let(Listeners::DocumentHighlight.new(target, parent, dispatcher), Listener[ResponseType])
+        @response_builder = T.let(
+          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,
+          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight],
+        )
+        Listeners::DocumentHighlight.new(@response_builder, target, parent, dispatcher)
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T::Array[Interface::DocumentHighlight]) }
       def perform
-        @listener.response
+        @response_builder.response
       end
     end
   end

data/lib/ruby_lsp/requests/document_link.rb

@@ -20,7 +20,6 @@ module RubyLsp
     # ```
     class DocumentLink < Request
       extend T::Sig
-      extend T::Generic
 
       class << self
         extend T::Sig
@@ -31,8 +30,6 @@ module RubyLsp
         end
       end
 
-      ResponseType = type_member { { fixed: T::Array[Interface::DocumentLink] } }
-
       sig do
         params(
           uri: URI::Generic,
@@ -42,12 +39,16 @@ module RubyLsp
       end
       def initialize(uri, comments, dispatcher)
         super()
-        @listener = T.let(Listeners::DocumentLink.new(uri, comments, dispatcher), Listener[ResponseType])
+        @response_builder = T.let(
+          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink].new,
+          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink],
+        )
+        Listeners::DocumentLink.new(@response_builder, uri, comments, dispatcher)
       end
 
-      sig { override.returns(ResponseType) }
+      sig { override.returns(T::Array[Interface::DocumentLink]) }
       def perform
-        @listener.response
+        @response_builder.response
       end
     end
   end