tapioca 0.16.11 → 0.17.0

data/lib/tapioca/dsl/compilers/smart_properties.rb

@@ -59,12 +59,10 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::SmartProperties) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
-          properties = T.let(
-            T.unsafe(constant).properties,
-            ::SmartProperties::PropertyCollection,
-          )
+          properties = T.unsafe(constant).properties #: ::SmartProperties::PropertyCollection
           return if properties.keys.empty?
 
           root.create_path(constant) do |k|
@@ -82,7 +80,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_modules.select do |c|
               name_of(c) &&
@@ -95,12 +94,7 @@ module Tapioca
 
         private
 
-        sig do
-          params(
-            mod: RBI::Scope,
-            property: ::SmartProperties::Property,
-          ).void
-        end
+        #: (RBI::Scope mod, ::SmartProperties::Property property) -> void
         def generate_methods_for_property(mod, property)
           type = type_for(property)
 
@@ -114,15 +108,12 @@ module Tapioca
           mod.create_method(property.reader.to_s, return_type: type)
         end
 
-        BOOLEANS = T.let(
-          [
-            [true, false],
-            [false, true],
-          ].freeze,
-          T::Array[[T::Boolean, T::Boolean]],
-        )
+        BOOLEANS = [
+          [true, false],
+          [false, true],
+        ].freeze #: Array[[bool, bool]]
 
-        sig { params(property: ::SmartProperties::Property).returns(String) }
+        #: (::SmartProperties::Property property) -> String
         def type_for(property)
           converter, accepter, required = property.to_h.fetch_values(
             :converter,

data/lib/tapioca/dsl/compilers/state_machines.rb

@@ -114,7 +114,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.all(Module, ::StateMachines::ClassMethods) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.state_machines.empty?
 
@@ -157,7 +158,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_classes.select { |mod| ::StateMachines::InstanceMethods > mod }
           end
@@ -165,7 +167,7 @@ module Tapioca
 
         private
 
-        sig { params(machine: ::StateMachines::Machine).returns(String) }
+        #: (::StateMachines::Machine machine) -> String
         def state_type_for(machine)
           value_types = machine.states.map { |state| state.value.class.name }.uniq
 
@@ -176,7 +178,7 @@ module Tapioca
           end
         end
 
-        sig { params(instance_module: RBI::Module).void }
+        #: (RBI::Module instance_module) -> void
         def define_activerecord_methods(instance_module)
           instance_module.create_method(
             "changed_for_autosave?",
@@ -184,7 +186,7 @@ module Tapioca
           )
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_state_methods(instance_module, machine)
           machine.states.each do |state|
             instance_module.create_method(
@@ -194,7 +196,7 @@ module Tapioca
           end
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_event_methods(instance_module, machine)
           machine.events.each do |event|
             instance_module.create_method(
@@ -219,13 +221,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            instance_module: RBI::Module,
-            machine: ::StateMachines::Machine,
-            state_type: String,
-          ).void
-        end
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine, String state_type) -> void
         def define_state_accessor(instance_module, machine, state_type)
           attribute = machine.attribute.to_s
           instance_module.create_method(
@@ -239,7 +235,7 @@ module Tapioca
           ) if ::StateMachines::HelperModule === machine.owner_class.instance_method("#{attribute}=").owner
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_state_predicate(instance_module, machine)
           instance_module.create_method(
             "#{machine.name}?",
@@ -248,7 +244,7 @@ module Tapioca
           )
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_event_helpers(instance_module, machine)
           events_attribute = machine.attribute(:events).to_s
           transitions_attribute = machine.attribute(:transitions).to_s
@@ -295,7 +291,7 @@ module Tapioca
           end
         end
 
-        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine) -> void
         def define_path_helpers(instance_module, machine)
           paths_attribute = machine.attribute(:paths).to_s
 
@@ -306,13 +302,7 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            instance_module: RBI::Module,
-            class_module: RBI::Module,
-            machine: ::StateMachines::Machine,
-          ).void
-        end
+        #: (RBI::Module instance_module, RBI::Module class_module, ::StateMachines::Machine machine) -> void
         def define_name_helpers(instance_module, class_module, machine)
           name_attribute = machine.attribute(:name).to_s
           event_name_attribute = machine.attribute(:event_name).to_s
@@ -337,7 +327,7 @@ module Tapioca
           )
         end
 
-        sig { params(class_module: RBI::Module, machine: ::StateMachines::Machine).void }
+        #: (RBI::Module class_module, ::StateMachines::Machine machine) -> void
         def define_scopes(class_module, machine)
           helper_modules = machine.instance_variable_get(:@helper_modules)
           class_methods = helper_modules[:class].instance_methods(false)

data/lib/tapioca/dsl/compilers/url_helpers.rb

@@ -83,7 +83,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: Module } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           case constant
           when GeneratedPathHelpersModule.singleton_class, GeneratedUrlHelpersModule.singleton_class
@@ -98,7 +99,8 @@ module Tapioca
 
         class << self
           extend T::Sig
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             return [] unless defined?(Rails.application) && Rails.application
 
@@ -130,7 +132,7 @@ module Tapioca
             constants.concat(NON_DISCOVERABLE_INCLUDERS).push(GeneratedUrlHelpersModule, GeneratedPathHelpersModule)
           end
 
-          sig { returns(T::Array[Module]) }
+          #: -> Array[Module]
           def gather_non_discoverable_includers
             [].tap do |includers|
               if defined?(ActionController::TemplateAssertions) && defined?(ActionDispatch::IntegrationTest)
@@ -145,7 +147,7 @@ module Tapioca
 
           # Returns `true` if `mod` "directly" includes `helper`.
           # For classes, this method will return false if the `helper` is included only by a superclass
-          sig { params(mod: Module, helper: Module).returns(T::Boolean) }
+          #: (Module mod, Module helper) -> bool
           private def includes_helper?(mod, helper)
             ancestors = ancestors_of(mod)
 
@@ -160,11 +162,11 @@ module Tapioca
           end
         end
 
-        NON_DISCOVERABLE_INCLUDERS = T.let(gather_non_discoverable_includers, T::Array[Module])
+        NON_DISCOVERABLE_INCLUDERS = gather_non_discoverable_includers #: Array[Module]
 
         private
 
-        sig { params(root: RBI::Tree, constant: Module).void }
+        #: (RBI::Tree root, Module constant) -> void
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
             mod.create_include("::ActionDispatch::Routing::UrlFor")
@@ -180,7 +182,7 @@ module Tapioca
           end
         end
 
-        sig { params(mod: RBI::Scope, helper_module: Module).void }
+        #: (RBI::Scope mod, Module helper_module) -> void
         def create_mixins_for(mod, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)

data/lib/tapioca/dsl/compilers.rb

@@ -10,13 +10,10 @@ module Tapioca
       # a different namespace and can only be referred to using their fully
       # qualified name. This constant encapsulates that dual lookup when
       # a compiler needs to be resolved by name.
-      NAMESPACES = T.let(
-        [
-          "#{name}::", # compilers in this namespace
-          "::", # compilers that need to be fully namespaced
-        ],
-        T::Array[String],
-      )
+      NAMESPACES = [
+        "#{name}::", # compilers in this namespace
+        "::", # compilers that need to be fully namespaced
+      ] #: Array[String]
     end
   end
 end

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