ruby-lsp 0.17.17 → 0.18.3

data/lib/ruby_lsp/base_server.rb

@@ -31,6 +31,7 @@ module RubyLsp
         Thread,
       )
 
+      @global_state = T.let(GlobalState.new, GlobalState)
       Thread.main.priority = 1
     end
 
@@ -52,7 +53,26 @@ module RubyLsp
               message[:params][:textDocument][:uri] = parsed_uri
 
               # We don't want to try to parse documents on text synchronization notifications
-              @store.get(parsed_uri).parse unless method.start_with?("textDocument/did")
+              unless method.start_with?("textDocument/did")
+                document = @store.get(parsed_uri)
+
+                # If the client supports request delegation and we're working with an ERB document and there was
+                # something to parse, then we have to maintain the client updated about the virtual state of the host
+                # language source
+                if document.parse! && @global_state.supports_request_delegation && document.is_a?(ERBDocument)
+                  send_message(
+                    Notification.new(
+                      method: "delegate/textDocument/virtualState",
+                      params: {
+                        textDocument: {
+                          uri: uri,
+                          text: document.host_language_source,
+                        },
+                      },
+                    ),
+                  )
+                end
+              end
             rescue Store::NonExistingDocumentError
               # If we receive a request for a file that no longer exists, we don't want to fail
             end

data/lib/ruby_lsp/document.rb

@@ -51,7 +51,8 @@ module RubyLsp
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
       @needs_parsing = T.let(true, T::Boolean)
-      @parse_result = T.let(parse, ParseResultType)
+      @parse_result = T.let(T.unsafe(nil), ParseResultType)
+      parse!
     end
 
     sig { params(other: Document[T.untyped]).returns(T::Boolean) }
@@ -106,8 +107,9 @@ module RubyLsp
       @cache.clear
     end
 
-    sig { abstract.returns(ParseResultType) }
-    def parse; end
+    # Returns `true` if the document was parsed and `false` if nothing needed parsing
+    sig { abstract.returns(T::Boolean) }
+    def parse!; end
 
     sig { abstract.returns(T::Boolean) }
     def syntax_error?; end

data/lib/ruby_lsp/erb_document.rb

@@ -6,17 +6,30 @@ module RubyLsp
     extend T::Sig
     extend T::Generic
 
+    sig { returns(String) }
+    attr_reader :host_language_source
+
     ParseResultType = type_member { { fixed: Prism::ParseResult } }
 
-    sig { override.returns(ParseResultType) }
-    def parse
-      return @parse_result unless @needs_parsing
+    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
+    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+      # This has to be initialized before calling super because we call `parse` in the parent constructor, which
+      # overrides this with the proper virtual host language source
+      @host_language_source = T.let("", String)
+      super
+    end
+
+    sig { override.returns(T::Boolean) }
+    def parse!
+      return false unless @needs_parsing
 
       @needs_parsing = false
       scanner = ERBScanner.new(@source)
       scanner.scan
+      @host_language_source = scanner.host_language
       # assigning empty scopes to turn Prism into eval mode
       @parse_result = Prism.parse(scanner.ruby, scopes: [[]])
+      true
     end
 
     sig { override.returns(T::Boolean) }
@@ -39,16 +52,22 @@ module RubyLsp
       RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
     end
 
+    sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }
+    def inside_host_language?(char_position)
+      char = @host_language_source[char_position]
+      char && char != " "
+    end
+
     class ERBScanner
       extend T::Sig
 
       sig { returns(String) }
-      attr_reader :ruby, :html
+      attr_reader :ruby, :host_language
 
       sig { params(source: String).void }
       def initialize(source)
         @source = source
-        @html = T.let(+"", String)
+        @host_language = T.let(+"", String)
         @ruby = T.let(+"", String)
         @current_pos = T.let(0, Integer)
         @inside_ruby = T.let(false, T::Boolean)
@@ -104,16 +123,16 @@ module RubyLsp
           end
         when "\r"
           @ruby << char
-          @html << char
+          @host_language << char
 
           if next_char == "\n"
             @ruby << next_char
-            @html << next_char
+            @host_language << next_char
             @current_pos += 1
           end
         when "\n"
           @ruby << char
-          @html << char
+          @host_language << char
         else
           push_char(T.must(char))
         end
@@ -123,10 +142,10 @@ module RubyLsp
       def push_char(char)
         if @inside_ruby
           @ruby << char
-          @html << " " * char.length
+          @host_language << " " * char.length
         else
           @ruby << " " * char.length
-          @html << char
+          @host_language << char
         end
       end
 

data/lib/ruby_lsp/global_state.rb

@@ -21,7 +21,7 @@ module RubyLsp
     attr_reader :encoding
 
     sig { returns(T::Boolean) }
-    attr_reader :supports_watching_files, :experimental_features
+    attr_reader :supports_watching_files, :experimental_features, :supports_request_delegation
 
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
@@ -39,8 +39,9 @@ module RubyLsp
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
       @supports_watching_files = T.let(false, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
-      @type_inferrer = T.let(TypeInferrer.new(@index, @experimental_features), TypeInferrer)
+      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @addon_settings = T.let({}, T::Hash[String, T.untyped])
+      @supports_request_delegation = T.let(false, T::Boolean)
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -123,7 +124,6 @@ module RubyLsp
       end
 
       @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
-      @type_inferrer.experimental_features = @experimental_features
 
       addon_settings = options.dig(:initializationOptions, :addonSettings)
       if addon_settings
@@ -131,6 +131,7 @@ module RubyLsp
         @addon_settings.merge!(addon_settings)
       end
 
+      @supports_request_delegation = options.dig(:capabilities, :experimental, :requestDelegation) || false
       notifications
     end
 

data/lib/ruby_lsp/internal.rb

@@ -30,8 +30,6 @@ require "ruby_lsp/parameter_scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
 require "ruby_lsp/type_inferrer"
-require "ruby_lsp/requests"
-require "ruby_lsp/response_builders"
 require "ruby_lsp/node_context"
 require "ruby_lsp/document"
 require "ruby_lsp/ruby_document"
@@ -39,6 +37,46 @@ require "ruby_lsp/erb_document"
 require "ruby_lsp/rbs_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
+
+# Response builders
+require "ruby_lsp/response_builders/response_builder"
+require "ruby_lsp/response_builders/collection_response_builder"
+require "ruby_lsp/response_builders/document_symbol"
+require "ruby_lsp/response_builders/hover"
+require "ruby_lsp/response_builders/semantic_highlighting"
+require "ruby_lsp/response_builders/signature_help"
+
+# Request support
+require "ruby_lsp/requests/support/selection_range"
+require "ruby_lsp/requests/support/annotation"
+require "ruby_lsp/requests/support/sorbet"
+require "ruby_lsp/requests/support/common"
+require "ruby_lsp/requests/support/formatter"
 require "ruby_lsp/requests/support/rubocop_runner"
 require "ruby_lsp/requests/support/rubocop_formatter"
 require "ruby_lsp/requests/support/syntax_tree_formatter"
+
+# Requests
+require "ruby_lsp/requests/request"
+require "ruby_lsp/requests/code_action_resolve"
+require "ruby_lsp/requests/code_actions"
+require "ruby_lsp/requests/code_lens"
+require "ruby_lsp/requests/completion_resolve"
+require "ruby_lsp/requests/completion"
+require "ruby_lsp/requests/definition"
+require "ruby_lsp/requests/diagnostics"
+require "ruby_lsp/requests/document_highlight"
+require "ruby_lsp/requests/document_link"
+require "ruby_lsp/requests/document_symbol"
+require "ruby_lsp/requests/folding_ranges"
+require "ruby_lsp/requests/formatting"
+require "ruby_lsp/requests/hover"
+require "ruby_lsp/requests/inlay_hints"
+require "ruby_lsp/requests/on_type_formatting"
+require "ruby_lsp/requests/prepare_type_hierarchy"
+require "ruby_lsp/requests/selection_ranges"
+require "ruby_lsp/requests/semantic_highlighting"
+require "ruby_lsp/requests/show_syntax_tree"
+require "ruby_lsp/requests/signature_help"
+require "ruby_lsp/requests/type_hierarchy_supertypes"
+require "ruby_lsp/requests/workspace_symbol"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -44,6 +44,7 @@ module RubyLsp
         @group_id_stack = T.let([], T::Array[Integer])
         # We want to avoid adding code lenses for nested definitions
         @def_depth = T.let(0, Integer)
+        @spec_id = T.let(0, Integer)
 
         dispatcher.register(
           self,
@@ -70,6 +71,7 @@ module RubyLsp
             name: class_name,
             command: generate_test_command(group_stack: @group_stack),
             kind: :group,
+            id: generate_fully_qualified_id(group_stack: @group_stack),
           )
 
           @group_id_stack.push(@group_id)
@@ -106,6 +108,7 @@ module RubyLsp
               name: method_name,
               command: generate_test_command(method_name: method_name, group_stack: @group_stack),
               kind: :example,
+              id: generate_fully_qualified_id(group_stack: @group_stack, method_name: method_name),
             )
           end
         end
@@ -166,19 +169,20 @@ module RubyLsp
         @visibility_stack.push([prev_visibility, prev_visibility])
         if node.name == DESCRIBE_KEYWORD
           @group_id_stack.pop
+          @group_stack.pop
         end
       end
 
       private
 
-      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
-      def add_test_code_lens(node, name:, command:, kind:)
+      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol, id: String).void }
+      def add_test_code_lens(node, name:, command:, kind:, id: name)
         # don't add code lenses if the test library is not supported or unknown
         return unless SUPPORTED_TEST_LIBRARIES.include?(@global_state.test_library) && @path
 
         arguments = [
           @path,
-          name,
+          id,
           command,
           {
             start_line: node.location.start_line - 1,
@@ -186,6 +190,7 @@ module RubyLsp
             end_line: node.location.end_line - 1,
             end_column: node.location.end_column,
           },
+          name,
         ]
 
         grouping_data = { group_id: @group_id_stack.last, kind: kind }
@@ -247,7 +252,7 @@ module RubyLsp
             # We know the entire path, do an exact match
             " --name " + Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)
           elsif spec_name
-            " --name " + "/#{Shellwords.escape(spec_name)}/"
+            " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}##{Shellwords.escape(spec_name)}$/\""
           else
             # Execute all tests of the selected class and tests in
             # modules/classes nested inside of that class
@@ -282,15 +287,39 @@ module RubyLsp
 
         return unless name
 
+        if kind == :example
+          # Increment spec_id for each example
+          @spec_id += 1
+        else
+          # Reset spec_id when entering a new group
+          @spec_id = 0
+          @group_stack.push(name)
+        end
+
         if @path
+          method_name = format("test_%04d_%s", @spec_id, name) if kind == :example
           add_test_code_lens(
             node,
             name: name,
-            command: generate_test_command(spec_name: name),
+            command: generate_test_command(group_stack: @group_stack, spec_name: method_name),
             kind: kind,
+            id: generate_fully_qualified_id(group_stack: @group_stack, method_name: method_name),
           )
         end
       end
+
+      sig { params(group_stack: T::Array[String], method_name: T.nilable(String)).returns(String) }
+      def generate_fully_qualified_id(group_stack:, method_name: nil)
+        if method_name
+          # For tests, this will be the test class and method name: `Foo::BarTest#test_baz`.
+          # For specs, this will be the nested descriptions and formatted test name: `a::b::c#test_001_foo`.
+          group_stack.join("::") + "#" + method_name
+        else
+          # For tests, this will be the test class: `Foo::BarTest`.
+          # For specs, this will be the nested descriptions: `a::b::c`.
+          group_stack.join("::")
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/listeners/completion.rb

@@ -104,7 +104,7 @@ module RubyLsp
         name = constant_name(node)
         return if name.nil?
 
-        candidates = @index.prefix_search(name, @node_context.nesting)
+        candidates = @index.constant_completion_candidates(name, @node_context.nesting)
         candidates.each do |entries|
           complete_name = T.must(entries.first).name
           @response_builder << build_entry_completion(
@@ -124,7 +124,13 @@ module RubyLsp
         # no sigil, Sorbet will still provide completion for constants
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
-        name = constant_name(node)
+        name = begin
+          node.full_name
+        rescue Prism::ConstantPathNode::MissingNodesInConstantPathError
+          node.slice
+        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+          nil
+        end
         return if name.nil?
 
         constant_path_completion(name, range_from_location(node.location))
@@ -230,7 +236,7 @@ module RubyLsp
 
         real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
 
-        candidates = @index.prefix_search(
+        candidates = @index.constant_completion_candidates(
           "#{real_namespace}::#{incomplete_name}",
           top_level_reference ? [] : nesting,
         )
@@ -240,8 +246,16 @@ module RubyLsp
           first_entry = T.must(entries.first)
           next if first_entry.private? && !first_entry.name.start_with?("#{nesting}::")
 
-          constant_name = first_entry.name.delete_prefix("#{real_namespace}::")
-          full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
+          entry_name = first_entry.name
+          full_name = if aliased_namespace != real_namespace
+            constant_name = entry_name.delete_prefix("#{real_namespace}::")
+            aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
+          elsif !entry_name.start_with?(aliased_namespace)
+            *_, short_name = entry_name.split("::")
+            "#{aliased_namespace}::#{short_name}"
+          else
+            entry_name
+          end
 
           @response_builder << build_entry_completion(
             full_name,
@@ -545,7 +559,7 @@ module RubyLsp
       sig { params(entry_name: String).returns(T::Boolean) }
       def top_level?(entry_name)
         nesting = @node_context.nesting
-        nesting.length.downto(0).each do |i|
+        nesting.length.downto(0) do |i|
           prefix = T.must(nesting[0...i]).join("::")
           full_name = prefix.empty? ? entry_name : "#{prefix}::#{entry_name}"
           next if full_name == entry_name

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -12,14 +12,12 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
-          range: T::Range[Integer],
           hints_configuration: RequestConfig,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, range, hints_configuration, dispatcher)
+      def initialize(response_builder, hints_configuration, dispatcher)
         @response_builder = response_builder
-        @range = range
         @hints_configuration = hints_configuration
 
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
@@ -31,7 +29,6 @@ module RubyLsp
         return unless node.exceptions.empty?
 
         loc = node.location
-        return unless visible?(node, @range)
 
         @response_builder << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
@@ -44,7 +41,6 @@ module RubyLsp
       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
@@ -69,17 +65,6 @@ module RubyLsp
           tooltip: tooltip,
         )
       end
-
-      private
-
-      sig { params(node: T.nilable(Prism::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
-      def visible?(node, range)
-        return true if range.nil?
-        return false if node.nil?
-
-        loc = node.location
-        range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
-      end
     end
   end
 end

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -42,17 +42,46 @@ module RubyLsp
         target_method = methods.first
         return unless target_method
 
-        parameters = target_method.parameters
-        name = target_method.name
+        signatures = target_method.signatures
 
         # If the method doesn't have any parameters, there's no need to show signature help
-        return if parameters.empty?
+        return if signatures.empty?
+
+        name = target_method.name
+        title = +""
+
+        extra_links = if type.is_a?(TypeInferrer::GuessedType)
+          title << "\n\nGuessed receiver: #{type.name}"
+          "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
+        end
 
-        label = "#{name}(#{parameters.map(&:decorated_name).join(", ")})"
+        active_signature, active_parameter = determine_active_signature_and_parameter(node, signatures)
 
+        signature_help = Interface::SignatureHelp.new(
+          signatures: generate_signatures(signatures, name, methods, title, extra_links),
+          active_signature: active_signature,
+          active_parameter: active_parameter,
+        )
+        @response_builder.replace(signature_help)
+      end
+
+      private
+
+      sig do
+        params(node: Prism::CallNode, signatures: T::Array[RubyIndexer::Entry::Signature]).returns([Integer, Integer])
+      end
+      def determine_active_signature_and_parameter(node, signatures)
         arguments_node = node.arguments
         arguments = arguments_node&.arguments || []
-        active_parameter = (arguments.length - 1).clamp(0, parameters.length - 1)
+
+        # Find the first signature that matches the current arguments. If the user is invoking a method incorrectly and
+        # none of the signatures match, we show the first one
+        active_sig_index = signatures.find_index do |signature|
+          signature.matches?(arguments)
+        end || 0
+
+        parameter_length = [T.must(signatures[active_sig_index]).parameters.length - 1, 0].max
+        active_parameter = (arguments.length - 1).clamp(0, parameter_length)
 
         # If there are arguments, then we need to check if there's a trailing comma after the end of the last argument
         # to advance the active parameter to the next one
@@ -61,27 +90,29 @@ module RubyLsp
           active_parameter += 1
         end
 
-        title = +""
-
-        extra_links = if type.is_a?(TypeInferrer::GuessedType)
-          title << "\n\nGuessed receiver: #{type.name}"
-          "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
-        end
+        [active_sig_index, active_parameter]
+      end
 
-        signature_help = Interface::SignatureHelp.new(
-          signatures: [
-            Interface::SignatureInformation.new(
-              label: label,
-              parameters: parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
-              documentation: Interface::MarkupContent.new(
-                kind: "markdown",
-                value: markdown_from_index_entries(title, methods, extra_links: extra_links),
-              ),
+      sig do
+        params(
+          signatures: T::Array[RubyIndexer::Entry::Signature],
+          method_name: String,
+          methods: T::Array[RubyIndexer::Entry],
+          title: String,
+          extra_links: T.nilable(String),
+        ).returns(T::Array[Interface::SignatureInformation])
+      end
+      def generate_signatures(signatures, method_name, methods, title, extra_links)
+        signatures.map do |signature|
+          Interface::SignatureInformation.new(
+            label:  "#{method_name}(#{signature.format})",
+            parameters: signature.parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
+            documentation: Interface::MarkupContent.new(
+              kind: "markdown",
+              value: markdown_from_index_entries(title, methods, extra_links: extra_links),
             ),
-          ],
-          active_parameter: active_parameter,
-        )
-        @response_builder.replace(signature_help)
+          )
+        end
       end
     end
   end

data/lib/ruby_lsp/rbs_document.rb

@@ -14,18 +14,19 @@ module RubyLsp
       super
     end
 
-    sig { override.returns(ParseResultType) }
-    def parse
-      return @parse_result unless @needs_parsing
+    sig { override.returns(T::Boolean) }
+    def parse!
+      return false unless @needs_parsing
 
       @needs_parsing = false
 
       _, _, declarations = RBS::Parser.parse_signature(@source)
       @syntax_error = false
       @parse_result = declarations
+      true
     rescue RBS::ParsingError
       @syntax_error = true
-      @parse_result
+      true
     end
 
     sig { override.returns(T::Boolean) }

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -3,24 +3,9 @@
 
 module RubyLsp
   module Requests
-    # ![Code action resolve demo](../../code_action_resolve.gif)
-    #
     # The [code action resolve](https://microsoft.github.io/language-server-protocol/specification#codeAction_resolve)
     # request is used to to resolve the edit field for a given code action, if it is not already provided in the
     # textDocument/codeAction response. We can use it for scenarios that require more computation such as refactoring.
-    #
-    # # Example: Extract to variable
-    #
-    # ```ruby
-    # # Before:
-    # 1 + 1 # Select the text and use Refactor: Extract Variable
-    #
-    # # After:
-    # new_variable = 1 + 1
-    # new_variable
-    #
-    # ```
-    #
     class CodeActionResolve < Request
       extend T::Sig
       include Support::Common

data/lib/ruby_lsp/requests/code_actions.rb

@@ -3,19 +3,9 @@
 
 module RubyLsp
   module Requests
-    # ![Code actions demo](../../code_actions.gif)
-    #
     # The [code actions](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction)
     # request informs the editor of RuboCop quick fixes that can be applied. These are accessible by hovering over a
     # specific diagnostic.
-    #
-    # # Example
-    #
-    # ```ruby
-    # def say_hello
-    # puts "Hello" # --> code action: quick fix indentation
-    # end
-    # ```
     class CodeActions < Request
       extend T::Sig
 

data/lib/ruby_lsp/requests/code_lens.rb

@@ -7,19 +7,9 @@ require "ruby_lsp/listeners/code_lens"
 
 module RubyLsp
   module Requests
-    # ![Code lens demo](../../code_lens.gif)
-    #
     # The
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
-    # request informs the editor of runnable commands such as testing and debugging
-    #
-    # # Example
-    #
-    # ```ruby
-    # # Run | Run in Terminal | Debug
-    # class Test < Minitest::Test
-    # end
-    # ```
+    # request informs the editor of runnable commands such as testing and debugging.
     class CodeLens < Request
       extend T::Sig