ruby-lsp 0.20.1 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58327a9f9a3d85375cbbf81e3e170a948d5c8dfbdcdcac0a1fdef5f685d20c95
-  data.tar.gz: 45572eb6645bce73d2079bed65f0d92c98921517926b968bba96788769a3aada
+  metadata.gz: efd5671eae595026a17c3114a00de1053865ac828726dd7ac5a66548f6b1ad56
+  data.tar.gz: ccf5b7af12a6e1e327cc2d458be11f39a9ac7319ab9049863ed5a74e333e8a6f
 SHA512:
-  metadata.gz: c506eeff4d24060e3afdb4ad9da319c12b725050c8f25a9348ec7dea9082f8adced7671b7b1eb8f7f09412942139e47a2df5059b5672d2b6a75f0ffc5a59885d
-  data.tar.gz: d9a89ce24946e5f9cc47b5a48086f6fd977176d31332a0b634950dc00a41fc9a36e4753eae2896e2da0129e92bff4278265eaa970252a5292c783e5bc82258e9
+  metadata.gz: 8fbcdfaac508788a17fb3b7e939ce290e33049a0080ff6260abfaeb609ee76a033234ccc2efa5724587e9c4cbf4552e2cd5d2cb0af1186971b8ed06fec290cb3
+  data.tar.gz: 3e37acf250618e60df2addbce7f9acf86df4bf3e771b7b49c4cd8f4ad326ea82e3d41ad80c5ce71e3b0429dab98385df51f4645824cd419e32dac5ea13778760

data/README.md

@@ -29,8 +29,8 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/Shopif
 be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor
 Covenant](CODE_OF_CONDUCT.md) code of conduct.
 
-If you wish to contribute, see [CONTRIBUTING](CONTRIBUTING.md) for development instructions and check out our pinned
-[roadmap issue](https://github.com/Shopify/ruby-lsp/issues) for a list of tasks to get started.
+If you wish to contribute, see [Contributing](https://shopify.github.io/ruby-lsp/contributing.html) for development instructions and check out our
+[Design and roadmap](https://shopify.github.io/ruby-lsp/design-and-roadmap.html) for a list of tasks to get started.
 
 ## License
 

data/VERSION

@@ -1 +1 @@
-0.20.1
+0.22.1

data/exe/ruby-lsp

@@ -33,6 +33,10 @@ parser = OptionParser.new do |opts|
     options[:doctor] = true
   end
 
+  opts.on("--use-launcher", "[EXPERIMENTAL] Use launcher mechanism to handle missing dependencies gracefully") do
+    options[:launcher] = true
+  end
+
   opts.on("-h", "--help", "Print this help") do
     puts opts.help
     puts
@@ -50,10 +54,21 @@ rescue OptionParser::InvalidOption => e
   exit(1)
 end
 
-# When we're running without bundler, then we need to make sure the custom bundle is fully configured and re-execute
+# When we're running without bundler, then we need to make sure the composed bundle is fully configured and re-execute
 # using `BUNDLE_GEMFILE=.ruby-lsp/Gemfile bundle exec ruby-lsp` so that we have access to the gems that are a part of
 # the application's bundle
 if ENV["BUNDLE_GEMFILE"].nil?
+  # Substitute the current process by the launcher. RubyGems activates all dependencies of a gem's executable eagerly,
+  # but we can't have that happen because we want to invoke Bundler.setup ourselves with the composed bundle and avoid
+  # duplicate spec activation errors. Replacing the process with the launcher executable will clear the activated specs,
+  # which gives us the opportunity to control which specs are activated and enter degraded mode if any gems failed to
+  # install rather than failing to boot the server completely
+  if options[:launcher]
+    command = +File.expand_path("ruby-lsp-launcher", __dir__)
+    command << " --debug" if options[:debug]
+    exit exec(command)
+  end
+
   require_relative "../lib/ruby_lsp/setup_bundler"
 
   begin
@@ -69,12 +84,12 @@ if ENV["BUNDLE_GEMFILE"].nil?
     "bundle"
   end
 
-  exit exec(env, "#{base_bundle} exec ruby-lsp #{original_args.join(" ")}")
+  exit exec(env, "#{base_bundle} exec ruby-lsp #{original_args.join(" ")}".strip)
 end
 
-require "ruby_lsp/load_sorbet"
-
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
 T::Utils.run_all_sig_blocks

data/exe/ruby-lsp-launcher

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# !!!!!!!
+# No gems can be required in this file until we invoke bundler setup except inside the forked process that sets up the
+# composed bundle
+# !!!!!!!
+
+setup_error = nil
+
+# Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
+# Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
+# to ensure that we're setting up the bundle in the right place
+$stdin.binmode
+headers = $stdin.gets("\r\n\r\n")
+content_length = headers[/Content-Length: (\d+)/i, 1].to_i
+raw_initialize = $stdin.read(content_length)
+
+# Compose the Ruby LSP bundle in a forked process so that we can require gems without polluting the main process
+# `$LOAD_PATH` and `Gem.loaded_specs`. Windows doesn't support forking, so we need a separate path to support it
+pid = if Gem.win_platform?
+  # Since we can't fork on Windows and spawn won't carry over the existing load paths, we need to explicitly pass that
+  # down to the child process or else requiring gems during composing the bundle will fail
+  load_path = $LOAD_PATH.flat_map do |path|
+    ["-I", File.expand_path(path)]
+  end
+
+  Process.spawn(
+    Gem.ruby,
+    *load_path,
+    File.expand_path("../lib/ruby_lsp/scripts/compose_bundle_windows.rb", __dir__),
+    raw_initialize,
+  )
+else
+  fork do
+    require_relative "../lib/ruby_lsp/scripts/compose_bundle"
+    compose(raw_initialize)
+  end
+end
+
+begin
+  # Wait until the composed Bundle is finished
+  Process.wait(pid)
+rescue Errno::ECHILD
+  # In theory, the child process can finish before we even get to the wait call, but that is not an error
+end
+
+begin
+  bundle_env_path = File.join(".ruby-lsp", "bundle_env")
+  # We can't require `bundler/setup` because that file prematurely exits the process if setup fails. However, we can't
+  # simply require bundler either because the version required might conflict with the one locked in the composed
+  # bundle. We need the composed bundle sub-process to inform us of the locked Bundler version, so that we can then
+  # activate the right spec and require the exact Bundler version required by the app
+  if File.exist?(bundle_env_path)
+    env = File.readlines(bundle_env_path).to_h { |line| line.chomp.split("=", 2) }
+    ENV.merge!(env)
+
+    if env["BUNDLER_VERSION"]
+      Gem::Specification.find_by_name("bundler", env["BUNDLER_VERSION"]).activate
+    end
+
+    require "bundler"
+    Bundler.ui.level = :silent
+    Bundler.setup
+    $stderr.puts("Composed Bundle set up successfully")
+  end
+rescue StandardError => e
+  # If installing gems failed for any reason, we don't want to exit the process prematurely. We can still provide most
+  # features in a degraded mode. We simply save the error so that we can report to the user that certain gems might be
+  # missing, but we respect the LSP life cycle
+  setup_error = e
+  $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
+
+  # If Bundler.setup fails, we need to restore the original $LOAD_PATH so that we can still require the Ruby LSP server
+  # in degraded mode
+  $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+end
+
+error_path = File.join(".ruby-lsp", "install_error")
+
+install_error = if File.exist?(error_path)
+  Marshal.load(File.read(error_path))
+end
+
+# Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already
+# configured the load path using the version of the Ruby LSP present in the composed bundle. Do not push any Ruby LSP
+# paths into the load path manually or we may end up requiring the wrong version of the gem
+require "ruby_lsp/load_sorbet"
+require "ruby_lsp/internal"
+
+T::Utils.run_all_sig_blocks
+
+if ARGV.include?("--debug")
+  if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
+    $stderr.puts "Debugging is not supported on Windows"
+  else
+    begin
+      ENV.delete("RUBY_DEBUG_IRB_CONSOLE")
+      require "debug/open_nonstop"
+    rescue LoadError
+      $stderr.puts("You need to install the debug gem to use the --debug flag")
+    end
+  end
+end
+
+# Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+$> = $stderr
+
+initialize_request = JSON.parse(raw_initialize, symbolize_names: true) if raw_initialize
+
+begin
+  RubyLsp::Server.new(
+    install_error: install_error,
+    setup_error: setup_error,
+    initialize_request: initialize_request,
+  ).start
+rescue ArgumentError
+  # If the launcher is booting an outdated version of the server, then the initializer doesn't accept a keyword splat
+  # and we already read the initialize request from the stdin pipe. In this case, we need to process the initialize
+  # request manually and then start the main loop
+  server = RubyLsp::Server.new
+  server.process_message(initialize_request)
+  server.start
+end

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -109,6 +109,12 @@ module RubyIndexer
 
       indexables = T.let([], T::Array[IndexablePath])
 
+      # Handle top level files separately. The path below is an optimization to prevent descending down directories that
+      # are going to be excluded anyway, so we need to handle top level scripts separately
+      Dir.glob(File.join(@workspace_path, "*.rb"), flags).each do |path|
+        indexables << IndexablePath.new(nil, path)
+      end
+
       # Add user specified patterns
       @included_patterns.each do |pattern|
         load_path_entry = T.let(nil, T.nilable(String))

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -18,13 +18,12 @@ module RubyIndexer
         parse_result: Prism::ParseResult,
         file_path: String,
         collect_comments: T::Boolean,
-        enhancements: T::Array[Enhancement],
       ).void
     end
-    def initialize(index, dispatcher, parse_result, file_path, collect_comments: false, enhancements: [])
+    def initialize(index, dispatcher, parse_result, file_path, collect_comments: false)
       @index = index
       @file_path = file_path
-      @enhancements = enhancements
+      @enhancements = T.let(Enhancement.all(self), T::Array[Enhancement])
       @visibility_stack = T.let([Entry::Visibility::PUBLIC], T::Array[Entry::Visibility])
       @comments_by_line = T.let(
         parse_result.comments.to_h do |c|
@@ -37,6 +36,7 @@ module RubyIndexer
         parse_result.code_units_cache(@index.configuration.encoding),
         T.any(T.proc.params(arg0: Integer).returns(Integer), Prism::CodeUnitsCache),
       )
+      @source_lines = T.let(parse_result.source.lines, T::Array[String])
 
       # The nesting stack we're currently inside. Used to determine the fully qualified name of constants, but only
       # stored by unresolved aliases which need the original nesting to be lazily resolved
@@ -85,15 +85,9 @@ module RubyIndexer
 
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_enter(node)
-      @visibility_stack.push(Entry::Visibility::PUBLIC)
       constant_path = node.constant_path
-      name = constant_path.slice
-
-      comments = collect_comments(node)
-
       superclass = node.superclass
-
-      nesting = actual_nesting(name)
+      nesting = actual_nesting(constant_path.slice)
 
       parent_class = case superclass
       when Prism::ConstantReadNode, Prism::ConstantPathNode
@@ -112,53 +106,29 @@ module RubyIndexer
         end
       end
 
-      entry = Entry::Class.new(
+      add_class(
         nesting,
-        @file_path,
-        Location.from_prism_location(node.location, @code_units_cache),
-        Location.from_prism_location(constant_path.location, @code_units_cache),
-        comments,
-        parent_class,
+        node.location,
+        constant_path.location,
+        parent_class_name: parent_class,
+        comments: collect_comments(node),
       )
-
-      @owner_stack << entry
-      @index.add(entry)
-      @stack << name
     end
 
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_leave(node)
-      @stack.pop
-      @owner_stack.pop
-      @visibility_stack.pop
+      pop_namespace_stack
     end
 
     sig { params(node: Prism::ModuleNode).void }
     def on_module_node_enter(node)
-      @visibility_stack.push(Entry::Visibility::PUBLIC)
       constant_path = node.constant_path
-      name = constant_path.slice
-
-      comments = collect_comments(node)
-
-      entry = Entry::Module.new(
-        actual_nesting(name),
-        @file_path,
-        Location.from_prism_location(node.location, @code_units_cache),
-        Location.from_prism_location(constant_path.location, @code_units_cache),
-        comments,
-      )
-
-      @owner_stack << entry
-      @index.add(entry)
-      @stack << name
+      add_module(constant_path.slice, node.location, constant_path.location, comments: collect_comments(node))
     end
 
     sig { params(node: Prism::ModuleNode).void }
     def on_module_node_leave(node)
-      @stack.pop
-      @owner_stack.pop
-      @visibility_stack.pop
+      pop_namespace_stack
     end
 
     sig { params(node: Prism::SingletonClassNode).void }
@@ -200,9 +170,7 @@ module RubyIndexer
 
     sig { params(node: Prism::SingletonClassNode).void }
     def on_singleton_class_node_leave(node)
-      @stack.pop
-      @owner_stack.pop
-      @visibility_stack.pop
+      pop_namespace_stack
     end
 
     sig { params(node: Prism::MultiWriteNode).void }
@@ -312,12 +280,19 @@ module RubyIndexer
         @visibility_stack.push(Entry::Visibility::PROTECTED)
       when :private
         @visibility_stack.push(Entry::Visibility::PRIVATE)
+      when :module_function
+        handle_module_function(node)
+      when :private_class_method
+        @visibility_stack.push(Entry::Visibility::PRIVATE)
+        handle_private_class_method(node)
       end
 
       @enhancements.each do |enhancement|
-        enhancement.on_call_node(@index, @owner_stack.last, node, @file_path, @code_units_cache)
+        enhancement.on_call_node_enter(node)
       rescue StandardError => e
-        @indexing_errors << "Indexing error in #{@file_path} with '#{enhancement.class.name}' enhancement: #{e.message}"
+        @indexing_errors << <<~MSG
+          Indexing error in #{@file_path} with '#{enhancement.class.name}' on call node enter enhancement: #{e.message}
+        MSG
       end
     end
 
@@ -325,13 +300,21 @@ module RubyIndexer
     def on_call_node_leave(node)
       message = node.name
       case message
-      when :public, :protected, :private
+      when :public, :protected, :private, :private_class_method
         # We want to restore the visibility stack when we leave a method definition with a visibility modifier
         # e.g. `private def foo; end`
         if node.arguments&.arguments&.first&.is_a?(Prism::DefNode)
           @visibility_stack.pop
         end
       end
+
+      @enhancements.each do |enhancement|
+        enhancement.on_call_node_leave(node)
+      rescue StandardError => e
+        @indexing_errors << <<~MSG
+          Indexing error in #{@file_path} with '#{enhancement.class.name}' on call node leave enhancement: #{e.message}
+        MSG
+      end
     end
 
     sig { params(node: Prism::DefNode).void }
@@ -451,6 +434,98 @@ module RubyIndexer
       )
     end
 
+    sig do
+      params(
+        name: String,
+        node_location: Prism::Location,
+        signatures: T::Array[Entry::Signature],
+        visibility: Entry::Visibility,
+        comments: T.nilable(String),
+      ).void
+    end
+    def add_method(name, node_location, signatures, visibility: Entry::Visibility::PUBLIC, comments: nil)
+      location = Location.from_prism_location(node_location, @code_units_cache)
+
+      @index.add(Entry::Method.new(
+        name,
+        @file_path,
+        location,
+        location,
+        comments,
+        signatures,
+        visibility,
+        @owner_stack.last,
+      ))
+    end
+
+    sig do
+      params(
+        name: String,
+        full_location: Prism::Location,
+        name_location: Prism::Location,
+        comments: T.nilable(String),
+      ).void
+    end
+    def add_module(name, full_location, name_location, comments: nil)
+      location = Location.from_prism_location(full_location, @code_units_cache)
+      name_loc = Location.from_prism_location(name_location, @code_units_cache)
+
+      entry = Entry::Module.new(
+        actual_nesting(name),
+        @file_path,
+        location,
+        name_loc,
+        comments,
+      )
+
+      advance_namespace_stack(name, entry)
+    end
+
+    sig do
+      params(
+        name_or_nesting: T.any(String, T::Array[String]),
+        full_location: Prism::Location,
+        name_location: Prism::Location,
+        parent_class_name: T.nilable(String),
+        comments: T.nilable(String),
+      ).void
+    end
+    def add_class(name_or_nesting, full_location, name_location, parent_class_name: nil, comments: nil)
+      nesting = name_or_nesting.is_a?(Array) ? name_or_nesting : actual_nesting(name_or_nesting)
+      entry = Entry::Class.new(
+        nesting,
+        @file_path,
+        Location.from_prism_location(full_location, @code_units_cache),
+        Location.from_prism_location(name_location, @code_units_cache),
+        comments,
+        parent_class_name,
+      )
+
+      advance_namespace_stack(T.must(nesting.last), entry)
+    end
+
+    sig { params(block: T.proc.params(index: Index, base: Entry::Namespace).void).void }
+    def register_included_hook(&block)
+      owner = @owner_stack.last
+      return unless owner
+
+      @index.register_included_hook(owner.name) do |index, base|
+        block.call(index, base)
+      end
+    end
+
+    sig { void }
+    def pop_namespace_stack
+      @stack.pop
+      @owner_stack.pop
+      @visibility_stack.pop
+    end
+
+    sig { returns(T.nilable(Entry::Namespace)) }
+    def current_owner
+      @owner_stack.last
+    end
+
     private
 
     sig do
@@ -649,8 +724,7 @@ module RubyIndexer
       comments = +""
 
       start_line = node.location.start_line - 1
-      start_line -= 1 unless @comments_by_line.key?(start_line)
-
+      start_line -= 1 unless comment_exists_at?(start_line)
       start_line.downto(1) do |line|
         comment = @comments_by_line[line]
         break unless comment
@@ -671,6 +745,11 @@ module RubyIndexer
       comments
     end
 
+    sig { params(line: Integer).returns(T::Boolean) }
+    def comment_exists_at?(line)
+      @comments_by_line.key?(line) || !@source_lines[line - 1].to_s.strip.empty?
+    end
+
     sig { params(name: String).returns(String) }
     def fully_qualify_name(name)
       if @stack.empty? || name.start_with?("::")
@@ -734,16 +813,22 @@ module RubyIndexer
       return unless arguments
 
       arguments.each do |node|
-        next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
-
-        case operation
-        when :include
-          owner.mixin_operations << Entry::Include.new(node.full_name)
-        when :prepend
-          owner.mixin_operations << Entry::Prepend.new(node.full_name)
-        when :extend
+        next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode) ||
+          (node.is_a?(Prism::SelfNode) && operation == :extend)
+
+        if node.is_a?(Prism::SelfNode)
           singleton = @index.existing_or_new_singleton_class(owner.name)
-          singleton.mixin_operations << Entry::Include.new(node.full_name)
+          singleton.mixin_operations << Entry::Include.new(owner.name)
+        else
+          case operation
+          when :include
+            owner.mixin_operations << Entry::Include.new(node.full_name)
+          when :prepend
+            owner.mixin_operations << Entry::Prepend.new(node.full_name)
+          when :extend
+            singleton = @index.existing_or_new_singleton_class(owner.name)
+            singleton.mixin_operations << Entry::Include.new(node.full_name)
+          end
         end
       rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
              Prism::ConstantPathNode::MissingNodesInConstantPathError
@@ -751,6 +836,87 @@ module RubyIndexer
       end
     end
 
+    sig { params(node: Prism::CallNode).void }
+    def handle_module_function(node)
+      arguments_node = node.arguments
+      return unless arguments_node
+
+      owner_name = @owner_stack.last&.name
+      return unless owner_name
+
+      arguments_node.arguments.each do |argument|
+        method_name = case argument
+        when Prism::StringNode
+          argument.content
+        when Prism::SymbolNode
+          argument.value
+        end
+        next unless method_name
+
+        entries = @index.resolve_method(method_name, owner_name)
+        next unless entries
+
+        entries.each do |entry|
+          entry_owner_name = entry.owner&.name
+          next unless entry_owner_name
+
+          entry.visibility = Entry::Visibility::PRIVATE
+
+          singleton = @index.existing_or_new_singleton_class(entry_owner_name)
+          location = Location.from_prism_location(argument.location, @code_units_cache)
+          @index.add(Entry::Method.new(
+            method_name,
+            @file_path,
+            location,
+            location,
+            collect_comments(node)&.concat(entry.comments),
+            entry.signatures,
+            Entry::Visibility::PUBLIC,
+            singleton,
+          ))
+        end
+      end
+    end
+
+    sig { params(node: Prism::CallNode).void }
+    def handle_private_class_method(node)
+      node.arguments&.arguments&.each do |argument|
+        string_or_symbol_nodes = case argument
+        when Prism::StringNode, Prism::SymbolNode
+          [argument]
+        when Prism::ArrayNode
+          argument.elements
+        else
+          []
+        end
+
+        unless string_or_symbol_nodes.empty?
+          # pop the visibility off since there isn't a method definition following `private_class_method`
+          @visibility_stack.pop
+        end
+
+        string_or_symbol_nodes.each do |string_or_symbol_node|
+          method_name = case string_or_symbol_node
+          when Prism::StringNode
+            string_or_symbol_node.content
+          when Prism::SymbolNode
+            string_or_symbol_node.value
+          end
+          next unless method_name
+
+          owner_name = @owner_stack.last&.name
+          next unless owner_name
+
+          entries = @index.resolve_method(method_name, @index.existing_or_new_singleton_class(owner_name).name)
+          next unless entries
+
+          entries.each do |entry|
+            entry.visibility = Entry::Visibility::PRIVATE
+          end
+        end
+      end
+    end
+
     sig { returns(Entry::Visibility) }
     def current_visibility
       T.must(@visibility_stack.last)
@@ -856,5 +1022,13 @@ module RubyIndexer
 
       corrected_nesting
     end
+
+    sig { params(short_name: String, entry: Entry::Namespace).void }
+    def advance_namespace_stack(short_name, entry)
+      @visibility_stack.push(Entry::Visibility::PUBLIC)
+      @owner_stack << entry
+      @index.add(entry)
+      @stack << short_name
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -2,29 +2,47 @@
 # frozen_string_literal: true
 
 module RubyIndexer
-  module Enhancement
+  class Enhancement
     extend T::Sig
     extend T::Helpers
 
-    interface!
+    abstract!
 
-    requires_ancestor { Object }
+    @enhancements = T.let([], T::Array[T::Class[Enhancement]])
+
+    class << self
+      extend T::Sig
+
+      sig { params(child: T::Class[Enhancement]).void }
+      def inherited(child)
+        @enhancements << child
+        super
+      end
+
+      sig { params(listener: DeclarationListener).returns(T::Array[Enhancement]) }
+      def all(listener)
+        @enhancements.map { |enhancement| enhancement.new(listener) }
+      end
+
+      # Only available for testing purposes
+      sig { void }
+      def clear
+        @enhancements.clear
+      end
+    end
+
+    sig { params(listener: DeclarationListener).void }
+    def initialize(listener)
+      @listener = listener
+    end
 
     # The `on_extend` indexing enhancement is invoked whenever an extend is encountered in the code. It can be used to
     # register for an included callback, similar to what `ActiveSupport::Concern` does in order to auto-extend the
     # `ClassMethods` modules
-    sig do
-      abstract.params(
-        index: Index,
-        owner: T.nilable(Entry::Namespace),
-        node: Prism::CallNode,
-        file_path: String,
-        code_units_cache: T.any(
-          T.proc.params(arg0: Integer).returns(Integer),
-          Prism::CodeUnitsCache,
-        ),
-      ).void
-    end
-    def on_call_node(index, owner, node, file_path, code_units_cache); end
+    sig { overridable.params(node: Prism::CallNode).void }
+    def on_call_node_enter(node); end # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+
+    sig { overridable.params(node: Prism::CallNode).void }
+    def on_call_node_leave(node); end # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
   end
 end