ruby-lsp 0.17.16 → 0.18.0

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/folding_ranges.rb

@@ -242,7 +242,7 @@ module RubyLsp
         body = statements.body
         return if body.empty?
 
-        add_lines_range(node.location.start_line, T.must(body.last).location.end_line)
+        add_lines_range(node.location.start_line, body.last.location.end_line)
       end
 
       sig { params(node: Prism::Node).void }

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -41,6 +41,7 @@ module RubyLsp
           :on_block_node_leave,
           :on_self_node_enter,
           :on_module_node_enter,
+          :on_local_variable_write_node_enter,
           :on_local_variable_read_node_enter,
           :on_block_parameter_node_enter,
           :on_required_keyword_parameter_node_enter,
@@ -49,6 +50,9 @@ module RubyLsp
           :on_optional_parameter_node_enter,
           :on_required_parameter_node_enter,
           :on_rest_parameter_node_enter,
+          :on_local_variable_and_write_node_enter,
+          :on_local_variable_operator_write_node_enter,
+          :on_local_variable_or_write_node_enter,
           :on_local_variable_target_node_enter,
           :on_block_local_variable_node_enter,
           :on_match_write_node_enter,
@@ -164,6 +168,12 @@ module RubyLsp
         @response_builder.add_token(node.location, :variable, [:default_library])
       end
 
+      sig { params(node: Prism::LocalVariableWriteNode).void }
+      def on_local_variable_write_node_enter(node)
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
+      end
+
       sig { params(node: Prism::LocalVariableReadNode).void }
       def on_local_variable_read_node_enter(node)
         return if @inside_implicit_node
@@ -177,6 +187,24 @@ module RubyLsp
         @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)
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
+      end
+
+      sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
+      def on_local_variable_operator_write_node_enter(node)
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
+      end
+
+      sig { params(node: Prism::LocalVariableOrWriteNode).void }
+      def on_local_variable_or_write_node_enter(node)
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
+      end
+
       sig { params(node: Prism::LocalVariableTargetNode).void }
       def on_local_variable_target_node_enter(node)
         # If we're inside a regex capture, Prism will add LocalVariableTarget nodes for each captured variable.

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
 

data/lib/ruby_lsp/requests/completion.rb

@@ -5,27 +5,8 @@ require "ruby_lsp/listeners/completion"
 
 module RubyLsp
   module Requests
-    # ![Completion demo](../../completion.gif)
-    #
     # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
     # suggests possible completions according to what the developer is typing.
-    #
-    # Currently supported targets:
-    #
-    # - Classes
-    # - Modules
-    # - Constants
-    # - Require paths
-    # - Methods invoked on self only
-    # - Instance variables
-    #
-    # # Example
-    #
-    # ```ruby
-    # require "ruby_lsp/requests" # --> completion: suggests `base_request`, `code_actions`, ...
-    #
-    # RubyLsp::Requests:: # --> completion: suggests `Completion`, `Hover`, ...
-    # ```
     class Completion < Request
       extend T::Sig
 
@@ -36,7 +17,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
-            trigger_characters: ["/", "\"", "'", ":", "@", "."],
+            trigger_characters: ["/", "\"", "'", ":", "@", ".", "=", "<"],
             completion_item: {
               labelDetailsSupport: true,
             },
@@ -60,6 +41,8 @@ module RubyLsp
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
         char_position = document.create_scanner.find_char_position(params[:position]) - 1
+        delegate_request_if_needed!(global_state, document, char_position)
+
         node_context = RubyDocument.locate(
           document.parse_result.value,
           char_position,

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -3,8 +3,6 @@
 
 module RubyLsp
   module Requests
-    # ![Completion resolve demo](../../completion_resolve.gif)
-    #
     # The [completionItem/resolve](https://microsoft.github.io/language-server-protocol/specification#completionItem_resolve)
     # request provides additional information about the currently selected completion. Specifically, the `labelDetails`
     # and `documentation` fields are provided, which are omitted from the completion items returned by
@@ -15,12 +13,6 @@ module RubyLsp
     #
     # At most 10 definitions are included, to ensure low latency during request processing and rendering the completion
     # item.
-    #
-    # # Example
-    #
-    # ```ruby
-    # A # -> as the user cycles through completion items, the documentation will be resolved and displayed
-    # ```
     class CompletionResolve < Request
       extend T::Sig
       include Requests::Support::Common

data/lib/ruby_lsp/requests/definition.rb

@@ -5,27 +5,9 @@ require "ruby_lsp/listeners/definition"
 
 module RubyLsp
   module Requests
-    # ![Definition demo](../../definition.gif)
-    #
     # The [definition
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_definition) jumps to the
     # definition of the symbol under the cursor.
-    #
-    # Currently supported targets:
-    #
-    # - Classes
-    # - Modules
-    # - Constants
-    # - Require paths
-    # - Methods invoked on self only and on receivers where the type is unknown
-    # - Instance variables
-    #
-    # # Example
-    #
-    # ```ruby
-    # require "some_gem/file" # <- Request go to definition on this string will take you to the file
-    # Product.new # <- Request go to definition on this class name will take you to its declaration.
-    # ```
     class Definition < Request
       extend T::Sig
       extend T::Generic
@@ -53,8 +35,12 @@ module RubyLsp
         )
         @dispatcher = dispatcher
 
-        node_context = document.locate_node(
-          position,
+        char_position = document.create_scanner.find_char_position(position)
+        delegate_request_if_needed!(global_state, document, char_position)
+
+        node_context = RubyDocument.locate(
+          document.parse_result.value,
+          char_position,
           node_types: [
             Prism::CallNode,
             Prism::ConstantReadNode,

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -3,19 +3,9 @@
 
 module RubyLsp
   module Requests
-    # ![Diagnostics demo](../../diagnostics.gif)
-    #
     # The
     # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
     # request informs the editor of RuboCop offenses for a given file.
-    #
-    # # Example
-    #
-    # ```ruby
-    # def say_hello
-    # puts "Hello" # --> diagnostics: incorrect indentation
-    # end
-    # ```
     class Diagnostics < Request
       extend T::Sig
 

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -5,8 +5,6 @@ require "ruby_lsp/listeners/document_highlight"
 
 module RubyLsp
   module Requests
-    # ![Document highlight demo](../../document_highlight.gif)
-    #
     # The [document highlight](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight)
     # informs the editor all relevant elements of the currently pointed item for highlighting. For example, when
     # the cursor is on the `F` of the constant `FOO`, the editor should identify other occurrences of `FOO`
@@ -14,29 +12,24 @@ module RubyLsp
     #
     # For writable elements like constants or variables, their read/write occurrences should be highlighted differently.
     # This is achieved by sending different "kind" attributes to the editor (2 for read and 3 for write).
-    #
-    # # Example
-    #
-    # ```ruby
-    # FOO = 1 # should be highlighted as "write"
-    #
-    # def foo
-    #   FOO # should be highlighted as "read"
-    # end
-    # ```
     class DocumentHighlight < Request
       extend T::Sig
 
       sig do
         params(
+          global_state: GlobalState,
           document: T.any(RubyDocument, ERBDocument),
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(document, position, dispatcher)
+      def initialize(global_state, document, position, dispatcher)
         super()
-        node_context = document.locate_node(position)
+        char_position = document.create_scanner.find_char_position(position)
+        delegate_request_if_needed!(global_state, document, char_position)
+
+        node_context = RubyDocument.locate(document.parse_result.value, char_position)
+
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight],

data/lib/ruby_lsp/requests/document_link.rb

@@ -5,19 +5,9 @@ require "ruby_lsp/listeners/document_link"
 
 module RubyLsp
   module Requests
-    # ![Document link demo](../../document_link.gif)
-    #
     # The [document link](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentLink)
     # makes `# source://PATH_TO_FILE#line` comments in a Ruby/RBI file clickable if the file exists.
     # When the user clicks the link, it'll open that location.
-    #
-    # # Example
-    #
-    # ```ruby
-    # # source://syntax_tree/3.2.1/lib/syntax_tree.rb#51 <- it will be clickable and will take the user to that location
-    # def format(source, maxwidth = T.unsafe(nil))
-    # end
-    # ```
     class DocumentLink < Request
       extend T::Sig
 

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -5,29 +5,12 @@ require "ruby_lsp/listeners/document_symbol"
 
 module RubyLsp
   module Requests
-    # ![Document symbol demo](../../document_symbol.gif)
-    #
     # The [document
     # symbol](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol) request
     # informs the editor of all the important symbols, such as classes, variables, and methods, defined in a file. With
     # this information, the editor can populate breadcrumbs, file outline and allow for fuzzy symbol searches.
     #
     # In VS Code, fuzzy symbol search can be accessed by opening the command palette and inserting an `@` symbol.
-    #
-    # # Example
-    #
-    # ```ruby
-    # class Person # --> document symbol: class
-    #   attr_reader :age # --> document symbol: field
-    #
-    #   def initialize
-    #     @age = 0 # --> document symbol: variable
-    #   end
-    #
-    #   def age # --> document symbol: method
-    #   end
-    # end
-    # ```
     class DocumentSymbol < Request
       extend T::Sig
 

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -5,18 +5,8 @@ require "ruby_lsp/listeners/folding_ranges"
 
 module RubyLsp
   module Requests
-    # ![Folding ranges demo](../../folding_ranges.gif)
-    #
     # The [folding ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange)
     # request informs the editor of the ranges where and how code can be folded.
-    #
-    # # Example
-    #
-    # ```ruby
-    # def say_hello # <-- folding range start
-    #   puts "Hello"
-    # end # <-- folding range end
-    # ```
     class FoldingRanges < Request
       extend T::Sig
 

data/lib/ruby_lsp/requests/formatting.rb

@@ -3,25 +3,9 @@
 
 module RubyLsp
   module Requests
-    # ![Formatting symbol demo](../../formatting.gif)
-    #
     # The [formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting)
     # request uses RuboCop to fix auto-correctable offenses in the document. This requires enabling format on save and
     # registering the ruby-lsp as the Ruby formatter.
-    #
-    # The `rubyLsp.formatter` setting specifies which formatter to use.
-    # If set to `auto` then it behaves as follows:
-    # * It will use RuboCop if it is part of the bundle.
-    # * If RuboCop is not available, and `syntax_tree` is a direct dependency, it will use that.
-    # * Otherwise, no formatting will be applied.
-    #
-    # # Example
-    #
-    # ```ruby
-    # def say_hello
-    # puts "Hello" # --> formatting: fixes the indentation on save
-    # end
-    # ```
     class Formatting < Request
       extend T::Sig
 
@@ -58,14 +42,16 @@ module RubyLsp
         formatted_text = @active_formatter.run_formatting(@uri, @document)
         return unless formatted_text
 
+        lines = @document.source.lines
         size = @document.source.size
+
         return if formatted_text.size == size && formatted_text == @document.source
 
         [
           Interface::TextEdit.new(
             range: Interface::Range.new(
               start: Interface::Position.new(line: 0, character: 0),
-              end: Interface::Position.new(line: size, character: size),
+              end: Interface::Position.new(line: lines.size, character: 0),
             ),
             new_text: formatted_text,
           ),