ruby-lsp 0.22.1 → 0.23.0

data/lib/ruby_indexer/test/uri_test.rb

@@ -0,0 +1,72 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class URITest < Minitest::Test
+    def test_from_path_on_unix
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
+      assert_equal("/some/unix/path/to/file.rb", uri.path)
+    end
+
+    def test_from_path_on_windows
+      uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
+      assert_equal("/C:/some/windows/path/to/file.rb", uri.path)
+    end
+
+    def test_from_path_on_windows_with_lowercase_drive
+      uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
+      assert_equal("/c:/some/windows/path/to/file.rb", uri.path)
+    end
+
+    def test_to_standardized_path_on_unix
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
+      assert_equal(uri.path, uri.to_standardized_path)
+    end
+
+    def test_to_standardized_path_on_windows
+      uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
+      assert_equal("C:/some/windows/path/to/file.rb", uri.to_standardized_path)
+    end
+
+    def test_to_standardized_path_on_windows_with_lowercase_drive
+      uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
+      assert_equal("c:/some/windows/path/to/file.rb", uri.to_standardized_path)
+    end
+
+    def test_to_standardized_path_on_windows_with_received_uri
+      uri = URI("file:///c%3A/some/windows/path/to/file.rb")
+      assert_equal("c:/some/windows/path/to/file.rb", uri.to_standardized_path)
+    end
+
+    def test_plus_signs_are_properly_unescaped
+      path = "/opt/rubies/3.3.0/lib/ruby/3.3.0+0/pathname.rb"
+      uri = URI::Generic.from_path(path: path)
+      assert_equal(path, uri.to_standardized_path)
+    end
+
+    def test_from_path_with_fragment
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb", fragment: "L1,3-2,9")
+      assert_equal("file:///some/unix/path/to/file.rb#L1,3-2,9", uri.to_s)
+    end
+
+    def test_from_path_windows_long_file_paths
+      uri = URI::Generic.from_path(path: "//?/C:/hostedtoolcache/windows/Ruby/3.3.1/x64/lib/ruby/3.3.0/open-uri.rb")
+      assert_equal("C:/hostedtoolcache/windows/Ruby/3.3.1/x64/lib/ruby/3.3.0/open-uri.rb", uri.to_standardized_path)
+    end
+
+    def test_from_path_computes_require_path_when_load_path_entry_is_given
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb", load_path_entry: "/some/unix/path")
+      assert_equal("to/file", uri.require_path)
+    end
+
+    def test_allows_adding_require_path_with_load_path_entry
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
+      assert_nil(uri.require_path)
+
+      uri.add_require_path_from_load_entry("/some/unix/path")
+      assert_equal("to/file", uri.require_path)
+    end
+  end
+end

data/lib/ruby_lsp/addon.rb

@@ -97,6 +97,15 @@ module RubyLsp
         errors
       end
 
+      # Unloads all add-ons. Only intended to be invoked once when shutting down the Ruby LSP server
+      sig { void }
+      def unload_addons
+        @addons.each(&:deactivate)
+        @addons.clear
+        @addon_classes.clear
+        @file_watcher_addons.clear
+      end
+
       # Get a reference to another add-on object by name and version. If an add-on exports an API that can be used by
       # other add-ons, this is the way to get access to that API.
       #

data/lib/ruby_lsp/base_server.rb

@@ -91,14 +91,13 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
+             "$/cancelRequest"
           process_message(message)
         when "shutdown"
-          send_log_message("Shutting down Ruby LSP...")
-
-          shutdown
-
           @mutex.synchronize do
+            send_log_message("Shutting down Ruby LSP...")
+            shutdown
             run_shutdown
             @writer.write(Result.new(id: message[:id], response: nil).to_hash)
           end
@@ -133,6 +132,12 @@ module RubyLsp
       @outgoing_queue.pop
     end
 
+    # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def push_message(message)
+      @incoming_queue << message
+    end
+
     sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
     def process_message(message); end
 
@@ -154,7 +159,11 @@ module RubyLsp
           # Check if the request was cancelled before trying to process it
           @mutex.synchronize do
             if id && @cancelled_requests.include?(id)
-              send_message(Result.new(id: id, response: nil))
+              send_message(Error.new(
+                id: id,
+                code: Constant::ErrorCodes::REQUEST_CANCELLED,
+                message: "Request #{id} was cancelled",
+              ))
               @cancelled_requests.delete(id)
               next
             end

data/lib/ruby_lsp/document.rb

@@ -15,6 +15,7 @@ module RubyLsp
     extend T::Helpers
     extend T::Generic
 
+    class LocationNotFoundError < StandardError; end
     ParseResultType = type_member
 
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
@@ -144,7 +145,15 @@ module RubyLsp
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
-          @pos += 1 until LINE_BREAK == @source[@pos]
+          until LINE_BREAK == @source[@pos]
+            @pos += 1
+
+            if @pos >= @source.length
+              # Pack the code points back into the original string to provide context in the error message
+              raise LocationNotFoundError, "Requested position: #{position}\nSource:\n\n#{@source.pack("U*")}"
+            end
+          end
+
           @pos += 1
           @current_line += 1
         end

data/lib/ruby_lsp/internal.rb

@@ -26,7 +26,6 @@ require "fileutils"
 require "ruby-lsp"
 require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
-require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/static_docs"
 require "ruby_lsp/scope"
@@ -78,6 +77,7 @@ require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"
 require "ruby_lsp/requests/prepare_type_hierarchy"
+require "ruby_lsp/requests/prepare_rename"
 require "ruby_lsp/requests/range_formatting"
 require "ruby_lsp/requests/references"
 require "ruby_lsp/requests/rename"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -15,7 +15,7 @@ module RubyLsp
           "bundle exec ruby"
         rescue Bundler::GemfileNotFound
           "ruby"
-        end + " -Itest ",
+        end,
         String,
       )
       ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
@@ -198,7 +198,7 @@ module RubyLsp
 
         @response_builder << create_code_lens(
           node,
-          title: "Run",
+          title: "▶ Run",
           command_name: "rubyLsp.runTest",
           arguments: arguments,
           data: { type: "test", **grouping_data },
@@ -206,7 +206,7 @@ module RubyLsp
 
         @response_builder << create_code_lens(
           node,
-          title: "Run In Terminal",
+          title: "▶ Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
           arguments: arguments,
           data: { type: "test_in_terminal", **grouping_data },
@@ -229,7 +229,11 @@ module RubyLsp
         ).returns(String)
       end
       def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
-        command = BASE_COMMAND + T.must(@path)
+        path = T.must(@path)
+        command = BASE_COMMAND
+        command += " -Itest" if File.fnmatch?("**/test/**/*", path, File::FNM_PATHNAME)
+        command += " -Ispec" if File.fnmatch?("**/spec/**/*", path, File::FNM_PATHNAME)
+        command += " #{path}"
 
         case @global_state.test_library
         when "minitest"

data/lib/ruby_lsp/listeners/completion.rb

@@ -97,6 +97,12 @@ module RubyLsp
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
+          :on_class_variable_and_write_node_enter,
+          :on_class_variable_operator_write_node_enter,
+          :on_class_variable_or_write_node_enter,
+          :on_class_variable_read_node_enter,
+          :on_class_variable_target_node_enter,
+          :on_class_variable_write_node_enter,
         )
       end
 
@@ -110,13 +116,14 @@ module RubyLsp
         name = constant_name(node)
         return if name.nil?
 
+        range = range_from_location(node.location)
         candidates = @index.constant_completion_candidates(name, @node_context.nesting)
         candidates.each do |entries|
           complete_name = T.must(entries.first).name
           @response_builder << build_entry_completion(
             complete_name,
             name,
-            range_from_location(node.location),
+            range,
             entries,
             top_level?(complete_name),
           )
@@ -246,6 +253,36 @@ module RubyLsp
         handle_instance_variable_completion(node.name.to_s, node.location)
       end
 
+      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      def on_class_variable_and_write_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      def on_class_variable_operator_write_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      def on_class_variable_or_write_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableTargetNode).void }
+      def on_class_variable_target_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.location)
+      end
+
+      sig { params(node: Prism::ClassVariableReadNode).void }
+      def on_class_variable_read_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.location)
+      end
+
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.name_loc)
+      end
+
       private
 
       sig { params(name: String, range: Interface::Range).void }
@@ -326,6 +363,37 @@ module RubyLsp
         end
       end
 
+      sig { params(name: String, location: Prism::Location).void }
+      def handle_class_variable_completion(name, location)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        range = range_from_location(location)
+
+        @index.class_variable_completion_candidates(name, type.name).each do |entry|
+          variable_name = entry.name
+
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: entry.file_name,
+          )
+
+          @response_builder << Interface::CompletionItem.new(
+            label: variable_name,
+            label_details: label_details,
+            text_edit: Interface::TextEdit.new(
+              range: range,
+              new_text: variable_name,
+            ),
+            kind: Constant::CompletionItemKind::FIELD,
+            data: {
+              owner_name: entry.owner&.name,
+            },
+          )
+        end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # 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, 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
@@ -335,6 +403,7 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
+        range = range_from_location(location)
         @index.instance_variable_completion_candidates(name, type.name).each do |entry|
           variable_name = entry.name
 
@@ -346,7 +415,7 @@ module RubyLsp
             label: variable_name,
             label_details: label_details,
             text_edit: Interface::TextEdit.new(
-              range: range_from_location(location),
+              range: range,
               new_text: variable_name,
             ),
             kind: Constant::CompletionItemKind::FIELD,
@@ -368,9 +437,9 @@ module RubyLsp
 
         return unless path_node_to_complete.is_a?(Prism::StringNode)
 
-        matched_indexable_paths = @index.search_require_paths(path_node_to_complete.content)
+        matched_uris = @index.search_require_paths(path_node_to_complete.content)
 
-        matched_indexable_paths.map!(&:require_path).sort!.each do |path|
+        matched_uris.map!(&:require_path).sort!.each do |path|
           @response_builder << build_completion(T.must(path), path_node_to_complete)
         end
       end

data/lib/ruby_lsp/listeners/definition.rb

@@ -55,6 +55,12 @@ module RubyLsp
           :on_symbol_node_enter,
           :on_super_node_enter,
           :on_forwarding_super_node_enter,
+          :on_class_variable_and_write_node_enter,
+          :on_class_variable_operator_write_node_enter,
+          :on_class_variable_or_write_node_enter,
+          :on_class_variable_read_node_enter,
+          :on_class_variable_target_node_enter,
+          :on_class_variable_write_node_enter,
         )
       end
 
@@ -196,6 +202,36 @@ module RubyLsp
         handle_super_node_definition
       end
 
+      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      def on_class_variable_and_write_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      def on_class_variable_operator_write_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      def on_class_variable_or_write_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableTargetNode).void }
+      def on_class_variable_target_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableReadNode).void }
+      def on_class_variable_read_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
       private
 
       sig { void }
@@ -223,7 +259,7 @@ module RubyLsp
           location = entry.location
 
           @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: entry.file_path).to_s,
+            uri: entry.uri.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),
@@ -232,6 +268,24 @@ module RubyLsp
         end
       end
 
+      sig { params(name: String).void }
+      def handle_class_variable_definition(name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_class_variable(name, type.name)
+        return unless entries
+
+        entries.each do |entry|
+          @response_builder << Interface::Location.new(
+            uri: entry.uri.to_s,
+            range: range_from_location(entry.location),
+          )
+        end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # 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_instance_variable_definition(name)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
@@ -248,7 +302,7 @@ module RubyLsp
           location = entry.location
 
           @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: entry.file_path).to_s,
+            uri: entry.uri.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),
@@ -275,11 +329,11 @@ module RubyLsp
         return unless methods
 
         methods.each do |target_method|
-          file_path = target_method.file_path
-          next if sorbet_level_true_or_higher?(@sorbet_level) && not_in_dependencies?(file_path)
+          uri = target_method.uri
+          next if sorbet_level_true_or_higher?(@sorbet_level) && not_in_dependencies?(T.must(uri.full_path))
 
           @response_builder << Interface::LocationLink.new(
-            target_uri: URI::Generic.from_path(path: file_path).to_s,
+            target_uri: uri.to_s,
             target_range: range_from_location(target_method.location),
             target_selection_range: range_from_location(target_method.name_location),
           )
@@ -290,20 +344,22 @@ module RubyLsp
       def handle_require_definition(node, message)
         case message
         when :require
-          entry = @index.search_require_paths(node.content).find do |indexable_path|
-            indexable_path.require_path == node.content
+          entry = @index.search_require_paths(node.content).find do |uri|
+            uri.require_path == node.content
           end
 
           if entry
             candidate = entry.full_path
 
-            @response_builder << Interface::Location.new(
-              uri: URI::Generic.from_path(path: candidate).to_s,
-              range: Interface::Range.new(
-                start: Interface::Position.new(line: 0, character: 0),
-                end: Interface::Position.new(line: 0, character: 0),
-              ),
-            )
+            if candidate
+              @response_builder << Interface::Location.new(
+                uri: URI::Generic.from_path(path: candidate).to_s,
+                range: Interface::Range.new(
+                  start: Interface::Position.new(line: 0, character: 0),
+                  end: Interface::Position.new(line: 0, character: 0),
+                ),
+              )
+            end
           end
         when :require_relative
           required_file = "#{node.content}.rb"
@@ -346,11 +402,11 @@ module RubyLsp
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
           # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
           # ignore
-          file_path = entry.file_path
-          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(file_path)
+          uri = entry.uri
+          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(T.must(uri.full_path))
 
           @response_builder << Interface::LocationLink.new(
-            target_uri: URI::Generic.from_path(path: file_path).to_s,
+            target_uri: uri.to_s,
             target_range: range_from_location(entry.location),
             target_selection_range: range_from_location(entry.name_location),
           )

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -41,6 +41,7 @@ module RubyLsp
           :on_module_node_enter,
           :on_module_node_leave,
           :on_instance_variable_write_node_enter,
+          :on_instance_variable_target_node_enter,
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_and_write_node_enter,
@@ -272,6 +273,16 @@ module RubyLsp
         )
       end
 
+      sig { params(node: Prism::InstanceVariableTargetNode).void }
+      def on_instance_variable_target_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::FIELD,
+          range_location: node.location,
+          selection_range_location: node.location,
+        )
+      end
+
       sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
       def on_instance_variable_operator_write_node_enter(node)
         create_document_symbol(
@@ -329,7 +340,7 @@ module RubyLsp
         ).returns(Interface::DocumentSymbol)
       end
       def create_document_symbol(name:, kind:, range_location:, selection_range_location:)
-        name = "<blank>" if name.empty?
+        name = "<blank>" if name.strip.empty?
         symbol = Interface::DocumentSymbol.new(
           name: name,
           kind: kind,

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -195,7 +195,7 @@ module RubyLsp
       def push_comment_ranges
         # Group comments that are on consecutive lines and then push ranges for each group that has at least 2 comments
         @comments.chunk_while do |this, other|
-          this.location.end_line + 1 == other.location.start_line
+          this.location.end_line + 1 == other.location.start_line && !this.trailing? && !other.trailing?
         end.each do |chunk|
           next if chunk.length == 1
 

data/lib/ruby_lsp/listeners/hover.rb

@@ -31,6 +31,12 @@ module RubyLsp
           Prism::SuperNode,
           Prism::ForwardingSuperNode,
           Prism::YieldNode,
+          Prism::ClassVariableAndWriteNode,
+          Prism::ClassVariableOperatorWriteNode,
+          Prism::ClassVariableOrWriteNode,
+          Prism::ClassVariableReadNode,
+          Prism::ClassVariableTargetNode,
+          Prism::ClassVariableWriteNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -85,6 +91,12 @@ module RubyLsp
           :on_string_node_enter,
           :on_interpolated_string_node_enter,
           :on_yield_node_enter,
+          :on_class_variable_and_write_node_enter,
+          :on_class_variable_operator_write_node_enter,
+          :on_class_variable_or_write_node_enter,
+          :on_class_variable_read_node_enter,
+          :on_class_variable_target_node_enter,
+          :on_class_variable_write_node_enter,
         )
       end
 
@@ -215,6 +227,36 @@ module RubyLsp
         handle_keyword_documentation(node.keyword)
       end
 
+      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      def on_class_variable_and_write_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      def on_class_variable_operator_write_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      def on_class_variable_or_write_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableTargetNode).void }
+      def on_class_variable_target_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableReadNode).void }
+      def on_class_variable_read_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
       private
 
       sig { params(node: T.any(Prism::InterpolatedStringNode, Prism::StringNode)).void }
@@ -317,6 +359,21 @@ module RubyLsp
         end
       end
 
+      sig { params(name: String).void }
+      def handle_class_variable_hover(name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_class_variable(name, type.name)
+        return unless entries
+
+        categorized_markdown_from_index_entries(name, entries).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # 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, location: Prism::Location).void }
       def generate_hover(name, location)
         entries = @index.resolve(name, @node_context.nesting)

data/lib/ruby_lsp/requests/completion.rb

@@ -62,6 +62,12 @@ module RubyLsp
             Prism::InstanceVariableOrWriteNode,
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
+            Prism::ClassVariableAndWriteNode,
+            Prism::ClassVariableOperatorWriteNode,
+            Prism::ClassVariableOrWriteNode,
+            Prism::ClassVariableReadNode,
+            Prism::ClassVariableTargetNode,
+            Prism::ClassVariableWriteNode,
           ],
           code_units_cache: document.code_units_cache,
         )

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -49,7 +49,8 @@ module RubyLsp
         if owner_name
           entries = entries.select do |entry|
             (entry.is_a?(RubyIndexer::Entry::Member) || entry.is_a?(RubyIndexer::Entry::InstanceVariable) ||
-            entry.is_a?(RubyIndexer::Entry::MethodAlias)) && entry.owner&.name == owner_name
+            entry.is_a?(RubyIndexer::Entry::MethodAlias) || entry.is_a?(RubyIndexer::Entry::ClassVariable)) &&
+              entry.owner&.name == owner_name
           end
         end
 

data/lib/ruby_lsp/requests/definition.rb

@@ -56,6 +56,12 @@ module RubyLsp
             Prism::StringNode,
             Prism::SuperNode,
             Prism::ForwardingSuperNode,
+            Prism::ClassVariableAndWriteNode,
+            Prism::ClassVariableOperatorWriteNode,
+            Prism::ClassVariableOrWriteNode,
+            Prism::ClassVariableReadNode,
+            Prism::ClassVariableTargetNode,
+            Prism::ClassVariableWriteNode,
           ],
           code_units_cache: document.code_units_cache,
         )