ruby-lsp 0.23.10 → 0.23.13

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()
 
@@ -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 | 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
 

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

@@ -8,12 +8,11 @@ module RubyLsp
         # WARNING: Methods in this class may be used by Ruby LSP add-ons such as
         # https://github.com/Shopify/ruby-lsp-rails, or add-ons by created by developers outside of Shopify, so be
         # cautious of changing anything.
-        extend T::Sig
         extend T::Helpers
 
         requires_ancestor { Kernel }
 
-        sig { params(node: Prism::Node).returns(Interface::Range) }
+        #: (Prism::Node node) -> Interface::Range
         def range_from_node(node)
           loc = node.location
 
@@ -26,7 +25,7 @@ module RubyLsp
           )
         end
 
-        sig { params(location: T.any(Prism::Location, RubyIndexer::Location)).returns(Interface::Range) }
+        #: ((Prism::Location | RubyIndexer::Location) location) -> Interface::Range
         def range_from_location(location)
           Interface::Range.new(
             start: Interface::Position.new(
@@ -37,15 +36,7 @@ module RubyLsp
           )
         end
 
-        sig do
-          params(
-            node: Prism::Node,
-            title: String,
-            command_name: String,
-            arguments: T.nilable(T::Array[T.untyped]),
-            data: T.nilable(T::Hash[T.untyped, T.untyped]),
-          ).returns(Interface::CodeLens)
-        end
+        #: (Prism::Node node, title: String, command_name: String, arguments: Array[untyped]?, data: Hash[untyped, untyped]?) -> Interface::CodeLens
         def create_code_lens(node, title:, command_name:, arguments:, data:)
           range = range_from_node(node)
 
@@ -60,26 +51,20 @@ module RubyLsp
           )
         end
 
-        sig { params(file_path: String).returns(T.nilable(T::Boolean)) }
+        #: (String file_path) -> bool?
         def not_in_dependencies?(file_path)
           BUNDLE_PATH &&
             !file_path.start_with?(T.must(BUNDLE_PATH)) &&
             !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
         end
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def self_receiver?(node)
           receiver = node.receiver
           receiver.nil? || receiver.is_a?(Prism::SelfNode)
         end
 
-        sig do
-          params(
-            title: String,
-            entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
-            max_entries: T.nilable(Integer),
-          ).returns(T::Hash[Symbol, String])
-        end
+        #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries) -> Hash[Symbol, String]
         def categorized_markdown_from_index_entries(title, entries, max_entries = nil)
           markdown_title = "```ruby\n#{title}\n```"
           definitions = []
@@ -112,14 +97,7 @@ module RubyLsp
           }
         end
 
-        sig do
-          params(
-            title: String,
-            entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
-            max_entries: T.nilable(Integer),
-            extra_links: T.nilable(String),
-          ).returns(String)
-        end
+        #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries, ?extra_links: String?) -> String
         def markdown_from_index_entries(title, entries, max_entries = nil, extra_links: nil)
           categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
 
@@ -135,20 +113,12 @@ module RubyLsp
           MARKDOWN
         end
 
-        sig do
-          params(
-            node: T.any(
-              Prism::ConstantPathNode,
-              Prism::ConstantReadNode,
-              Prism::ConstantPathTargetNode,
-            ),
-          ).returns(T.nilable(String))
-        end
+        #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String?
         def constant_name(node)
           RubyIndexer::Index.constant_name(node)
         end
 
-        sig { params(node: T.any(Prism::ModuleNode, Prism::ClassNode)).returns(T.nilable(String)) }
+        #: ((Prism::ModuleNode | Prism::ClassNode) node) -> String?
         def namespace_constant_name(node)
           path = node.constant_path
           case path
@@ -160,14 +130,9 @@ module RubyLsp
         # Iterates over each part of a constant path, so that we can easily push response items for each section of the
         # name. For example, for `Foo::Bar::Baz`, this method will invoke the block with `Foo`, then `Bar` and finally
         # `Baz`.
-        sig do
-          params(
-            node: Prism::Node,
-            block: T.proc.params(part: Prism::Node).void,
-          ).void
-        end
+        #: (Prism::Node node) { (Prism::Node part) -> void } -> void
         def each_constant_path_part(node, &block)
-          current = T.let(node, T.nilable(Prism::Node))
+          current = node #: Prism::Node?
 
           while current.is_a?(Prism::ConstantPathNode)
             block.call(current)
@@ -175,7 +140,7 @@ module RubyLsp
           end
         end
 
-        sig { params(entry: RubyIndexer::Entry).returns(T.nilable(Integer)) }
+        #: (RubyIndexer::Entry entry) -> Integer?
         def kind_for_entry(entry)
           case entry
           when RubyIndexer::Entry::Class
@@ -193,7 +158,7 @@ module RubyLsp
           end
         end
 
-        sig { params(sorbet_level: RubyDocument::SorbetLevel).returns(T::Boolean) }
+        #: (RubyDocument::SorbetLevel sorbet_level) -> bool
         def sorbet_level_true_or_higher?(sorbet_level)
           sorbet_level == RubyDocument::SorbetLevel::True || sorbet_level == RubyDocument::SorbetLevel::Strict
         end

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

@@ -5,40 +5,32 @@ module RubyLsp
   module Requests
     module Support
       class RuboCopDiagnostic
-        extend T::Sig
-
-        RUBOCOP_TO_LSP_SEVERITY = T.let(
-          {
-            info: Constant::DiagnosticSeverity::HINT,
-            refactor: Constant::DiagnosticSeverity::INFORMATION,
-            convention: Constant::DiagnosticSeverity::INFORMATION,
-            warning: Constant::DiagnosticSeverity::WARNING,
-            error: Constant::DiagnosticSeverity::ERROR,
-            fatal: Constant::DiagnosticSeverity::ERROR,
-          }.freeze,
-          T::Hash[Symbol, Integer],
-        )
-
-        ENHANCED_DOC_URL = T.let(
-          begin
-            gem("rubocop", ">= 1.64.0")
-            true
-          rescue LoadError
-            false
-          end,
-          T::Boolean,
-        )
+        RUBOCOP_TO_LSP_SEVERITY = {
+          info: Constant::DiagnosticSeverity::HINT,
+          refactor: Constant::DiagnosticSeverity::INFORMATION,
+          convention: Constant::DiagnosticSeverity::INFORMATION,
+          warning: Constant::DiagnosticSeverity::WARNING,
+          error: Constant::DiagnosticSeverity::ERROR,
+          fatal: Constant::DiagnosticSeverity::ERROR,
+        }.freeze #: Hash[Symbol, Integer]
+
+        ENHANCED_DOC_URL = begin
+          gem("rubocop", ">= 1.64.0")
+          true
+        rescue LoadError
+          false
+        end #: bool
 
         # TODO: avoid passing document once we have alternative ways to get at
         # encoding and file source
-        sig { params(document: RubyDocument, offense: ::RuboCop::Cop::Offense, uri: URI::Generic).void }
+        #: (RubyDocument document, ::RuboCop::Cop::Offense offense, URI::Generic uri) -> void
         def initialize(document, offense, uri)
           @document = document
           @offense = offense
           @uri = uri
         end
 
-        sig { returns(T::Array[Interface::CodeAction]) }
+        #: -> Array[Interface::CodeAction]
         def to_lsp_code_actions
           code_actions = []
 
@@ -48,7 +40,7 @@ module RubyLsp
           code_actions
         end
 
-        sig { params(config: ::RuboCop::Config).returns(Interface::Diagnostic) }
+        #: (::RuboCop::Config config) -> Interface::Diagnostic
         def to_lsp_diagnostic(config)
           # highlighted_area contains the begin and end position of the first line
           # This ensures that multiline offenses don't clutter the editor
@@ -78,19 +70,19 @@ module RubyLsp
 
         private
 
-        sig { returns(String) }
+        #: -> String
         def message
           message  = @offense.message
           message += "\n\nThis offense is not auto-correctable.\n" unless correctable?
           message
         end
 
-        sig { returns(T.nilable(Integer)) }
+        #: -> Integer?
         def severity
           RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
         end
 
-        sig { params(config: ::RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
+        #: (::RuboCop::Config config) -> Interface::CodeDescription?
         def code_description(config)
           cop = RuboCopRunner.find_cop_by_name(@offense.cop_name)
           return unless cop
@@ -103,7 +95,7 @@ module RubyLsp
           Interface::CodeDescription.new(href: doc_url) if doc_url
         end
 
-        sig { returns(Interface::CodeAction) }
+        #: -> Interface::CodeAction
         def autocorrect_action
           Interface::CodeAction.new(
             title: "Autocorrect #{@offense.cop_name}",
@@ -123,7 +115,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(T::Array[Interface::TextEdit]) }
+        #: -> Array[Interface::TextEdit]
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|
             Interface::TextEdit.new(
@@ -136,7 +128,7 @@ module RubyLsp
           end
         end
 
-        sig { returns(Interface::CodeAction) }
+        #: -> Interface::CodeAction
         def disable_line_action
           Interface::CodeAction.new(
             title: "Disable #{@offense.cop_name} for this line",
@@ -155,7 +147,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(T::Array[Interface::TextEdit]) }
+        #: -> Array[Interface::TextEdit]
         def line_disable_comment
           new_text = if @offense.source_line.include?(" # rubocop:disable ")
             ",#{@offense.cop_name}"
@@ -178,7 +170,7 @@ module RubyLsp
           [inline_comment]
         end
 
-        sig { params(line: String).returns(Integer) }
+        #: (String line) -> Integer
         def length_of_line(line)
           if @document.encoding == Encoding::UTF_16LE
             line_length = 0
@@ -197,7 +189,7 @@ module RubyLsp
         # When `RuboCop::LSP.enable` is called, contextual autocorrect will not offer itself
         # as `correctable?` to prevent annoying changes while typing. Instead check if
         # a corrector is present. If it is, then that means some code transformation can be applied.
-        sig { returns(T::Boolean) }
+        #: -> bool
         def correctable?
           !@offense.corrector.nil?
         end

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

@@ -9,17 +9,17 @@ module RubyLsp
   module Requests
     module Support
       class RuboCopFormatter
-        extend T::Sig
         include Formatter
 
-        sig { void }
+        #: -> void
         def initialize
-          @diagnostic_runner = T.let(RuboCopRunner.new, RuboCopRunner)
+          @diagnostic_runner = RuboCopRunner.new #: RuboCopRunner
           # -a is for "--auto-correct" (or "--autocorrect" on newer versions of RuboCop)
-          @format_runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
+          @format_runner = RuboCopRunner.new("-a") #: RuboCopRunner
         end
 
-        sig { override.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
+        # @override
+        #: (URI::Generic uri, RubyDocument document) -> String?
         def run_formatting(uri, document)
           filename = T.must(uri.to_standardized_path || uri.opaque)
 
@@ -29,17 +29,14 @@ module RubyLsp
         end
 
         # RuboCop does not support range formatting
-        sig { override.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        # @override
+        #: (URI::Generic uri, String source, Integer base_indentation) -> String?
         def run_range_formatting(uri, source, base_indentation)
           nil
         end
 
-        sig do
-          override.params(
-            uri: URI::Generic,
-            document: RubyDocument,
-          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
-        end
+        # @override
+        #: (URI::Generic uri, RubyDocument document) -> Array[Interface::Diagnostic]?
         def run_diagnostic(uri, document)
           filename = T.must(uri.to_standardized_path || uri.opaque)
           # Invoke RuboCop with just this file in `paths`

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

@@ -32,15 +32,13 @@ module RubyLsp
   module Requests
     module Support
       class InternalRuboCopError < StandardError
-        extend T::Sig
-
         MESSAGE = <<~EOS
           An internal error occurred %s.
           Updating to a newer version of RuboCop may solve this.
           For more details, run RuboCop on the command line.
         EOS
 
-        sig { params(rubocop_error: T.any(::RuboCop::ErrorWithAnalyzedFileLocation, StandardError)).void }
+        #: ((::RuboCop::ErrorWithAnalyzedFileLocation | StandardError) rubocop_error) -> void
         def initialize(rubocop_error)
           message = case rubocop_error
           when ::RuboCop::ErrorWithAnalyzedFileLocation
@@ -54,24 +52,19 @@ module RubyLsp
 
       # :nodoc:
       class RuboCopRunner < ::RuboCop::Runner
-        extend T::Sig
-
         class ConfigurationError < StandardError; end
 
-        DEFAULT_ARGS = T.let(
-          [
-            "--stderr", # Print any output to stderr so that our stdout does not get polluted
-            "--force-exclusion",
-            "--format",
-            "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
-          ],
-          T::Array[String],
-        )
-
-        sig { returns(T::Array[::RuboCop::Cop::Offense]) }
+        DEFAULT_ARGS = [
+          "--stderr", # Print any output to stderr so that our stdout does not get polluted
+          "--force-exclusion",
+          "--format",
+          "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+        ] #: Array[String]
+
+        #: Array[::RuboCop::Cop::Offense]
         attr_reader :offenses
 
-        sig { returns(::RuboCop::Config) }
+        #: ::RuboCop::Config
         attr_reader :config_for_working_directory
 
         begin
@@ -82,24 +75,24 @@ module RubyLsp
         end
         DEFAULT_ARGS.freeze
 
-        sig { params(args: String).void }
+        #: (*String args) -> void
         def initialize(*args)
-          @options = T.let({}, T::Hash[Symbol, T.untyped])
-          @offenses = T.let([], T::Array[::RuboCop::Cop::Offense])
-          @errors = T.let([], T::Array[String])
-          @warnings = T.let([], T::Array[String])
+          @options = {} #: Hash[Symbol, untyped]
+          @offenses = [] #: Array[::RuboCop::Cop::Offense]
+          @errors = [] #: Array[String]
+          @warnings = [] #: Array[String]
 
           args += DEFAULT_ARGS
           rubocop_options = ::RuboCop::Options.new.parse(args).first
 
           config_store = ::RuboCop::ConfigStore.new
           config_store.options_config = rubocop_options[:config] if rubocop_options[:config]
-          @config_for_working_directory = T.let(config_store.for_pwd, ::RuboCop::Config)
+          @config_for_working_directory = config_store.for_pwd #: ::RuboCop::Config
 
           super(rubocop_options, config_store)
         end
 
-        sig { params(path: String, contents: String).void }
+        #: (String path, String contents) -> void
         def run(path, contents)
           # Clear Runner state between runs since we get a single instance of this class
           # on every use site.
@@ -121,33 +114,28 @@ module RubyLsp
           raise InternalRuboCopError, error
         end
 
-        sig { returns(String) }
+        #: -> String
         def formatted_source
           @options[:stdin]
         end
 
         class << self
-          extend T::Sig
-
-          sig { params(cop_name: String).returns(T.nilable(T.class_of(::RuboCop::Cop::Base))) }
+          #: (String cop_name) -> singleton(::RuboCop::Cop::Base)?
           def find_cop_by_name(cop_name)
             cop_registry[cop_name]&.first
           end
 
           private
 
-          sig { returns(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]) }
+          #: -> Hash[String, [singleton(::RuboCop::Cop::Base)]]
           def cop_registry
-            @cop_registry ||= T.let(
-              ::RuboCop::Cop::Registry.global.to_h,
-              T.nilable(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]),
-            )
+            @cop_registry ||= ::RuboCop::Cop::Registry.global.to_h #: Hash[String, [singleton(::RuboCop::Cop::Base)]]?
           end
         end
 
         private
 
-        sig { params(_file: String, offenses: T::Array[::RuboCop::Cop::Offense]).void }
+        #: (String _file, Array[::RuboCop::Cop::Offense] offenses) -> void
         def file_finished(_file, offenses)
           @offenses = offenses
         end

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

@@ -5,9 +5,7 @@ module RubyLsp
   module Requests
     module Support
       class SelectionRange < Interface::SelectionRange
-        extend T::Sig
-
-        sig { params(position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+        #: (Hash[Symbol, untyped] position) -> bool
         def cover?(position)
           start_covered = range.start.line < position[:line] ||
             (range.start.line == position[:line] && range.start.character <= position[:character])

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

@@ -6,45 +6,36 @@ module RubyLsp
     module Support
       class Sorbet
         class << self
-          extend T::Sig
+          ANNOTATIONS = {
+            abstract!: Annotation.new(arity: 0),
+            absurd: Annotation.new(arity: 1, receiver: true),
+            all: Annotation.new(arity: (2..), receiver: true),
+            any: Annotation.new(arity: (2..), receiver: true),
+            assert_type!: Annotation.new(arity: 2, receiver: true),
+            attached_class: Annotation.new(arity: 0, receiver: true),
+            bind: Annotation.new(arity: 2, receiver: true),
+            cast: Annotation.new(arity: 2, receiver: true),
+            class_of: Annotation.new(arity: 1, receiver: true),
+            enums: Annotation.new(arity: 0),
+            interface!: Annotation.new(arity: 0),
+            let: Annotation.new(arity: 2, receiver: true),
+            mixes_in_class_methods: Annotation.new(arity: 1),
+            must: Annotation.new(arity: 1, receiver: true),
+            must_because: Annotation.new(arity: 1, receiver: true),
+            nilable: Annotation.new(arity: 1, receiver: true),
+            noreturn: Annotation.new(arity: 0, receiver: true),
+            requires_ancestor: Annotation.new(arity: 0),
+            reveal_type: Annotation.new(arity: 1, receiver: true),
+            sealed!: Annotation.new(arity: 0),
+            self_type: Annotation.new(arity: 0, receiver: true),
+            sig: Annotation.new(arity: 0),
+            type_member: Annotation.new(arity: (0..1)),
+            type_template: Annotation.new(arity: 0),
+            unsafe: Annotation.new(arity: 1),
+            untyped: Annotation.new(arity: 0, receiver: true),
+          } #: Hash[Symbol, Annotation]
 
-          ANNOTATIONS = T.let(
-            {
-              abstract!: Annotation.new(arity: 0),
-              absurd: Annotation.new(arity: 1, receiver: true),
-              all: Annotation.new(arity: (2..), receiver: true),
-              any: Annotation.new(arity: (2..), receiver: true),
-              assert_type!: Annotation.new(arity: 2, receiver: true),
-              attached_class: Annotation.new(arity: 0, receiver: true),
-              bind: Annotation.new(arity: 2, receiver: true),
-              cast: Annotation.new(arity: 2, receiver: true),
-              class_of: Annotation.new(arity: 1, receiver: true),
-              enums: Annotation.new(arity: 0),
-              interface!: Annotation.new(arity: 0),
-              let: Annotation.new(arity: 2, receiver: true),
-              mixes_in_class_methods: Annotation.new(arity: 1),
-              must: Annotation.new(arity: 1, receiver: true),
-              must_because: Annotation.new(arity: 1, receiver: true),
-              nilable: Annotation.new(arity: 1, receiver: true),
-              noreturn: Annotation.new(arity: 0, receiver: true),
-              requires_ancestor: Annotation.new(arity: 0),
-              reveal_type: Annotation.new(arity: 1, receiver: true),
-              sealed!: Annotation.new(arity: 0),
-              self_type: Annotation.new(arity: 0, receiver: true),
-              sig: Annotation.new(arity: 0),
-              type_member: Annotation.new(arity: (0..1)),
-              type_template: Annotation.new(arity: 0),
-              unsafe: Annotation.new(arity: 1),
-              untyped: Annotation.new(arity: 0, receiver: true),
-            },
-            T::Hash[Symbol, Annotation],
-          )
-
-          sig do
-            params(
-              node: Prism::CallNode,
-            ).returns(T::Boolean)
-          end
+          #: (Prism::CallNode node) -> bool
           def annotation?(node)
             !!ANNOTATIONS[node.name]&.match?(node)
           end