ruby-lsp 0.19.0 → 0.20.0

data/lib/ruby_lsp/ruby_document.rb

@@ -25,10 +25,14 @@ module RubyLsp
         params(
           node: Prism::Node,
           char_position: Integer,
+          code_units_cache: T.any(
+            T.proc.params(arg0: Integer).returns(Integer),
+            Prism::CodeUnitsCache,
+          ),
           node_types: T::Array[T.class_of(Prism::Node)],
         ).returns(NodeContext)
       end
-      def locate(node, char_position, node_types: [])
+      def locate(node, char_position, code_units_cache:, node_types: [])
         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 +65,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.cached_start_code_units_offset(code_units_cache)
+          loc_end_offset = loc.cached_end_code_units_offset(code_units_cache)
+          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.cached_end_code_units_offset(code_units_cache))
+            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 +92,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.cached_start_code_units_offset(code_units_cache)...
+                            arg_loc.cached_end_code_units_offset(code_units_cache)).cover?(char_position)) ||
+                (blk_loc && (blk_loc.cached_start_code_units_offset(code_units_cache)...
+                            blk_loc.cached_end_code_units_offset(code_units_cache)).cover?(char_position))
               call_node = candidate
             end
           end
@@ -94,7 +105,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.cached_start_code_units_offset(code_units_cache)
+          closest_node_end_offset = closest_loc.cached_end_code_units_offset(code_units_cache)
+          if loc_end_offset - loc_start_offset <= closest_node_end_offset - closest_node_start_offset
             parent = closest
             closest = candidate
           end
@@ -121,12 +134,30 @@ module RubyLsp
       end
     end
 
+    sig do
+      returns(T.any(
+        T.proc.params(arg0: Integer).returns(Integer),
+        Prism::CodeUnitsCache,
+      ))
+    end
+    attr_reader :code_units_cache
+
+    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
+    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+      super
+      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
+        T.proc.params(arg0: Integer).returns(Integer),
+        Prism::CodeUnitsCache,
+      ))
+    end
+
     sig { override.returns(T::Boolean) }
     def parse!
       return false unless @needs_parsing
 
       @needs_parsing = false
       @parse_result = Prism.parse(@source)
+      @code_units_cache = @parse_result.code_units_cache(@encoding)
       true
     end
 
@@ -201,7 +232,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),
+        code_units_cache: @code_units_cache,
+        node_types: node_types,
+      )
     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"
@@ -69,6 +71,8 @@ module RubyLsp
         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"
@@ -87,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,
           ),
         )
@@ -230,6 +243,8 @@ module RubyLsp
           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,
           },
@@ -513,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
@@ -636,6 +679,24 @@ module RubyLsp
       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
@@ -711,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/type_inferrer.rb

@@ -93,7 +93,7 @@ module RubyLsp
         raw_receiver = if receiver.is_a?(Prism::CallNode)
           receiver.message
         else
-          receiver&.slice
+          receiver.slice
         end
 
         if raw_receiver

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 2024-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -30,7 +30,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -40,7 +40,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -111,6 +111,7 @@ files:
 - lib/ruby_indexer/test/configuration_test.rb
 - lib/ruby_indexer/test/constant_test.rb
 - lib/ruby_indexer/test/enhancements_test.rb
+- lib/ruby_indexer/test/global_variable_test.rb
 - lib/ruby_indexer/test/index_test.rb
 - lib/ruby_indexer/test/instance_variables_test.rb
 - lib/ruby_indexer/test/method_test.rb
@@ -154,6 +155,8 @@ files:
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
 - lib/ruby_lsp/requests/prepare_type_hierarchy.rb
+- lib/ruby_lsp/requests/range_formatting.rb
+- lib/ruby_lsp/requests/references.rb
 - lib/ruby_lsp/requests/rename.rb
 - lib/ruby_lsp/requests/request.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
@@ -209,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.20
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby