ruby-lsp 0.18.3 → 0.19.1

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

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class Scope
+    extend T::Sig
+
+    sig { returns(T.nilable(Scope)) }
+    attr_reader :parent
+
+    sig { params(parent: T.nilable(Scope)).void }
+    def initialize(parent = nil)
+      @parent = parent
+
+      # A hash of name => type
+      @locals = T.let({}, T::Hash[Symbol, Local])
+    end
+
+    # Add a new local to this scope. The types should only be `:parameter` or `:variable`
+    sig { params(name: T.any(String, Symbol), type: Symbol).void }
+    def add(name, type)
+      @locals[name.to_sym] = Local.new(type)
+    end
+
+    sig { params(name: T.any(String, Symbol)).returns(T.nilable(Local)) }
+    def lookup(name)
+      sym = name.to_sym
+      entry = @locals[sym]
+      return entry if entry
+      return unless @parent
+
+      @parent.lookup(sym)
+    end
+
+    class Local
+      extend T::Sig
+
+      sig { returns(Symbol) }
+      attr_reader :type
+
+      sig { params(type: Symbol).void }
+      def initialize(type)
+        @type = type
+      end
+    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(
@@ -142,7 +157,7 @@ module RubyLsp
             method: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::WARNING,
-              message: "Error loading addons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
+              message: "Error loading add-ons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
             ),
           ),
         )
@@ -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,
           },
@@ -285,8 +303,9 @@ module RubyLsp
         rescue RuboCop::Error => e
           # The user may have provided unknown config switches in .rubocop or
           # is trying to load a non-existant config file.
-          send_message(Notification.window_show_error(
+          send_message(Notification.window_show_message(
             "RuboCop configuration error: #{e.message}. Formatting will not be available.",
+            type: Constant::MessageType::ERROR,
           ))
         end
       end
@@ -319,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,
               ),
             ),
           )
@@ -505,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
@@ -531,10 +582,16 @@ module RubyLsp
       response = Requests::Formatting.new(@global_state, document).perform
       send_message(Result.new(id: message[:id], response: response))
     rescue Requests::Request::InvalidFormatter => error
-      send_message(Notification.window_show_error("Configuration error: #{error.message}"))
+      send_message(Notification.window_show_message(
+        "Configuration error: #{error.message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     rescue StandardError, LoadError => error
-      send_message(Notification.window_show_error("Formatting error: #{error.message}"))
+      send_message(Notification.window_show_message(
+        "Formatting error: #{error.message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     end
 
@@ -602,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
@@ -673,30 +768,19 @@ module RubyLsp
       document = @store.get(uri)
 
       unless document.is_a?(RubyDocument)
-        send_message(Notification.window_show_error("Code actions are currently only available for Ruby documents"))
-        raise Requests::CodeActionResolve::CodeActionError
+        fail_request_and_notify(message[:id], "Code actions are currently only available for Ruby documents")
+        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
-        send_message(Notification.window_show_error("Invalid selection for Extract Variable refactor"))
-        raise Requests::CodeActionResolve::CodeActionError
+        fail_request_and_notify(message[:id], "Invalid selection for extract variable refactor")
       when Requests::CodeActionResolve::Error::InvalidTargetRange
-        send_message(
-          Notification.window_show_error(
-            "Couldn't find an appropriate location to place extracted refactor",
-          ),
-        )
-        raise Requests::CodeActionResolve::CodeActionError
+        fail_request_and_notify(message[:id], "Couldn't find an appropriate location to place extracted refactor")
       when Requests::CodeActionResolve::Error::UnknownCodeAction
-        send_message(
-          Notification.window_show_error(
-            "Unknown code action",
-          ),
-        )
-        raise Requests::CodeActionResolve::CodeActionError
+        fail_request_and_notify(message[:id], "Unknown code action")
       else
         send_message(Result.new(id: message[:id], response: result))
       end
@@ -729,10 +813,16 @@ module RubyLsp
         ),
       )
     rescue Requests::Request::InvalidFormatter => error
-      send_message(Notification.window_show_error("Configuration error: #{error.message}"))
+      send_message(Notification.window_show_message(
+        "Configuration error: #{error.message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     rescue StandardError, LoadError => error
-      send_message(Notification.window_show_error("Error running diagnostics: #{error.message}"))
+      send_message(Notification.window_show_message(
+        "Error running diagnostics: #{error.message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     end
 
@@ -969,7 +1059,9 @@ module RubyLsp
             false
           end
         rescue StandardError => error
-          send_message(Notification.window_show_error("Error while indexing: #{error.message}"))
+          message = "Error while indexing (see [troubleshooting steps]" \
+            "(https://shopify.github.io/ruby-lsp/troubleshooting#indexing)): #{error.message}"
+          send_message(Notification.window_show_message(message, type: Constant::MessageType::ERROR))
         end
 
         # Indexing produces a high number of short lived object allocations. That might lead to some fragmentation and
@@ -1054,8 +1146,9 @@ module RubyLsp
         @global_state.formatter = "none"
 
         send_message(
-          Notification.window_show_error(
+          Notification.window_show_message(
             "Ruby LSP formatter is set to `rubocop` but RuboCop was not found in the Gemfile or gemspec.",
+            type: Constant::MessageType::ERROR,
           ),
         )
       end

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/lib/ruby_lsp/utils.rb

@@ -64,14 +64,11 @@ module RubyLsp
     class << self
       extend T::Sig
 
-      sig { params(message: String).returns(Notification) }
-      def window_show_error(message)
+      sig { params(message: String, type: Integer).returns(Notification) }
+      def window_show_message(message, type: Constant::MessageType::INFO)
         new(
           method: "window/showMessage",
-          params: Interface::ShowMessageParams.new(
-            type: Constant::MessageType::ERROR,
-            message: message,
-          ),
+          params: Interface::ShowMessageParams.new(type: type, message: message),
         )
       end
 

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
+```