ruby-lsp 0.20.1 → 0.21.0

data/lib/ruby_lsp/base_server.rb

@@ -8,9 +8,11 @@ module RubyLsp
 
     abstract!
 
-    sig { params(test_mode: T::Boolean).void }
-    def initialize(test_mode: false)
-      @test_mode = T.let(test_mode, T::Boolean)
+    sig { params(options: T.untyped).void }
+    def initialize(**options)
+      @test_mode = T.let(options[:test_mode], T.nilable(T::Boolean))
+      @setup_error = T.let(options[:setup_error], T.nilable(StandardError))
+      @install_error = T.let(options[:install_error], T.nilable(StandardError))
       @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
       @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
       @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
@@ -22,7 +24,7 @@ module RubyLsp
       @store = T.let(Store.new, Store)
       @outgoing_dispatcher = T.let(
         Thread.new do
-          unless test_mode
+          unless @test_mode
             while (message = @outgoing_queue.pop)
               @mutex.synchronize { @writer.write(message.to_hash) }
             end
@@ -33,6 +35,11 @@ module RubyLsp
 
       @global_state = T.let(GlobalState.new, GlobalState)
       Thread.main.priority = 1
+
+      # We read the initialize request in `exe/ruby-lsp` to be able to determine the workspace URI where Bundler should
+      # be set up
+      initialize_request = options[:initialize_request]
+      process_message(initialize_request) if initialize_request
     end
 
     sig { void }
@@ -59,7 +66,9 @@ module RubyLsp
                 # If the client supports request delegation and we're working with an ERB document and there was
                 # something to parse, then we have to maintain the client updated about the virtual state of the host
                 # language source
-                if document.parse! && @global_state.supports_request_delegation && document.is_a?(ERBDocument)
+                if document.parse! && @global_state.client_capabilities.supports_request_delegation &&
+                    document.is_a?(ERBDocument)
+
                   send_message(
                     Notification.new(
                       method: "delegate/textDocument/virtualState",

data/lib/ruby_lsp/client_capabilities.rb

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # This class stores all client capabilities that the Ruby LSP and its add-ons depend on to ensure that we're
+  # not enabling functionality unsupported by the editor connecting to the server
+  class ClientCapabilities
+    extend T::Sig
+
+    sig { returns(T::Boolean) }
+    attr_reader :supports_watching_files,
+      :supports_request_delegation,
+      :window_show_message_supports_extra_properties
+
+    sig { void }
+    def initialize
+      # The editor supports watching files. This requires two capabilities: dynamic registration and relative pattern
+      # support
+      @supports_watching_files = T.let(false, T::Boolean)
+
+      # The editor supports request delegation. This is an experimental capability since request delegation has not been
+      # standardized into the LSP spec yet
+      @supports_request_delegation = T.let(false, T::Boolean)
+
+      # The editor supports extra arbitrary properties for `window/showMessageRequest`. Necessary for add-ons to show
+      # dialogs with user interactions
+      @window_show_message_supports_extra_properties = T.let(false, T::Boolean)
+
+      # Which resource operations the editor supports, like renaming files
+      @supported_resource_operations = T.let([], T::Array[String])
+    end
+
+    sig { params(capabilities: T::Hash[Symbol, T.untyped]).void }
+    def apply_client_capabilities(capabilities)
+      workspace_capabilities = capabilities[:workspace] || {}
+
+      file_watching_caps = workspace_capabilities[:didChangeWatchedFiles]
+      if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
+        @supports_watching_files = true
+      end
+
+      @supports_request_delegation = capabilities.dig(:experimental, :requestDelegation) || false
+      supported_resource_operations = workspace_capabilities.dig(:workspaceEdit, :resourceOperations)
+      @supported_resource_operations = supported_resource_operations if supported_resource_operations
+
+      supports_additional_properties = capabilities.dig(
+        :window,
+        :showMessage,
+        :messageActionItem,
+        :additionalPropertiesSupport,
+      )
+      @window_show_message_supports_extra_properties = supports_additional_properties || false
+    end
+
+    sig { returns(T::Boolean) }
+    def supports_rename?
+      @supported_resource_operations.include?("rename")
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -63,7 +63,7 @@ module RubyLsp
     sig { abstract.returns(LanguageId) }
     def language_id; end
 
-    # TODO: remove this method once all nonpositional requests have been migrated to the listener pattern
+    # TODO: remove this method once all non-positional requests have been migrated to the listener pattern
     sig do
       type_parameters(:T)
         .params(

data/lib/ruby_lsp/global_state.rb

@@ -21,14 +21,14 @@ module RubyLsp
     attr_reader :encoding
 
     sig { returns(T::Boolean) }
-    attr_reader :supports_watching_files, :experimental_features, :supports_request_delegation
-
-    sig { returns(T::Array[String]) }
-    attr_reader :supported_resource_operations
+    attr_reader :experimental_features, :top_level_bundle
 
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
 
+    sig { returns(ClientCapabilities) }
+    attr_reader :client_capabilities
+
     sig { void }
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
@@ -40,12 +40,19 @@ module RubyLsp
       @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
-      @supports_watching_files = T.let(false, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
       @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @addon_settings = T.let({}, T::Hash[String, T.untyped])
-      @supports_request_delegation = T.let(false, T::Boolean)
-      @supported_resource_operations = T.let([], T::Array[String])
+      @top_level_bundle = T.let(
+        begin
+          Bundler.with_original_env { Bundler.default_gemfile }
+          true
+        rescue Bundler::GemfileNotFound, Bundler::GitError
+          false
+        end,
+        T::Boolean,
+      )
+      @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -123,12 +130,8 @@ module RubyLsp
       end
       @index.configuration.encoding = @encoding
 
-      file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
-      if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
-        @supports_watching_files = true
-      end
-
       @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
+      @client_capabilities.apply_client_capabilities(options[:capabilities]) if options[:capabilities]
 
       addon_settings = options.dig(:initializationOptions, :addonSettings)
       if addon_settings
@@ -136,10 +139,6 @@ module RubyLsp
         @addon_settings.merge!(addon_settings)
       end
 
-      @supports_request_delegation = options.dig(:capabilities, :experimental, :requestDelegation) || false
-      supported_resource_operations = options.dig(:capabilities, :workspace, :workspaceEdit, :resourceOperations)
-      @supported_resource_operations = supported_resource_operations if supported_resource_operations
-
       notifications
     end
 
@@ -231,14 +230,16 @@ module RubyLsp
     sig { returns(T::Array[String]) }
     def gather_direct_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
-      Bundler.locked_gems.dependencies.keys + gemspec_dependencies
+
+      dependencies = Bundler.locked_gems&.dependencies&.keys || []
+      dependencies + gemspec_dependencies
     rescue Bundler::GemfileNotFound
       []
     end
 
     sig { returns(T::Array[String]) }
     def gemspec_dependencies
-      Bundler.locked_gems.sources
+      (Bundler.locked_gems&.sources || [])
         .grep(Bundler::Source::Gemspec)
         .flat_map { _1.gemspec&.dependencies&.map(&:name) }
     end
@@ -246,7 +247,7 @@ module RubyLsp
     sig { returns(T::Array[String]) }
     def gather_direct_and_indirect_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
-      Bundler.locked_gems.specs.map(&:name)
+      Bundler.locked_gems&.specs&.map(&:name) || []
     rescue Bundler::GemfileNotFound
       []
     end

data/lib/ruby_lsp/internal.rb

@@ -12,6 +12,7 @@ require "sorbet-runtime"
 require "bundler"
 Bundler.ui.level = :silent
 
+require "json"
 require "uri"
 require "cgi"
 require "set"
@@ -28,6 +29,7 @@ require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/static_docs"
 require "ruby_lsp/scope"
+require "ruby_lsp/client_capabilities"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
 require "ruby_lsp/type_inferrer"

data/lib/ruby_lsp/listeners/completion.rb

@@ -85,6 +85,12 @@ module RubyLsp
           :on_constant_path_node_enter,
           :on_constant_read_node_enter,
           :on_call_node_enter,
+          :on_global_variable_and_write_node_enter,
+          :on_global_variable_operator_write_node_enter,
+          :on_global_variable_or_write_node_enter,
+          :on_global_variable_read_node_enter,
+          :on_global_variable_target_node_enter,
+          :on_global_variable_write_node_enter,
           :on_instance_variable_read_node_enter,
           :on_instance_variable_write_node_enter,
           :on_instance_variable_and_write_node_enter,
@@ -180,6 +186,36 @@ module RubyLsp
         end
       end
 
+      sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+      def on_global_variable_and_write_node_enter(node)
+        handle_global_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+      def on_global_variable_operator_write_node_enter(node)
+        handle_global_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+      def on_global_variable_or_write_node_enter(node)
+        handle_global_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::GlobalVariableReadNode).void }
+      def on_global_variable_read_node_enter(node)
+        handle_global_variable_completion(node.name.to_s, node.location)
+      end
+
+      sig { params(node: Prism::GlobalVariableTargetNode).void }
+      def on_global_variable_target_node_enter(node)
+        handle_global_variable_completion(node.name.to_s, node.location)
+      end
+
+      sig { params(node: Prism::GlobalVariableWriteNode).void }
+      def on_global_variable_write_node_enter(node)
+        handle_global_variable_completion(node.name.to_s, node.name_loc)
+      end
+
       sig { params(node: Prism::InstanceVariableReadNode).void }
       def on_instance_variable_read_node_enter(node)
         handle_instance_variable_completion(node.name.to_s, node.location)
@@ -267,6 +303,29 @@ module RubyLsp
         end
       end
 
+      sig { params(name: String, location: Prism::Location).void }
+      def handle_global_variable_completion(name, location)
+        candidates = @index.prefix_search(name)
+
+        return if candidates.none?
+
+        range = range_from_location(location)
+
+        candidates.flatten.uniq(&:name).each do |entry|
+          entry_name = entry.name
+
+          @response_builder << Interface::CompletionItem.new(
+            label: entry_name,
+            filter_text: entry_name,
+            label_details: Interface::CompletionItemLabelDetails.new(
+              description: entry.file_name,
+            ),
+            text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
+            kind: Constant::CompletionItemKind::VARIABLE,
+          )
+        end
+      end
+
       sig { params(name: String, location: Prism::Location).void }
       def handle_instance_variable_completion(name, location)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
@@ -381,8 +440,11 @@ module RubyLsp
         return unless range
 
         guessed_type = type.is_a?(TypeInferrer::GuessedType) && type.name
+        external_references = @node_context.fully_qualified_name != type.name
 
         @index.method_completion_candidates(method_name, type.name).each do |entry|
+          next if entry.visibility != RubyIndexer::Entry::Visibility::PUBLIC && external_references
+
           entry_name = entry.name
           owner_name = entry.owner&.name
 

data/lib/ruby_lsp/listeners/definition.rb

@@ -39,7 +39,12 @@ module RubyLsp
           :on_block_argument_node_enter,
           :on_constant_read_node_enter,
           :on_constant_path_node_enter,
+          :on_global_variable_and_write_node_enter,
+          :on_global_variable_operator_write_node_enter,
+          :on_global_variable_or_write_node_enter,
           :on_global_variable_read_node_enter,
+          :on_global_variable_target_node_enter,
+          :on_global_variable_write_node_enter,
           :on_instance_variable_read_node_enter,
           :on_instance_variable_write_node_enter,
           :on_instance_variable_and_write_node_enter,
@@ -121,23 +126,34 @@ module RubyLsp
         find_in_index(name)
       end
 
+      sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+      def on_global_variable_and_write_node_enter(node)
+        handle_global_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+      def on_global_variable_operator_write_node_enter(node)
+        handle_global_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+      def on_global_variable_or_write_node_enter(node)
+        handle_global_variable_definition(node.name.to_s)
+      end
+
       sig { params(node: Prism::GlobalVariableReadNode).void }
       def on_global_variable_read_node_enter(node)
-        entries = @index[node.name.to_s]
-
-        return unless entries
+        handle_global_variable_definition(node.name.to_s)
+      end
 
-        entries.each do |entry|
-          location = entry.location
+      sig { params(node: Prism::GlobalVariableTargetNode).void }
+      def on_global_variable_target_node_enter(node)
+        handle_global_variable_definition(node.name.to_s)
+      end
 
-          @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
+      sig { params(node: Prism::GlobalVariableWriteNode).void }
+      def on_global_variable_write_node_enter(node)
+        handle_global_variable_definition(node.name.to_s)
       end
 
       sig { params(node: Prism::InstanceVariableReadNode).void }
@@ -197,6 +213,25 @@ module RubyLsp
         )
       end
 
+      sig { params(name: String).void }
+      def handle_global_variable_definition(name)
+        entries = @index[name]
+
+        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(name: String).void }
       def handle_instance_variable_definition(name)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able

data/lib/ruby_lsp/listeners/hover.rb

@@ -13,6 +13,12 @@ module RubyLsp
           Prism::ConstantReadNode,
           Prism::ConstantWriteNode,
           Prism::ConstantPathNode,
+          Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode,
+          Prism::GlobalVariableReadNode,
+          Prism::GlobalVariableTargetNode,
+          Prism::GlobalVariableWriteNode,
           Prism::InstanceVariableReadNode,
           Prism::InstanceVariableAndWriteNode,
           Prism::InstanceVariableOperatorWriteNode,
@@ -62,6 +68,12 @@ module RubyLsp
           :on_constant_write_node_enter,
           :on_constant_path_node_enter,
           :on_call_node_enter,
+          :on_global_variable_and_write_node_enter,
+          :on_global_variable_operator_write_node_enter,
+          :on_global_variable_or_write_node_enter,
+          :on_global_variable_read_node_enter,
+          :on_global_variable_target_node_enter,
+          :on_global_variable_write_node_enter,
           :on_instance_variable_read_node_enter,
           :on_instance_variable_write_node_enter,
           :on_instance_variable_and_write_node_enter,
@@ -128,6 +140,36 @@ module RubyLsp
         handle_method_hover(message)
       end
 
+      sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+      def on_global_variable_and_write_node_enter(node)
+        handle_global_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+      def on_global_variable_operator_write_node_enter(node)
+        handle_global_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+      def on_global_variable_or_write_node_enter(node)
+        handle_global_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::GlobalVariableReadNode).void }
+      def on_global_variable_read_node_enter(node)
+        handle_global_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::GlobalVariableTargetNode).void }
+      def on_global_variable_target_node_enter(node)
+        handle_global_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::GlobalVariableWriteNode).void }
+      def on_global_variable_write_node_enter(node)
+        handle_global_variable_hover(node.name.to_s)
+      end
+
       sig { params(node: Prism::InstanceVariableReadNode).void }
       def on_instance_variable_read_node_enter(node)
         handle_instance_variable_hover(node.name.to_s)
@@ -265,6 +307,16 @@ module RubyLsp
         # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
+      sig { params(name: String).void }
+      def handle_global_variable_hover(name)
+        entries = @index[name]
+        return unless entries
+
+        categorized_markdown_from_index_entries(name, entries).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      end
+
       sig { params(name: String, location: Prism::Location).void }
       def generate_hover(name, location)
         entries = @index.resolve(name, @node_context.nesting)

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -121,7 +121,7 @@ module RubyLsp
         return Error::InvalidTargetRange if closest_node.is_a?(Prism::MissingNode)
 
         closest_node_loc = closest_node.location
-        # If the parent expression is a single line block, then we have to extract it inside of the oneline block
+        # If the parent expression is a single line block, then we have to extract it inside of the one-line block
         if parent_statements.is_a?(Prism::BlockNode) &&
             parent_statements.location.start_line == parent_statements.location.end_line
 

data/lib/ruby_lsp/requests/completion.rb

@@ -17,7 +17,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
-            trigger_characters: ["/", "\"", "'", ":", "@", ".", "=", "<"],
+            trigger_characters: ["/", "\"", "'", ":", "@", ".", "=", "<", "$"],
             completion_item: {
               labelDetailsSupport: true,
             },
@@ -50,6 +50,12 @@ module RubyLsp
             Prism::CallNode,
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
+            Prism::GlobalVariableAndWriteNode,
+            Prism::GlobalVariableOperatorWriteNode,
+            Prism::GlobalVariableOrWriteNode,
+            Prism::GlobalVariableReadNode,
+            Prism::GlobalVariableTargetNode,
+            Prism::GlobalVariableWriteNode,
             Prism::InstanceVariableReadNode,
             Prism::InstanceVariableAndWriteNode,
             Prism::InstanceVariableOperatorWriteNode,

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -34,7 +34,7 @@ module RubyLsp
 
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
-        # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behaviour might
+        # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behavior might
         # be broken.
         #
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the

data/lib/ruby_lsp/requests/definition.rb

@@ -12,12 +12,6 @@ module RubyLsp
       extend T::Sig
       extend T::Generic
 
-      SPECIAL_METHOD_CALLS = [
-        :require,
-        :require_relative,
-        :autoload,
-      ].freeze
-
       sig do
         params(
           document: T.any(RubyDocument, ERBDocument),
@@ -46,7 +40,12 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::BlockArgumentNode,
+            Prism::GlobalVariableAndWriteNode,
+            Prism::GlobalVariableOperatorWriteNode,
+            Prism::GlobalVariableOrWriteNode,
             Prism::GlobalVariableReadNode,
+            Prism::GlobalVariableTargetNode,
+            Prism::GlobalVariableWriteNode,
             Prism::InstanceVariableReadNode,
             Prism::InstanceVariableAndWriteNode,
             Prism::InstanceVariableOperatorWriteNode,
@@ -72,11 +71,7 @@ module RubyLsp
             parent,
             position,
           )
-        elsif target.is_a?(Prism::CallNode) && !SPECIAL_METHOD_CALLS.include?(target.message) && !covers_position?(
-          target.message_loc, position
-        )
-          # If the target is a method call, we need to ensure that the requested position is exactly on top of the
-          # method identifier. Otherwise, we risk showing definitions for unrelated things
+        elsif position_outside_target?(position, target)
           target = nil
         # For methods with block arguments using symbol-to-proc
         elsif target.is_a?(Prism::SymbolNode) && parent.is_a?(Prism::BlockArgumentNode)
@@ -107,6 +102,26 @@ module RubyLsp
         @dispatcher.dispatch_once(@target) if @target
         @response_builder.response
       end
+
+      private
+
+      sig { params(position: T::Hash[Symbol, T.untyped], target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def position_outside_target?(position, target)
+        case target
+        when Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode,
+          Prism::GlobalVariableWriteNode,
+          Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableWriteNode
+
+          !covers_position?(target.name_loc, position)
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -10,7 +10,8 @@ module RubyLsp
     # informs the editor of all the important symbols, such as classes, variables, and methods, defined in a file. With
     # this information, the editor can populate breadcrumbs, file outline and allow for fuzzy symbol searches.
     #
-    # In VS Code, fuzzy symbol search can be accessed by opening the command palette and inserting an `@` symbol.
+    # In VS Code, symbol search known as 'Go To Symbol in Editor' and can be accessed with Ctrl/Cmd-Shift-O,
+    # or by opening the command palette and inserting an `@` symbol.
     class DocumentSymbol < Request
       extend T::Sig
 

data/lib/ruby_lsp/requests/hover.rb

@@ -46,17 +46,13 @@ module RubyLsp
         target = node_context.node
         parent = node_context.parent
 
-        if (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-            !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
-            (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+        if should_refine_target?(parent, target)
           target = determine_target(
             T.must(target),
             T.must(parent),
             position,
           )
-        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
-            !covers_position?(target.message_loc, position)
-
+        elsif position_outside_target?(position, target)
           target = nil
         end
 
@@ -89,6 +85,28 @@ module RubyLsp
           ),
         )
       end
+
+      private
+
+      sig { params(parent: T.nilable(Prism::Node), target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def should_refine_target?(parent, target)
+        (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
+        !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
+          (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+      end
+
+      sig { params(position: T::Hash[Symbol, T.untyped], target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def position_outside_target?(position, target)
+        case target
+        when Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode,
+          Prism::GlobalVariableWriteNode
+          !covers_position?(target.name_loc, position)
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/rename.rb

@@ -72,7 +72,7 @@ module RubyLsp
 
         # 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")
+        unless @global_state.client_capabilities.supports_rename?
           return Interface::WorkspaceEdit.new(changes: changes)
         end
 

data/lib/ruby_lsp/requests/request.rb

@@ -26,7 +26,7 @@ module RubyLsp
         ).void
       end
       def delegate_request_if_needed!(global_state, document, char_position)
-        if global_state.supports_request_delegation &&
+        if global_state.client_capabilities.supports_request_delegation &&
             document.is_a?(ERBDocument) &&
             document.inside_host_language?(char_position)
           raise DelegateRequestError