ruby-lsp 0.23.11 → 0.23.17

data/lib/ruby_lsp/requests/references.rb

@@ -7,27 +7,20 @@ 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
         @store = store
         @document = document
         @params = params
-        @locations = T.let([], T::Array[Interface::Location])
+        @locations = [] #: 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)
@@ -62,22 +55,7 @@ module RubyLsp
           )
         end
 
-        target = T.cast(
-          target,
-          T.any(
-            Prism::ConstantReadNode,
-            Prism::ConstantPathNode,
-            Prism::ConstantPathTargetNode,
-            Prism::InstanceVariableAndWriteNode,
-            Prism::InstanceVariableOperatorWriteNode,
-            Prism::InstanceVariableOrWriteNode,
-            Prism::InstanceVariableReadNode,
-            Prism::InstanceVariableTargetNode,
-            Prism::InstanceVariableWriteNode,
-            Prism::CallNode,
-            Prism::DefNode,
-          ),
-        )
+        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode, # rubocop:disable Layout/LineLength
 
         reference_target = create_reference_target(target, node_context)
         return @locations unless reference_target
@@ -103,24 +81,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
@@ -130,7 +91,8 @@ module RubyLsp
           entries = @global_state.index.resolve(name, node_context.nesting)
           return unless entries
 
-          fully_qualified_name = T.must(entries.first).name
+          fully_qualified_name = entries.first #: as !nil
+            .name
           RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
         when
           Prism::InstanceVariableAndWriteNode,
@@ -145,13 +107,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,38 +7,29 @@ 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
         @store = store
         @document = document
-        @position = T.let(params[:position], T::Hash[Symbol, Integer])
-        @new_name = T.let(params[:newName], String)
+        @position = params[:position] #: Hash[Symbol, Integer]
+        @new_name = params[:newName] #: String
       end
 
-      sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
+      # @override
+      #: -> Interface::WorkspaceEdit?
       def perform
         char_position, _ = @document.find_index_by_position(@position)
 
@@ -60,10 +51,7 @@ module RubyLsp
           )
         end
 
-        target = T.cast(
-          target,
-          T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode),
-        )
+        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode
 
         name = RubyIndexer::Index.constant_name(target)
         return unless name
@@ -72,10 +60,11 @@ module RubyLsp
         return unless entries
 
         if (conflict_entries = @global_state.index.resolve(@new_name, node_context.nesting))
-          raise InvalidNameError, "The new name is already in use by #{T.must(conflict_entries.first).name}"
+          raise InvalidNameError, "The new name is already in use by #{conflict_entries.first&.name}"
         end
 
-        fully_qualified_name = T.must(entries.first).name
+        fully_qualified_name = entries.first #: as !nil
+          .name
         reference_target = RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
         changes = collect_text_edits(reference_target, name)
 
@@ -100,20 +89,15 @@ 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.
         #
         # We also look for an associated test file and rename it too
-        short_name = T.must(fully_qualified_name.split("::").last)
+        short_name = fully_qualified_name.split("::").last #: as !nil
 
-        T.must(@global_state.index[fully_qualified_name]).each do |entry|
+        @global_state.index[fully_qualified_name]&.each do |entry|
           # Do not rename files that are not part of the workspace
           uri = entry.uri
           file_path = uri.full_path
@@ -126,7 +110,9 @@ module RubyLsp
             file_name = file_from_constant_name(short_name)
 
             if "#{file_name}.rb" == entry.file_name
-              new_file_name = file_from_constant_name(T.must(@new_name.split("::").last))
+              new_file_name = file_from_constant_name(
+                @new_name.split("::").last, #: as !nil
+              )
 
               new_uri = URI::Generic.from_path(path: File.join(
                 File.dirname(file_path),
@@ -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,18 +55,13 @@ 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)
 
-        target = T.let(parent, Prism::Node)
-        parent = T.let(T.cast(target, Prism::ConstantPathNode).parent, T.nilable(Prism::Node))
+        target = parent #: Prism::Node
+        parent = target #: as Prism::ConstantPathNode
+          .parent #: Prism::Node?
 
         while parent && cover?(parent.location, position)
           target = parent
@@ -83,7 +72,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,18 +11,18 @@ 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
-        @ranges = T.let([], T::Array[Support::SelectionRange])
-        @stack = T.let([], T::Array[Support::SelectionRange])
+        @ranges = [] #: Array[Support::SelectionRange]
+        @stack = [] #: 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]]
@@ -32,7 +32,7 @@ module RubyLsp
           next unless node
 
           range = Support::SelectionRange.new(range: range_from_location(node.location), parent: parent)
-          T.unsafe(queue).unshift(*node.child_nodes.map { |child| [child, range] })
+          queue.unshift(*node.child_nodes.map { |child| [child, range] })
           @ranges.unshift(range)
         end
 

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 }
@@ -53,8 +43,8 @@ module RubyLsp
           # Filter the tokens based on the first different position. This must happen at this stage, before we try to
           # find the next position from the end or else we risk confusing sets of token that may have different lengths,
           # but end with the exact same token
-          old_tokens = T.must(previous_tokens[first_different_position...])
-          new_tokens = T.must(current_tokens[first_different_position...])
+          old_tokens = previous_tokens[first_different_position...] #: as !nil
+          new_tokens = current_tokens[first_different_position...] #: as !nil
 
           # Then search from the end to find the first token that doesn't match. Since the user is normally editing the
           # middle of the file, this will minimize the number of edits since the end of the token array has not changed
@@ -63,8 +53,8 @@ module RubyLsp
           end || 0
 
           # Filter the old and new tokens to only the section that will be replaced/inserted/deleted
-          old_tokens = T.must(old_tokens[...old_tokens.length - first_different_token_from_end])
-          new_tokens = T.must(new_tokens[...new_tokens.length - first_different_token_from_end])
+          old_tokens = old_tokens[...old_tokens.length - first_different_token_from_end] #: as !nil
+          new_tokens = new_tokens[...new_tokens.length - first_different_token_from_end] #: as !nil
 
           # And we send back a single edit, replacing an entire section for the new tokens
           Interface::SemanticTokensDelta.new(
@@ -73,7 +63,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(Integer) }
+        #: -> Integer
         def next_result_id
           @mutex.synchronize do
             @result_id += 1
@@ -81,29 +71,19 @@ module RubyLsp
         end
       end
 
-      @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
+      @result_id = 0 #: Integer
+      @mutex = Mutex.new #: Mutex
+
+      #: (GlobalState global_state, Prism::Dispatcher dispatcher, (RubyDocument | ERBDocument) document, String? previous_result_id, ?range: Range[Integer]?) -> void
       def initialize(global_state, dispatcher, document, previous_result_id, range: nil)
         super()
 
         @document = document
         @previous_result_id = previous_result_id
         @range = range
-        @result_id = T.let(SemanticHighlighting.next_result_id.to_s, String)
-        @response_builder = T.let(
-          ResponseBuilders::SemanticHighlighting.new(document.code_units_cache),
-          ResponseBuilders::SemanticHighlighting,
-        )
+        @result_id = SemanticHighlighting.next_result_id.to_s #: String
+        @response_builder = ResponseBuilders::SemanticHighlighting
+          .new(document.code_units_cache) #: ResponseBuilders::SemanticHighlighting
         Listeners::SemanticHighlighting.new(dispatcher, @response_builder)
 
         Addon.addons.each do |addon|
@@ -111,7 +91,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,17 +7,16 @@ 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
         @range = range
-        @tree = T.let(document.parse_result.value, Prism::ProgramNode)
+        @tree = document.parse_result.value #: Prism::ProgramNode
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def perform
         return ast_for_range if @range
 
@@ -28,9 +27,9 @@ module RubyLsp
 
       private
 
-      sig { returns(String) }
+      #: -> String
       def ast_for_range
-        range = T.must(@range)
+        range = @range #: as !nil
         start_char, end_char = @document.find_index_by_position(range[:start], range[:end])
 
         queue = @tree.statements.body.dup
@@ -47,7 +46,7 @@ module RubyLsp
           if (start_char..end_char).cover?(loc.start_offset..loc.end_offset)
             found_nodes << node
           else
-            T.unsafe(queue).unshift(*node.child_nodes)
+            queue.unshift(*node.child_nodes)
           end
         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, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
 
@@ -48,13 +35,14 @@ module RubyLsp
 
         target = adjust_for_nested_target(node_context.node, node_context.parent, position)
 
-        @target = T.let(target, T.nilable(Prism::Node))
+        @target = target #: Prism::Node?
         @dispatcher = dispatcher
-        @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
+        @response_builder = ResponseBuilders::SignatureHelp.new #: ResponseBuilders::SignatureHelp
         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 | 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