ruby-lsp 0.19.1 → 0.20.1

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
@@ -78,6 +78,8 @@ module RubyLsp
 
           parse_result = Prism.parse_file(path)
           collect_references(reference_target, parse_result, uri)
+        rescue Errno::EISDIR, Errno::ENOENT
+          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
         end
 
         @store.each do |_uri, document|

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
@@ -147,6 +147,8 @@ module RubyLsp
           parse_result = Prism.parse_file(path)
           edits = collect_changes(target, parse_result, name, uri)
           changes[uri.to_s] = edits unless edits.empty?
+        rescue Errno::EISDIR, Errno::ENOENT
+          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
         end
 
         @store.each do |uri, document|

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

@@ -48,7 +48,9 @@ module RubyLsp
       @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
       @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
 
-      @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
+      dependencies, bundler_version = load_dependencies
+      @dependencies = T.let(dependencies, T::Hash[String, T.untyped])
+      @bundler_version = T.let(bundler_version, T.nilable(Gem::Version))
       @rails_app = T.let(rails_app?, T::Boolean)
       @retry = T.let(false, T::Boolean)
     end
@@ -156,14 +158,15 @@ module RubyLsp
       @custom_gemfile.write(content) unless @custom_gemfile.exist? && @custom_gemfile.read == content
     end
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    sig { returns([T::Hash[String, T.untyped], T.nilable(Gem::Version)]) }
     def load_dependencies
-      return {} unless @lockfile&.exist?
+      return [{}, nil] unless @lockfile&.exist?
 
       # We need to parse the Gemfile.lock manually here. If we try to do `bundler/setup` to use something more
       # convenient, we may end up with issues when the globally installed `ruby-lsp` version mismatches the one included
       # in the `Gemfile`
-      dependencies = Bundler::LockfileParser.new(@lockfile.read).dependencies
+      lockfile_parser = Bundler::LockfileParser.new(@lockfile.read)
+      dependencies = lockfile_parser.dependencies
 
       # When working on a gem, the `ruby-lsp` might be listed as a dependency in the gemspec. We need to make sure we
       # check those as well or else we may get version mismatch errors. Notice that bundler allows more than one
@@ -172,7 +175,7 @@ module RubyLsp
         dependencies.merge!(Bundler.load_gemspec(path).dependencies.to_h { |dep| [dep.name, dep] })
       end
 
-      dependencies
+      [dependencies, lockfile_parser.bundler_version]
     end
 
     sig { params(bundle_gemfile: T.nilable(Pathname)).returns(T::Hash[String, String]) }
@@ -188,6 +191,16 @@ module RubyLsp
         env["BUNDLE_PATH"] = File.expand_path(env["BUNDLE_PATH"], @project_path)
       end
 
+      # If there's a Bundler version locked, then we need to use that one to run bundle commands, so that the composed
+      # lockfile is also locked to the same version. This avoids Bundler restarts on version mismatches
+      base_bundle = if @bundler_version
+        env["BUNDLER_VERSION"] = @bundler_version.to_s
+        install_bundler_if_needed
+        "bundle _#{@bundler_version}_"
+      else
+        "bundle"
+      end
+
       # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
       # to upgrade them or else we'll produce undesired source control changes. If the custom bundle was just created
       # and any of `ruby-lsp`, `ruby-lsp-rails` or `debug` weren't a part of the Gemfile, then we need to run `bundle
@@ -196,13 +209,13 @@ module RubyLsp
 
       # When not updating, we run `(bundle check || bundle install)`
       # When updating, we run `((bundle check && bundle update ruby-lsp debug) || bundle install)`
-      command = +"(bundle check"
+      command = +"(#{base_bundle} check"
 
       if should_bundle_update?
         # If any of `ruby-lsp`, `ruby-lsp-rails` or `debug` are not in the Gemfile, try to update them to the latest
         # version
         command.prepend("(")
-        command << " && bundle update "
+        command << " && #{base_bundle} update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
         command << "ruby-lsp-rails " if @rails_app && !@dependencies["ruby-lsp-rails"]
@@ -212,7 +225,7 @@ module RubyLsp
         @last_updated_path.write(Time.now.iso8601)
       end
 
-      command << " || bundle install) "
+      command << " || #{base_bundle} install) "
 
       # Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
       # responses
@@ -259,6 +272,15 @@ module RubyLsp
       end
     end
 
+    sig { void }
+    def install_bundler_if_needed
+      # Try to find the bundler version specified in the lockfile in installed gems. If not found, install it
+      requirement = Gem::Requirement.new(@bundler_version.to_s)
+      return if Gem::Specification.any? { |s| s.name == "bundler" && requirement =~ s.version }
+
+      Gem.install("bundler", @bundler_version.to_s)
+    end
+
     sig { returns(T::Boolean) }
     def should_bundle_update?
       # If `ruby-lsp`, `ruby-lsp-rails` and `debug` are in the Gemfile, then we shouldn't try to upgrade them or else it

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.1
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-04 00:00:00.000000000 Z
+date: 2024-10-16 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