ruby-lsp 0.20.0 → 0.21.0

data/lib/ruby_indexer/test/index_test.rb

@@ -904,7 +904,7 @@ module RubyIndexer
       assert_equal(14, entry.location.start_line)
     end
 
-    def test_resolving_inherited_alised_namespace
+    def test_resolving_inherited_aliased_namespace
       index(<<~RUBY)
         module Bar
           TARGET = 123
@@ -1490,7 +1490,7 @@ module RubyIndexer
       assert_kind_of(Entry::UnresolvedMethodAlias, entry)
     end
 
-    def test_unresolable_method_aliases
+    def test_unresolvable_method_aliases
       index(<<~RUBY)
         class Foo
           alias bar baz
@@ -1934,5 +1934,94 @@ module RubyIndexer
       real_namespace = @index.follow_aliased_namespace("Namespace::Second")
       assert_equal("First::Second", real_namespace)
     end
+
+    def test_resolving_alias_to_non_existing_namespace
+      index(<<~RUBY)
+        module Namespace
+          class Foo
+            module InnerNamespace
+              Constants = Namespace::Foo::Constants
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("Constants", ["Namespace", "Foo", "InnerNamespace"])&.first
+      assert_instance_of(Entry::UnresolvedConstantAlias, entry)
+
+      entry = @index.resolve("Namespace::Foo::Constants", ["Namespace", "Foo", "InnerNamespace"])&.first
+      assert_nil(entry)
+    end
+
+    def test_resolving_alias_to_existing_constant_from_inner_namespace
+      index(<<~RUBY)
+        module Parent
+          CONST = 123
+        end
+
+        module First
+          module Namespace
+            class Foo
+              include Parent
+
+              module InnerNamespace
+                Constants = Namespace::Foo::CONST
+              end
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("Namespace::Foo::CONST", ["First", "Namespace", "Foo", "InnerNamespace"])&.first
+      assert_equal("Parent::CONST", entry.name)
+      assert_instance_of(Entry::Constant, entry)
+    end
+
+    def test_build_non_redundant_name
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Namespace", "Foo", "InnerNamespace"],
+        ),
+      )
+
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Namespace", "Foo"],
+        ),
+      )
+
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Foo::Constants",
+          ["Namespace", "Foo"],
+        ),
+      )
+
+      assert_equal(
+        "Bar::Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Bar"],
+        ),
+      )
+
+      assert_equal(
+        "First::Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["First", "Namespace", "Foo", "InnerNamespace"],
+        ),
+      )
+    end
   end
 end

data/lib/ruby_indexer/test/instance_variables_test.rb

@@ -209,7 +209,7 @@ module RubyIndexer
         end
       RUBY
 
-      # If the surrounding method is beind defined on any dynamic value that isn't `self`, then we attribute the
+      # If the surrounding method is being defined on any dynamic value that isn't `self`, then we attribute the
       # instance variable to the wrong owner since there's no way to understand that statically
       entry = T.must(@index["@a"]&.first)
       owner = T.must(entry.owner)

data/lib/ruby_indexer/test/method_test.rb

@@ -123,6 +123,32 @@ module RubyIndexer
       assert_entry("baz", Entry::Method, "/fake/path/foo.rb:9-2:9-14", visibility: Entry::Visibility::PRIVATE)
     end
 
+    def test_visibility_tracking_with_module_function
+      index(<<~RUBY)
+        module Test
+          def foo; end
+          def bar; end
+          module_function :foo, "bar"
+        end
+      RUBY
+
+      ["foo", "bar"].each do |keyword|
+        entries = T.must(@index[keyword])
+        # should receive two entries because module_function creates a singleton method
+        # for the Test module and a private method for classes include the Test module
+        assert_equal(entries.size, 2)
+        first_entry, second_entry = *entries
+        # The first entry points to the location of the module_function call
+        assert_equal("Test", first_entry.owner.name)
+        assert_instance_of(Entry::Module, first_entry.owner)
+        assert_equal(Entry::Visibility::PRIVATE, first_entry.visibility)
+        # The second entry points to the public singleton method
+        assert_equal("Test::<Class:Test>", second_entry.owner.name)
+        assert_instance_of(Entry::SingletonClass, second_entry.owner)
+        assert_equal(Entry::Visibility::PUBLIC, second_entry.visibility)
+      end
+    end
+
     def test_method_with_parameters
       index(<<~RUBY)
         class Foo

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,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)