ruby-lsp 0.23.11 → 0.23.12

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -6,12 +6,8 @@ module RubyLsp
     # The [on type formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_onTypeFormatting)
     # request formats code as the user is typing. For example, automatically adding `end` to class definitions.
     class OnTypeFormatting < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DocumentOnTypeFormattingRegistrationOptions) }
+        #: -> Interface::DocumentOnTypeFormattingRegistrationOptions
         def provider
           Interface::DocumentOnTypeFormattingRegistrationOptions.new(
             document_selector: nil,
@@ -30,14 +26,7 @@ module RubyLsp
         T::Array[Regexp],
       )
 
-      sig do
-        params(
-          document: RubyDocument,
-          position: T::Hash[Symbol, T.untyped],
-          trigger_character: String,
-          client_name: String,
-        ).void
-      end
+      #: (RubyDocument document, Hash[Symbol, untyped] position, String trigger_character, String client_name) -> void
       def initialize(document, position, trigger_character, client_name)
         super()
         @document = document
@@ -52,7 +41,8 @@ module RubyLsp
         @client_name = client_name
       end
 
-      sig { override.returns(T.all(T::Array[Interface::TextEdit], Object)) }
+      # @override
+      #: -> (Array[Interface::TextEdit] & Object)
       def perform
         case @trigger_character
         when "{"
@@ -60,7 +50,10 @@ module RubyLsp
         when "|"
           handle_pipe if @document.syntax_error?
         when "\n"
-          if (comment_match = @previous_line.match(/^#(\s*)/))
+          # If the previous line is a simple comment, we'll add a comment continuation
+          # But if it's a RBS signature starting with `#:`, we'll ignore it
+          # so users can immediately continue typing the method definition
+          if (comment_match = @previous_line.match(/^#(?!:)(\s*)/))
             handle_comment_line(T.must(comment_match[1]))
           elsif @document.syntax_error?
             match = /(<<((-|~)?))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
@@ -81,7 +74,7 @@ module RubyLsp
 
       private
 
-      sig { void }
+      #: -> void
       def handle_pipe
         current_line = @lines[@position[:line]]
         return unless /((?<=do)|(?<={))\s+\|/.match?(current_line)
@@ -112,7 +105,7 @@ module RubyLsp
         move_cursor_to(@position[:line], @position[:character])
       end
 
-      sig { void }
+      #: -> void
       def handle_curly_brace
         return unless /".*#\{/.match?(@previous_line)
 
@@ -120,7 +113,7 @@ module RubyLsp
         move_cursor_to(@position[:line], @position[:character])
       end
 
-      sig { void }
+      #: -> void
       def handle_statement_end
         # If a keyword occurs in a line which appears be a comment or a string, we will not try to format it, since
         # it could be a coincidental match. This approach is not perfect, but it should cover most cases.
@@ -142,7 +135,7 @@ module RubyLsp
         end
       end
 
-      sig { params(delimiter: String).void }
+      #: (String delimiter) -> void
       def handle_heredoc_end(delimiter)
         indents = " " * @indentation
         add_edit_with_text("\n")
@@ -150,12 +143,12 @@ module RubyLsp
         move_cursor_to(@position[:line], @indentation + 2)
       end
 
-      sig { params(spaces: String).void }
+      #: (String spaces) -> void
       def handle_comment_line(spaces)
         add_edit_with_text("##{spaces}")
       end
 
-      sig { params(text: String, position: T::Hash[Symbol, T.untyped]).void }
+      #: (String text, ?Hash[Symbol, untyped] position) -> void
       def add_edit_with_text(text, position = @position)
         pos = Interface::Position.new(
           line: position[:line],
@@ -168,7 +161,7 @@ module RubyLsp
         )
       end
 
-      sig { params(line: Integer, character: Integer).void }
+      #: (Integer line, Integer character) -> void
       def move_cursor_to(line, character)
         return unless /Visual Studio Code|Cursor/.match?(@client_name)
 
@@ -189,7 +182,7 @@ module RubyLsp
         )
       end
 
-      sig { params(line: String).returns(Integer) }
+      #: (String line) -> Integer
       def find_indentation(line)
         count = 0
 
@@ -202,7 +195,7 @@ module RubyLsp
         count
       end
 
-      sig { void }
+      #: -> void
       def auto_indent_after_end_keyword
         current_line = @lines[@position[:line]]
         return unless current_line && current_line.strip == "end"

data/lib/ruby_lsp/requests/prepare_rename.rb

@@ -7,22 +7,17 @@ module RubyLsp
     # [prepare_rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_prepareRename)
     # # request checks the validity of a rename operation at a given location.
     class PrepareRename < Request
-      extend T::Sig
       include Support::Common
 
-      sig do
-        params(
-          document: RubyDocument,
-          position: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: (RubyDocument document, Hash[Symbol, untyped] position) -> void
       def initialize(document, position)
         super()
         @document = document
         @position = T.let(position, T::Hash[Symbol, Integer])
       end
 
-      sig { override.returns(T.nilable(Interface::Range)) }
+      # @override
+      #: -> Interface::Range?
       def perform
         char_position, _ = @document.find_index_by_position(@position)
 

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -9,26 +9,16 @@ module RubyLsp
     #
     # Currently only supports supertypes due to a limitation of the index.
     class PrepareTypeHierarchy < Request
-      extend T::Sig
-
       include Support::Common
 
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::TypeHierarchyOptions) }
+        #: -> Interface::TypeHierarchyOptions
         def provider
           Interface::TypeHierarchyOptions.new
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          index: RubyIndexer::Index,
-          position: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, RubyIndexer::Index index, Hash[Symbol, untyped] position) -> void
       def initialize(document, index, position)
         super()
 
@@ -37,7 +27,8 @@ module RubyLsp
         @position = position
       end
 
-      sig { override.returns(T.nilable(T::Array[Interface::TypeHierarchyItem])) }
+      # @override
+      #: -> Array[Interface::TypeHierarchyItem]?
       def perform
         context = @document.locate_node(
           @position,

data/lib/ruby_lsp/requests/range_formatting.rb

@@ -6,9 +6,7 @@ module RubyLsp
     # The [range formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_rangeFormatting)
     # is used to format a selection or to format on paste.
     class RangeFormatting < Request
-      extend T::Sig
-
-      sig { params(global_state: GlobalState, document: RubyDocument, params: T::Hash[Symbol, T.untyped]).void }
+      #: (GlobalState global_state, RubyDocument document, Hash[Symbol, untyped] params) -> void
       def initialize(global_state, document, params)
         super()
         @document = document
@@ -17,7 +15,8 @@ module RubyLsp
         @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
       end
 
-      sig { override.returns(T.nilable(T::Array[Interface::TextEdit])) }
+      # @override
+      #: -> Array[Interface::TextEdit]?
       def perform
         return unless @active_formatter
         return if @document.syntax_error?

data/lib/ruby_lsp/requests/references.rb

@@ -7,17 +7,9 @@ module RubyLsp
     # [references](https://microsoft.github.io/language-server-protocol/specification#textDocument_references)
     # request finds all references for the selected symbol.
     class References < Request
-      extend T::Sig
       include Support::Common
 
-      sig do
-        params(
-          global_state: GlobalState,
-          store: Store,
-          document: T.any(RubyDocument, ERBDocument),
-          params: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: (GlobalState global_state, Store store, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] params) -> void
       def initialize(global_state, store, document, params)
         super()
         @global_state = global_state
@@ -27,7 +19,8 @@ module RubyLsp
         @locations = T.let([], T::Array[Interface::Location])
       end
 
-      sig { override.returns(T::Array[Interface::Location]) }
+      # @override
+      #: -> Array[Interface::Location]
       def perform
         position = @params[:position]
         char_position, _ = @document.find_index_by_position(position)
@@ -103,24 +96,7 @@ module RubyLsp
 
       private
 
-      sig do
-        params(
-          target_node: T.any(
-            Prism::ConstantReadNode,
-            Prism::ConstantPathNode,
-            Prism::ConstantPathTargetNode,
-            Prism::InstanceVariableAndWriteNode,
-            Prism::InstanceVariableOperatorWriteNode,
-            Prism::InstanceVariableOrWriteNode,
-            Prism::InstanceVariableReadNode,
-            Prism::InstanceVariableTargetNode,
-            Prism::InstanceVariableWriteNode,
-            Prism::CallNode,
-            Prism::DefNode,
-          ),
-          node_context: NodeContext,
-        ).returns(T.nilable(RubyIndexer::ReferenceFinder::Target))
-      end
+      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode) target_node, NodeContext node_context) -> RubyIndexer::ReferenceFinder::Target?
       def create_reference_target(target_node, node_context)
         case target_node
         when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
@@ -145,13 +121,7 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          target: RubyIndexer::ReferenceFinder::Target,
-          parse_result: Prism::ParseResult,
-          uri: URI::Generic,
-        ).void
-      end
+      #: (RubyIndexer::ReferenceFinder::Target target, Prism::ParseResult parse_result, URI::Generic uri) -> void
       def collect_references(target, parse_result, uri)
         dispatcher = Prism::Dispatcher.new
         finder = RubyIndexer::ReferenceFinder.new(

data/lib/ruby_lsp/requests/rename.rb

@@ -7,28 +7,18 @@ module RubyLsp
     # [rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_rename)
     # request renames all instances of a symbol in a document.
     class Rename < Request
-      extend T::Sig
       include Support::Common
 
       class InvalidNameError < StandardError; end
 
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::RenameOptions) }
+        #: -> Interface::RenameOptions
         def provider
           Interface::RenameOptions.new(prepare_provider: true)
         end
       end
 
-      sig do
-        params(
-          global_state: GlobalState,
-          store: Store,
-          document: T.any(RubyDocument, ERBDocument),
-          params: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: (GlobalState global_state, Store store, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] params) -> void
       def initialize(global_state, store, document, params)
         super()
         @global_state = global_state
@@ -38,7 +28,8 @@ module RubyLsp
         @new_name = T.let(params[:newName], String)
       end
 
-      sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
+      # @override
+      #: -> Interface::WorkspaceEdit?
       def perform
         char_position, _ = @document.find_index_by_position(@position)
 
@@ -100,12 +91,7 @@ module RubyLsp
 
       private
 
-      sig do
-        params(
-          fully_qualified_name: String,
-          document_changes: T::Array[T.any(Interface::RenameFile, Interface::TextDocumentEdit)],
-        ).void
-      end
+      #: (String fully_qualified_name, Array[(Interface::RenameFile | Interface::TextDocumentEdit)] document_changes) -> void
       def collect_file_renames(fully_qualified_name, document_changes)
         # Check if the declarations of the symbol being renamed match the file name. In case they do, we automatically
         # rename the files for the user.
@@ -139,12 +125,7 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          target: RubyIndexer::ReferenceFinder::Target,
-          name: String,
-        ).returns(T::Hash[String, T::Array[Interface::TextEdit]])
-      end
+      #: (RubyIndexer::ReferenceFinder::Target target, String name) -> Hash[String, Array[Interface::TextEdit]]
       def collect_text_edits(target, name)
         changes = {}
 
@@ -169,14 +150,7 @@ module RubyLsp
         changes
       end
 
-      sig do
-        params(
-          target: RubyIndexer::ReferenceFinder::Target,
-          parse_result: Prism::ParseResult,
-          name: String,
-          uri: URI::Generic,
-        ).returns(T::Array[Interface::TextEdit])
-      end
+      #: (RubyIndexer::ReferenceFinder::Target target, Prism::ParseResult parse_result, String name, URI::Generic uri) -> Array[Interface::TextEdit]
       def collect_changes(target, parse_result, name, uri)
         dispatcher = Prism::Dispatcher.new
         finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher, uri)
@@ -187,7 +161,7 @@ module RubyLsp
         end
       end
 
-      sig { params(name: String, reference: RubyIndexer::ReferenceFinder::Reference).returns(Interface::TextEdit) }
+      #: (String name, RubyIndexer::ReferenceFinder::Reference reference) -> Interface::TextEdit
       def adjust_reference_for_edit(name, reference)
         # The reference may include a namespace in front. We need to check if the rename new name includes namespaces
         # and then adjust both the text and the location to produce the correct edit
@@ -197,7 +171,7 @@ module RubyLsp
         Interface::TextEdit.new(range: range_from_location(location), new_text: new_text)
       end
 
-      sig { params(constant_name: String).returns(String) }
+      #: (String constant_name) -> String
       def file_from_constant_name(constant_name)
         constant_name
           .gsub(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/, '\1\3_\2\4')

data/lib/ruby_lsp/requests/request.rb

@@ -4,8 +4,8 @@
 module RubyLsp
   module Requests
     class Request
-      extend T::Sig
       extend T::Generic
+      extend T::Sig
 
       class InvalidFormatter < StandardError; end
 
@@ -18,13 +18,7 @@ module RubyLsp
 
       # Signals to the client that the request should be delegated to the language server server for the host language
       # in ERB files
-      sig do
-        params(
-          global_state: GlobalState,
-          document: Document[T.untyped],
-          char_position: Integer,
-        ).void
-      end
+      #: (GlobalState global_state, Document[untyped] document, Integer char_position) -> void
       def delegate_request_if_needed!(global_state, document, char_position)
         if global_state.client_capabilities.supports_request_delegation &&
             document.is_a?(ERBDocument) &&
@@ -34,7 +28,7 @@ module RubyLsp
       end
 
       # Checks if a location covers a position
-      sig { params(location: Prism::Location, position: T.untyped).returns(T::Boolean) }
+      #: (Prism::Location location, untyped position) -> bool
       def cover?(location, position)
         start_covered =
           location.start_line - 1 < position[:line] ||
@@ -61,13 +55,7 @@ module RubyLsp
       #  #   ^ Going to definition here should go to Foo::Bar
       # #^ Going to definition here should go to Foo
       # ```
-      sig do
-        params(
-          target: Prism::Node,
-          parent: Prism::Node,
-          position: T::Hash[Symbol, Integer],
-        ).returns(Prism::Node)
-      end
+      #: (Prism::Node target, Prism::Node parent, Hash[Symbol, Integer] position) -> Prism::Node
       def determine_target(target, parent, position)
         return target unless parent.is_a?(Prism::ConstantPathNode)
 
@@ -83,7 +71,7 @@ module RubyLsp
       end
 
       # Checks if a given location covers the position requested
-      sig { params(location: T.nilable(Prism::Location), position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      #: (Prism::Location? location, Hash[Symbol, untyped] position) -> bool
       def covers_position?(location, position)
         return false unless location
 

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -11,10 +11,9 @@ module RubyLsp
     #
     # Note that if using VSCode Neovim, you will need to be in Insert mode for this to work correctly.
     class SelectionRanges < Request
-      extend T::Sig
       include Support::Common
 
-      sig { params(document: T.any(RubyDocument, ERBDocument)).void }
+      #: ((RubyDocument | ERBDocument) document) -> void
       def initialize(document)
         super()
         @document = document
@@ -22,7 +21,8 @@ module RubyLsp
         @stack = T.let([], T::Array[Support::SelectionRange])
       end
 
-      sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
+      # @override
+      #: -> (Array[Support::SelectionRange] & Object)
       def perform
         # [node, parent]
         queue = [[@document.parse_result.value, nil]]

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -9,12 +9,8 @@ module RubyLsp
     # highlighting](https://microsoft.github.io/language-server-protocol/specification#textDocument_semanticTokens)
     # request informs the editor of the correct token types to provide consistent and accurate highlighting for themes.
     class SemanticHighlighting < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::SemanticTokensRegistrationOptions) }
+        #: -> Interface::SemanticTokensRegistrationOptions
         def provider
           Interface::SemanticTokensRegistrationOptions.new(
             document_selector: nil,
@@ -29,13 +25,7 @@ module RubyLsp
 
         # The compute_delta method receives the current semantic tokens and the previous semantic tokens and then tries
         # to compute the smallest possible semantic token edit that will turn previous into current
-        sig do
-          params(
-            current_tokens: T::Array[Integer],
-            previous_tokens: T::Array[Integer],
-            result_id: String,
-          ).returns(Interface::SemanticTokensDelta)
-        end
+        #: (Array[Integer] current_tokens, Array[Integer] previous_tokens, String result_id) -> Interface::SemanticTokensDelta
         def compute_delta(current_tokens, previous_tokens, result_id)
           # Find the index of the first token that is different between the two sets of tokens
           first_different_position = current_tokens.zip(previous_tokens).find_index { |new, old| new != old }
@@ -73,7 +63,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(Integer) }
+        #: -> Integer
         def next_result_id
           @mutex.synchronize do
             @result_id += 1
@@ -84,15 +74,7 @@ module RubyLsp
       @result_id = T.let(0, Integer)
       @mutex = T.let(Mutex.new, Mutex)
 
-      sig do
-        params(
-          global_state: GlobalState,
-          dispatcher: Prism::Dispatcher,
-          document: T.any(RubyDocument, ERBDocument),
-          previous_result_id: T.nilable(String),
-          range: T.nilable(T::Range[Integer]),
-        ).void
-      end
+      #: (GlobalState global_state, Prism::Dispatcher dispatcher, (RubyDocument | ERBDocument) document, String? previous_result_id, ?range: T::Range[Integer]?) -> void
       def initialize(global_state, dispatcher, document, previous_result_id, range: nil)
         super()
 
@@ -111,7 +93,8 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(T.any(Interface::SemanticTokens, Interface::SemanticTokensDelta)) }
+      # @override
+      #: -> (Interface::SemanticTokens | Interface::SemanticTokensDelta)
       def perform
         previous_tokens = @document.semantic_tokens
         tokens = @response_builder.response

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -7,9 +7,7 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#requestMessage) that displays the AST
     # for the current document or for the current selection in a new tab.
     class ShowSyntaxTree < Request
-      extend T::Sig
-
-      sig { params(document: RubyDocument, range: T.nilable(T::Hash[Symbol, T.untyped])).void }
+      #: (RubyDocument document, Hash[Symbol, untyped]? range) -> void
       def initialize(document, range)
         super()
         @document = document
@@ -17,7 +15,8 @@ module RubyLsp
         @tree = T.let(document.parse_result.value, Prism::ProgramNode)
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def perform
         return ast_for_range if @range
 
@@ -28,7 +27,7 @@ module RubyLsp
 
       private
 
-      sig { returns(String) }
+      #: -> String
       def ast_for_range
         range = T.must(@range)
         start_char, end_char = @document.find_index_by_position(range[:start], range[:end])

data/lib/ruby_lsp/requests/signature_help.rb

@@ -9,12 +9,8 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_signatureHelp) displays
     # information about the parameters of a method as you type an invocation.
     class SignatureHelp < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::SignatureHelpOptions) }
+        #: -> Interface::SignatureHelpOptions
         def provider
           # Identifier characters are automatically included, such as A-Z, a-z, 0-9, _, * or :
           Interface::SignatureHelpOptions.new(
@@ -23,16 +19,7 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          global_state: GlobalState,
-          position: T::Hash[Symbol, T.untyped],
-          context: T.nilable(T::Hash[Symbol, T.untyped]),
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Hash[Symbol, untyped]? context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
 
@@ -54,7 +41,8 @@ module RubyLsp
         Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, sorbet_level)
       end
 
-      sig { override.returns(T.nilable(Interface::SignatureHelp)) }
+      # @override
+      #: -> Interface::SignatureHelp?
       def perform
         return unless @target
 
@@ -70,13 +58,7 @@ module RubyLsp
       # foo(another_method_call)
       #
       # In that case, we want to provide signature help for `foo` and not `another_method_call`.
-      sig do
-        params(
-          target: T.nilable(Prism::Node),
-          parent: T.nilable(Prism::Node),
-          position: T::Hash[Symbol, T.untyped],
-        ).returns(T.nilable(Prism::Node))
-      end
+      #: (Prism::Node? target, Prism::Node? parent, Hash[Symbol, untyped] position) -> Prism::Node?
       def adjust_for_nested_target(target, parent, position)
         # If the parent node is not a method call, then make no adjustments
         return target unless parent.is_a?(Prism::CallNode)
@@ -92,7 +74,7 @@ module RubyLsp
         arguments.nil? || !node_covers?(arguments, position) ? parent : target
       end
 
-      sig { params(node: Prism::Node, position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      #: (Prism::Node node, Hash[Symbol, untyped] position) -> bool
       def node_covers?(node, position)
         location = node.location
         start_line = location.start_line - 1

data/lib/ruby_lsp/requests/support/annotation.rb

@@ -5,32 +5,26 @@ module RubyLsp
   module Requests
     module Support
       class Annotation
-        extend T::Sig
-        sig do
-          params(
-            arity: T.any(Integer, T::Range[Integer]),
-            receiver: T::Boolean,
-          ).void
-        end
+        #: (arity: (Integer | T::Range[Integer]), ?receiver: bool) -> void
         def initialize(arity:, receiver: false)
           @arity = arity
           @receiver = receiver
         end
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def match?(node)
           receiver_matches?(node) && arity_matches?(node)
         end
 
         private
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def receiver_matches?(node)
           node_receiver = node.receiver
           (node_receiver && @receiver && node_receiver.location.slice == "T") || (!node_receiver && !@receiver)
         end
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def arity_matches?(node)
           node_arity = node.arguments&.arguments&.size || 0