wrapper-lite 0.5.2

#![doc = include_str!("../README.md")]
#![no_std]

#[macro_export]
/// Helper macro for building a wrapper type and implementing common traits for
/// it.
///
/// ## Basic usage
///
/// Write the wrapper type definition using standard struct syntax, then add
/// `#[wrapper(...)]` attributes to automatically generate trait implementations
/// for interoperability with the inner type:
///
/// ```rust
/// wrapper_lite::wrapper!(
///     #[wrapper(AsRef)]
///     #[derive(Debug, Clone, Copy)]
///     pub struct Foobar([u8; 128]);
/// );
///
/// wrapper_lite::wrapper!(
///     #[wrapper(AsRef)]
///     #[derive(Debug, Clone, Copy)]
///     pub struct Barfoo {
///         inner: [u8; 128],
///     }
/// );
/// ```
///
/// This macro supports both tuple struct syntax and braced struct syntax. When
/// using the braced struct syntax, the first field will be treated as the
/// "inner" field.
///
/// ### Associated constructor method: `from_inner`
///
/// This macro will generate a const associated constructor method `from_inner`
/// when applicable, which takes an instance of the inner type and returns an
/// instance of the wrapper struct. The method will have the same visibility as
/// the inner field.
///
/// ```rust,compile_fail
/// mod inner {
///     wrapper_lite::wrapper!(
///         pub(crate) struct Foobar<'a>(&'a str);
///     );
/// }
///
/// const _: () = {
///     let _ = inner::FooBar::from_inner("Hello");
/// };
/// ```
///
/// ```rust
/// mod inner {
///     wrapper_lite::wrapper!(
///         pub(crate) struct Foobar<'a>(pub(crate) &'a str);
///     );
/// }
///
/// const _: () = {
///     let _ = inner::Foobar::from_inner("Hello");
/// };
/// ```
///
/// ### The `#[default(...)]` attribute
///
/// When there are other fields in the wrapper struct, it is not possible to
/// construct an instance of the wrapper struct from the inner type alone. The
/// `#[default(...)]` attribute allows specifying default values for those
/// other fields to work around this limitation.
///
/// ```rust,compile_fail
/// wrapper_lite::wrapper!(
///     struct Foobar {
///         inner_field: &'static str,
///         other_field: u8,
///     }
/// );
///
/// const _: () = {
///     let _ = Foobar::from_inner("Hello");
/// };
/// ```
///
/// ```rust
/// wrapper_lite::wrapper!(
///     struct Foobar {
///         inner_field: &'static str,
///         #[default(0)]
///         other_field: u8,
///     }
/// );
///
/// const _: () = {
///     let foobar = Foobar::from_inner("Hello");
///     assert!(foobar.other_field == 0);
/// };
/// ```
///
/// Both the `from_inner` method and the [`From`] trait implementation
/// benefit from this.
///
/// ### The `#[wrapper(...)]` attribute
///
/// Instructs the macro to automatically generate implementations of
/// commonly used traits for the wrapper struct.
///
/// #### `#[wrapper(Debug)]`
///
/// Implements trait [`Debug`] for the wrapper struct if the inner type
/// implements it.
///
/// ```rust
/// wrapper_lite::wrapper!(
///     #[wrapper(Debug)]
///     struct Wrapper<'a>(&'a str);
/// );
///
/// assert_eq!(format!("{:?}", Wrapper { inner: "168" }), "\"168\"");
/// ```
///
/// #### `#[wrapper(DebugName)]`
///
/// Implements trait [`Debug`] for the wrapper struct, but only prints the name
/// of the wrapper struct.
///
/// ```rust
/// wrapper_lite::wrapper!(
///     #[wrapper(DebugName)]
///     struct Wrapper<'a>(&'a str);
/// );
///
/// assert_eq!(format!("{:?}", Wrapper { inner: "168" }), "Wrapper");
/// ```
///
/// #### `#[wrapper(Display)]`
///
/// Implements trait [`Display`] for the wrapper struct if the inner type
/// implements it.
///
/// ```rust
/// wrapper_lite::wrapper!(
///     #[wrapper(Display)]
///     struct Wrapper<'a>(&'a str);
/// );
///
/// assert_eq!(format!("{}", Wrapper { inner: "168" }), "168");
/// ```
///
/// #### `#[wrapper(AsRef)]` / `#[wrapper(AsMut)]` / `#[wrapper(Borrow)]` / `#[wrapper(BorrowMut)]` / `#[wrapper(Deref)]` / `#[wrapper(DerefMut)]`
///
/// Implements trait [`AsRef`] / [`AsMut`] / [`Borrow`] / [`BorrowMut`] /
/// [`Deref`] / [`DerefMut`] for the wrapper struct.
///
/// The *target* type can be either the inner type or a custom type, provided
/// that the inner type coerces to the target via deref coercion.
///
/// ```rust
/// wrapper_lite::wrapper!(
///     #[wrapper(AsRef)]
///     #[wrapper(AsRef<[u8]>)]
///     struct Wrapper([u8; 42]);
/// );
///
/// const fn assert_as_ref<T, U>()
/// where
///     T: AsRef<U>,
///     U: ?Sized,
/// {
/// }
///
/// assert_as_ref::<Wrapper, [u8; 42]>();
/// assert_as_ref::<Wrapper, [u8]>();
/// ```
///
/// ```rust
/// wrapper_lite::wrapper!(
///     #[wrapper(AsMut)]
///     #[wrapper(AsMut<[u8]>)]
///     struct Wrapper([u8; 42]);
/// );
///
/// const fn assert_as_mut<T, U>()
/// where
///     T: AsMut<U>,
///     U: ?Sized,
/// {
/// }
///
/// assert_as_mut::<Wrapper, [u8; 42]>();
/// assert_as_mut::<Wrapper, [u8]>();
/// ```
///
/// ```rust
/// use core::borrow::Borrow;
///
/// wrapper_lite::wrapper!(
///     #[wrapper(Borrow)]
///     #[wrapper(Borrow<[u8]>)]
///     struct Wrapper([u8; 42]);
/// );
///
/// const fn assert_borrow<T, U>()
/// where
///     T: Borrow<U>,
///     U: ?Sized,
/// {
/// }
///
/// assert_borrow::<Wrapper, [u8; 42]>();
/// assert_borrow::<Wrapper, [u8]>();
/// ```
///
/// ```rust
/// use core::borrow::{Borrow, BorrowMut};
///
/// wrapper_lite::wrapper!(
///     #[wrapper(BorrowMut)]
///     #[wrapper(BorrowMut<[u8]>)]
///     struct Wrapper([u8; 42]);
/// );
///
/// const fn assert_borrow<T, U>()
/// where
///     T: Borrow<U>,
///     U: ?Sized,
/// {
/// }
///
/// const fn assert_borrow_mut<T, U>()
/// where
///     T: BorrowMut<U>,
///     U: ?Sized,
/// {
/// }
///
/// assert_borrow::<Wrapper, [u8; 42]>();
/// assert_borrow_mut::<Wrapper, [u8; 42]>();
/// assert_borrow::<Wrapper, [u8]>();
/// assert_borrow_mut::<Wrapper, [u8]>();
/// ```
///
/// ```rust
/// use core::ops::Deref;
///
/// wrapper_lite::wrapper!(
///     #[wrapper(Deref)]
///     struct WrapperA([u8; 42]);
/// );
///
/// wrapper_lite::wrapper!(
///     #[wrapper(Deref<[u8]>)]
///     struct WrapperB([u8; 42]);
/// );
///
/// const fn assert_deref<T, U>()
/// where
///     T: Deref<Target = U>,
///     U: ?Sized,
/// {
/// }
///
/// assert_deref::<WrapperA, [u8; 42]>();
/// assert_deref::<WrapperB, [u8]>();
/// ```
///
/// ```rust
/// use core::ops::{Deref, DerefMut};
///
/// wrapper_lite::wrapper!(
///     #[wrapper(DerefMut)]
///     struct WrapperA([u8; 42]);
/// );
///
/// wrapper_lite::wrapper!(
///     #[wrapper(DerefMut<[u8]>)]
///     struct WrapperB([u8; 42]);
/// );
///
/// const fn assert_deref<T, U>()
/// where
///     T: Deref<Target = U>,
///     U: ?Sized,
/// {
/// }
///
/// const fn assert_deref_mut<T, U>()
/// where
///     T: DerefMut<Target = U>,
///     U: ?Sized,
/// {
/// }
///
/// assert_deref::<WrapperA, [u8; 42]>();
/// assert_deref_mut::<WrapperA, [u8; 42]>();
/// assert_deref::<WrapperB, [u8]>();
/// assert_deref_mut::<WrapperB, [u8]>();
/// ```
///
/// When `#[wrapper(AsRef)]` or `#[wrapper(AsMut)]` is specified, we will also
/// generate associated method `as_inner` or `as_inner_mut` that returns a
/// (mutable) reference to the inner value. These methods will have the same
/// visibility as the wrapper struct. Additionally, since mutable references are
/// not allowed in constant functions before Rust 1.83, and this library's MSRV
/// is 1.56, by default the associated method `as_inner_mut` we generate is not
/// a const method, but we support the `#[wrapper([const] AsMut)]` syntax to
/// make `as_inner_mut` a const method like `as_inner` as well.
///
/// ```rust
/// wrapper_lite::wrapper!(
///     #[wrapper([const] AsMut)]
///     pub struct Wrapper<P>(pub(crate) P);
/// );
///
/// const fn test_const_as_inner_mut<P>(wrapper: &mut Wrapper<P>) {
///     let _ = wrapper.as_inner_mut();
/// }
/// ```
///
/// When `#[wrapper(BorrowMut)]` or `#[wrapper(DerefMut)]` is specified, the
/// corresponding [`Borrow`] or [`Deref`] implementation is generated
/// automatically. Combining them with an explicit `#[wrapper(Borrow)]` or
/// `#[wrapper(Deref)]` therefore results in a duplicate implementation error:
///
/// ```rust,compile_fail
/// wrapper_lite::wrapper!(
///     #[wrapper(Borrow)]
///     #[wrapper(BorrowMut)]
///     pub struct Wrapper<P>(pub(crate) P);
/// );
/// ```
///
/// ```rust,compile_fail
/// wrapper_lite::wrapper!(
///     #[wrapper(Deref)]
///     #[wrapper(DerefMut)]
///     pub struct Wrapper<P>(pub(crate) P);
/// );
/// ```
///
/// #### `#[wrapper(From)]`
///
/// Implements trait [`From`] for the wrapper struct, allowing it to be
/// constructed from the inner type. A const associated constructor method
/// with the same name `from` will also be generated.
///
/// ```rust
/// wrapper_lite::wrapper!(
///     #[wrapper(From)]
///     pub struct Wrapper<P>(pub(crate) P);
/// );
///
/// const fn assert_from<T, U>()
/// where
///     T: From<U>,
/// {
/// }
///
/// const _: () = {
///     assert_from::<Wrapper<()>, ()>();
///
///     // This actually tests the generated `from` method.
///     let _ = Wrapper::from("Hello");
/// };
/// ```
///
/// ## Advanced usage
///
/// ### `#[repr(align(cache))]`
///
/// You can use `#[repr(align(cache))]` to pad and align the wrapper type to the
/// length of a cache line. This is useful for performance optimization in
/// certain scenarios.
/// ```rust
/// use core::mem::align_of;
///
/// wrapper_lite::wrapper!(
///     #[repr(align(cache))]
///     pub struct Foobar(u8);
/// );
///
/// #[cfg(target_arch = "x86_64")]
/// const _: () = {
///     assert!(align_of::<Foobar>() == 128);
/// };
/// ```
///
/// ## Notes
///
/// ### `wrapper! { ... }` vs. `wrapper!( ... );`
///
/// The syntax `wrapper! { ... }` is equivalent to `wrapper!( ... );`. The
/// parenthesized form is preferred, as it is better supported by `rustfmt`.
///
/// ### Limitation on generic parameters
///
/// Due to the inherent limitations of declarative macros, some complex syntax
/// related to generic parameters is not supported.
///
/// - A trait bound with more than one token like `?Sized` is **not** supported:
///
///   ```rust,compile_fail
///   wrapper_lite::wrapper!(
///       //                           👇
///       pub struct HolyMolyCow<'a, P: ?Sized>(&'a P);
///   );
///   ```
///
/// - A trailing comma after the last generic parameter is **not** supported:
///
///   ```rust,compile_fail
///   wrapper_lite::wrapper!(
///       //                                  👇
///       pub struct HolyMolyCow<'a, P: Default,>(&'a P);
///   );
///   ```
///
/// - `where` clauses are not supported. There is currently no workaround:
///
///   ```rust,compile_fail
///   wrapper_lite::wrapper!(
///       pub struct HolyMolyCow<'a, P>(&'a P)
///       where
///           P: ?Sized + Clone;
///   );
///   ```
///
/// The `#[bound(...)]` attribute serves as a partial workaround for the
/// limitations above:
/// ```rust
/// wrapper_lite::wrapper!(
///     #[bound(P: ?Sized + Clone)]
///     pub struct HolyMolyCow<'a, P = ::core::marker::PhantomData<()>>(&'a P);
/// );
/// ```
///
/// ### Limitation on conditional compilation attribute `#[cfg(...)]`
///
/// This macro can correctly handle conditional compilation attribute
/// `#[cfg(...)]` at the struct level currently. However, due to the
/// inherent complexity limitations of declarative macros, `#[cfg(...)]` on
/// struct fields are not supported now. This will affect scenarios involving
/// the construction of wrapper types, such as implementing the `From` trait,
/// etc.
///
/// [`Debug`]: core::fmt::Debug
/// [`Display`]: core::fmt::Display
/// [`AsRef`]: core::convert::AsRef
/// [`AsMut`]: core::convert::AsMut
/// [`Borrow`]: core::borrow::Borrow
/// [`BorrowMut`]: core::borrow::BorrowMut
/// [`Deref`]: core::ops::Deref
/// [`DerefMut`]: core::ops::DerefMut
macro_rules! wrapper {
    ($($tt:tt)*) => {
        $crate::__wrapper!($($tt)*);
    };
}

#[macro_export]
#[doc(hidden)]
macro_rules! __wrapper {
    // ! Filters out `#[cfg(...)]` attributes.
    (
        @parse
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        #[cfg($($c:tt)+)]
        $($rest:tt)*
    ) => {
        $crate::__wrapper! {
            @parse
            [
                $($cfg)*
                #[cfg($($c)+)]
            ]
            [
                $($repr)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            [
                $($meta)*
            ]
            $($rest)*
        }
    };

    // ! Filters out `#[repr(...)]` attributes.
    (
        @parse
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        #[repr($($r:tt)+)]
        $($rest:tt)*
    ) => {
        $crate::__wrapper! {
            @parse
            [
                $($cfg)*
            ]
            [
                $($repr)*
                #[repr($($r)+)]
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            [
                $($meta)*
            ]
            $($rest)*
        }
    };

    // ! Filters out `#[bound(...)]` attributes.
    (
        @parse
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        #[bound($($b:tt)+)]
        $($rest:tt)*
    ) => {
        $crate::__wrapper! {
            @parse
            [
                $($cfg)*
            ]
            [
                $($repr)*
            ]
            [
                $($b)+,
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            [
                $($meta)*
            ]
            $($rest)*
        }
    };

    // ! Filters out `#[wrapper(...)]` attributes.
    (
        @parse
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        #[wrapper($($g:tt)+)]
        $($rest:tt)*
    ) => {
        $crate::__wrapper! {
            @parse
            [
                $($cfg)*
            ]
            [
                $($repr)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
                #[wrapper($($g)+)]
            ]
            [
                $($meta)*
            ]
            $($rest)*
        }
    };

    // ! Filters out `#[gen(...)]` attributes.
    (
        @parse
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        #[gen($($g:tt)+)]
        $($rest:tt)*
    ) => {
        $crate::__wrapper! {
            @parse
            [
                $($cfg)*
            ]
            [
                $($repr)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
                #[wrapper($($g)+)]
            ]
            [
                $($meta)*
            ]
            $($rest)*
        }
    };

    // ! Filters out `#[wrapper_impl(...)]` attributes.
    (
        @parse
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        #[wrapper_impl($($g:tt)+)]
        $($rest:tt)*
    ) => {
        $crate::__wrapper! {
            @parse
            [
                $($cfg)*
            ]
            [
                $($repr)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
                #[wrapper($($g)+)]
            ]
            [
                $($meta)*
            ]
            $($rest)*
        }
    };

    // ! Collects the other attributes.
    (
        @parse
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        #[$($m:tt)+]
        $($rest:tt)*
    ) => {
        $crate::__wrapper! {
            @parse
            [
                $($cfg)*
            ]
            [
                $($repr)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            [
                $($meta)*
                #[$($m)+]
            ]
            $($rest)*
        }
    };

    // ! All attributes have been parsed.
    (
        @parse
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        $($rest:tt)*
    ) => {
        $crate::__wrapper! {
            @emit
            [
                $($cfg)*
            ]
            [
                $($repr)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            [
                $($meta)*
            ]
            $($rest)*
        }
    };

    // ! Format: `$vis struct $name($ivis $ity);`
    (
        @emit
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? ($ivis:vis $ity:ty $(,)?);
    ) => {
        $crate::__wrapper! {
            @emit
            [
                $($cfg)*
            ]
            [
                $($repr)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            [
                $($meta)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                /// The inner value being wrapped in this wrapper type.
                $ivis inner: $ity,
            }
        }
    };

    // ! Format: `$vis struct $name { $inner: $ity, ... }`
    (
        @emit
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                #[default($($fdefault:tt)*)]
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $crate::__wrapper_type! {
            $($cfg)*
            $($repr)*
            $($meta)*
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)?
            where
                $($bound)*
            {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }

        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            #[allow(dead_code)]
            #[inline]
            #[doc = concat!(" Wraps the given inner value with [`", stringify!($name), "`]")]
            #[doc = ""]
            #[doc = " The other fields will be each set to the specified default value."]
            $ivis const fn from_inner($inner: $ity) -> Self {
                Self {
                    $inner,
                    $(
                        $field: $($fdefault)*,
                    )*
                }
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    #[default($($fdefault)*)]
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @emit
        [
            $($cfg:tt)*
        ]
        [
            $($repr:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            $($wrapper:tt)*
        ]
        [
            $($meta:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $crate::__wrapper_type! {
            $($cfg)*
            $($repr)*
            $($meta)*
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)?
            where
                $($bound)*
            {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };

    // ! Generating implementation.
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {};
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(Debug)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::fmt::Debug for $name$(<$($lt),+>)?
        where
            $ity: ::core::fmt::Debug,
            $($bound)*
        {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                ::core::fmt::Debug::fmt(&self.$inner, f)
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(DebugName)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::fmt::Debug for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                f.debug_struct(stringify!($name)).finish()
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(Display)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::fmt::Display for $name$(<$($lt),+>)?
        where
            $ity: ::core::fmt::Display,
            $($bound)*
        {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                ::core::fmt::Display::fmt(&self.$inner, f)
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(AsRef)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            #[allow(dead_code)]
            #[inline]
            #[doc = concat!(" Returns a reference to the inner value of the [`", stringify!($name), "`].")]
            $vis const fn as_inner(&self) -> &$ity {
                &self.$inner
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                #[wrapper(AsRef<$ity>)]
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(AsRef<$tty:ty>)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::convert::AsRef<$tty> for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            fn as_ref(&self) -> &$tty {
                &self.$inner
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper($([$cst:tt])?AsMut)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            #[allow(dead_code)]
            #[inline]
            #[doc = concat!(" Returns a mutable reference to the inner value of [`", stringify!($name), "`].")]
            $vis $($cst)? fn as_inner_mut(&mut self) -> &mut $ity {
                &mut self.$inner
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                #[wrapper(AsMut<$ity>)]
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(AsMut<$tty:ty>)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::convert::AsMut<$tty> for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            fn as_mut(&mut self) -> &mut $tty {
                &mut self.$inner
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(Borrow)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                #[wrapper(Borrow<$ity>)]
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(Borrow<$tty:ty>)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::borrow::Borrow<$tty> for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            fn borrow(&self) -> &$tty {
                &self.$inner
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(BorrowMut)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                #[wrapper(BorrowMut<$ity>)]
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(BorrowMut<$tty:ty>)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::borrow::Borrow<$tty> for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            fn borrow(&self) -> &$tty {
                &self.$inner
            }
        }

        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::borrow::BorrowMut<$tty> for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            fn borrow_mut(&mut self) -> &mut $tty {
                &mut self.$inner
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(Deref)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                #[wrapper(Deref<$ity>)]
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(Deref<$tty:ty>)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::ops::Deref for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            type Target = $tty;

            fn deref(&self) -> &$tty {
                &self.$inner
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(DerefMut)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                #[wrapper(DerefMut<$ity>)]
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(DerefMut<$tty:ty>)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::ops::Deref for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            type Target = $tty;

            fn deref(&self) -> &$tty {
                &self.$inner
            }
        }

        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::ops::DerefMut for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            fn deref_mut(&mut self) -> &mut $tty {
                &mut self.$inner
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(From)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                #[default($($fdefault:tt)*)]
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            #[allow(dead_code)]
            #[doc = concat!(" Wraps the given inner value with [`", stringify!($name), "`]")]
            #[doc = ""]
            #[doc = " The other fields will be each set to the specified default value."]
            $vis const fn from($inner: $ity) -> Self {
                Self {
                    $inner,
                    $(
                        $field: $($fdefault)*,
                    )*
                }
            }
        }

        $($cfg)*
        impl$(<$($lt$(:$blt$(+$mblt)*)?),+>)? ::core::convert::From<$ity> for $name$(<$($lt),+>)?
        where
            $($bound)*
        {
            fn from($inner: $ity) -> Self {
                Self {
                    $inner,
                    $(
                        $field: $($fdefault)*,
                    )*
                }
            }
        }

        $crate::__wrapper! {
            @gen
            [
                $($cfg)*
            ]
            [
                $($bound)*
            ]
            [
                $($wrapper)*
            ]
            $vis struct $name$(<$($lt$(:$blt$(+$mblt)*)?$(=$default)?),+>)? {
                $(#[$($imeta)*])*
                $ivis $inner: $ity,
                $(
                    #[default($($fdefault)*)]
                    $(#[$($fmeta)*])*
                    $fvis $field: $fty,
                )*
            }
        }
    };
    (
        @gen
        [
            $($cfg:tt)*
        ]
        [
            $($bound:tt)*
        ]
        [
            #[wrapper(From)]
            $($wrapper:tt)*
        ]
        $vis:vis struct $name:ident$(<$($lt:tt$(:$blt:tt$(+$mblt:tt)*)?$(=$default:ty)?),+>)? {
            $(#[$($imeta:tt)*])*
            $ivis:vis $inner:ident: $ity:ty
            $(
                ,
                $(#[$($fmeta:tt)*])*
                $fvis:vis $field:ident: $fty:ty
            )*
            $(,)?
        }
    ) => {
        compile_error!(
            "Fields except `inner` should be each provided a default value for implementing `From`."
        );
    };

    // ! Catch-all for unsupported syntax.
    (@ $($other:tt)*) => {
        compile_error!(
            "Incorrect or unsupported syntax, please refer to `wrapper!`'s documentation."
        );
    };

    // ! Entry point.
    ($($input:tt)*) => {
        $crate::__wrapper! {
            @parse [] [] [] [] [] $($input)*
        }
    };
}

#[macro_export]
#[doc(hidden)]
macro_rules! __wrapper_type {
    (
        #[repr(align(cache))]
        $($tt:tt)*
    ) => {
        // Starting from Intel's Sandy Bridge, spatial prefetcher is now pulling pairs of 64-byte cache
        // lines at a time, so we have to align to 128 bytes rather than 64.
        //
        // Sources:
        // - https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf
        // - https://github.com/facebook/folly/blob/1b5288e6eea6df074758f877c849b6e73bbb9fbb/folly/lang/Align.h#L107
        //
        // aarch64/arm64ec's big.LITTLE architecture has asymmetric cores and "big" cores have 128-byte cache line size.
        //
        // Sources:
        // - https://www.mono-project.com/news/2016/09/12/arm64-icache/
        //
        // powerpc64 has 128-byte cache line size.
        //
        // Sources:
        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_ppc64x.go#L9
        // - https://github.com/torvalds/linux/blob/3516bd729358a2a9b090c1905bd2a3fa926e24c6/arch/powerpc/include/asm/cache.h#L26
        #[cfg_attr(
            any(
                target_arch = "x86_64",
                target_arch = "aarch64",
                target_arch = "arm64ec",
                target_arch = "powerpc64",
            ),
            repr(align(128))
        )]
        // arm, mips, mips64, sparc, and hexagon have 32-byte cache line size.
        //
        // Sources:
        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_arm.go#L7
        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mips.go#L7
        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mipsle.go#L7
        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mips64x.go#L9
        // - https://github.com/torvalds/linux/blob/3516bd729358a2a9b090c1905bd2a3fa926e24c6/arch/sparc/include/asm/cache.h#L17
        // - https://github.com/torvalds/linux/blob/3516bd729358a2a9b090c1905bd2a3fa926e24c6/arch/hexagon/include/asm/cache.h#L12
        #[cfg_attr(
            any(
                target_arch = "arm",
                target_arch = "mips",
                target_arch = "mips32r6",
                target_arch = "mips64",
                target_arch = "mips64r6",
                target_arch = "sparc",
                target_arch = "hexagon",
            ),
            repr(align(32))
        )]
        // m68k has 16-byte cache line size.
        //
        // Sources:
        // - https://github.com/torvalds/linux/blob/3516bd729358a2a9b090c1905bd2a3fa926e24c6/arch/m68k/include/asm/cache.h#L9
        #[cfg_attr(target_arch = "m68k", repr(align(16)))]
        // s390x has 256-byte cache line size.
        //
        // Sources:
        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_s390x.go#L7
        // - https://github.com/torvalds/linux/blob/3516bd729358a2a9b090c1905bd2a3fa926e24c6/arch/s390/include/asm/cache.h#L13
        #[cfg_attr(target_arch = "s390x", repr(align(256)))]
        // x86, wasm, riscv, and sparc64 have 64-byte cache line size.
        //
        // Sources:
        // - https://github.com/golang/go/blob/dda2991c2ea0c5914714469c4defc2562a907230/src/internal/cpu/cpu_x86.go#L9
        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_wasm.go#L7
        // - https://github.com/torvalds/linux/blob/3516bd729358a2a9b090c1905bd2a3fa926e24c6/arch/riscv/include/asm/cache.h#L10
        // - https://github.com/torvalds/linux/blob/3516bd729358a2a9b090c1905bd2a3fa926e24c6/arch/sparc/include/asm/cache.h#L19
        //
        // All others are assumed to have 64-byte cache line size.
        #[cfg_attr(
            not(any(
                target_arch = "x86_64",
                target_arch = "aarch64",
                target_arch = "arm64ec",
                target_arch = "powerpc64",
                target_arch = "arm",
                target_arch = "mips",
                target_arch = "mips32r6",
                target_arch = "mips64",
                target_arch = "mips64r6",
                target_arch = "sparc",
                target_arch = "hexagon",
                target_arch = "m68k",
                target_arch = "s390x",
            )),
            repr(align(64))
        )]
        $($tt)*
    };
    ($($tt:tt)*) => {
        $($tt)*
    };
}

#[deprecated(since = "0.5.0", note = "Use `wrapper!` instead")]
#[macro_export]
#[doc(hidden)]
macro_rules! general_wrapper {
    ($($tt:tt)+) => {
        $crate::wrapper! {
            #[wrapper(AsRef)]
            #[wrapper(Borrow)]
            #[wrapper(From)]
            $($tt)+
        }
    };
}

#[deprecated(since = "0.5.0", note = "Use `wrapper!` instead")]
#[macro_export]
#[doc(hidden)]
macro_rules! aligned {
    ($($tt:tt)+) => {
        $crate::wrapper! {
            #[repr(align(cache))]
            $($tt)+
        }
    };
}

wrapper!(
    #[wrapper(AsRef)]
    #[wrapper(AsMut)]
    #[wrapper(From)]
    #[allow(dead_code)]
    struct TestConstFromFromInnerAsInner<T> {
        inner: T,
    }
);