ruby-lsp 0.20.1 → 0.22.1

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -100,7 +100,7 @@ module RubyIndexer
     end
 
     def test_location_and_name_location_are_the_same
-      # NOTE: RBS does not store the name location for classes, modules or methods. This behaviour is not exactly what
+      # NOTE: RBS does not store the name location for classes, modules or methods. This behavior is not exactly what
       # we would like, but for now we assign the same location to both
 
       entries = @index["Array"]

data/lib/ruby_lsp/addon.rb

@@ -46,7 +46,7 @@ module RubyLsp
       sig { returns(T::Array[T.class_of(Addon)]) }
       attr_reader :addon_classes
 
-      # Automatically track and instantiate addon classes
+      # Automatically track and instantiate add-on classes
       sig { params(child_class: T.class_of(Addon)).void }
       def inherited(child_class)
         addon_classes << child_class
@@ -82,7 +82,7 @@ module RubyLsp
           e
         end
 
-        # Instantiate all discovered addon classes
+        # Instantiate all discovered add-on classes
         self.addons = addon_classes.map(&:new)
         self.file_watcher_addons = addons.select { |addon| addon.respond_to?(:workspace_did_change_watched_files) }
 
@@ -194,6 +194,13 @@ module RubyLsp
     sig { abstract.returns(String) }
     def version; end
 
+    # Handle a response from a window/showMessageRequest request. Add-ons must include the addon_name as part of the
+    # original request so that the response is delegated to the correct add-on and must override this method to handle
+    # the response
+    # https://microsoft.github.io/language-server-protocol/specification#window_showMessageRequest
+    sig { overridable.params(title: String).void }
+    def handle_window_show_message_response(title); end
+
     # Creates a new CodeLens listener. This method is invoked on every CodeLens request
     sig do
       overridable.params(

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,67 @@
+# 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,
+      :supports_progress
+
+    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])
+
+      # The editor supports displaying progress requests
+      @supports_progress = T.let(false, T::Boolean)
+    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
+
+      progress = capabilities.dig(:window, :workDoneProgress)
+      @supports_progress = progress if progress
+    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 :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)
+      @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -123,12 +130,7 @@ 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,13 +138,17 @@ 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
+      enabled_flags = options.dig(:initializationOptions, :enabledFeatureFlags)
+      @enabled_feature_flags = enabled_flags if enabled_flags
 
       notifications
     end
 
+    sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
+    def enabled_feature?(flag)
+      @enabled_feature_flags[:all] || @enabled_feature_flags[flag]
+    end
+
     sig { returns(String) }
     def workspace_path
       T.must(@workspace_uri.to_standardized_path)
@@ -160,6 +166,11 @@ module RubyLsp
       end
     end
 
+    sig { returns(T::Boolean) }
+    def supports_watching_files
+      @client_capabilities.supports_watching_files
+    end
+
     private
 
     sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }
@@ -231,14 +242,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 +259,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"
@@ -20,6 +21,7 @@ require "prism"
 require "prism/visitor"
 require "language_server-protocol"
 require "rbs"
+require "fileutils"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"
@@ -28,6 +30,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/document_highlight.rb

@@ -92,14 +92,15 @@ module RubyLsp
           target: T.nilable(Prism::Node),
           parent: T.nilable(Prism::Node),
           dispatcher: Prism::Dispatcher,
+          position: T::Hash[Symbol, T.untyped],
         ).void
       end
-      def initialize(response_builder, target, parent, dispatcher)
+      def initialize(response_builder, target, parent, dispatcher, position)
         @response_builder = response_builder
 
         return unless target && parent
 
-        highlight_target =
+        highlight_target, highlight_target_value =
           case target
           when Prism::GlobalVariableReadNode, Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode,
             Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode, Prism::GlobalVariableWriteNode,
@@ -116,13 +117,17 @@ module RubyLsp
             Prism::CallNode, Prism::BlockParameterNode, Prism::RequiredKeywordParameterNode,
             Prism::RequiredKeywordParameterNode, Prism::KeywordRestParameterNode, Prism::OptionalParameterNode,
             Prism::RequiredParameterNode, Prism::RestParameterNode
+            [target, node_value(target)]
+          when Prism::ModuleNode, Prism::ClassNode, Prism::SingletonClassNode, Prism::DefNode, Prism::CaseNode,
+            Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::IfNode, Prism::UnlessNode
             target
           end
 
         @target = T.let(highlight_target, T.nilable(Prism::Node))
-        @target_value = T.let(node_value(highlight_target), T.nilable(String))
+        @target_value = T.let(highlight_target_value, T.nilable(String))
+        @target_position = position
 
-        if @target && @target_value
+        if @target
           dispatcher.register(
             self,
             :on_call_node_enter,
@@ -172,6 +177,13 @@ module RubyLsp
             :on_global_variable_or_write_node_enter,
             :on_global_variable_and_write_node_enter,
             :on_global_variable_operator_write_node_enter,
+            :on_singleton_class_node_enter,
+            :on_case_node_enter,
+            :on_while_node_enter,
+            :on_until_node_enter,
+            :on_for_node_enter,
+            :on_if_node_enter,
+            :on_unless_node_enter,
           )
         end
       end
@@ -189,6 +201,8 @@ module RubyLsp
 
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
+        add_matching_end_highlights(node.def_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::DefNode)
+
         return unless matches?(node, [Prism::CallNode, Prism::DefNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
@@ -252,6 +266,8 @@ module RubyLsp
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
+        add_matching_end_highlights(node.class_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::ClassNode)
+
         return unless matches?(node, CONSTANT_NODES + CONSTANT_PATH_NODES + [Prism::ClassNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.constant_path.location)
@@ -259,6 +275,8 @@ module RubyLsp
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
+        add_matching_end_highlights(node.module_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::ModuleNode)
+
         return unless matches?(node, CONSTANT_NODES + CONSTANT_PATH_NODES + [Prism::ModuleNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.constant_path.location)
@@ -511,6 +529,55 @@ module RubyLsp
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
       end
 
+      sig { params(node: Prism::SingletonClassNode).void }
+      def on_singleton_class_node_enter(node)
+        return unless @target.is_a?(Prism::SingletonClassNode)
+
+        add_matching_end_highlights(node.class_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::CaseNode).void }
+      def on_case_node_enter(node)
+        return unless @target.is_a?(Prism::CaseNode)
+
+        add_matching_end_highlights(node.case_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::WhileNode).void }
+      def on_while_node_enter(node)
+        return unless @target.is_a?(Prism::WhileNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.closing_loc)
+      end
+
+      sig { params(node: Prism::UntilNode).void }
+      def on_until_node_enter(node)
+        return unless @target.is_a?(Prism::UntilNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.closing_loc)
+      end
+
+      sig { params(node: Prism::ForNode).void }
+      def on_for_node_enter(node)
+        return unless @target.is_a?(Prism::ForNode)
+
+        add_matching_end_highlights(node.for_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::IfNode).void }
+      def on_if_node_enter(node)
+        return unless @target.is_a?(Prism::IfNode)
+
+        add_matching_end_highlights(node.if_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::UnlessNode).void }
+      def on_unless_node_enter(node)
+        return unless @target.is_a?(Prism::UnlessNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.end_keyword_loc)
+      end
+
       private
 
       sig { params(node: Prism::Node, classes: T::Array[T.class_of(Prism::Node)]).returns(T.nilable(T::Boolean)) }
@@ -550,6 +617,26 @@ module RubyLsp
           node.constant_path.slice
         end
       end
+
+      sig { params(keyword_loc: T.nilable(Prism::Location), end_loc: T.nilable(Prism::Location)).void }
+      def add_matching_end_highlights(keyword_loc, end_loc)
+        return unless keyword_loc && end_loc && end_loc.length.positive?
+        return unless covers_target_position?(keyword_loc) || covers_target_position?(end_loc)
+
+        add_highlight(Constant::DocumentHighlightKind::TEXT, keyword_loc)
+        add_highlight(Constant::DocumentHighlightKind::TEXT, end_loc)
+      end
+
+      sig { params(location: Prism::Location).returns(T::Boolean) }
+      def covers_target_position?(location)
+        start_line = location.start_line - 1
+        end_line = location.end_line - 1
+        start_covered = start_line < @target_position[:line] ||
+          (start_line == @target_position[:line] && location.start_column <= @target_position[:character])
+        end_covered = end_line > @target_position[:line] ||
+          (end_line == @target_position[:line] && location.end_column >= @target_position[:character])
+        start_covered && end_covered
+      end
     end
   end
 end