rbs_rails 0.12.0 → 0.13.0

data/lib/rbs_rails/active_record.rb

@@ -1,45 +1,58 @@
 module RbsRails
   module ActiveRecord
 
-    def self.generatable?(klass)
+    # @rbs klass: untyped
+    def self.generatable?(klass) #: boolish
       return false if klass.abstract_class?
 
       klass.connection.table_exists?(klass.table_name)
     end
 
-    def self.class_to_rbs(klass, dependencies: [])
-      Generator.new(klass, dependencies: dependencies).generate
+    # @rbs klass: untyped
+    # @rbs dependencies: Array[String]
+    def self.class_to_rbs(klass) #: untyped
+      Generator.new(klass).generate
     end
 
     class Generator
-      IGNORED_ENUM_KEYS = %i[_prefix _suffix _default _scopes]
+      IGNORED_ENUM_KEYS = %i[_prefix _suffix _default _scopes] #: Array[Symbol]
 
-      def initialize(klass, dependencies:)
+      # @rbs @parse_model_file: nil | Parser::AST::Node
+      # @rbs @enum_definitions: Array[Hash[Symbol, untyped]]
+      # @rbs @klass_name: String
+
+      attr_reader :dependencies #: DependencyBuilder
+
+      # @rbs klass: singleton(ActiveRecord::Base) & Enum
+      def initialize(klass) #: untyped
         @klass = klass
-        @dependencies = dependencies
-        @klass_name = Util.module_name(klass)
+        @dependencies = DependencyBuilder.new
+        @klass_name = Util.module_name(klass, abs: false)
 
-        namespaces = klass_name.split('::').tap{ |names| names.pop }
+        namespaces = klass_name(abs: false).split('::').tap{ |names| names.pop }
         @dependencies << namespaces.join('::') unless namespaces.empty?
       end
 
-      def generate
+      def generate #: String
         Util.format_rbs klass_decl
       end
 
-      private def klass_decl
+      private def klass_decl #: String
         <<~RBS
+          # resolve-type-names: false
+
           #{header}
-            extend _ActiveRecord_Relation_ClassMethods[#{klass_name}, #{relation_class_name}, #{pk_type}]
+            extend ::ActiveRecord::Base::ClassMethods[#{klass_name}, #{relation_class_name}, #{pk_type}]
 
           #{columns}
+          #{alias_columns}
           #{associations}
           #{generated_association_methods}
           #{has_secure_password}
           #{delegated_type_instance}
           #{delegated_type_scope(singleton: true)}
           #{enum_instance_methods}
-          #{enum_scope_methods(singleton: true)}
+          #{enum_class_methods(singleton: true)}
           #{scopes(singleton: true)}
 
           #{generated_relation_methods_decl}
@@ -49,80 +62,106 @@ module RbsRails
           #{collection_proxy_decl}
 
           #{footer}
+
+          #{dependencies.build}
         RBS
       end
 
-      private def pk_type
+      private def pk_type #: String
         pk = klass.primary_key
         return 'top' unless pk
 
-        col = klass.columns.find {|col| col.name == pk }
-        sql_type_to_class(col.type)
+        case klass.primary_key
+        when Array
+          types = klass.columns
+                       .select { |column| klass.primary_key.include?(column.name) }
+                       .map { |pk| sql_type_to_class(pk.type) }
+          "[#{types.join(' , ')}]"
+        else
+          col = klass.columns.find { |column| column.name == pk }
+          sql_type_to_class(col.type)
+        end
       end
 
-      private def generated_relation_methods_decl
+      private def generated_relation_methods_decl #: String
         <<~RBS
-          module GeneratedRelationMethods
-            #{enum_scope_methods(singleton: false)}
+          module #{generated_relation_methods_name}
+            #{enum_class_methods(singleton: false)}
             #{scopes(singleton: false)}
             #{delegated_type_scope(singleton: false)}
           end
         RBS
       end
 
-      private def relation_decl
+      private def relation_decl #: String
         <<~RBS
           class #{relation_class_name} < ::ActiveRecord::Relation
-            include GeneratedRelationMethods
-            include _ActiveRecord_Relation[#{klass_name}, #{pk_type}]
-            include Enumerable[#{klass_name}]
+            include ::Enumerable[#{klass_name}]
+            include #{generated_relation_methods_name}
+            include ::ActiveRecord::Relation::Methods[#{klass_name}, #{pk_type}]
           end
         RBS
       end
 
-      private def collection_proxy_decl
+      private def collection_proxy_decl #: String
         <<~RBS
-          class ActiveRecord_Associations_CollectionProxy < ::ActiveRecord::Associations::CollectionProxy
-            include GeneratedRelationMethods
-            include _ActiveRecord_Relation[#{klass_name}, #{pk_type}]
+          class #{klass_name}::ActiveRecord_Associations_CollectionProxy < ::ActiveRecord::Associations::CollectionProxy
+            include ::Enumerable[#{klass_name}]
+            include #{generated_relation_methods_name}
+            include ::ActiveRecord::Relation::Methods[#{klass_name}, #{pk_type}]
+
+            def build: (?::ActiveRecord::Associations::CollectionProxy::_EachPair attributes) ?{ () -> untyped } -> #{klass_name}
+                     | (::Array[::ActiveRecord::Associations::CollectionProxy::_EachPair] attributes) ?{ () -> untyped } -> ::Array[#{klass_name}]
+            def create: (?::ActiveRecord::Associations::CollectionProxy::_EachPair attributes) ?{ () -> untyped } -> #{klass_name}
+                      | (::Array[::ActiveRecord::Associations::CollectionProxy::_EachPair] attributes) ?{ () -> untyped } -> ::Array[#{klass_name}]
+            def create!: (?::ActiveRecord::Associations::CollectionProxy::_EachPair attributes) ?{ () -> untyped } -> #{klass_name}
+                       | (::Array[::ActiveRecord::Associations::CollectionProxy::_EachPair] attributes) ?{ () -> untyped } -> ::Array[#{klass_name}]
+            def reload: () -> ::Array[#{klass_name}]
+
+            def replace: (::Array[#{klass_name}]) -> void
+            def delete: (*#{klass_name} | #{pk_type}) -> ::Array[#{klass_name}]
+            def destroy: (*#{klass_name} | #{pk_type}) -> ::Array[#{klass_name}]
+            def <<: (*#{klass_name} | ::Array[#{klass_name}]) -> self
+            def prepend: (*#{klass_name} | ::Array[#{klass_name}]) -> self
           end
         RBS
       end
 
-      private def header
+      private def header #: String
         namespace = +''
-        klass_name.split('::').map do |mod_name|
+        klass_name(abs: false).split('::').map do |mod_name|
           namespace += "::#{mod_name}"
           mod_object = Object.const_get(namespace)
           case mod_object
           when Class
             # @type var superclass: Class
             superclass = _ = mod_object.superclass
-            superclass_name = Util.module_name(superclass)
+            superclass_name = Util.module_name(superclass, abs: false)
             @dependencies << superclass_name
 
-            "class #{mod_name} < ::#{superclass_name}"
+            "class #{namespace} < ::#{superclass_name}"
           when Module
-            "module #{mod_name}"
+            "module #{namespace}"
           else
             raise 'unreachable'
           end
         end.join("\n")
       end
 
-      private def footer
-        "end\n" * klass_name.split('::').size
+      private def footer #: String
+        "end\n" * klass_name(abs: false).split('::').size
       end
 
-      private def associations
+      private def associations #: String
         [
           has_many,
+          has_and_belongs_to_many,
           has_one,
           belongs_to,
         ].join("\n")
       end
 
-      private def has_many
+      private def has_many #: String
         klass.reflect_on_all_associations(:has_many).map do |a|
           @dependencies << a.klass.name
 
@@ -133,14 +172,32 @@ module RbsRails
 
           <<~RUBY.chomp
             def #{a.name}: () -> #{collection_type}
-            def #{a.name}=: (#{collection_type} | Array[#{type}]) -> (#{collection_type} | Array[#{type}])
-            def #{singular_name}_ids: () -> Array[Integer]
-            def #{singular_name}_ids=: (Array[Integer]) -> Array[Integer]
+            def #{a.name}=: (#{collection_type} | ::Array[#{type}]) -> (#{collection_type} | ::Array[#{type}])
+            def #{singular_name}_ids: () -> ::Array[::Integer]
+            def #{singular_name}_ids=: (::Array[::Integer]) -> ::Array[::Integer]
+          RUBY
+        end.join("\n")
+      end
+
+      private def has_and_belongs_to_many #: String
+        klass.reflect_on_all_associations(:has_and_belongs_to_many).map do |a|
+          @dependencies << a.klass.name
+
+          singular_name = a.name.to_s.singularize
+          type = Util.module_name(a.klass)
+          collection_type = "#{type}::ActiveRecord_Associations_CollectionProxy"
+          @dependencies << collection_type
+
+          <<~RUBY.chomp
+            def #{a.name}: () -> #{collection_type}
+            def #{a.name}=: (#{collection_type} | ::Array[#{type}]) -> (#{collection_type} | ::Array[#{type}])
+            def #{singular_name}_ids: () -> ::Array[::Integer]
+            def #{singular_name}_ids=: (::Array[::Integer]) -> ::Array[::Integer]
           RUBY
         end.join("\n")
       end
 
-      private def has_one
+      private def has_one #: String
         klass.reflect_on_all_associations(:has_one).map do |a|
           @dependencies << a.klass.name unless a.polymorphic?
 
@@ -149,15 +206,15 @@ module RbsRails
           <<~RUBY.chomp
             def #{a.name}: () -> #{type_optional}
             def #{a.name}=: (#{type_optional}) -> #{type_optional}
-            def build_#{a.name}: (untyped) -> #{type}
-            def create_#{a.name}: (untyped) -> #{type}
-            def create_#{a.name}!: (untyped) -> #{type}
+            def build_#{a.name}: (?untyped) -> #{type}
+            def create_#{a.name}: (?untyped) -> #{type}
+            def create_#{a.name}!: (?untyped) -> #{type}
             def reload_#{a.name}: () -> #{type_optional}
           RUBY
         end.join("\n")
       end
 
-      private def belongs_to
+      private def belongs_to #: String
         klass.reflect_on_all_associations(:belongs_to).map do |a|
           @dependencies << a.klass.name unless a.polymorphic?
 
@@ -179,42 +236,43 @@ module RbsRails
         end.join("\n")
       end
 
-      private def generated_association_methods
+      private def generated_association_methods #: String
         # @type var sigs: Array[String]
         sigs = []
 
         # Needs to require "active_storage/engine"
         if klass.respond_to?(:attachment_reflections)
-          sigs << "module GeneratedAssociationMethods"
+          sigs << "module #{klass_name}::GeneratedAssociationMethods"
           sigs << klass.attachment_reflections.map do |name, reflection|
             case reflection.macro
             when :has_one_attached
               <<~EOS
-                def #{name}: () -> ActiveStorage::Attached::One
-                def #{name}=: (ActionDispatch::Http::UploadedFile) -> ActionDispatch::Http::UploadedFile
-                            | (Rack::Test::UploadedFile) -> Rack::Test::UploadedFile
-                            | (ActiveStorage::Blob) -> ActiveStorage::Blob
-                            | (String) -> String
-                            | ({ io: IO, filename: String, content_type: String? }) -> { io: IO, filename: String, content_type: String? }
+                def #{name}: () -> ::ActiveStorage::Attached::One
+                def #{name}=: (::ActionDispatch::Http::UploadedFile) -> ::ActionDispatch::Http::UploadedFile
+                            | (::Rack::Test::UploadedFile) -> ::Rack::Test::UploadedFile
+                            | (::ActiveStorage::Blob) -> ::ActiveStorage::Blob
+                            | (::String) -> ::String
+                            | ({ io: ::IO, filename: ::String, content_type: ::String? }) -> { io: ::IO, filename: ::String, content_type: ::String? }
                             | (nil) -> nil
               EOS
             when :has_many_attached
               <<~EOS
-                def #{name}: () -> ActiveStorage::Attached::Many
+                def #{name}: () -> ::ActiveStorage::Attached::Many
                 def #{name}=: (untyped) -> untyped
               EOS
             else
-              raise
+              raise "unknown macro: #{reflection.macro}"
             end
           end.join("\n")
           sigs << "end"
-          sigs << "include GeneratedAssociationMethods"
+          sigs << "include #{klass_name}::GeneratedAssociationMethods"
         end
 
         sigs.join("\n")
       end
 
-      private def delegated_type_scope(singleton:)
+      # @rbs singleton: bool
+      private def delegated_type_scope(singleton:) #: String
         definitions = delegated_type_definitions
         return "" unless definitions
         definitions.map do |definition|
@@ -225,14 +283,14 @@ module RbsRails
         end.flatten.join("\n")
       end
 
-      private def delegated_type_instance
+      private def delegated_type_instance #: String
         definitions = delegated_type_definitions
         return "" unless definitions
         # @type var methods: Array[String]
         methods = []
         definitions.each do |definition|
-          methods << "def #{definition[:role]}_class: () -> Class"
-          methods << "def #{definition[:role]}_name: () -> String"
+          methods << "def #{definition[:role]}_class: () -> ::Class"
+          methods << "def #{definition[:role]}_name: () -> ::String"
           methods << definition[:types].map do |type|
             scope_name = type.tableize.gsub("/", "_")
             singular = scope_name.singularize
@@ -246,7 +304,7 @@ module RbsRails
         methods.join("\n")
       end
 
-      private def delegated_type_definitions
+      private def delegated_type_definitions #: Array[{ role: Symbol, types: Array[String] }]?
         ast = parse_model_file
         return unless ast
 
@@ -285,7 +343,7 @@ module RbsRails
         end.compact
       end
 
-      private def has_secure_password
+      private def has_secure_password #: String?
         ast = parse_model_file
         return unless ast
 
@@ -303,99 +361,47 @@ module RbsRails
                       end
 
           <<~EOS
-            module ActiveModel_SecurePassword_InstanceMethodsOnActivation_#{attribute}
-              attr_reader #{attribute}: String?
-              def #{attribute}=: (String) -> String
-              def #{attribute}_confirmation=: (String) -> String
-              def authenticate_#{attribute}: (String) -> (#{klass_name} | false)
+            module #{klass_name}::ActiveModel_SecurePassword_InstanceMethodsOnActivation_#{attribute}
+              attr_reader #{attribute}: ::String?
+              def #{attribute}=: (::String) -> ::String
+              def #{attribute}_confirmation=: (::String) -> ::String
+              def authenticate_#{attribute}: (::String) -> (#{klass_name} | false)
               #{attribute == :password ? "alias authenticate authenticate_password" : ""}
             end
-            include ActiveModel_SecurePassword_InstanceMethodsOnActivation_#{attribute}
+            include #{klass_name}::ActiveModel_SecurePassword_InstanceMethodsOnActivation_#{attribute}
           EOS
         end.compact.join("\n")
       end
 
-      private def enum_instance_methods
+      private def enum_instance_methods #: String
         # @type var methods: Array[String]
         methods = []
-        enum_definitions.each do |hash|
-          hash.each do |name, values|
-            next if IGNORED_ENUM_KEYS.include?(name)
-
-            values.each do |label, value|
-              value_method_name = enum_method_name(hash, name, label)
-              methods << "def #{value_method_name}!: () -> bool"
-              methods << "def #{value_method_name}?: () -> bool"
-            end
-          end
+        klass.enum_definitions.each do |_, method_name|
+          methods << "def #{method_name}!: () -> bool"
+          methods << "def #{method_name}?: () -> bool"
         end
 
         methods.join("\n")
       end
 
-      private def enum_scope_methods(singleton:)
+      # @rbs singleton: untyped
+      private def enum_class_methods(singleton:) #: String
         # @type var methods: Array[String]
         methods = []
-        enum_definitions.each do |hash|
-          hash.each do |name, values|
-            next if IGNORED_ENUM_KEYS.include?(name)
-
-            values.each do |label, value|
-              value_method_name = enum_method_name(hash, name, label)
-              methods << "def #{singleton ? 'self.' : ''}#{value_method_name}: () -> #{relation_class_name}"
-            end
-          end
-        end
-        methods.join("\n")
-      end
-
-      private def enum_definitions
-        @enum_definitions ||= build_enum_definitions
-      end
-
-      # We need static analysis to detect enum.
-      # ActiveRecord has `defined_enums` method,
-      # but it does not contain _prefix and _suffix information.
-      private def build_enum_definitions
-        ast = parse_model_file
-        return [] unless ast
-
-        traverse(ast).map do |node|
-          # @type block: nil | Hash[untyped, untyped]
-          next unless node.type == :send
-          next unless node.children[0].nil?
-          next unless node.children[1] == :enum
-
-          definitions = node.children[2]
-          next unless definitions
-          next unless definitions.type == :hash
-          next unless traverse(definitions).all? { |n| [:str, :sym, :int, :hash, :pair, :true, :false].include?(n.type) }
-
-          code = definitions.loc.expression.source
-          code = "{#{code}}" if code[0] != '{'
-          eval(code)
-        end.compact
-      end
-
-      private def enum_method_name(hash, name, label)
-        enum_prefix = hash[:_prefix]
-        enum_suffix = hash[:_suffix]
-
-        if enum_prefix == true
-          prefix = "#{name}_"
-        elsif enum_prefix
-          prefix = "#{enum_prefix}_"
+        klass.enum_definitions.map(&:first).uniq.each do |name|
+          column = klass.columns_hash[name.to_s] || klass.columns_hash[klass.attribute_aliases[name.to_s]]
+          class_name = sql_type_to_class(column.type)
+          methods << "def #{singleton ? 'self.' : ''}#{name.to_s.pluralize}: () -> ::ActiveSupport::HashWithIndifferentAccess[::String, #{class_name}]"
         end
-        if enum_suffix == true
-          suffix = "_#{name}"
-        elsif enum_suffix
-          suffix = "_#{enum_suffix}"
+        klass.enum_definitions.each do |_, method_name|
+          methods << "def #{singleton ? 'self.' : ''}#{method_name}: () -> #{relation_class_name}"
+          methods << "def #{singleton ? 'self.' : ''}not_#{method_name}: () -> #{relation_class_name}"
         end
-
-        "#{prefix}#{label}#{suffix}"
+        methods.join("\n")
       end
 
-      private def scopes(singleton:)
+      # @rbs singleton: untyped
+      private def scopes(singleton:) #: untyped
         ast = parse_model_file
         return '' unless ast
 
@@ -429,7 +435,8 @@ module RbsRails
         sigs.join("\n")
       end
 
-      private def args_to_type(args_node)
+      # @rbs args_node: untyped
+      private def args_to_type(args_node) #: untyped
         # @type var res: Array[String]
         res = []
         # @type var block: String?
@@ -457,97 +464,188 @@ module RbsRails
         "(#{res.join(", ")})#{block}"
       end
 
-      private def parse_model_file
+      private def parse_model_file #: untyped
         return @parse_model_file if defined?(@parse_model_file)
 
-        path = Rails.root.join('app/models/', klass_name.underscore + '.rb')
-        return @parse_model_file = nil unless path.exist?
-        return [] unless path.exist?
+        path, _line = Object.const_source_location(klass.name) rescue nil
+        return @parse_model_file = nil unless path
 
-        ast = Parser::CurrentRuby.parse path.read
-        return @parse_model_file = nil unless path.exist?
+        begin
+          @parse_model_file = parser_class.parse File.read(path)
+        rescue => e
+          @parse_model_file = nil
+        end
+      end
 
-        @parse_model_file = ast
+      private def parser_class #: untyped
+        case RUBY_VERSION
+        when /\A3\.2\./
+          # backward campatibility
+          require 'parser/ruby32'
+          Parser::Ruby32
+        when /\A3\.3\./
+          Prism::Translation::Parser33 # steep:ignore
+        when /\A3\.4\./
+          Prism::Translation::Parser34 # steep:ignore
+        else
+          # For Prism v1.5.0+, Prism::Translation::ParserCurrent should be used instead.
+          Prism::Translation::Parser34 # steep:ignore
+        end
       end
 
+      #: (Parser::AST::Node) { (Parser::AST::Node) -> untyped } -> untyped
+      #: (Parser::AST::Node) -> Enumerator[Parser::AST::Node, untyped]
       private def traverse(node, &block)
-        return to_enum(__method__ || raise, node) unless block_given?
+        return to_enum(__method__ || raise, node) unless block
 
-        # @type var block: ^(Parser::AST::Node) -> untyped
         block.call node
         node.children.each do |child|
           traverse(child, &block) if child.is_a?(Parser::AST::Node)
         end
       end
 
-      private def relation_class_name
-        "ActiveRecord_Relation"
+      private def relation_class_name #: String
+        "#{klass_name}::ActiveRecord_Relation"
+      end
+
+      # @rbs abs: boolish
+      private def klass_name(abs: true) #: String
+        abs ? "::#{@klass_name}" : @klass_name
+      end
+
+      private def generated_relation_methods_name #: String
+        "#{klass_name}::GeneratedRelationMethods"
       end
 
-      private def columns
-        mod_sig = +"module GeneratedAttributeMethods\n"
+
+      private def columns #: untyped
+        mod_sig = +"module #{klass_name}::GeneratedAttributeMethods\n"
         mod_sig << klass.columns.map do |col|
-          class_name = if enum_definitions.any? { |hash| hash.key?(col.name) || hash.key?(col.name.to_sym) }
-                         'String'
-                       else
-                         sql_type_to_class(col.type)
-                       end
-          class_name_opt = optional(class_name)
+          # NOTE:
+          #   `klass.attribute_types[col.name].try(:coder)` is for Rails 6.0 and before
+          #   `klass.attribute_types[col.name]&.instance_variable_get(:@coder)` is for Rails 6.1 and after
+          col_serializer = klass.attribute_types[col.name].try(:coder) ||
+                           klass.attribute_types[col.name]&.instance_variable_get(:@coder)
+          # e.g. ActiveRecord::Coders::JSON
+          #      if your model has `serialize ..., JSON`
+          # e.g. #<ActiveRecord::Coders::YAMLColumn:0x0000aaaafdc54970 @attr_name=..., @object_class=Array>
+          #      if your model has `serialize ..., Array`
+          # etc.
+          col_serialize_to = col_serializer.try(:object_class)&.name
+          if col_serializer.is_a?(Class) && col_serializer.name == 'ActiveRecord::Coders::JSON'
+            class_name = 'untyped' # JSON
+          elsif col_serialize_to == 'Array'
+            class_name = '::Array[untyped]' # Array
+          elsif col_serialize_to == 'Hash'
+            class_name = '::Hash[untyped, untyped]' # Hash
+          else
+            class_name = if klass.enum_definitions.any? { |name, _| name == col.name.to_sym }
+                           '::String'
+                         else
+                           sql_type_to_class(col.type)
+                         end
+          end
+          sql_class_name = col.type == :datetime ? '::Time' : sql_type_to_class(col.type)
+          # If the DB says the column can be null, we need `<type>?`
+          # ...but if the type is already `untyped` there's no point in writing `untyped?`
+          class_name_opt = (class_name == 'untyped') ? 'untyped' : optional(class_name)
           column_type = col.null ? class_name_opt : class_name
+          sql_column_type = col.null ? optional(sql_class_name) : sql_class_name
           sig = <<~EOS
             def #{col.name}: () -> #{column_type}
             def #{col.name}=: (#{column_type}) -> #{column_type}
             def #{col.name}?: () -> bool
-            def #{col.name}_changed?: () -> bool
+            def #{col.name}_changed?: (?from: #{class_name_opt}, ?to: #{class_name_opt}) -> bool
             def #{col.name}_change: () -> [#{class_name_opt}, #{class_name_opt}]
             def #{col.name}_will_change!: () -> void
             def #{col.name}_was: () -> #{class_name_opt}
-            def #{col.name}_previously_changed?: () -> bool
-            def #{col.name}_previous_change: () -> Array[#{class_name_opt}]?
+            def #{col.name}_previously_changed?: (?from: #{class_name_opt}, ?to: #{class_name_opt}) -> bool
+            def #{col.name}_previous_change: () -> ::Array[#{class_name_opt}]?
             def #{col.name}_previously_was: () -> #{class_name_opt}
             def #{col.name}_before_last_save: () -> #{class_name_opt}
-            def #{col.name}_change_to_be_saved: () -> Array[#{class_name_opt}]?
+            def #{col.name}_change_to_be_saved: () -> ::Array[#{class_name_opt}]?
             def #{col.name}_in_database: () -> #{class_name_opt}
-            def saved_change_to_#{col.name}: () -> Array[#{class_name_opt}]?
+            def saved_change_to_#{col.name}: () -> ::Array[#{class_name_opt}]?
             def saved_change_to_#{col.name}?: () -> bool
             def will_save_change_to_#{col.name}?: () -> bool
             def restore_#{col.name}!: () -> void
             def clear_#{col.name}_change: () -> void
+            def #{col.name}_before_type_cast: () -> #{sql_column_type}
+            def #{col.name}_for_database: () -> #{sql_column_type}
+          EOS
+          sig << "\n"
+          sig
+        end.join("\n")
+        mod_sig << "\nend\n"
+        mod_sig << "include #{klass_name}::GeneratedAttributeMethods"
+        mod_sig
+      end
+
+      private def alias_columns
+        attribute_aliases = klass.attribute_aliases.dup
+        attribute_aliases["id_value"] ||= "id" if klass.attribute_names.include?("id")
+
+        mod_sig = +"module #{klass_name}::GeneratedAliasAttributeMethods\n"
+        mod_sig << "include #{klass_name}::GeneratedAttributeMethods\n"
+        mod_sig << attribute_aliases.map do |col|
+          sig = <<~EOS
+            alias #{col[0]} #{col[1]}
+            alias #{col[0]}= #{col[1]}=
+            alias #{col[0]}? #{col[1]}?
+            alias #{col[0]}_changed? #{col[1]}_changed?
+            alias #{col[0]}_change #{col[1]}_change
+            alias #{col[0]}_will_change! #{col[1]}_will_change!
+            alias #{col[0]}_was #{col[1]}_was
+            alias #{col[0]}_previously_changed? #{col[1]}_previously_changed?
+            alias #{col[0]}_previous_change #{col[1]}_previous_change
+            alias #{col[0]}_previously_was #{col[1]}_previously_was
+            alias #{col[0]}_before_last_save #{col[1]}_before_last_save
+            alias #{col[0]}_change_to_be_saved #{col[1]}_change_to_be_saved
+            alias #{col[0]}_in_database #{col[1]}_in_database
+            alias saved_change_to_#{col[0]} saved_change_to_#{col[1]}
+            alias saved_change_to_#{col[0]}? saved_change_to_#{col[1]}?
+            alias will_save_change_to_#{col[0]}? will_save_change_to_#{col[1]}?
+            alias restore_#{col[0]}! restore_#{col[1]}!
+            alias clear_#{col[0]}_change clear_#{col[1]}_change
+            alias #{col[0]}_before_type_cast #{col[1]}_before_type_cast
+            alias #{col[0]}_for_database #{col[1]}_for_database
           EOS
           sig << "\n"
           sig
         end.join("\n")
         mod_sig << "\nend\n"
-        mod_sig << "include GeneratedAttributeMethods"
+        mod_sig << "include #{klass_name}::GeneratedAliasAttributeMethods"
         mod_sig
       end
 
-      private def optional(class_name)
+      # @rbs class_name: String
+      private def optional(class_name) #: String
         class_name.include?("|") ? "(#{class_name})?" : "#{class_name}?"
       end
 
-      private def sql_type_to_class(t)
+      # @rbs t: untyped
+      private def sql_type_to_class(t) #: untyped
         case t
         when :integer
-          'Integer'
+          '::Integer'
         when :float
-          'Float'
+          '::Float'
         when :decimal
-          'BigDecimal'
+          '::BigDecimal'
         when :string, :text, :citext, :uuid, :binary
-          'String'
+          '::String'
         when :datetime
-          'ActiveSupport::TimeWithZone'
+          '::ActiveSupport::TimeWithZone'
         when :boolean
           "bool"
         when :jsonb, :json
           "untyped"
         when :date
-          'Date'
+          '::Date'
         when :time
-          'Time'
+          '::Time'
         when :inet
-          "IPAddr"
+          "::IPAddr"
         else
           # Unknown column type, give up
           'untyped'
@@ -555,7 +653,7 @@ module RbsRails
       end
 
       private
-      attr_reader :klass, :klass_name
+      attr_reader :klass #: singleton(ActiveRecord::Base) & Enum
     end
   end
 end