ruby-lsp-rails 0.3.31 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1d9f0d516dcad6d833e05e05defd6ba7ea0bbb3fb2b0c48e7edb9709306d854
-  data.tar.gz: 41b2f9dec0e1ba1d3d4d92a5eb1b4ad5dfd6b6d8c3e62b69822ac156f3232bfd
+  metadata.gz: ea71850cee42d73b31e37c68aa3438a7d59c4c610fef1e2e20a157ff7c7bd92d
+  data.tar.gz: 5d4506c255005cc442fbe95fc73bfe58220a70155313b4451b8a3e549feef9de
 SHA512:
-  metadata.gz: f4421fb81f4cffaa89abe05244ec8bcc2da8ffa0e27b5f7c310c49747d7b2e20a6eec85b58dfe77f5107bd8281ca9d2e61a5f70b2d100c5938f4a2932deedfd0
-  data.tar.gz: aa8476c6f72a66782d9d8b3225944c862f708cd9fc60fd17cf871d9f3332885bd0b7060cbf778710e9213686d5e24c1e415327c14a00a738e28f934dfae156c7
+  metadata.gz: e8538d6e4330168cc5d480ca157cb0c57e178ff3b24429f1a456986e3f91f471a830b3d6ab04b943dd5d18f4d9116ff25ccf94da91db28e8c9c4ad850a488532
+  data.tar.gz: d527c41fcffc45935bab4a5b6332d940c07fdcbaaec189a223bbba5db46459d2f5fb033a3a4809f7ffc74aa1bf1cdcb0ed228cc6f244db4b25ff2ea57aa57421

data/Rakefile

@@ -10,10 +10,19 @@ load "rails/tasks/statistics.rake"
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+# Since `server.rb` runs within the host Rails application, we want to ensure
+# we don't accidentally depend on sorbet-runtime. `server_test` intentionally doesn't use `test_helper`.
+# We run `server_test` in a seperate Rake task.
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"] - ["test/ruby_lsp_rails/server_test.rb"]
 end
 
-task default: [:"db:setup", :test]
+Rake::TestTask.new(:server_test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = ["test/ruby_lsp_rails/server_test.rb"]
+end
+
+task default: [:"db:setup", :test, :server_test]

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -13,17 +13,16 @@ require_relative "hover"
 require_relative "code_lens"
 require_relative "document_symbol"
 require_relative "definition"
+require_relative "rails_test_style"
 require_relative "completion"
 require_relative "indexing_enhancement"
 
 module RubyLsp
   module Rails
     class Addon < ::RubyLsp::Addon
-      extend T::Sig
-
       RUN_MIGRATIONS_TITLE = "Run Migrations"
 
-      sig { void }
+      #: -> void
       def initialize
         super
 
@@ -32,6 +31,12 @@ module RubyLsp
         @rails_runner_client = T.let(NullClient.new, RunnerClient)
         @global_state = T.let(nil, T.nilable(GlobalState))
         @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
+        @settings = T.let(
+          {
+            enablePendingMigrationsPrompt: true,
+          },
+          T::Hash[Symbol, T.untyped],
+        )
         @addon_mutex = T.let(Mutex.new, Mutex)
         @client_mutex = T.let(Mutex.new, Mutex)
         @client_mutex.lock
@@ -39,100 +44,99 @@ module RubyLsp
         Thread.new do
           @addon_mutex.synchronize do
             # We need to ensure the Rails client is fully loaded before we activate the server addons
-            @client_mutex.synchronize { @rails_runner_client = RunnerClient.create_client(T.must(@outgoing_queue)) }
+            @client_mutex.synchronize do
+              @rails_runner_client = RunnerClient.create_client(T.must(@outgoing_queue), T.must(@global_state))
+            end
             offer_to_run_pending_migrations
           end
         end
       end
 
-      sig { returns(RunnerClient) }
+      #: -> RunnerClient
       def rails_runner_client
         @addon_mutex.synchronize { @rails_runner_client }
       end
 
-      sig { override.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+      # @override
+      #: (GlobalState global_state, Thread::Queue outgoing_queue) -> void
       def activate(global_state, outgoing_queue)
         @global_state = global_state
         @outgoing_queue = outgoing_queue
         @outgoing_queue << Notification.window_log_message("Activating Ruby LSP Rails add-on v#{VERSION}")
 
+        addon_settings = @global_state.settings_for_addon(name)
+        @settings.merge!(addon_settings) if addon_settings
+
         register_additional_file_watchers(global_state: global_state, outgoing_queue: outgoing_queue)
 
         # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
         @client_mutex.unlock
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def deactivate
         @rails_runner_client.shutdown
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def version
         VERSION
       end
 
-      # Creates a new CodeLens listener. This method is invoked on every CodeLens request
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
+      # @override
+      #: (ResponseBuilders::TestCollection response_builder, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+      def create_discover_tests_listener(response_builder, dispatcher, uri)
+        return unless @global_state
+
+        RailsTestStyle.new(@rails_runner_client, response_builder, @global_state, dispatcher, uri)
       end
-      def create_code_lens_listener(response_builder, uri, dispatcher)
-        CodeLens.new(@rails_runner_client, T.must(@global_state), response_builder, uri, dispatcher)
+
+      # @override
+      #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+      def resolve_test_commands(items)
+        RailsTestStyle.resolve_test_commands(items)
       end
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::Hover,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-        ).void
+      # Creates a new CodeLens listener. This method is invoked on every CodeLens request
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
+      def create_code_lens_listener(response_builder, uri, dispatcher)
+        return unless @global_state
+
+        CodeLens.new(@rails_runner_client, @global_state, response_builder, uri, dispatcher)
       end
+
+      # @override
+      #: (ResponseBuilders::Hover response_builder, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
       def create_hover_listener(response_builder, node_context, dispatcher)
-        Hover.new(@rails_runner_client, response_builder, node_context, T.must(@global_state), dispatcher)
-      end
+        return unless @global_state
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::DocumentSymbol,
-          dispatcher: Prism::Dispatcher,
-        ).returns(Object)
+        Hover.new(@rails_runner_client, response_builder, node_context, @global_state, dispatcher)
       end
+
+      # @override
+      #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> Object
       def create_document_symbol_listener(response_builder, dispatcher)
         DocumentSymbol.new(response_builder, dispatcher)
       end
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
-            Interface::Location, Interface::LocationLink
-          )],
-          uri: URI::Generic,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
       def create_definition_listener(response_builder, uri, node_context, dispatcher)
-        index = T.must(@global_state).index
-        Definition.new(@rails_runner_client, response_builder, node_context, index, dispatcher)
-      end
+        return unless @global_state
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          uri: URI::Generic,
-        ).void
+        Definition.new(@rails_runner_client, response_builder, node_context, @global_state.index, dispatcher)
       end
+
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
       def create_completion_listener(response_builder, node_context, dispatcher, uri)
         Completion.new(@rails_runner_client, response_builder, node_context, dispatcher, uri)
       end
 
-      sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
+      #: (Array[{uri: String, type: Integer}] changes) -> void
       def workspace_did_change_watched_files(changes)
         if changes.any? { |c| c[:uri].end_with?("db/schema.rb") || c[:uri].end_with?("structure.sql") }
           @rails_runner_client.trigger_reload
@@ -146,12 +150,14 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def name
         "Ruby LSP Rails"
       end
 
-      sig { override.params(title: String).void }
+      # @override
+      #: (String title) -> void
       def handle_window_show_message_response(title)
         if title == RUN_MIGRATIONS_TITLE
 
@@ -178,7 +184,7 @@ module RubyLsp
 
       private
 
-      sig { params(id: String, title: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
+      #: (String id, String title, ?percentage: Integer?, ?message: String?) -> void
       def begin_progress(id, title, percentage: nil, message: nil)
         return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
 
@@ -196,21 +202,21 @@ module RubyLsp
         )
       end
 
-      sig { params(id: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
-      def report_progress(id,  percentage: nil, message: nil)
+      #: (String id, ?percentage: Integer?, ?message: String?) -> void
+      def report_progress(id, percentage: nil, message: nil)
         return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
 
         @outgoing_queue << Notification.progress_report(id, percentage: percentage, message: message)
       end
 
-      sig { params(id: String).void }
+      #: (String id) -> void
       def end_progress(id)
         return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
 
         @outgoing_queue << Notification.progress_end(id)
       end
 
-      sig { params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+      #: (global_state: GlobalState, outgoing_queue: Thread::Queue) -> void
       def register_additional_file_watchers(global_state:, outgoing_queue:)
         return unless global_state.client_capabilities.supports_watching_files
 
@@ -231,7 +237,7 @@ module RubyLsp
         )
       end
 
-      sig { returns(Interface::FileSystemWatcher) }
+      #: -> Interface::FileSystemWatcher
       def structure_sql_file_watcher
         Interface::FileSystemWatcher.new(
           glob_pattern: "**/*structure.sql",
@@ -239,7 +245,7 @@ module RubyLsp
         )
       end
 
-      sig { returns(Interface::FileSystemWatcher) }
+      #: -> Interface::FileSystemWatcher
       def fixture_file_watcher
         Interface::FileSystemWatcher.new(
           glob_pattern: "**/fixtures/**/*.{yml,yaml,yml.erb,yaml.erb}",
@@ -247,10 +253,11 @@ module RubyLsp
         )
       end
 
-      sig { void }
+      #: -> void
       def offer_to_run_pending_migrations
         return unless @outgoing_queue
         return unless @global_state&.client_capabilities&.window_show_message_supports_extra_properties
+        return unless @settings[:enablePendingMigrationsPrompt]
 
         migration_message = @rails_runner_client.pending_migrations_message
         return unless migration_message

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -72,19 +72,10 @@ module RubyLsp
     # Note: Complex routing configurations may not be supported.
     #
     class CodeLens
-      extend T::Sig
       include Requests::Support::Common
       include ActiveSupportTestCaseHelper
 
-      sig do
-        params(
-          client: RunnerClient,
-          global_state: GlobalState,
-          response_builder:  ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (RunnerClient client, GlobalState global_state, ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(client, global_state, response_builder, uri, dispatcher)
         @client = client
         @global_state = global_state
@@ -105,7 +96,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         content = extract_test_case_name(node)
 
@@ -117,7 +108,7 @@ module RubyLsp
       end
 
       # Although uncommon, Rails tests can be written with the classic "def test_name" syntax.
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         method_name = node.name.to_s
 
@@ -133,7 +124,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         class_name = node.constant_path.slice
         superclass_name = node.superclass&.slice
@@ -157,7 +148,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_leave(node)
         class_name = node.constant_path.slice
 
@@ -168,19 +159,19 @@ module RubyLsp
         @constant_name_stack.pop
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         @constant_name_stack << [node.constant_path.slice, nil]
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_leave(node)
         @constant_name_stack.pop
       end
 
       private
 
-      sig { returns(T.nilable(T::Boolean)) }
+      #: -> bool?
       def controller?
         class_name, superclass_name = @constant_name_stack.last
         return false unless class_name && superclass_name
@@ -188,7 +179,7 @@ module RubyLsp
         class_name.end_with?("Controller") && superclass_name.end_with?("Controller")
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def add_jump_to_view(node)
         class_name = @constant_name_stack.map(&:first).join("::")
         action_name = node.name
@@ -216,7 +207,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def add_route_code_lens_to_action(node)
         class_name, _ = T.must(@constant_name_stack.last)
         route = @client.route(controller: class_name, action: node.name.to_s)
@@ -233,22 +224,22 @@ module RubyLsp
         )
       end
 
-      sig { returns(String) }
+      #: -> String
       def test_command
         "#{RbConfig.ruby} bin/rails test"
       end
 
-      sig { returns(String) }
+      #: -> String
       def migrate_command
         "#{RbConfig.ruby} bin/rails db:migrate"
       end
 
-      sig { returns(T.nilable(String)) }
+      #: -> String?
       def migration_version
         File.basename(T.must(@path)).split("_").first
       end
 
-      sig { params(node: Prism::Node, name: String, command: String).void }
+      #: (Prism::Node node, name: String, command: String) -> void
       def add_migrate_code_lens(node, name:, command:)
         return unless @path
 
@@ -261,7 +252,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
+      #: (Prism::Node node, name: String, command: String, kind: Symbol) -> void
       def add_test_code_lens(node, name:, command:, kind:)
         return unless @path
         return unless @global_state.test_library == "rails"

data/lib/ruby_lsp/ruby_lsp_rails/completion.rb

@@ -4,18 +4,10 @@
 module RubyLsp
   module Rails
     class Completion
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        override.params(
-          client: RunnerClient,
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          uri: URI::Generic,
-        ).void
-      end
+      # @override
+      #: (RunnerClient client, ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
       def initialize(client, response_builder, node_context, dispatcher, uri)
         @response_builder = response_builder
         @client = client
@@ -26,7 +18,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         call_node = @node_context.call_node
         return unless call_node
@@ -39,12 +31,12 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::CallNode, receiver: Prism::ConstantReadNode).void }
+      #: (node: Prism::CallNode, receiver: Prism::ConstantReadNode) -> void
       def handle_active_record_where_completions(node:, receiver:)
         resolved_class = @client.model(receiver.name.to_s)
         return if resolved_class.nil?
 
-        arguments = T.must(@node_context.call_node).arguments&.arguments
+        arguments = @node_context.call_node.arguments&.arguments
         indexed_call_node_args = T.let({}, T::Hash[String, Prism::Node])
 
         if arguments
@@ -70,7 +62,7 @@ module RubyLsp
         end
       end
 
-      sig { params(arguments: T::Array[Prism::Node]).returns(T::Hash[String, Prism::Node]) }
+      #: (arguments: Array[Prism::Node]) -> Hash[String, Prism::Node]
       def index_call_node_args(arguments:)
         indexed_call_node_args = {}
         arguments.each do |argument|

data/lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -28,20 +28,9 @@ module RubyLsp
     # - If using `constraints`, the route can only be found if the constraints are met.
     # - Changes to routes won't be picked up until the server is restarted.
     class Definition
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        params(
-          client: RunnerClient,
-          response_builder: RubyLsp::ResponseBuilders::CollectionResponseBuilder[T.any(
-            Interface::Location, Interface::LocationLink
-          )],
-          node_context: NodeContext,
-          index: RubyIndexer::Index,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (RunnerClient client, RubyLsp::ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, NodeContext node_context, RubyIndexer::Index index, Prism::Dispatcher dispatcher) -> void
       def initialize(client, response_builder, node_context, index, dispatcher)
         @client = client
         @response_builder = response_builder
@@ -52,17 +41,17 @@ module RubyLsp
         dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
       end
 
-      sig { params(node: Prism::SymbolNode).void }
+      #: (Prism::SymbolNode node) -> void
       def on_symbol_node_enter(node)
         handle_possible_dsl(node)
       end
 
-      sig { params(node: Prism::StringNode).void }
+      #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         handle_possible_dsl(node)
       end
 
-      sig { params(node: T.any(Prism::SymbolNode, Prism::StringNode)).void }
+      #: ((Prism::SymbolNode | Prism::StringNode) node) -> void
       def handle_possible_dsl(node)
         node = @node_context.call_node
         return unless node
@@ -79,7 +68,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         return unless self_receiver?(node)
 
@@ -94,7 +83,7 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_callback(node)
         arguments = node.arguments&.arguments
         return unless arguments&.any?
@@ -113,7 +102,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_association(node)
         first_argument = node.arguments&.arguments&.first
         return unless first_argument.is_a?(Prism::SymbolNode)
@@ -130,7 +119,7 @@ module RubyLsp
         @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_route(node)
         result = @client.route_location(T.must(node.message))
         return unless result
@@ -138,7 +127,7 @@ module RubyLsp
         @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
       end
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def collect_definitions(name)
         methods = @index.resolve_method(name, @nesting.join("::"))
         return unless methods

data/lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -9,16 +9,10 @@ module RubyLsp
     # request allows users to navigate between associations, validations, callbacks and ActiveSupport test cases with
     # VS Code's "Go to Symbol" feature.
     class DocumentSymbol
-      extend T::Sig
       include Requests::Support::Common
       include ActiveSupportTestCaseHelper
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::DocumentSymbol,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, dispatcher)
         @response_builder = response_builder
         @namespace_stack = T.let([], T::Array[String])
@@ -33,7 +27,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         return if @namespace_stack.empty?
 
@@ -62,39 +56,39 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         add_to_namespace_stack(node)
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_leave(node)
         remove_from_namespace_stack(node)
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         add_to_namespace_stack(node)
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_leave(node)
         remove_from_namespace_stack(node)
       end
 
       private
 
-      sig { params(node: T.any(Prism::ClassNode, Prism::ModuleNode)).void }
+      #: ((Prism::ClassNode | Prism::ModuleNode) node) -> void
       def add_to_namespace_stack(node)
         @namespace_stack << node.constant_path.slice
       end
 
-      sig { params(node: T.any(Prism::ClassNode, Prism::ModuleNode)).void }
+      #: ((Prism::ClassNode | Prism::ModuleNode) node) -> void
       def remove_from_namespace_stack(node)
         @namespace_stack.delete(node.constant_path.slice)
       end
 
-      sig { params(node: Prism::CallNode, message: String).void }
+      #: (Prism::CallNode node, String message) -> void
       def handle_all_arg_types(node, message)
         block = node.block
 
@@ -164,7 +158,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode, message: String).void }
+      #: (Prism::CallNode node, String message) -> void
       def handle_symbol_and_string_arg_types(node, message)
         arguments = node.arguments&.arguments
         return unless arguments&.any?
@@ -193,7 +187,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode, message: String).void }
+      #: (Prism::CallNode node, String message) -> void
       def handle_class_arg_types(node, message)
         arguments = node.arguments&.arguments
         return unless arguments&.any?
@@ -213,13 +207,7 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          name: String,
-          range: RubyLsp::Interface::Range,
-          selection_range: RubyLsp::Interface::Range,
-        ).void
-      end
+      #: (name: String, range: RubyLsp::Interface::Range, selection_range: RubyLsp::Interface::Range) -> void
       def append_document_symbol(name:, range:, selection_range:)
         @response_builder.last.children << RubyLsp::Interface::DocumentSymbol.new(
           name: name,