tapioca 0.16.9 → 0.17.7

data/lib/tapioca/dsl/helpers/active_model_type_helper.rb

@@ -10,7 +10,7 @@ module Tapioca
 
           # Returns the type indicated by the custom ActiveModel::Type::Value.
           # Accepts subclasses of ActiveModel::Type::Value as well as classes that implement similar methods.
-          sig { params(type_value: T.untyped).returns(String) }
+          #: (untyped type_value) -> String
           def type_for(type_value)
             return "T.untyped" if Runtime::GenericTypeRegistry.generic_type_instance?(type_value)
 
@@ -23,34 +23,31 @@ module Tapioca
             type.to_s
           end
 
-          sig { params(type_value: T.untyped).returns(T::Boolean) }
+          #: (untyped type_value) -> bool
           def assume_nilable?(type_value)
             !type_value.respond_to?(:__tapioca_type)
           end
 
           private
 
-          MEANINGLESS_TYPES = T.let(
-            [
-              T.untyped,
-              T.noreturn,
-              T::Private::Types::Void,
-              T::Private::Types::NotTyped,
-            ].freeze,
-            T::Array[Object],
-          )
+          MEANINGLESS_TYPES = [
+            T.untyped,
+            T.noreturn,
+            T::Private::Types::Void,
+            T::Private::Types::NotTyped,
+          ].freeze #: Array[Object]
 
-          sig { params(type: T.untyped).returns(T::Boolean) }
+          #: (untyped type) -> bool
           def meaningful_type?(type)
             !MEANINGLESS_TYPES.include?(type)
           end
 
-          sig { params(obj: T.untyped).returns(T.nilable(T::Types::Base)) }
+          #: (untyped obj) -> T::Types::Base?
           def lookup_tapioca_type(obj)
             T::Utils.coerce(obj.__tapioca_type) if obj.respond_to?(:__tapioca_type)
           end
 
-          sig { params(obj: T.untyped, method: Symbol).returns(T.nilable(T::Types::Base)) }
+          #: (untyped obj, Symbol method) -> T::Types::Base?
           def lookup_return_type_of_method(obj, method)
             return_type = lookup_signature_of_method(obj, method)&.return_type
             return unless return_type && meaningful_type?(return_type)
@@ -58,7 +55,7 @@ module Tapioca
             return_type
           end
 
-          sig { params(obj: T.untyped, method: Symbol).returns(T.nilable(T::Types::Base)) }
+          #: (untyped obj, Symbol method) -> T::Types::Base?
           def lookup_arg_type_of_method(obj, method)
             # Arg types is an array of [name, type] entries, so we dig into first entry (index 0)
             # and then into the type which is the last element (index 1)
@@ -68,7 +65,7 @@ module Tapioca
             first_arg_type
           end
 
-          sig { params(obj: T.untyped, method: Symbol).returns(T.untyped) }
+          #: (untyped obj, Symbol method) -> untyped
           def lookup_signature_of_method(obj, method)
             Runtime::Reflection.signature_of(obj.method(method))
           rescue NameError

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -22,12 +22,7 @@ module Tapioca
           class << self
             extend T::Sig
 
-            sig do
-              params(
-                options: T::Hash[String, T.untyped],
-                block: T.proc.params(value: String, default_column_type_option: ColumnTypeOption).void,
-              ).returns(ColumnTypeOption)
-            end
+            #: (Hash[String, untyped] options) { (String value, ColumnTypeOption default_column_type_option) -> void } -> ColumnTypeOption
             def from_options(options, &block)
               column_type_option = Persisted
               value = options["ActiveRecordColumnTypes"]
@@ -44,39 +39,29 @@ module Tapioca
             end
           end
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def persisted?
             self == ColumnTypeOption::Persisted
           end
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def nilable?
             self == ColumnTypeOption::Nilable
           end
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def untyped?
             self == ColumnTypeOption::Untyped
           end
         end
 
-        sig do
-          params(
-            constant: T.class_of(ActiveRecord::Base),
-            column_type_option: ColumnTypeOption,
-          ).void
-        end
+        #: (singleton(ActiveRecord::Base) constant, ?column_type_option: ColumnTypeOption) -> void
         def initialize(constant, column_type_option: ColumnTypeOption::Persisted)
           @constant = constant
           @column_type_option = column_type_option
         end
 
-        sig do
-          params(
-            attribute_name: String,
-            column_name: String,
-          ).returns([String, String])
-        end
+        #: (String attribute_name, ?String column_name) -> [String, String]
         def type_for(attribute_name, column_name = attribute_name)
           return id_type if attribute_name == "id"
 
@@ -85,7 +70,7 @@ module Tapioca
 
         private
 
-        sig { returns([String, String]) }
+        #: -> [String, String]
         def id_type
           if @constant.respond_to?(:composite_primary_key?) && T.unsafe(@constant).composite_primary_key?
             primary_key_columns = @constant.primary_key
@@ -105,7 +90,7 @@ module Tapioca
           end
         end
 
-        sig { params(column_name: T.nilable(String)).returns([String, String]) }
+        #: (String? column_name) -> [String, String]
         def column_type_for(column_name)
           return ["T.untyped", "T.untyped"] if @column_type_option.untyped?
 
@@ -128,7 +113,7 @@ module Tapioca
           end
         end
 
-        sig { params(column_type: T.untyped, column_nullability: T::Boolean).returns(String) }
+        #: (untyped column_type, column_nullability: bool) -> String
         def type_for_activerecord_value(column_type, column_nullability:)
           case column_type
           when ->(type) { defined?(MoneyColumn) && MoneyColumn::ActiveRecordType === type }
@@ -229,7 +214,7 @@ module Tapioca
           end
         end
 
-        sig { params(base_type: String, column_nullability: T::Boolean).returns(String) }
+        #: (String base_type, column_nullability: bool) -> String
         def as_non_nilable_if_persisted_and_not_nullable(base_type, column_nullability:)
           # It's possible that when ActiveModel::Type::Value is used, the signature being reflected on in
           # ActiveModelTypeHelper.type_for(type_value) may say the type can be nilable. However, if the type is
@@ -239,7 +224,7 @@ module Tapioca
           base_type
         end
 
-        sig { params(column_type: ActiveRecord::Enum::EnumType).returns(String) }
+        #: (ActiveRecord::Enum::EnumType column_type) -> String
         def enum_setter_type(column_type)
           # In Rails < 7 this method is private. When support for that is dropped we can call the method directly
           case column_type.send(:subtype)
@@ -250,7 +235,7 @@ module Tapioca
           end
         end
 
-        sig { params(column_type: ActiveRecord::Type::Serialized).returns(String) }
+        #: (ActiveRecord::Type::Serialized column_type) -> String
         def serialized_column_type(column_type)
           case column_type.coder
           when ActiveRecord::Coders::YAMLColumn
@@ -267,7 +252,7 @@ module Tapioca
           end
         end
 
-        sig { params(column_type: T.untyped).returns(T::Boolean) }
+        #: (untyped column_type) -> bool
         def not_nilable_serialized_column?(column_type)
           return false unless column_type.is_a?(ActiveRecord::Type::Serialized)
           return false unless column_type.coder.is_a?(ActiveRecord::Coders::YAMLColumn)

data/lib/tapioca/dsl/helpers/active_record_constants_helper.rb

@@ -11,23 +11,27 @@ module Tapioca
           T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
         end
 
-        AttributeMethodsModuleName = T.let("GeneratedAttributeMethods", String)
-        AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
-        DelegatedTypesModuleName = T.let("GeneratedDelegatedTypeMethods", String)
-        SecureTokensModuleName = T.let("GeneratedSecureTokenMethods", String)
-        StoredAttributesModuleName = T.let("GeneratedStoredAttributesMethods", String)
+        # rubocop:disable Naming/ConstantName
 
-        RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
-        AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)
-        CommonRelationMethodsModuleName = T.let("CommonRelationMethods", String)
+        AttributeMethodsModuleName = "GeneratedAttributeMethods" #: String
+        AssociationMethodsModuleName = "GeneratedAssociationMethods" #: String
+        DelegatedTypesModuleName = "GeneratedDelegatedTypeMethods" #: String
+        SecureTokensModuleName = "GeneratedSecureTokenMethods" #: String
+        StoredAttributesModuleName = "GeneratedStoredAttributesMethods" #: String
 
-        RelationClassName = T.let("PrivateRelation", String)
-        RelationGroupChainClassName = T.let("PrivateRelationGroupChain", String)
-        RelationWhereChainClassName = T.let("PrivateRelationWhereChain", String)
-        AssociationRelationClassName = T.let("PrivateAssociationRelation", String)
-        AssociationRelationGroupChainClassName = T.let("PrivateAssociationRelationGroupChain", String)
-        AssociationRelationWhereChainClassName = T.let("PrivateAssociationRelationWhereChain", String)
-        AssociationsCollectionProxyClassName = T.let("PrivateCollectionProxy", String)
+        RelationMethodsModuleName = "GeneratedRelationMethods" #: String
+        AssociationRelationMethodsModuleName = "GeneratedAssociationRelationMethods" #: String
+        CommonRelationMethodsModuleName = "CommonRelationMethods" #: String
+
+        RelationClassName = "PrivateRelation" #: String
+        RelationGroupChainClassName = "PrivateRelationGroupChain" #: String
+        RelationWhereChainClassName = "PrivateRelationWhereChain" #: String
+        AssociationRelationClassName = "PrivateAssociationRelation" #: String
+        AssociationRelationGroupChainClassName = "PrivateAssociationRelationGroupChain" #: String
+        AssociationRelationWhereChainClassName = "PrivateAssociationRelationWhereChain" #: String
+        AssociationsCollectionProxyClassName = "PrivateCollectionProxy" #: String
+
+        # rubocop:enable Naming/ConstantName
       end
     end
   end

data/lib/tapioca/dsl/helpers/graphql_type_helper.rb

@@ -9,12 +9,7 @@ module Tapioca
 
         extend T::Sig
 
-        sig do
-          params(
-            argument: GraphQL::Schema::Argument,
-            constant: T.any(T.class_of(GraphQL::Schema::Mutation), T.class_of(GraphQL::Schema::InputObject)),
-          ).returns(String)
-        end
+        #: (GraphQL::Schema::Argument argument, (singleton(GraphQL::Schema::Mutation) | singleton(GraphQL::Schema::InputObject)) constant) -> String
         def type_for_argument(argument, constant)
           type = if argument.loads
             loads_type = ::GraphQL::Schema::Wrapper.new(argument.loads)
@@ -39,21 +34,7 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            type: T.any(
-              GraphQL::Schema::Wrapper,
-              T.class_of(GraphQL::Schema::Scalar),
-              T.class_of(GraphQL::Schema::Enum),
-              T.class_of(GraphQL::Schema::Union),
-              T.class_of(GraphQL::Schema::Object),
-              T.class_of(GraphQL::Schema::Interface),
-              T.class_of(GraphQL::Schema::InputObject),
-            ),
-            ignore_nilable_wrapper: T::Boolean,
-            prepare_method: T.nilable(Method),
-          ).returns(String)
-        end
+        #: ((GraphQL::Schema::Wrapper | singleton(GraphQL::Schema::Scalar) | singleton(GraphQL::Schema::Enum) | singleton(GraphQL::Schema::Union) | singleton(GraphQL::Schema::Object) | singleton(GraphQL::Schema::Interface) | singleton(GraphQL::Schema::InputObject)) type, ?ignore_nilable_wrapper: bool, ?prepare_method: Method?) -> String
         def type_for(type, ignore_nilable_wrapper: false, prepare_method: nil)
           unwrapped_type = type.unwrap
 
@@ -116,7 +97,7 @@ module Tapioca
 
         private
 
-        sig { params(constant: Module).returns(String) }
+        #: (Module constant) -> String
         def type_for_constant(constant)
           if constant.instance_methods.include?(:prepare)
             prepare_method = constant.instance_method(:prepare)
@@ -129,12 +110,12 @@ module Tapioca
           Runtime::Reflection.qualified_name_of(constant) || "T.untyped"
         end
 
-        sig { params(argument: GraphQL::Schema::Argument).returns(T::Boolean) }
+        #: (GraphQL::Schema::Argument argument) -> bool
         def has_replaceable_default?(argument)
           !!argument.replace_null_with_default? && !argument.default_value.nil?
         end
 
-        sig { params(return_type: T.nilable(T::Types::Base)).returns(T::Boolean) }
+        #: (T::Types::Base? return_type) -> bool
         def valid_return_type?(return_type)
           !!return_type && !(T::Private::Types::Void === return_type || T::Private::Types::NotTyped === return_type)
         end

data/lib/tapioca/dsl/pipeline.rb

@@ -6,37 +6,25 @@ module Tapioca
     class Pipeline
       extend T::Sig
 
-      sig { returns(T::Enumerable[T.class_of(Compiler)]) }
+      #: T::Enumerable[singleton(Compiler)]
       attr_reader :active_compilers
 
-      sig { returns(T::Array[Module]) }
+      #: Array[Module]
       attr_reader :requested_constants
 
-      sig { returns(T::Array[Pathname]) }
+      #: Array[Pathname]
       attr_reader :requested_paths
 
-      sig { returns(T::Array[Module]) }
+      #: Array[Module]
       attr_reader :skipped_constants
 
-      sig { returns(T.proc.params(error: String).void) }
+      #: ^(String error) -> void
       attr_reader :error_handler
 
-      sig { returns(T::Array[String]) }
+      #: Array[String]
       attr_reader :errors
 
-      sig do
-        params(
-          requested_constants: T::Array[Module],
-          requested_paths: T::Array[Pathname],
-          requested_compilers: T::Array[T.class_of(Compiler)],
-          excluded_compilers: T::Array[T.class_of(Compiler)],
-          error_handler: T.proc.params(error: String).void,
-          skipped_constants: T::Array[Module],
-          number_of_workers: T.nilable(Integer),
-          compiler_options: T::Hash[String, T.untyped],
-          lsp_addon: T::Boolean,
-        ).void
-      end
+      #: (requested_constants: Array[Module], ?requested_paths: Array[Pathname], ?requested_compilers: Array[singleton(Compiler)], ?excluded_compilers: Array[singleton(Compiler)], ?error_handler: ^(String error) -> void, ?skipped_constants: Array[Module], ?number_of_workers: Integer?, ?compiler_options: Hash[String, untyped], ?lsp_addon: bool) -> void
       def initialize(
         requested_constants:,
         requested_paths: [],
@@ -48,10 +36,8 @@ module Tapioca
         compiler_options: {},
         lsp_addon: false
       )
-        @active_compilers = T.let(
-          gather_active_compilers(requested_compilers, excluded_compilers),
-          T::Enumerable[T.class_of(Compiler)],
-        )
+        @active_compilers =
+          gather_active_compilers(requested_compilers, excluded_compilers) #: Enumerable[singleton(Compiler)]
         @requested_constants = requested_constants
         @requested_paths = requested_paths
         @error_handler = error_handler
@@ -59,14 +45,10 @@ module Tapioca
         @number_of_workers = number_of_workers
         @compiler_options = compiler_options
         @lsp_addon = lsp_addon
-        @errors = T.let([], T::Array[String])
+        @errors = [] #: Array[String]
       end
 
-      sig do
-        type_parameters(:T).params(
-          blk: T.proc.params(constant: Module, rbi: RBI::File).returns(T.type_parameter(:T)),
-        ).returns(T::Array[T.type_parameter(:T)])
-      end
+      #: [T] { (Module constant, RBI::File rbi) -> T } -> Array[T]
       def run(&blk)
         constants_to_process = gather_constants(requested_constants, requested_paths, skipped_constants)
           .select { |c| Module === c } # Filter value constants out
@@ -78,6 +60,7 @@ module Tapioca
             No classes/modules can be matched for RBI generation.
             Please check that the requested classes/modules include processable DSL methods.
           ERROR
+          raise Tapioca::Error, ""
         end
 
         if defined?(::ActiveRecord::Base) && constants_to_process.any? { |c| ::ActiveRecord::Base > c }
@@ -94,19 +77,23 @@ module Tapioca
           blk.call(constant, rbi)
         end
 
-        errors.each do |msg|
-          report_error(msg)
+        if errors.any?
+          errors.each do |msg|
+            report_error(msg)
+          end
+
+          raise Tapioca::Error, ""
         end
 
         result.compact
       end
 
-      sig { params(error: String).void }
+      #: (String error) -> void
       def add_error(error)
         @errors << error
       end
 
-      sig { params(compiler_name: String).returns(T::Boolean) }
+      #: (String compiler_name) -> bool
       def compiler_enabled?(compiler_name)
         potential_names = Compilers::NAMESPACES.map { |namespace| namespace + compiler_name }
 
@@ -115,24 +102,16 @@ module Tapioca
         end
       end
 
-      sig { returns(T::Array[T.class_of(Compiler)]) }
+      #: -> Array[singleton(Compiler)]
       def compilers
-        @compilers ||= T.let(
-          Runtime::Reflection.descendants_of(Compiler).sort_by do |compiler|
-            T.must(compiler.name)
-          end,
-          T.nilable(T::Array[T.class_of(Compiler)]),
-        )
+        @compilers ||= Runtime::Reflection.descendants_of(Compiler).sort_by do |compiler|
+          T.must(compiler.name)
+        end #: Array[singleton(Compiler)]?
       end
 
       private
 
-      sig do
-        params(
-          requested_compilers: T::Array[T.class_of(Compiler)],
-          excluded_compilers: T::Array[T.class_of(Compiler)],
-        ).returns(T::Enumerable[T.class_of(Compiler)])
-      end
+      #: (Array[singleton(Compiler)] requested_compilers, Array[singleton(Compiler)] excluded_compilers) -> T::Enumerable[singleton(Compiler)]
       def gather_active_compilers(requested_compilers, excluded_compilers)
         active_compilers = compilers
         active_compilers -= excluded_compilers
@@ -140,13 +119,7 @@ module Tapioca
         active_compilers
       end
 
-      sig do
-        params(
-          requested_constants: T::Array[Module],
-          requested_paths: T::Array[Pathname],
-          skipped_constants: T::Array[Module],
-        ).returns(T::Set[Module])
-      end
+      #: (Array[Module] requested_constants, Array[Pathname] requested_paths, Array[Module] skipped_constants) -> Set[Module]
       def gather_constants(requested_constants, requested_paths, skipped_constants)
         Compiler.requested_constants = requested_constants
         constants = Set.new.compare_by_identity
@@ -168,7 +141,7 @@ module Tapioca
         constants
       end
 
-      sig { params(constants: T::Set[Module]).returns(T::Set[Module]) }
+      #: (Set[Module] constants) -> Set[Module]
       def filter_anonymous_and_reloaded_constants(constants)
         # Group constants by their names
         constants_by_name = constants
@@ -197,7 +170,7 @@ module Tapioca
         Set.new.compare_by_identity.merge(filtered_constants)
       end
 
-      sig { params(constant: Module).returns(T.nilable(RBI::File)) }
+      #: (Module constant) -> RBI::File?
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 
@@ -216,14 +189,13 @@ module Tapioca
         file
       end
 
-      sig { params(error: String).returns(T.noreturn) }
+      #: (String error) -> void
       def report_error(error)
         handler = error_handler
         handler.call(error)
-        exit(1)
       end
 
-      sig { void }
+      #: -> void
       def abort_if_pending_migrations!
         # When running within the add-on, we cannot invoke the abort if pending migrations task because that will exit
         # the process and crash the Rails runtime server. Instead, the Rails add-on checks for pending migrations and

data/lib/tapioca/executor.rb

@@ -5,26 +5,20 @@ module Tapioca
   class Executor
     extend T::Sig
 
-    MINIMUM_ITEMS_PER_WORKER = T.let(2, Integer)
+    MINIMUM_ITEMS_PER_WORKER = 2 #: Integer
 
-    sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(Integer)).void }
+    #: (Array[untyped] queue, ?number_of_workers: Integer?) -> void
     def initialize(queue, number_of_workers: nil)
       @queue = queue
 
       # Forking workers is expensive and not worth it for a low number of gems. Here we assign the number of workers to
       # be the minimum between the number of available processors (max) or the number of workers to make sure that each
       # one has at least 4 items to process
-      @number_of_workers = T.let(
-        number_of_workers || [max_processors, (queue.length.to_f / MINIMUM_ITEMS_PER_WORKER).ceil].min,
-        Integer,
-      )
+      @number_of_workers = number_of_workers ||
+        [max_processors, (queue.length.to_f / MINIMUM_ITEMS_PER_WORKER).ceil].min #: Integer
     end
 
-    sig do
-      type_parameters(:T).params(
-        block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T)),
-      ).returns(T::Array[T.type_parameter(:T)])
-    end
+    #: [T] { (untyped item) -> T } -> Array[T]
     def run_in_parallel(&block)
       # To have the parallel gem run jobs in the parent process, you must pass 0 as the number of processes
       number_of_processes = @number_of_workers == 1 ? 0 : @number_of_workers
@@ -33,7 +27,7 @@ module Tapioca
 
     private
 
-    sig { returns(Integer) }
+    #: -> Integer
     def max_processors
       env_max_processors = ENV["PARALLEL_PROCESSOR_COUNT"].to_i
       env_max_processors.positive? ? env_max_processors : Etc.nprocessors

data/lib/tapioca/gem/events.rb

@@ -3,20 +3,18 @@
 
 module Tapioca
   module Gem
+    # @abstract
     class Event
       extend T::Sig
-      extend T::Helpers
-
-      abstract!
     end
 
     class SymbolFound < Event
       extend T::Sig
 
-      sig { returns(String) }
+      #: String
       attr_reader :symbol
 
-      sig { params(symbol: String).void }
+      #: (String symbol) -> void
       def initialize(symbol)
         super()
         @symbol = symbol
@@ -26,13 +24,15 @@ module Tapioca
     class ConstantFound < Event
       extend T::Sig
 
-      sig { returns(String) }
+      #: String
       attr_reader :symbol
 
-      sig { returns(BasicObject).checked(:never) }
+      # @without_runtime
+      #: BasicObject
       attr_reader :constant
 
-      sig { params(symbol: String, constant: BasicObject).void.checked(:never) }
+      # @without_runtime
+      #: (String symbol, BasicObject constant) -> void
       def initialize(symbol, constant)
         super()
         @symbol = symbol
@@ -43,30 +43,29 @@ module Tapioca
     class ForeignConstantFound < ConstantFound
       extend T::Sig
 
-      sig { override.returns(Module) }
+      # @override
+      #: -> Module
       def constant
         T.cast(@constant, Module)
       end
 
-      sig { params(symbol: String, constant: Module).void }
+      #: (String symbol, Module constant) -> void
       def initialize(symbol, constant)
         super
       end
     end
 
+    # @abstract
     class NodeAdded < Event
-      extend T::Helpers
       extend T::Sig
 
-      abstract!
-
-      sig { returns(String) }
+      #: String
       attr_reader :symbol
 
-      sig { returns(Module).checked(:never) }
+      #: Module
       attr_reader :constant
 
-      sig { params(symbol: String, constant: Module).void.checked(:never) }
+      #: (String symbol, Module constant) -> void
       def initialize(symbol, constant)
         super()
         @symbol = symbol
@@ -77,10 +76,10 @@ module Tapioca
     class ConstNodeAdded < NodeAdded
       extend T::Sig
 
-      sig { returns(RBI::Const) }
+      #: RBI::Const
       attr_reader :node
 
-      sig { params(symbol: String, constant: Module, node: RBI::Const).void.checked(:never) }
+      #: (String symbol, Module constant, RBI::Const node) -> void
       def initialize(symbol, constant, node)
         super(symbol, constant)
         @node = node
@@ -90,10 +89,10 @@ module Tapioca
     class ScopeNodeAdded < NodeAdded
       extend T::Sig
 
-      sig { returns(RBI::Scope) }
+      #: RBI::Scope
       attr_reader :node
 
-      sig { params(symbol: String, constant: Module, node: RBI::Scope).void.checked(:never) }
+      #: (String symbol, Module constant, RBI::Scope node) -> void
       def initialize(symbol, constant, node)
         super(symbol, constant)
         @node = node
@@ -105,28 +104,19 @@ module Tapioca
     class MethodNodeAdded < NodeAdded
       extend T::Sig
 
-      sig { returns(UnboundMethod) }
+      #: UnboundMethod
       attr_reader :method
 
-      sig { returns(RBI::Method) }
+      #: RBI::Method
       attr_reader :node
 
-      sig { returns(T.untyped) }
+      #: untyped
       attr_reader :signature
 
-      sig { returns(T::Array[[Symbol, String]]) }
+      #: Array[[Symbol, String]]
       attr_reader :parameters
 
-      sig do
-        params(
-          symbol: String,
-          constant: Module,
-          method: UnboundMethod,
-          node: RBI::Method,
-          signature: T.untyped,
-          parameters: T::Array[[Symbol, String]],
-        ).void.checked(:never)
-      end
+      #: (String symbol, Module constant, UnboundMethod method, RBI::Method node, untyped signature, Array[[Symbol, String]] parameters) -> void
       def initialize(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
         super(symbol, constant)
         @node = node