ruby-lsp 0.18.4 → 0.19.1

data/lib/ruby_lsp/requests/rename.rb

@@ -0,0 +1,196 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_rename)
+    # request renames all instances of a symbol in a document.
+    class Rename < Request
+      extend T::Sig
+      include Support::Common
+
+      class InvalidNameError < StandardError; end
+
+      sig do
+        params(
+          global_state: GlobalState,
+          store: Store,
+          document: T.any(RubyDocument, ERBDocument),
+          params: T::Hash[Symbol, T.untyped],
+        ).void
+      end
+      def initialize(global_state, store, document, params)
+        super()
+        @global_state = global_state
+        @store = store
+        @document = document
+        @position = T.let(params[:position], T::Hash[Symbol, Integer])
+        @new_name = T.let(params[:newName], String)
+      end
+
+      sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
+      def perform
+        char_position = @document.create_scanner.find_char_position(@position)
+
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          char_position,
+          node_types: [Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode],
+          encoding: @global_state.encoding,
+        )
+        target = node_context.node
+        parent = node_context.parent
+        return if !target || target.is_a?(Prism::ProgramNode)
+
+        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          target = determine_target(
+            target,
+            parent,
+            @position,
+          )
+        end
+
+        target = T.cast(
+          target,
+          T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode),
+        )
+
+        name = constant_name(target)
+        return unless name
+
+        entries = @global_state.index.resolve(name, node_context.nesting)
+        return unless entries
+
+        if (conflict_entries = @global_state.index.resolve(@new_name, node_context.nesting))
+          raise InvalidNameError, "The new name is already in use by #{T.must(conflict_entries.first).name}"
+        end
+
+        fully_qualified_name = T.must(entries.first).name
+        reference_target = RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
+        changes = collect_text_edits(reference_target, name)
+
+        # If the client doesn't support resource operations, such as renaming files, then we can only return the basic
+        # text changes
+        unless @global_state.supported_resource_operations.include?("rename")
+          return Interface::WorkspaceEdit.new(changes: changes)
+        end
+
+        # Text edits must be applied before any resource operations, such as renaming files. Otherwise, the file is
+        # renamed and then the URI associated to the text edit no longer exists, causing it to be dropped
+        document_changes = changes.map do |uri, edits|
+          Interface::TextDocumentEdit.new(
+            text_document: Interface::VersionedTextDocumentIdentifier.new(uri: uri, version: nil),
+            edits: edits,
+          )
+        end
+
+        collect_file_renames(fully_qualified_name, document_changes)
+        Interface::WorkspaceEdit.new(document_changes: document_changes)
+      end
+
+      private
+
+      sig do
+        params(
+          fully_qualified_name: String,
+          document_changes: T::Array[T.any(Interface::RenameFile, Interface::TextDocumentEdit)],
+        ).void
+      end
+      def collect_file_renames(fully_qualified_name, document_changes)
+        # Check if the declarations of the symbol being renamed match the file name. In case they do, we automatically
+        # rename the files for the user.
+        #
+        # We also look for an associated test file and rename it too
+        short_name = T.must(fully_qualified_name.split("::").last)
+
+        T.must(@global_state.index[fully_qualified_name]).each do |entry|
+          # Do not rename files that are not part of the workspace
+          next unless entry.file_path.start_with?(@global_state.workspace_path)
+
+          case entry
+          when RubyIndexer::Entry::Class, RubyIndexer::Entry::Module, RubyIndexer::Entry::Constant,
+               RubyIndexer::Entry::ConstantAlias, RubyIndexer::Entry::UnresolvedConstantAlias
+
+            file_name = file_from_constant_name(short_name)
+
+            if "#{file_name}.rb" == entry.file_name
+              new_file_name = file_from_constant_name(T.must(@new_name.split("::").last))
+
+              old_uri = URI::Generic.from_path(path: entry.file_path).to_s
+              new_uri = URI::Generic.from_path(path: File.join(
+                File.dirname(entry.file_path),
+                "#{new_file_name}.rb",
+              )).to_s
+
+              document_changes << Interface::RenameFile.new(kind: "rename", old_uri: old_uri, new_uri: new_uri)
+            end
+          end
+        end
+      end
+
+      sig do
+        params(
+          target: RubyIndexer::ReferenceFinder::Target,
+          name: String,
+        ).returns(T::Hash[String, T::Array[Interface::TextEdit]])
+      end
+      def collect_text_edits(target, name)
+        changes = {}
+
+        Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
+          uri = URI::Generic.from_path(path: path)
+          # If the document is being managed by the client, then we should use whatever is present in the store instead
+          # of reading from disk
+          next if @store.key?(uri)
+
+          parse_result = Prism.parse_file(path)
+          edits = collect_changes(target, parse_result, name, uri)
+          changes[uri.to_s] = edits unless edits.empty?
+        end
+
+        @store.each do |uri, document|
+          edits = collect_changes(target, document.parse_result, name, document.uri)
+          changes[uri] = edits unless edits.empty?
+        end
+
+        changes
+      end
+
+      sig do
+        params(
+          target: RubyIndexer::ReferenceFinder::Target,
+          parse_result: Prism::ParseResult,
+          name: String,
+          uri: URI::Generic,
+        ).returns(T::Array[Interface::TextEdit])
+      end
+      def collect_changes(target, parse_result, name, uri)
+        dispatcher = Prism::Dispatcher.new
+        finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher)
+        dispatcher.visit(parse_result.value)
+
+        finder.references.map do |reference|
+          adjust_reference_for_edit(name, reference)
+        end
+      end
+
+      sig { params(name: String, reference: RubyIndexer::ReferenceFinder::Reference).returns(Interface::TextEdit) }
+      def adjust_reference_for_edit(name, reference)
+        # The reference may include a namespace in front. We need to check if the rename new name includes namespaces
+        # and then adjust both the text and the location to produce the correct edit
+        location = reference.location
+        new_text = reference.name.sub(name, @new_name)
+
+        Interface::TextEdit.new(range: range_from_location(location), new_text: new_text)
+      end
+
+      sig { params(constant_name: String).returns(String) }
+      def file_from_constant_name(constant_name)
+        constant_name
+          .gsub(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/, '\1\3_\2\4')
+          .downcase
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/signature_help.rb

@@ -39,7 +39,12 @@ module RubyLsp
         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])
+        node_context = RubyDocument.locate(
+          document.parse_result.value,
+          char_position,
+          node_types: [Prism::CallNode],
+          encoding: global_state.encoding,
+        )
 
         target = adjust_for_nested_target(node_context.node, node_context.parent, position)
 

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

@@ -13,6 +13,9 @@ module RubyLsp
         sig { abstract.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
         def run_formatting(uri, document); end
 
+        sig { abstract.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        def run_range_formatting(uri, source, base_indentation); end
+
         sig do
           abstract.params(
             uri: URI::Generic,

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

@@ -28,6 +28,12 @@ module RubyLsp
           @format_runner.formatted_source
         end
 
+        # RuboCop does not support range formatting
+        sig { override.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        def run_range_formatting(uri, source, base_indentation)
+          nil
+        end
+
         sig do
           override.params(
             uri: URI::Generic,

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

@@ -19,6 +19,13 @@ module URI
       T::Array[Symbol],
     )
 
+    # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
+    # warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
+    # On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
+    # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
+    # have the uri gem in their own bundle and thus not use a compatible version.
+    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
+
     T.unsafe(self).alias_method(:gem_name, :host)
     T.unsafe(self).alias_method(:line_number, :fragment)
 
@@ -41,7 +48,7 @@ module URI
           {
             scheme: "source",
             host: gem_name,
-            path: DEFAULT_PARSER.escape("/#{gem_version}/#{path}"),
+            path: PARSER.escape("/#{gem_version}/#{path}"),
             fragment: line_number,
           }
         )

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

@@ -37,6 +37,14 @@ module RubyLsp
           SyntaxTree.format(document.source, @options.print_width, options: @options.formatter_options)
         end
 
+        sig { override.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        def run_range_formatting(uri, source, base_indentation)
+          path = uri.to_standardized_path
+          return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
+
+          SyntaxTree.format(source, @options.print_width, base_indentation, options: @options.formatter_options)
+        end
+
         sig do
           override.params(
             uri: URI::Generic,

data/lib/ruby_lsp/ruby_document.rb

@@ -26,9 +26,10 @@ module RubyLsp
           node: Prism::Node,
           char_position: Integer,
           node_types: T::Array[T.class_of(Prism::Node)],
+          encoding: Encoding,
         ).returns(NodeContext)
       end
-      def locate(node, char_position, node_types: [])
+      def locate(node, char_position, node_types: [], encoding: Encoding::UTF_8)
         queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
         closest = node
         parent = T.let(nil, T.nilable(Prism::Node))
@@ -61,16 +62,21 @@ module RubyLsp
 
           # Skip if the current node doesn't cover the desired position
           loc = candidate.location
-          next unless (loc.start_offset...loc.end_offset).cover?(char_position)
+          loc_start_offset = loc.start_code_units_offset(encoding)
+          loc_end_offset = loc.end_code_units_offset(encoding)
+          next unless (loc_start_offset...loc_end_offset).cover?(char_position)
 
           # If the node's start character is already past the position, then we should've found the closest node
           # already
-          break if char_position < loc.start_offset
+          break if char_position < loc_start_offset
 
           # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level
           # and need to pop the stack
           previous_level = nesting_nodes.last
-          nesting_nodes.pop if previous_level && loc.start_offset > previous_level.location.end_offset
+          if previous_level &&
+              (loc_start_offset > previous_level.location.end_code_units_offset(encoding))
+            nesting_nodes.pop
+          end
 
           # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of
           # the target when it is a constant
@@ -83,8 +89,10 @@ module RubyLsp
           if candidate.is_a?(Prism::CallNode)
             arg_loc = candidate.arguments&.location
             blk_loc = candidate.block&.location
-            if (arg_loc && (arg_loc.start_offset...arg_loc.end_offset).cover?(char_position)) ||
-                (blk_loc && (blk_loc.start_offset...blk_loc.end_offset).cover?(char_position))
+            if (arg_loc && (arg_loc.start_code_units_offset(encoding)...
+                            arg_loc.end_code_units_offset(encoding)).cover?(char_position)) ||
+                (blk_loc && (blk_loc.start_code_units_offset(encoding)...
+                            blk_loc.end_code_units_offset(encoding)).cover?(char_position))
               call_node = candidate
             end
           end
@@ -94,7 +102,9 @@ module RubyLsp
 
           # If the current node is narrower than or equal to the previous closest node, then it is more precise
           closest_loc = closest.location
-          if loc.end_offset - loc.start_offset <= closest_loc.end_offset - closest_loc.start_offset
+          closest_node_start_offset = closest_loc.start_code_units_offset(encoding)
+          closest_node_end_offset = closest_loc.end_code_units_offset(encoding)
+          if loc_end_offset - loc_start_offset <= closest_node_end_offset - closest_node_start_offset
             parent = closest
             closest = candidate
           end
@@ -201,7 +211,12 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
-      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+      RubyDocument.locate(
+        @parse_result.value,
+        create_scanner.find_char_position(position),
+        node_types: node_types,
+        encoding: @encoding,
+      )
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -43,6 +43,8 @@ module RubyLsp
         text_document_semantic_tokens_range(message)
       when "textDocument/formatting"
         text_document_formatting(message)
+      when "textDocument/rangeFormatting"
+        text_document_range_formatting(message)
       when "textDocument/documentHighlight"
         text_document_document_highlight(message)
       when "textDocument/onTypeFormatting"
@@ -67,6 +69,10 @@ module RubyLsp
         text_document_definition(message)
       when "textDocument/prepareTypeHierarchy"
         text_document_prepare_type_hierarchy(message)
+      when "textDocument/rename"
+        text_document_rename(message)
+      when "textDocument/references"
+        text_document_references(message)
       when "typeHierarchy/supertypes"
         type_hierarchy_supertypes(message)
       when "typeHierarchy/subtypes"
@@ -85,7 +91,16 @@ module RubyLsp
             id: message[:id],
             response:
               Addon.addons.map do |addon|
-                { name: addon.name, errored: addon.error? }
+                version_method = addon.method(:version)
+
+                # If the add-on doesn't define a `version` method, we'd be calling the abstract method defined by
+                # Sorbet, which would raise an error.
+                # Therefore, we only call the method if it's defined by the add-on itself
+                if version_method.owner != Addon
+                  version = addon.version
+                end
+
+                { name: addon.name, version: version, errored: addon.error? }
               end,
           ),
         )
@@ -123,9 +138,9 @@ module RubyLsp
       send_log_message("Error processing #{message[:method]}: #{e.full_message}", type: Constant::MessageType::ERROR)
     end
 
-    sig { void }
-    def load_addons
-      errors = Addon.load_addons(@global_state, @outgoing_queue)
+    sig { params(include_project_addons: T::Boolean).void }
+    def load_addons(include_project_addons: true)
+      errors = Addon.load_addons(@global_state, @outgoing_queue, include_project_addons: include_project_addons)
 
       if errors.any?
         send_log_message(
@@ -227,6 +242,9 @@ module RubyLsp
           workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.has_type_checker,
           signature_help_provider: signature_help_provider,
           type_hierarchy_provider: type_hierarchy_provider,
+          rename_provider: !@global_state.has_type_checker,
+          references_provider: !@global_state.has_type_checker,
+          document_range_formatting_provider: true,
           experimental: {
             addon_detection: true,
           },
@@ -320,14 +338,18 @@ module RubyLsp
           language_id: language_id,
         )
 
-        if document.past_expensive_limit?
+        if document.past_expensive_limit? && text_document[:uri].scheme == "file"
+          log_message = <<~MESSAGE
+            The file #{text_document[:uri].path} is too long. For performance reasons, semantic highlighting and
+            diagnostics will be disabled.
+          MESSAGE
+
           send_message(
             Notification.new(
-              method: "window/showMessage",
-              params: Interface::ShowMessageParams.new(
+              method: "window/logMessage",
+              params: Interface::LogMessageParams.new(
                 type: Constant::MessageType::WARNING,
-                message: "This file is too long. For performance reasons, semantic highlighting and " \
-                  "diagnostics will be disabled",
+                message: log_message,
               ),
             ),
           )
@@ -506,6 +528,34 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_range_formatting(message)
+      # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
+      if @global_state.formatter == "none"
+        send_empty_response(message[:id])
+        return
+      end
+
+      params = message[:params]
+      uri = params.dig(:textDocument, :uri)
+      # Do not format files outside of the workspace. For example, if someone is looking at a gem's source code, we
+      # don't want to format it
+      path = uri.to_standardized_path
+      unless path.nil? || path.start_with?(@global_state.workspace_path)
+        send_empty_response(message[:id])
+        return
+      end
+
+      document = @store.get(uri)
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      response = Requests::RangeFormatting.new(@global_state, document, params).perform
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_formatting(message)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
@@ -609,6 +659,44 @@ module RubyLsp
       )
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_rename(message)
+      params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      send_message(
+        Result.new(
+          id: message[:id],
+          response: Requests::Rename.new(@global_state, @store, document, params).perform,
+        ),
+      )
+    rescue Requests::Rename::InvalidNameError => e
+      send_message(Error.new(id: message[:id], code: Constant::ErrorCodes::REQUEST_FAILED, message: e.message))
+    end
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_references(message)
+      params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      send_message(
+        Result.new(
+          id: message[:id],
+          response: Requests::References.new(@global_state, @store, document, params).perform,
+        ),
+      )
+    end
+
     sig { params(document: Document[T.untyped]).returns(RubyDocument::SorbetLevel) }
     def sorbet_level(document)
       return RubyDocument::SorbetLevel::Ignore unless @global_state.has_type_checker
@@ -684,7 +772,7 @@ module RubyLsp
         return
       end
 
-      result = Requests::CodeActionResolve.new(document, params).perform
+      result = Requests::CodeActionResolve.new(document, @global_state, params).perform
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection

data/lib/ruby_lsp/static_docs.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # The path to the `static_docs` directory, where we keep long-form static documentation
+  STATIC_DOCS_PATH = T.let(File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs"), String)
+
+  # A map of keyword => short documentation to be displayed on hover or completion
+  KEYWORD_DOCS = T.let(
+    {
+      "yield" => "Invokes the passed block with the given arguments",
+    }.freeze,
+    T::Hash[String, String],
+  )
+end

data/lib/ruby_lsp/store.rb

@@ -99,6 +99,18 @@ module RubyLsp
       @state.delete(uri.to_s)
     end
 
+    sig { params(uri: URI::Generic).returns(T::Boolean) }
+    def key?(uri)
+      @state.key?(uri.to_s)
+    end
+
+    sig { params(block: T.proc.params(uri: String, document: Document[T.untyped]).void).void }
+    def each(&block)
+      @state.each do |uri, document|
+        block.call(uri, document)
+      end
+    end
+
     sig do
       type_parameters(:T)
         .params(

data/lib/ruby_lsp/test_helper.rb

@@ -42,7 +42,7 @@ module RubyLsp
         RubyIndexer::IndexablePath.new(nil, T.must(uri.to_standardized_path)),
         source,
       )
-      server.load_addons if load_addons
+      server.load_addons(include_project_addons: false) if load_addons
       block.call(server, uri)
     ensure
       if load_addons

data/lib/ruby_lsp/type_inferrer.rb

@@ -89,7 +89,12 @@ module RubyLsp
 
         Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
       else
-        raw_receiver = node.receiver&.slice
+
+        raw_receiver = if receiver.is_a?(Prism::CallNode)
+          receiver.message
+        else
+          receiver&.slice
+        end
 
         if raw_receiver
           guessed_name = raw_receiver

data/static_docs/yield.md

@@ -0,0 +1,81 @@
+# Yield
+
+In Ruby, every method implicitly accepts a block, even when not included in the parameters list.
+
+```ruby
+def foo
+end
+
+foo { 123 } # works!
+```
+
+The `yield` keyword is used to invoke the block that was passed with arguments.
+
+```ruby
+# Consider this method call. The block being passed to the method `foo` accepts an argument called `a`.
+# It then takes whatever argument was passed and multiplies it by 2
+foo do |a|
+  a * 2
+end
+
+# In the `foo` method declaration, we can use `yield` to invoke the block that was passed and provide the block
+# with the value for the `a` argument
+def foo
+  # Invoke the block passed to `foo` with the number 10 as the argument `a`
+  result = yield(10)
+  puts result # Will print 20
+end
+```
+
+If `yield` is used to invoke the block, but no block was passed, that will result in a local jump error.
+
+```ruby
+# If we invoke `foo` without a block, trying to `yield` will fail
+foo
+
+# `foo': no block given (yield) (LocalJumpError)
+```
+
+We can decide to use `yield` conditionally by using Ruby's `block_given?` method, which will return `true` if a block
+was passed to the method.
+
+```ruby
+def foo
+  # If a block is passed when invoking `foo`, call the block with argument 10 and print the result.
+  # Otherwise, just print that no block was passed
+  if block_given?
+    result = yield(10)
+    puts result
+  else
+    puts "No block passed!"
+  end
+end
+
+foo do |a|
+  a * 2
+end
+# => 20
+
+foo
+# => No block passed!
+```
+
+## Block parameter
+
+In addition to implicit blocks, Ruby also allows developers to use explicit block parameters as part of the method's
+signature. In this scenario, we can use the reference to the block directly instead of relying on the `yield` keyword.
+
+```ruby
+# Block parameters are prefixed with & and a name
+def foo(&my_block_param)
+  # If a block was passed to `foo`, `my_block_param` will be a `Proc` object. Otherwise, it will be `nil`. We can use
+  # that to check for its presence
+  if my_block_param
+    # Explicit block parameters are invoked using the method `call`, which is present in all `Proc` objects
+    result = my_block_param.call(10)
+    puts result
+  else
+    puts "No block passed!"
+  end
+end
+```