Move Attribute and AttributeSet to ActiveModel

Use these to back the attributes API.  Stop automatically including
ActiveModel::Dirty in ActiveModel::Attributes, and make it optional.

15 files changed, 19 insertions, 1284 deletions

diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index bf6dfd46e1..0e036f05f5 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -27,14 +27,14 @@ require "active_support"
 require "active_support/rails"
 require "active_model"
 require "arel"
+require "yaml"
 
 require "active_record/version"
-require "active_record/attribute_set"
+require "active_model/attribute_set"
 
 module ActiveRecord
   extend ActiveSupport::Autoload
 
-  autoload :Attribute
   autoload :Base
   autoload :Callbacks
   autoload :Core
@@ -181,3 +181,7 @@ end
 ActiveSupport.on_load(:i18n) do
   I18n.load_path << File.expand_path("active_record/locale/en.yml", __dir__)
 end
+
+YAML.load_tags["!ruby/object:ActiveRecord::AttributeSet"] = "ActiveModel::AttributeSet"
+YAML.load_tags["!ruby/object:ActiveRecord::Attribute::FromDatabase"] = "ActiveModel::Attribute::FromDatabase"
+YAML.load_tags["!ruby/object:ActiveRecord::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"
diff --git a/activerecord/lib/active_record/attribute.rb b/activerecord/lib/active_record/attribute.rb
deleted file mode 100644
index fc474edc15..0000000000
--- a/activerecord/lib/active_record/attribute.rb
+++ /dev/null
@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class Attribute # :nodoc:
-    class << self
-      def from_database(name, value, type)
-        FromDatabase.new(name, value, type)
-      end
-
-      def from_user(name, value, type, original_attribute = nil)
-        FromUser.new(name, value, type, original_attribute)
-      end
-
-      def with_cast_value(name, value, type)
-        WithCastValue.new(name, value, type)
-      end
-
-      def null(name)
-        Null.new(name)
-      end
-
-      def uninitialized(name, type)
-        Uninitialized.new(name, type)
-      end
-    end
-
-    attr_reader :name, :value_before_type_cast, :type
-
-    # This method should not be called directly.
-    # Use #from_database or #from_user
-    def initialize(name, value_before_type_cast, type, original_attribute = nil)
-      @name = name
-      @value_before_type_cast = value_before_type_cast
-      @type = type
-      @original_attribute = original_attribute
-    end
-
-    def value
-      # `defined?` is cheaper than `||=` when we get back falsy values
-      @value = type_cast(value_before_type_cast) unless defined?(@value)
-      @value
-    end
-
-    def original_value
-      if assigned?
-        original_attribute.original_value
-      else
-        type_cast(value_before_type_cast)
-      end
-    end
-
-    def value_for_database
-      type.serialize(value)
-    end
-
-    def changed?
-      changed_from_assignment? || changed_in_place?
-    end
-
-    def changed_in_place?
-      has_been_read? && type.changed_in_place?(original_value_for_database, value)
-    end
-
-    def forgetting_assignment
-      with_value_from_database(value_for_database)
-    end
-
-    def with_value_from_user(value)
-      type.assert_valid_value(value)
-      self.class.from_user(name, value, type, original_attribute || self)
-    end
-
-    def with_value_from_database(value)
-      self.class.from_database(name, value, type)
-    end
-
-    def with_cast_value(value)
-      self.class.with_cast_value(name, value, type)
-    end
-
-    def with_type(type)
-      if changed_in_place?
-        with_value_from_user(value).with_type(type)
-      else
-        self.class.new(name, value_before_type_cast, type, original_attribute)
-      end
-    end
-
-    def type_cast(*)
-      raise NotImplementedError
-    end
-
-    def initialized?
-      true
-    end
-
-    def came_from_user?
-      false
-    end
-
-    def has_been_read?
-      defined?(@value)
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        name == other.name &&
-        value_before_type_cast == other.value_before_type_cast &&
-        type == other.type
-    end
-    alias eql? ==
-
-    def hash
-      [self.class, name, value_before_type_cast, type].hash
-    end
-
-    def init_with(coder)
-      @name = coder["name"]
-      @value_before_type_cast = coder["value_before_type_cast"]
-      @type = coder["type"]
-      @original_attribute = coder["original_attribute"]
-      @value = coder["value"] if coder.map.key?("value")
-    end
-
-    def encode_with(coder)
-      coder["name"] = name
-      coder["value_before_type_cast"] = value_before_type_cast unless value_before_type_cast.nil?
-      coder["type"] = type if type
-      coder["original_attribute"] = original_attribute if original_attribute
-      coder["value"] = value if defined?(@value)
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :original_attribute
-      alias_method :assigned?, :original_attribute
-
-      def original_value_for_database
-        if assigned?
-          original_attribute.original_value_for_database
-        else
-          _original_value_for_database
-        end
-      end
-
-    private
-      def initialize_dup(other)
-        if defined?(@value) && @value.duplicable?
-          @value = @value.dup
-        end
-      end
-
-      def changed_from_assignment?
-        assigned? && type.changed?(original_value, value, value_before_type_cast)
-      end
-
-      def _original_value_for_database
-        type.serialize(original_value)
-      end
-
-      class FromDatabase < Attribute # :nodoc:
-        def type_cast(value)
-          type.deserialize(value)
-        end
-
-        def _original_value_for_database
-          value_before_type_cast
-        end
-      end
-
-      class FromUser < Attribute # :nodoc:
-        def type_cast(value)
-          type.cast(value)
-        end
-
-        def came_from_user?
-          !type.value_constructed_by_mass_assignment?(value_before_type_cast)
-        end
-      end
-
-      class WithCastValue < Attribute # :nodoc:
-        def type_cast(value)
-          value
-        end
-
-        def changed_in_place?
-          false
-        end
-      end
-
-      class Null < Attribute # :nodoc:
-        def initialize(name)
-          super(name, nil, Type.default_value)
-        end
-
-        def type_cast(*)
-          nil
-        end
-
-        def with_type(type)
-          self.class.with_cast_value(name, nil, type)
-        end
-
-        def with_value_from_database(value)
-          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
-        end
-        alias_method :with_value_from_user, :with_value_from_database
-      end
-
-      class Uninitialized < Attribute # :nodoc:
-        UNINITIALIZED_ORIGINAL_VALUE = Object.new
-
-        def initialize(name, type)
-          super(name, nil, type)
-        end
-
-        def value
-          if block_given?
-            yield name
-          end
-        end
-
-        def original_value
-          UNINITIALIZED_ORIGINAL_VALUE
-        end
-
-        def value_for_database
-        end
-
-        def initialized?
-          false
-        end
-
-        def with_type(type)
-          self.class.new(name, type)
-        end
-      end
-      private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
-  end
-end
diff --git a/activerecord/lib/active_record/attribute/user_provided_default.rb b/activerecord/lib/active_record/attribute/user_provided_default.rb
deleted file mode 100644
index f746960fac..0000000000
--- a/activerecord/lib/active_record/attribute/user_provided_default.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record/attribute"
-
-module ActiveRecord
-  class Attribute # :nodoc:
-    class UserProvidedDefault < FromUser # :nodoc:
-      def initialize(name, value, type, database_default)
-        @user_provided_value = value
-        super(name, value, type, database_default)
-      end
-
-      def value_before_type_cast
-        if user_provided_value.is_a?(Proc)
-          @memoized_value_before_type_cast ||= user_provided_value.call
-        else
-          @user_provided_value
-        end
-      end
-
-      def with_type(type)
-        self.class.new(name, user_provided_value, type, original_attribute)
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :user_provided_value
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb
index 79110d04f4..3de6fe566d 100644
--- a/activerecord/lib/active_record/attribute_methods/dirty.rb
+++ b/activerecord/lib/active_record/attribute_methods/dirty.rb
@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/module/attribute_accessors"
-require "active_record/attribute_mutation_tracker"
 
 module ActiveRecord
   module AttributeMethods
@@ -33,65 +32,13 @@ module ActiveRecord
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
+          @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
           @mutations_before_last_save = nil
+          @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
           @mutations_from_database = nil
-          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
         end
       end
 
-      def initialize_dup(other) # :nodoc:
-        super
-        @attributes = self.class._default_attributes.map do |attr|
-          attr.with_value_from_user(@attributes.fetch_value(attr.name))
-        end
-        @mutations_from_database = nil
-      end
-
-      def changes_applied # :nodoc:
-        @mutations_before_last_save = mutations_from_database
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        forget_attribute_assignments
-        @mutations_from_database = nil
-      end
-
-      def clear_changes_information # :nodoc:
-        @mutations_before_last_save = nil
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        forget_attribute_assignments
-        @mutations_from_database = nil
-      end
-
-      def clear_attribute_changes(attr_names) # :nodoc:
-        super
-        attr_names.each do |attr_name|
-          clear_attribute_change(attr_name)
-        end
-      end
-
-      def changed_attributes # :nodoc:
-        # This should only be set by methods which will call changed_attributes
-        # multiple times when it is known that the computed value cannot change.
-        if defined?(@cached_changed_attributes)
-          @cached_changed_attributes
-        else
-          super.reverse_merge(mutations_from_database.changed_values).freeze
-        end
-      end
-
-      def changes # :nodoc:
-        cache_changed_attributes do
-          super
-        end
-      end
-
-      def previous_changes # :nodoc:
-        mutations_before_last_save.changes
-      end
-
-      def attribute_changed_in_place?(attr_name) # :nodoc:
-        mutations_from_database.changed_in_place?(attr_name)
-      end
-
       # Did this attribute change when we last saved? This method can be invoked
       # as +saved_change_to_name?+ instead of <tt>saved_change_to_attribute?("name")</tt>.
       # Behaves similarly to +attribute_changed?+. This method is useful in
@@ -182,26 +129,6 @@ module ActiveRecord
           result
         end
 
-        def mutations_from_database
-          unless defined?(@mutations_from_database)
-            @mutations_from_database = nil
-          end
-          @mutations_from_database ||= AttributeMutationTracker.new(@attributes)
-        end
-
-        def changes_include?(attr_name)
-          super || mutations_from_database.changed?(attr_name)
-        end
-
-        def clear_attribute_change(attr_name)
-          mutations_from_database.forget_change(attr_name)
-        end
-
-        def attribute_will_change!(attr_name)
-          super
-          mutations_from_database.force_change(attr_name)
-        end
-
         def _update_record(*)
           partial_writes? ? super(keys_for_partial_write) : super
         end
@@ -213,25 +140,6 @@ module ActiveRecord
         def keys_for_partial_write
           changed_attribute_names_to_save & self.class.column_names
         end
-
-        def forget_attribute_assignments
-          @attributes = @attributes.map(&:forgetting_assignment)
-        end
-
-        def mutations_before_last_save
-          @mutations_before_last_save ||= NullMutationTracker.instance
-        end
-
-        def cache_changed_attributes
-          @cached_changed_attributes = changed_attributes
-          yield
-        ensure
-          clear_changed_attributes_cache
-        end
-
-        def clear_changed_attributes_cache
-          remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_mutation_tracker.rb b/activerecord/lib/active_record/attribute_mutation_tracker.rb
deleted file mode 100644
index 94bf641a5d..0000000000
--- a/activerecord/lib/active_record/attribute_mutation_tracker.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class AttributeMutationTracker # :nodoc:
-    OPTION_NOT_GIVEN = Object.new
-
-    def initialize(attributes)
-      @attributes = attributes
-      @forced_changes = Set.new
-    end
-
-    def changed_values
-      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
-        if changed?(attr_name)
-          result[attr_name] = attributes[attr_name].original_value
-        end
-      end
-    end
-
-    def changes
-      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
-        change = change_to_attribute(attr_name)
-        if change
-          result[attr_name] = change
-        end
-      end
-    end
-
-    def change_to_attribute(attr_name)
-      attr_name = attr_name.to_s
-      if changed?(attr_name)
-        [attributes[attr_name].original_value, attributes.fetch_value(attr_name)]
-      end
-    end
-
-    def any_changes?
-      attr_names.any? { |attr| changed?(attr) }
-    end
-
-    def changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
-      attr_name = attr_name.to_s
-      forced_changes.include?(attr_name) ||
-        attributes[attr_name].changed? &&
-        (OPTION_NOT_GIVEN == from || attributes[attr_name].original_value == from) &&
-        (OPTION_NOT_GIVEN == to || attributes[attr_name].value == to)
-    end
-
-    def changed_in_place?(attr_name)
-      attributes[attr_name.to_s].changed_in_place?
-    end
-
-    def forget_change(attr_name)
-      attr_name = attr_name.to_s
-      attributes[attr_name] = attributes[attr_name].forgetting_assignment
-      forced_changes.delete(attr_name)
-    end
-
-    def original_value(attr_name)
-      attributes[attr_name.to_s].original_value
-    end
-
-    def force_change(attr_name)
-      forced_changes << attr_name.to_s
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :attributes, :forced_changes
-
-    private
-
-      def attr_names
-        attributes.keys
-      end
-  end
-
-  class NullMutationTracker # :nodoc:
-    include Singleton
-
-    def changed_values(*)
-      {}
-    end
-
-    def changes(*)
-      {}
-    end
-
-    def change_to_attribute(attr_name)
-    end
-
-    def any_changes?(*)
-      false
-    end
-
-    def changed?(*)
-      false
-    end
-
-    def changed_in_place?(*)
-      false
-    end
-
-    def forget_change(*)
-    end
-
-    def original_value(*)
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_set.rb b/activerecord/lib/active_record/attribute_set.rb
deleted file mode 100644
index 9785666e77..0000000000
--- a/activerecord/lib/active_record/attribute_set.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record/attribute_set/builder"
-require "active_record/attribute_set/yaml_encoder"
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    delegate :each_value, :fetch, to: :attributes
-
-    def initialize(attributes)
-      @attributes = attributes
-    end
-
-    def [](name)
-      attributes[name] || Attribute.null(name)
-    end
-
-    def []=(name, value)
-      attributes[name] = value
-    end
-
-    def values_before_type_cast
-      attributes.transform_values(&:value_before_type_cast)
-    end
-
-    def to_hash
-      initialized_attributes.transform_values(&:value)
-    end
-    alias_method :to_h, :to_hash
-
-    def key?(name)
-      attributes.key?(name) && self[name].initialized?
-    end
-
-    def keys
-      attributes.each_key.select { |name| self[name].initialized? }
-    end
-
-    if defined?(JRUBY_VERSION)
-      # This form is significantly faster on JRuby, and this is one of our biggest hotspots.
-      # https://github.com/jruby/jruby/pull/2562
-      def fetch_value(name, &block)
-        self[name].value(&block)
-      end
-    else
-      def fetch_value(name)
-        self[name].value { |n| yield n if block_given? }
-      end
-    end
-
-    def write_from_database(name, value)
-      attributes[name] = self[name].with_value_from_database(value)
-    end
-
-    def write_from_user(name, value)
-      attributes[name] = self[name].with_value_from_user(value)
-    end
-
-    def write_cast_value(name, value)
-      attributes[name] = self[name].with_cast_value(value)
-    end
-
-    def freeze
-      @attributes.freeze
-      super
-    end
-
-    def deep_dup
-      self.class.allocate.tap do |copy|
-        copy.instance_variable_set(:@attributes, attributes.deep_dup)
-      end
-    end
-
-    def initialize_dup(_)
-      @attributes = attributes.dup
-      super
-    end
-
-    def initialize_clone(_)
-      @attributes = attributes.clone
-      super
-    end
-
-    def reset(key)
-      if key?(key)
-        write_from_database(key, nil)
-      end
-    end
-
-    def accessed
-      attributes.select { |_, attr| attr.has_been_read? }.keys
-    end
-
-    def map(&block)
-      new_attributes = attributes.transform_values(&block)
-      AttributeSet.new(new_attributes)
-    end
-
-    def ==(other)
-      attributes == other.attributes
-    end
-
-    protected
-
-      attr_reader :attributes
-
-    private
-
-      def initialized_attributes
-        attributes.select { |_, attr| attr.initialized? }
-      end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_set/builder.rb b/activerecord/lib/active_record/attribute_set/builder.rb
deleted file mode 100644
index 349cc7e403..0000000000
--- a/activerecord/lib/active_record/attribute_set/builder.rb
+++ /dev/null
@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record/attribute"
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    class Builder # :nodoc:
-      attr_reader :types, :always_initialized, :default
-
-      def initialize(types, always_initialized = nil, &default)
-        @types = types
-        @always_initialized = always_initialized
-        @default = default
-      end
-
-      def build_from_database(values = {}, additional_types = {})
-        if always_initialized && !values.key?(always_initialized)
-          values[always_initialized] = nil
-        end
-
-        attributes = LazyAttributeHash.new(types, values, additional_types, &default)
-        AttributeSet.new(attributes)
-      end
-    end
-  end
-
-  class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, :each_value, :fetch, to: :materialize
-
-    def initialize(types, values, additional_types, &default)
-      @types = types
-      @values = values
-      @additional_types = additional_types
-      @materialized = false
-      @delegate_hash = {}
-      @default = default || proc {}
-    end
-
-    def key?(key)
-      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
-    end
-
-    def [](key)
-      delegate_hash[key] || assign_default_value(key)
-    end
-
-    def []=(key, value)
-      if frozen?
-        raise RuntimeError, "Can't modify frozen hash"
-      end
-      delegate_hash[key] = value
-    end
-
-    def deep_dup
-      dup.tap do |copy|
-        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
-      end
-    end
-
-    def initialize_dup(_)
-      @delegate_hash = Hash[delegate_hash]
-      super
-    end
-
-    def select
-      keys = types.keys | values.keys | delegate_hash.keys
-      keys.each_with_object({}) do |key, hash|
-        attribute = self[key]
-        if yield(key, attribute)
-          hash[key] = attribute
-        end
-      end
-    end
-
-    def ==(other)
-      if other.is_a?(LazyAttributeHash)
-        materialize == other.materialize
-      else
-        materialize == other
-      end
-    end
-
-    def marshal_dump
-      materialize
-    end
-
-    def marshal_load(delegate_hash)
-      @delegate_hash = delegate_hash
-      @types = {}
-      @values = {}
-      @additional_types = {}
-      @materialized = true
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :types, :values, :additional_types, :delegate_hash, :default
-
-      def materialize
-        unless @materialized
-          values.each_key { |key| self[key] }
-          types.each_key { |key| self[key] }
-          unless frozen?
-            @materialized = true
-          end
-        end
-        delegate_hash
-      end
-
-    private
-
-      def assign_default_value(name)
-        type = additional_types.fetch(name, types[name])
-        value_present = true
-        value = values.fetch(name) { value_present = false }
-
-        if value_present
-          delegate_hash[name] = Attribute.from_database(name, value, type)
-        elsif types.key?(name)
-          delegate_hash[name] = default.call(name) || Attribute.uninitialized(name, type)
-        end
-      end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_set/yaml_encoder.rb b/activerecord/lib/active_record/attribute_set/yaml_encoder.rb
deleted file mode 100644
index 9254ce16ab..0000000000
--- a/activerecord/lib/active_record/attribute_set/yaml_encoder.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class AttributeSet
-    # Attempts to do more intelligent YAML dumping of an
-    # ActiveRecord::AttributeSet to reduce the size of the resulting string
-    class YAMLEncoder # :nodoc:
-      def initialize(default_types)
-        @default_types = default_types
-      end
-
-      def encode(attribute_set, coder)
-        coder["concise_attributes"] = attribute_set.each_value.map do |attr|
-          if attr.type.equal?(default_types[attr.name])
-            attr.with_type(nil)
-          else
-            attr
-          end
-        end
-      end
-
-      def decode(coder)
-        if coder["attributes"]
-          coder["attributes"]
-        else
-          attributes_hash = Hash[coder["concise_attributes"].map do |attr|
-            if attr.type.nil?
-              attr = attr.with_type(default_types[attr.name])
-            end
-            [attr.name, attr]
-          end]
-          AttributeSet.new(attributes_hash)
-        end
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :default_types
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attributes.rb b/activerecord/lib/active_record/attributes.rb
index 9224d58928..0b7c9398a8 100644
--- a/activerecord/lib/active_record/attributes.rb
+++ b/activerecord/lib/active_record/attributes.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_record/attribute/user_provided_default"
+require "active_model/attribute/user_provided_default"
 
 module ActiveRecord
   # See ActiveRecord::Attributes::ClassMethods for documentation
@@ -250,14 +250,14 @@ module ActiveRecord
           if value == NO_DEFAULT_PROVIDED
             default_attribute = _default_attributes[name].with_type(type)
           elsif from_user
-            default_attribute = Attribute::UserProvidedDefault.new(
+            default_attribute = ActiveModel::Attribute::UserProvidedDefault.new(
               name,
               value,
               type,
               _default_attributes.fetch(name.to_s) { nil },
             )
           else
-            default_attribute = Attribute.from_database(name, value, type)
+            default_attribute = ActiveModel::Attribute.from_database(name, value, type)
           end
           _default_attributes[name] = default_attribute
         end
diff --git a/activerecord/lib/active_record/legacy_yaml_adapter.rb b/activerecord/lib/active_record/legacy_yaml_adapter.rb
index 23644aab8f..ffa095dd94 100644
--- a/activerecord/lib/active_record/legacy_yaml_adapter.rb
+++ b/activerecord/lib/active_record/legacy_yaml_adapter.rb
@@ -8,7 +8,7 @@ module ActiveRecord
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
-        if coder["attributes"].is_a?(AttributeSet)
+        if coder["attributes"].is_a?(ActiveModel::AttributeSet)
           Rails420.convert(klass, coder)
         else
           Rails41.convert(klass, coder)
diff --git a/activerecord/lib/active_record/model_schema.rb b/activerecord/lib/active_record/model_schema.rb
index bed9400f51..12ee4a4137 100644
--- a/activerecord/lib/active_record/model_schema.rb
+++ b/activerecord/lib/active_record/model_schema.rb
@@ -323,7 +323,7 @@ module ActiveRecord
       end
 
       def attributes_builder # :nodoc:
-        @attributes_builder ||= AttributeSet::Builder.new(attribute_types, primary_key) do |name|
+        @attributes_builder ||= ActiveModel::AttributeSet::Builder.new(attribute_types, primary_key) do |name|
           unless columns_hash.key?(name)
             _default_attributes[name].dup
           end
@@ -346,7 +346,7 @@ module ActiveRecord
       end
 
       def yaml_encoder # :nodoc:
-        @yaml_encoder ||= AttributeSet::YAMLEncoder.new(attribute_types)
+        @yaml_encoder ||= ActiveModel::AttributeSet::YAMLEncoder.new(attribute_types)
       end
 
       # Returns the type of the attribute with the given name, after applying
@@ -376,7 +376,7 @@ module ActiveRecord
       end
 
       def _default_attributes # :nodoc:
-        @default_attributes ||= AttributeSet.new({})
+        @default_attributes ||= ActiveModel::AttributeSet.new({})
       end
 
       # Returns an array of column names as strings.
diff --git a/activerecord/lib/active_record/relation/query_attribute.rb b/activerecord/lib/active_record/relation/query_attribute.rb
index fad08e2613..3532f28858 100644
--- a/activerecord/lib/active_record/relation/query_attribute.rb
+++ b/activerecord/lib/active_record/relation/query_attribute.rb
@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "active_record/attribute"
+require "active_model/attribute"
 
 module ActiveRecord
   class Relation
-    class QueryAttribute < Attribute # :nodoc:
+    class QueryAttribute < ActiveModel::Attribute # :nodoc:
       def type_cast(value)
         value
       end
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index 897ff5c8af..9c5be4ad9b 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -930,7 +930,7 @@ module ActiveRecord
         arel.where(where_clause.ast) unless where_clause.empty?
         arel.having(having_clause.ast) unless having_clause.empty?
         if limit_value
-          limit_attribute = Attribute.with_cast_value(
+          limit_attribute = ActiveModel::Attribute.with_cast_value(
             "LIMIT".freeze,
             connection.sanitize_limit(limit_value),
             Type.default_value,
@@ -938,7 +938,7 @@ module ActiveRecord
           arel.take(Arel::Nodes::BindParam.new(limit_attribute))
         end
         if offset_value
-          offset_attribute = Attribute.with_cast_value(
+          offset_attribute = ActiveModel::Attribute.with_cast_value(
             "OFFSET".freeze,
             offset_value.to_i,
             Type.default_value,
diff --git a/activerecord/test/cases/attribute_set_test.rb b/activerecord/test/cases/attribute_set_test.rb
deleted file mode 100644
index 8be77ed88f..0000000000
--- a/activerecord/test/cases/attribute_set_test.rb
+++ /dev/null
@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-require "cases/helper"
-
-module ActiveRecord
-  class AttributeSetTest < ActiveRecord::TestCase
-    test "building a new set from raw attributes" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2.2, attributes[:bar].value
-      assert_equal :foo, attributes[:foo].name
-      assert_equal :bar, attributes[:bar].name
-    end
-
-    test "building with custom types" do
-      builder = AttributeSet::Builder.new(foo: Type::Float.new)
-      attributes = builder.build_from_database({ foo: "3.3", bar: "4.4" }, { bar: Type::Integer.new })
-
-      assert_equal 3.3, attributes[:foo].value
-      assert_equal 4, attributes[:bar].value
-    end
-
-    test "[] returns a null object" do
-      builder = AttributeSet::Builder.new(foo: Type::Float.new)
-      attributes = builder.build_from_database(foo: "3.3")
-
-      assert_equal "3.3", attributes[:foo].value_before_type_cast
-      assert_nil attributes[:bar].value_before_type_cast
-      assert_equal :bar, attributes[:bar].name
-    end
-
-    test "duping creates a new hash, but does not dup the attributes" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
-      attributes = builder.build_from_database(foo: 1, bar: "foo")
-
-      # Ensure the type cast value is cached
-      attributes[:foo].value
-      attributes[:bar].value
-
-      duped = attributes.dup
-      duped.write_from_database(:foo, 2)
-      duped[:bar].value << "bar"
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2, duped[:foo].value
-      assert_equal "foobar", attributes[:bar].value
-      assert_equal "foobar", duped[:bar].value
-    end
-
-    test "deep_duping creates a new hash and dups each attribute" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::String.new)
-      attributes = builder.build_from_database(foo: 1, bar: "foo")
-
-      # Ensure the type cast value is cached
-      attributes[:foo].value
-      attributes[:bar].value
-
-      duped = attributes.deep_dup
-      duped.write_from_database(:foo, 2)
-      duped[:bar].value << "bar"
-
-      assert_equal 1, attributes[:foo].value
-      assert_equal 2, duped[:foo].value
-      assert_equal "foo", attributes[:bar].value
-      assert_equal "foobar", duped[:bar].value
-    end
-
-    test "freezing cloned set does not freeze original" do
-      attributes = AttributeSet.new({})
-      clone = attributes.clone
-
-      clone.freeze
-
-      assert clone.frozen?
-      assert_not attributes.frozen?
-    end
-
-    test "to_hash returns a hash of the type cast values" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal({ foo: 1, bar: 2.2 }, attributes.to_hash)
-      assert_equal({ foo: 1, bar: 2.2 }, attributes.to_h)
-    end
-
-    test "to_hash maintains order" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "2.2", bar: "3.3")
-
-      attributes[:bar]
-      hash = attributes.to_h
-
-      assert_equal [[:foo, 2], [:bar, 3.3]], hash.to_a
-    end
-
-    test "values_before_type_cast" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal({ foo: "1.1", bar: "2.2" }, attributes.values_before_type_cast)
-    end
-
-    test "known columns are built with uninitialized attributes" do
-      attributes = attributes_with_uninitialized_key
-      assert attributes[:foo].initialized?
-      assert_not attributes[:bar].initialized?
-    end
-
-    test "uninitialized attributes are not included in the attributes hash" do
-      attributes = attributes_with_uninitialized_key
-      assert_equal({ foo: 1 }, attributes.to_hash)
-    end
-
-    test "uninitialized attributes are not included in keys" do
-      attributes = attributes_with_uninitialized_key
-      assert_equal [:foo], attributes.keys
-    end
-
-    test "uninitialized attributes return false for key?" do
-      attributes = attributes_with_uninitialized_key
-      assert attributes.key?(:foo)
-      assert_not attributes.key?(:bar)
-    end
-
-    test "unknown attributes return false for key?" do
-      attributes = attributes_with_uninitialized_key
-      assert_not attributes.key?(:wibble)
-    end
-
-    test "fetch_value returns the value for the given initialized attribute" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      attributes = builder.build_from_database(foo: "1.1", bar: "2.2")
-
-      assert_equal 1, attributes.fetch_value(:foo)
-      assert_equal 2.2, attributes.fetch_value(:bar)
-    end
-
-    test "fetch_value returns nil for unknown attributes" do
-      attributes = attributes_with_uninitialized_key
-      assert_nil attributes.fetch_value(:wibble) { "hello" }
-    end
-
-    test "fetch_value returns nil for unknown attributes when types has a default" do
-      types = Hash.new(Type::Value.new)
-      builder = AttributeSet::Builder.new(types)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:wibble) { "hello" }
-    end
-
-    test "fetch_value uses the given block for uninitialized attributes" do
-      attributes = attributes_with_uninitialized_key
-      value = attributes.fetch_value(:bar) { |n| n.to_s + "!" }
-      assert_equal "bar!", value
-    end
-
-    test "fetch_value returns nil for uninitialized attributes if no block is given" do
-      attributes = attributes_with_uninitialized_key
-      assert_nil attributes.fetch_value(:bar)
-    end
-
-    test "the primary_key is always initialized" do
-      builder = AttributeSet::Builder.new({ foo: Type::Integer.new }, :foo)
-      attributes = builder.build_from_database
-
-      assert attributes.key?(:foo)
-      assert_equal [:foo], attributes.keys
-      assert attributes[:foo].initialized?
-    end
-
-    class MyType
-      def cast(value)
-        return if value.nil?
-        value + " from user"
-      end
-
-      def deserialize(value)
-        return if value.nil?
-        value + " from database"
-      end
-
-      def assert_valid_value(*)
-      end
-    end
-
-    test "write_from_database sets the attribute with database typecasting" do
-      builder = AttributeSet::Builder.new(foo: MyType.new)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:foo)
-
-      attributes.write_from_database(:foo, "value")
-
-      assert_equal "value from database", attributes.fetch_value(:foo)
-    end
-
-    test "write_from_user sets the attribute with user typecasting" do
-      builder = AttributeSet::Builder.new(foo: MyType.new)
-      attributes = builder.build_from_database
-
-      assert_nil attributes.fetch_value(:foo)
-
-      attributes.write_from_user(:foo, "value")
-
-      assert_equal "value from user", attributes.fetch_value(:foo)
-    end
-
-    def attributes_with_uninitialized_key
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Float.new)
-      builder.build_from_database(foo: "1.1")
-    end
-
-    test "freezing doesn't prevent the set from materializing" do
-      builder = AttributeSet::Builder.new(foo: Type::String.new)
-      attributes = builder.build_from_database(foo: "1")
-
-      attributes.freeze
-      assert_equal({ foo: "1" }, attributes.to_hash)
-    end
-
-    test "#accessed_attributes returns only attributes which have been read" do
-      builder = AttributeSet::Builder.new(foo: Type::Value.new, bar: Type::Value.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-
-      assert_equal [], attributes.accessed
-
-      attributes.fetch_value(:foo)
-
-      assert_equal [:foo], attributes.accessed
-    end
-
-    test "#map returns a new attribute set with the changes applied" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-      new_attributes = attributes.map do |attr|
-        attr.with_cast_value(attr.value + 1)
-      end
-
-      assert_equal 2, new_attributes.fetch_value(:foo)
-      assert_equal 3, new_attributes.fetch_value(:bar)
-    end
-
-    test "comparison for equality is correctly implemented" do
-      builder = AttributeSet::Builder.new(foo: Type::Integer.new, bar: Type::Integer.new)
-      attributes = builder.build_from_database(foo: "1", bar: "2")
-      attributes2 = builder.build_from_database(foo: "1", bar: "2")
-      attributes3 = builder.build_from_database(foo: "2", bar: "2")
-
-      assert_equal attributes, attributes2
-      assert_not_equal attributes2, attributes3
-    end
-  end
-end
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
deleted file mode 100644
index 1731e7926e..0000000000
--- a/activerecord/test/cases/attribute_test.rb
+++ /dev/null
@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-require "cases/helper"
-
-module ActiveRecord
-  class AttributeTest < ActiveRecord::TestCase
-    setup do
-      @type = Minitest::Mock.new
-    end
-
-    teardown do
-      assert @type.verify
-    end
-
-    test "from_database + read type casts from database" do
-      @type.expect(:deserialize, "type cast from database", ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      type_cast_value = attribute.value
-
-      assert_equal "type cast from database", type_cast_value
-    end
-
-    test "from_user + read type casts from user" do
-      @type.expect(:cast, "type cast from user", ["a value"])
-      attribute = Attribute.from_user(nil, "a value", @type)
-
-      type_cast_value = attribute.value
-
-      assert_equal "type cast from user", type_cast_value
-    end
-
-    test "reading memoizes the value" do
-      @type.expect(:deserialize, "from the database", ["whatever"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      type_cast_value = attribute.value
-      second_read = attribute.value
-
-      assert_equal "from the database", type_cast_value
-      assert_same type_cast_value, second_read
-    end
-
-    test "reading memoizes falsy values" do
-      @type.expect(:deserialize, false, ["whatever"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      attribute.value
-      attribute.value
-    end
-
-    test "read_before_typecast returns the given value" do
-      attribute = Attribute.from_database(nil, "raw value", @type)
-
-      raw_value = attribute.value_before_type_cast
-
-      assert_equal "raw value", raw_value
-    end
-
-    test "from_database + read_for_database type casts to and from database" do
-      @type.expect(:deserialize, "read from database", ["whatever"])
-      @type.expect(:serialize, "ready for database", ["read from database"])
-      attribute = Attribute.from_database(nil, "whatever", @type)
-
-      serialize = attribute.value_for_database
-
-      assert_equal "ready for database", serialize
-    end
-
-    test "from_user + read_for_database type casts from the user to the database" do
-      @type.expect(:cast, "read from user", ["whatever"])
-      @type.expect(:serialize, "ready for database", ["read from user"])
-      attribute = Attribute.from_user(nil, "whatever", @type)
-
-      serialize = attribute.value_for_database
-
-      assert_equal "ready for database", serialize
-    end
-
-    test "duping dups the value" do
-      @type.expect(:deserialize, "type cast".dup, ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      value_from_orig = attribute.value
-      value_from_clone = attribute.dup.value
-      value_from_orig << " foo"
-
-      assert_equal "type cast foo", value_from_orig
-      assert_equal "type cast", value_from_clone
-    end
-
-    test "duping does not dup the value if it is not dupable" do
-      @type.expect(:deserialize, false, ["a value"])
-      attribute = Attribute.from_database(nil, "a value", @type)
-
-      assert_same attribute.value, attribute.dup.value
-    end
-
-    test "duping does not eagerly type cast if we have not yet type cast" do
-      attribute = Attribute.from_database(nil, "a value", @type)
-      attribute.dup
-    end
-
-    class MyType
-      def cast(value)
-        value + " from user"
-      end
-
-      def deserialize(value)
-        value + " from database"
-      end
-
-      def assert_valid_value(*)
-      end
-    end
-
-    test "with_value_from_user returns a new attribute with the value from the user" do
-      old = Attribute.from_database(nil, "old", MyType.new)
-      new = old.with_value_from_user("new")
-
-      assert_equal "old from database", old.value
-      assert_equal "new from user", new.value
-    end
-
-    test "with_value_from_database returns a new attribute with the value from the database" do
-      old = Attribute.from_user(nil, "old", MyType.new)
-      new = old.with_value_from_database("new")
-
-      assert_equal "old from user", old.value
-      assert_equal "new from database", new.value
-    end
-
-    test "uninitialized attributes yield their name if a block is given to value" do
-      block = proc { |name| name.to_s + "!" }
-      foo = Attribute.uninitialized(:foo, nil)
-      bar = Attribute.uninitialized(:bar, nil)
-
-      assert_equal "foo!", foo.value(&block)
-      assert_equal "bar!", bar.value(&block)
-    end
-
-    test "uninitialized attributes have no value" do
-      assert_nil Attribute.uninitialized(:foo, nil).value
-    end
-
-    test "attributes equal other attributes with the same constructor arguments" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 1, Type::Integer.new)
-      assert_equal first, second
-    end
-
-    test "attributes do not equal attributes with different names" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:bar, 1, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes with different types" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 1, Type::Float.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes with different values" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_database(:foo, 2, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "attributes do not equal attributes of other classes" do
-      first = Attribute.from_database(:foo, 1, Type::Integer.new)
-      second = Attribute.from_user(:foo, 1, Type::Integer.new)
-      assert_not_equal first, second
-    end
-
-    test "an attribute has not been read by default" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      assert_not attribute.has_been_read?
-    end
-
-    test "an attribute has been read when its value is calculated" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      attribute.value
-      assert attribute.has_been_read?
-    end
-
-    test "an attribute is not changed if it hasn't been assigned or mutated" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-
-      refute attribute.changed?
-    end
-
-    test "an attribute is changed if it's been assigned a new value" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      changed = attribute.with_value_from_user(2)
-
-      assert changed.changed?
-    end
-
-    test "an attribute is not changed if it's assigned the same value" do
-      attribute = Attribute.from_database(:foo, 1, Type::Value.new)
-      unchanged = attribute.with_value_from_user(1)
-
-      refute unchanged.changed?
-    end
-
-    test "an attribute can not be mutated if it has not been read,
-      and skips expensive calculations" do
-      type_which_raises_from_all_methods = Object.new
-      attribute = Attribute.from_database(:foo, "bar", type_which_raises_from_all_methods)
-
-      assert_not attribute.changed_in_place?
-    end
-
-    test "an attribute is changed if it has been mutated" do
-      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
-      attribute.value << "!"
-
-      assert attribute.changed_in_place?
-      assert attribute.changed?
-    end
-
-    test "an attribute can forget its changes" do
-      attribute = Attribute.from_database(:foo, "bar", Type::String.new)
-      changed = attribute.with_value_from_user("foo")
-      forgotten = changed.forgetting_assignment
-
-      assert changed.changed? # sanity check
-      refute forgotten.changed?
-    end
-
-    test "with_value_from_user validates the value" do
-      type = Type::Value.new
-      type.define_singleton_method(:assert_valid_value) do |value|
-        if value == 1
-          raise ArgumentError
-        end
-      end
-
-      attribute = Attribute.from_database(:foo, 1, type)
-      assert_equal 1, attribute.value
-      assert_equal 2, attribute.with_value_from_user(2).value
-      assert_raises ArgumentError do
-        attribute.with_value_from_user(1)
-      end
-    end
-
-    test "with_type preserves mutations" do
-      attribute = Attribute.from_database(:foo, "".dup, Type::Value.new)
-      attribute.value << "1"
-
-      assert_equal 1, attribute.with_type(Type::Integer.new).value
-    end
-  end
-end