ruby-lsp 0.19.1 → 0.20.0

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -9,14 +9,14 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           return unless owner
           return unless node.name == :extend
 
           arguments = node.arguments&.arguments
           return unless arguments
 
-          location = node.location
+          location = Location.from_prism_location(node.location, code_units_cache)
 
           arguments.each do |node|
             next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
@@ -39,7 +39,6 @@ module RubyIndexer
               location,
               location,
               nil,
-              index.configuration.encoding,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
               Entry::Visibility::PUBLIC,
               owner,
@@ -102,7 +101,7 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           return unless owner
 
           name = node.name
@@ -114,7 +113,7 @@ module RubyIndexer
           association_name = arguments.first
           return unless association_name.is_a?(Prism::SymbolNode)
 
-          location = association_name.location
+          location = Location.from_prism_location(association_name.location, code_units_cache)
 
           index.add(Entry::Method.new(
             T.must(association_name.value),
@@ -122,7 +121,6 @@ module RubyIndexer
             location,
             location,
             nil,
-            index.configuration.encoding,
             [],
             Entry::Visibility::PUBLIC,
             owner,
@@ -166,7 +164,7 @@ module RubyIndexer
       enhancement_class = Class.new do
         include Enhancement
 
-        def on_call_node(index, owner, node, file_path)
+        def on_call_node(index, owner, node, file_path, code_units_cache)
           raise "Error"
         end
 

data/lib/ruby_indexer/test/global_variable_test.rb

@@ -0,0 +1,49 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class GlobalVariableTest < TestCase
+    def test_global_variable_and_write
+      index(<<~RUBY)
+        $foo &&= 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_operator_write
+      index(<<~RUBY)
+        $foo += 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_or_write
+      index(<<~RUBY)
+        $foo ||= 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+
+    def test_global_variable_target_node
+      index(<<~RUBY)
+        $foo, $bar = 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+      assert_entry("$bar", Entry::GlobalVariable, "/fake/path/foo.rb:0-6:0-10")
+    end
+
+    def test_global_variable_write
+      index(<<~RUBY)
+        $foo = 1
+      RUBY
+
+      assert_entry("$foo", Entry::GlobalVariable, "/fake/path/foo.rb:0-0:0-4")
+    end
+  end
+end

data/lib/ruby_lsp/erb_document.rb

@@ -6,10 +6,18 @@ module RubyLsp
     extend T::Sig
     extend T::Generic
 
+    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+
     sig { returns(String) }
     attr_reader :host_language_source
 
-    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+    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)
@@ -17,6 +25,10 @@ module RubyLsp
       # overrides this with the proper virtual host language source
       @host_language_source = T.let("", String)
       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) }
@@ -30,6 +42,7 @@ module RubyLsp
       # Use partial script to avoid syntax errors in ERB files where keywords may be used without the full context in
       # which they will be evaluated
       @parse_result = Prism.parse(scanner.ruby, partial_script: true)
+      @code_units_cache = @parse_result.code_units_cache(@encoding)
       true
     end
 
@@ -53,8 +66,8 @@ module RubyLsp
       RubyDocument.locate(
         @parse_result.value,
         create_scanner.find_char_position(position),
+        code_units_cache: @code_units_cache,
         node_types: node_types,
-        encoding: @encoding,
       )
     end
 

data/lib/ruby_lsp/listeners/definition.rb

@@ -39,6 +39,7 @@ module RubyLsp
           :on_block_argument_node_enter,
           :on_constant_read_node_enter,
           :on_constant_path_node_enter,
+          :on_global_variable_read_node_enter,
           :on_instance_variable_read_node_enter,
           :on_instance_variable_write_node_enter,
           :on_instance_variable_and_write_node_enter,
@@ -120,6 +121,25 @@ module RubyLsp
         find_in_index(name)
       end
 
+      sig { params(node: Prism::GlobalVariableReadNode).void }
+      def on_global_variable_read_node_enter(node)
+        entries = @index[node.name.to_s]
+
+        return unless entries
+
+        entries.each do |entry|
+          location = entry.location
+
+          @response_builder << Interface::Location.new(
+            uri: URI::Generic.from_path(path: entry.file_path).to_s,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+            ),
+          )
+        end
+      end
+
       sig { params(node: Prism::InstanceVariableReadNode).void }
       def on_instance_variable_read_node_enter(node)
         handle_instance_variable_definition(node.name.to_s)

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -239,10 +239,10 @@ module RubyLsp
         statements = node.statements
         return unless statements
 
-        body = statements.body
-        return if body.empty?
+        statement = statements.body.last
+        return unless statement
 
-        add_lines_range(node.location.start_line, body.last.location.end_line)
+        add_lines_range(node.location.start_line, statement.location.end_line)
       end
 
       sig { params(node: Prism::Node).void }

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -99,7 +99,13 @@ module RubyLsp
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = RubyDocument
-          .locate(@document.parse_result.value, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
+          .locate(@document.parse_result.value,
+            start_index,
+            node_types: [
+              Prism::StatementsNode,
+              Prism::BlockNode,
+            ],
+            code_units_cache: @document.code_units_cache)
 
         closest_statements = node_context.node
         parent_statements = node_context.parent
@@ -196,7 +202,7 @@ module RubyLsp
           @document.parse_result.value,
           start_index,
           node_types: [Prism::DefNode],
-          encoding: @global_state.encoding,
+          code_units_cache: @document.code_units_cache,
         )
         closest_node = node_context.node
         return Error::InvalidTargetRange unless closest_node

data/lib/ruby_lsp/requests/completion.rb

@@ -57,7 +57,7 @@ module RubyLsp
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
           ],
-          encoding: global_state.encoding,
+          code_units_cache: document.code_units_cache,
         )
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,

data/lib/ruby_lsp/requests/definition.rb

@@ -46,6 +46,7 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::BlockArgumentNode,
+            Prism::GlobalVariableReadNode,
             Prism::InstanceVariableReadNode,
             Prism::InstanceVariableAndWriteNode,
             Prism::InstanceVariableOperatorWriteNode,
@@ -57,7 +58,7 @@ module RubyLsp
             Prism::SuperNode,
             Prism::ForwardingSuperNode,
           ],
-          encoding: global_state.encoding,
+          code_units_cache: document.code_units_cache,
         )
 
         target = node_context.node

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -28,7 +28,11 @@ 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, encoding: global_state.encoding)
+        node_context = RubyDocument.locate(
+          document.parse_result.value,
+          char_position,
+          code_units_cache: document.code_units_cache,
+        )
 
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,

data/lib/ruby_lsp/requests/hover.rb

@@ -41,7 +41,7 @@ module RubyLsp
           document.parse_result.value,
           char_position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
-          encoding: global_state.encoding,
+          code_units_cache: document.code_units_cache,
         )
         target = node_context.node
         parent = node_context.parent

data/lib/ruby_lsp/requests/range_formatting.rb

@@ -34,16 +34,18 @@ module RubyLsp
         )
         return unless formatted_text
 
+        code_units_cache = @document.code_units_cache
+
         [
           Interface::TextEdit.new(
             range: Interface::Range.new(
               start: Interface::Position.new(
                 line: location.start_line - 1,
-                character: location.start_code_units_column(@document.encoding),
+                character: location.cached_start_code_units_column(code_units_cache),
               ),
               end: Interface::Position.new(
                 line: location.end_line - 1,
-                character: location.end_code_units_column(@document.encoding),
+                character: location.cached_end_code_units_column(code_units_cache),
               ),
             ),
             new_text: formatted_text.strip,

data/lib/ruby_lsp/requests/references.rb

@@ -42,7 +42,7 @@ module RubyLsp
             Prism::CallNode,
             Prism::DefNode,
           ],
-          encoding: @global_state.encoding,
+          code_units_cache: @document.code_units_cache,
         )
         target = node_context.node
         parent = node_context.parent

data/lib/ruby_lsp/requests/rename.rb

@@ -37,7 +37,7 @@ module RubyLsp
           @document.parse_result.value,
           char_position,
           node_types: [Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode],
-          encoding: @global_state.encoding,
+          code_units_cache: @document.code_units_cache,
         )
         target = node_context.node
         parent = node_context.parent

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -101,7 +101,7 @@ module RubyLsp
         @range = range
         @result_id = T.let(SemanticHighlighting.next_result_id.to_s, String)
         @response_builder = T.let(
-          ResponseBuilders::SemanticHighlighting.new(global_state.encoding),
+          ResponseBuilders::SemanticHighlighting.new(document.code_units_cache),
           ResponseBuilders::SemanticHighlighting,
         )
         Listeners::SemanticHighlighting.new(dispatcher, @response_builder)

data/lib/ruby_lsp/requests/signature_help.rb

@@ -43,7 +43,7 @@ module RubyLsp
           document.parse_result.value,
           char_position,
           node_types: [Prism::CallNode],
-          encoding: global_state.encoding,
+          code_units_cache: document.code_units_cache,
         )
 
         target = adjust_for_nested_target(node_context.node, node_context.parent, position)

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

@@ -159,7 +159,7 @@ module RubyLsp
         def namespace_constant_name(node)
           path = node.constant_path
           case path
-          when Prism::ConstantPathNode, Prism::ConstantReadNode, Prism::ConstantPathTargetNode
+          when Prism::ConstantPathNode, Prism::ConstantReadNode
             constant_name(path)
           end
         end

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

@@ -47,12 +47,6 @@ module RubyLsp
 
         class ConfigurationError < StandardError; end
 
-        sig { returns(T::Array[RuboCop::Cop::Offense]) }
-        attr_reader :offenses
-
-        sig { returns(::RuboCop::Config) }
-        attr_reader :config_for_working_directory
-
         DEFAULT_ARGS = T.let(
           [
             "--stderr", # Print any output to stderr so that our stdout does not get polluted
@@ -63,6 +57,12 @@ module RubyLsp
           T::Array[String],
         )
 
+        sig { returns(T::Array[RuboCop::Cop::Offense]) }
+        attr_reader :offenses
+
+        sig { returns(::RuboCop::Config) }
+        attr_reader :config_for_working_directory
+
         begin
           RuboCop::Options.new.parse(["--raise-cop-error"])
           DEFAULT_ARGS << "--raise-cop-error"

data/lib/ruby_lsp/response_builders/document_symbol.rb

@@ -4,6 +4,8 @@
 module RubyLsp
   module ResponseBuilders
     class DocumentSymbol < ResponseBuilder
+      extend T::Sig
+
       ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
 
       class SymbolHierarchyRoot
@@ -18,8 +20,6 @@ module RubyLsp
         end
       end
 
-      extend T::Sig
-
       sig { void }
       def initialize
         super

data/lib/ruby_lsp/response_builders/hover.rb

@@ -4,11 +4,11 @@
 module RubyLsp
   module ResponseBuilders
     class Hover < ResponseBuilder
-      ResponseType = type_member { { fixed: String } }
-
       extend T::Sig
       extend T::Generic
 
+      ResponseType = type_member { { fixed: String } }
+
       sig { void }
       def initialize
         super

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -6,6 +6,8 @@ module RubyLsp
     class SemanticHighlighting < ResponseBuilder
       class UndefinedTokenType < StandardError; end
 
+      extend T::Sig
+
       TOKEN_TYPES = T.let(
         {
           namespace: 0,
@@ -51,25 +53,29 @@ module RubyLsp
         T::Hash[Symbol, Integer],
       )
 
-      extend T::Sig
-
       ResponseType = type_member { { fixed: Interface::SemanticTokens } }
 
-      sig { params(encoding: Encoding).void }
-      def initialize(encoding)
+      sig do
+        params(code_units_cache: T.any(
+          T.proc.params(arg0: Integer).returns(Integer),
+          Prism::CodeUnitsCache,
+        )).void
+      end
+      def initialize(code_units_cache)
         super()
-        @encoding = encoding
+        @code_units_cache = code_units_cache
         @stack = T.let([], T::Array[SemanticToken])
       end
 
       sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
-        length = location.end_code_units_offset(@encoding) - location.start_code_units_offset(@encoding)
+        end_code_unit = location.cached_end_code_units_offset(@code_units_cache)
+        length = end_code_unit - location.cached_start_code_units_offset(@code_units_cache)
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
         @stack.push(
           SemanticToken.new(
             start_line: location.start_line,
-            start_code_unit_column: location.start_code_units_column(@encoding),
+            start_code_unit_column: location.cached_start_code_units_column(@code_units_cache),
             length: length,
             type: T.must(TOKEN_TYPES[type]),
             modifier: modifiers_indices,
@@ -83,7 +89,7 @@ module RubyLsp
         return false unless token
 
         token.start_line == location.start_line &&
-          token.start_code_unit_column == location.start_code_units_column(@encoding)
+          token.start_code_unit_column == location.cached_start_code_units_column(@code_units_cache)
       end
 
       sig { returns(T.nilable(SemanticToken)) }

data/lib/ruby_lsp/response_builders/signature_help.rb

@@ -4,10 +4,10 @@
 module RubyLsp
   module ResponseBuilders
     class SignatureHelp < ResponseBuilder
-      ResponseType = type_member { { fixed: T.nilable(Interface::SignatureHelp) } }
-
       extend T::Sig
 
+      ResponseType = type_member { { fixed: T.nilable(Interface::SignatureHelp) } }
+
       sig { void }
       def initialize
         super

data/lib/ruby_lsp/ruby_document.rb

@@ -25,11 +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)],
-          encoding: Encoding,
         ).returns(NodeContext)
       end
-      def locate(node, char_position, node_types: [], encoding: Encoding::UTF_8)
+      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))
@@ -62,8 +65,8 @@ module RubyLsp
 
           # Skip if the current node doesn't cover the desired position
           loc = candidate.location
-          loc_start_offset = loc.start_code_units_offset(encoding)
-          loc_end_offset = loc.end_code_units_offset(encoding)
+          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
@@ -74,7 +77,7 @@ module RubyLsp
           # and need to pop the stack
           previous_level = nesting_nodes.last
           if previous_level &&
-              (loc_start_offset > previous_level.location.end_code_units_offset(encoding))
+              (loc_start_offset > previous_level.location.cached_end_code_units_offset(code_units_cache))
             nesting_nodes.pop
           end
 
@@ -89,10 +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_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))
+            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
@@ -102,8 +105,8 @@ 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
-          closest_node_start_offset = closest_loc.start_code_units_offset(encoding)
-          closest_node_end_offset = closest_loc.end_code_units_offset(encoding)
+          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
@@ -131,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
 
@@ -214,8 +235,8 @@ module RubyLsp
       RubyDocument.locate(
         @parse_result.value,
         create_scanner.find_char_position(position),
+        code_units_cache: @code_units_cache,
         node_types: node_types,
-        encoding: @encoding,
       )
     end
   end

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.1
+  version: 0.20.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-04 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
@@ -211,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