oct 0.36.2

// Copyright 2024-2026 Gabriel Bjørnager Jensen.
//
// SPDX: MIT OR Apache-2.0

//! The [`Init`] trait.

use core::cell::{Cell, UnsafeCell};
use core::cmp::Reverse;
use core::convert::Infallible;
use core::marker::{PhantomData, PhantomPinned};
use core::mem::ManuallyDrop;
use core::num::{NonZero, Saturating, Wrapping};

#[cfg(feature = "ascii")]
use core::ascii;

#[cfg(feature = "bstr")]
use core::bstr::ByteStr;

#[cfg(feature = "simd")]
use core::simd::{Simd, SimdElement};

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
use core::arch::aarch64 as arch;

#[cfg(target_arch = "wasm32")]
use core::arch::wasm32 as arch;

#[cfg(target_arch = "x86")]
use core::arch::x86 as arch;

#[cfg(target_arch = "x86_64")]
use core::arch::x86_64 as arch;

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
use core::sync::atomic::{AtomicI128, AtomicU128};

#[cfg(target_has_atomic = "16")]
use core::sync::atomic::{AtomicI16, AtomicU16};

#[cfg(target_has_atomic = "32")]
use core::sync::atomic::{AtomicI32, AtomicU32};

#[cfg(target_has_atomic = "64")]
use core::sync::atomic::{AtomicI64, AtomicU64};

#[cfg(target_has_atomic = "8")]
use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};

#[cfg(target_has_atomic = "ptr")]
use core::sync::atomic::{AtomicIsize, AtomicUsize};

/// Denotes a type that is always initialised.
///
/// This trait is implemented conservatively as
/// types rarely have any obvious guarantees about
/// the required invariants.
///
/// # Safety
///
/// Types that support being in an uninitialised
/// state (e.g. [`MaybeUninit`]) may not implement
/// this trait. Implementing types may still,
/// however, contain `!Init` fields *if* these
/// fields are guaranteed to also still be
/// initialised.
///
/// [`MaybeUninit`]: core::mem::MaybeUninit
#[doc(alias = "NoUninit")]
pub unsafe trait Init {}

// SORT: array
// SAFETY: Arrays do not induce padding.
unsafe impl<T: Init, const N: usize> Init for [T; N] {}

// SAFETY: `AtomicBool` is transparent to `bool`.
#[cfg(target_has_atomic = "8")]
unsafe impl Init for AtomicBool {}

// SAFETY: `AtomicI128` is transparent to `i128`.
#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
unsafe impl Init for AtomicI128 {}

// SAFETY: `AtomicI16` is transparent to `i16`.
#[cfg(target_has_atomic = "16")]
unsafe impl Init for AtomicI16 {}

// SAFETY: `AtomicI32` is transparent to `i32`.
#[cfg(target_has_atomic = "32")]
unsafe impl Init for AtomicI32 {}

// SAFETY: `AtomicI64` is transparent to `i64`.
#[cfg(target_has_atomic = "64")]
unsafe impl Init for AtomicI64 {}

// SAFETY: `AtomicI8` is transparent to `i8`.
#[cfg(target_has_atomic = "8")]
unsafe impl Init for AtomicI8 {}

// SAFETY: `AtomicIsize` is transparent to `isize`.
#[cfg(target_has_atomic = "ptr")]
unsafe impl Init for AtomicIsize {}

// SAFETY: `AtomicU128` is transparent to `u128`.
#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
unsafe impl Init for AtomicU128 {}

// SAFETY: `AtomicU16` is transparent to `u16`.
#[cfg(target_has_atomic = "16")]
unsafe impl Init for AtomicU16 {}

// SAFETY: `AtomicU32` is transparent to `u32`.
#[cfg(target_has_atomic = "32")]
unsafe impl Init for AtomicU32 {}

// SAFETY: `AtomicU64` is transparent to `u64`.
#[cfg(target_has_atomic = "64")]
unsafe impl Init for AtomicU64 {}

// SAFETY: `AtomicU8` is transparent to `u8`.
#[cfg(target_has_atomic = "8")]
unsafe impl Init for AtomicU8 {}

// SAFETY: `AtomicUsize` is transparent to `usize`.
#[cfg(target_has_atomic = "ptr")]
unsafe impl Init for AtomicUsize {}

unsafe impl Init for bool {}

// SAFETY: `ByteStr` is transparent to `[u8]`.
#[cfg(feature = "bstr")]
unsafe impl Init for ByteStr {}

// SAFETY: `Cell<T>` is transparent to `T`.
unsafe impl<T: Init> Init for Cell<T> {}

unsafe impl Init for char {}

#[cfg(feature = "ascii")]
unsafe impl Init for ascii::Char {}

// SAFETY: This structure is exhaustive and homoge-
// neous.
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::CpuidResult {}

#[cfg(feature = "f128")]
unsafe impl Init for f128 {}

#[cfg(feature = "f16")]
unsafe impl Init for f16 {}

unsafe impl Init for f32 {}

unsafe impl Init for f64 {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::float16x4_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::float16x4x2_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::float16x4x3_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::float16x4x4_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::float16x8_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::float16x8x2_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::float16x8x3_t {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::float16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::float32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::float32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::float32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::float32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::float32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::float32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::float32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::float32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Init for arch::float64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Init for arch::float64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Init for arch::float64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Init for arch::float64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Init for arch::float64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Init for arch::float64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Init for arch::float64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl Init for arch::float64x2x4_t {}

unsafe impl Init for i128 {}

unsafe impl Init for i16 {}

unsafe impl Init for i32 {}

unsafe impl Init for i64 {}

unsafe impl Init for i8 {}

// SAFETY: `Infallible` cannot be constructed.
unsafe impl Init for Infallible {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int64x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int8x16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::int8x8x4_t {}

unsafe impl Init for isize {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m128 {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl Init for arch::__m128bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m128d {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::__m128h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m128i {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m256 {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl Init for arch::__m256bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m256d {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::__m256h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m256i {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m512 {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl Init for arch::__m512bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m512d {}

#[expect(clippy::incompatible_msrv)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl Init for arch::__m512h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl Init for arch::__m512i {}

// SAFETY: `ManuallyDrop<T>` is transparent to `T`.
unsafe impl<T: Init> Init for ManuallyDrop<T> {}

// // SORT: never
// unsafe impl Init for ! {}

// SAFETY: `NonZero<i128>` is transparent to `i128`.
unsafe impl Init for NonZero<i128> {}

// SAFETY: `NonZero<i16>` is transparent to `i16`.
unsafe impl Init for NonZero<i16> {}

// SAFETY: `NonZero<i32>` is transparent to `i32`.
unsafe impl Init for NonZero<i32> {}

// SAFETY: `NonZero<i64>` is transparent to `i64`.
unsafe impl Init for NonZero<i64> {}

// SAFETY: `NonZero<i8>` is transparent to `i8`.
unsafe impl Init for NonZero<i8> {}

// SAFETY: `NonZero<isize>` is transparent to `isize`.
unsafe impl Init for NonZero<isize> {}

// SAFETY: `NonZero<u128>` is transparent to `u128`.
unsafe impl Init for NonZero<u128> {}

// SAFETY: `NonZero<u16>` is transparent to `u16`.
unsafe impl Init for NonZero<u16> {}

// SAFETY: `NonZero<u32>` is transparent to `u32`.
unsafe impl Init for NonZero<u32> {}

// SAFETY: `NonZero<u64>` is transparent to `u64`.
unsafe impl Init for NonZero<u64> {}

// SAFETY: `NonZero<u8>` is transparent to `u8`.
unsafe impl Init for NonZero<u8> {}

// SAFETY: `NonZero<usize>` is transparent to `usize`.
unsafe impl Init for NonZero<usize> {}

// SAFETY: `Option<NonZero<i128>>` is transparent
// to `i128`.
unsafe impl Init for Option<NonZero<i128>> {}

// SAFETY: `Option<NonZero<i16>>` is transparent to
// `i16`.
unsafe impl Init for Option<NonZero<i16>> {}

// SAFETY: `Option<NonZero<i32>>` is transparent to
// `i32`.
unsafe impl Init for Option<NonZero<i32>> {}

// SAFETY: `Option<NonZero<i64>>` is transparent to
// `i64`.
unsafe impl Init for Option<NonZero<i64>> {}

// SAFETY: `Option<NonZero<i8>>` is transparent to
// `i8`.
unsafe impl Init for Option<NonZero<i8>> {}

// SAFETY: `Option<NonZero<isize>>` is transparent
// to `isize`.
unsafe impl Init for Option<NonZero<isize>> {}

// SAFETY: `Option<NonZero<u128>>` is transparent
// to `u128`.
unsafe impl Init for Option<NonZero<u128>> {}

// SAFETY: `Option<NonZero<u16>>` is transparent to
// `u16`.
unsafe impl Init for Option<NonZero<u16>> {}

// SAFETY: `Option<NonZero<u32>>` is transparent to
// `u32`.
unsafe impl Init for Option<NonZero<u32>> {}

// SAFETY: `Option<NonZero<u64>>` is transparent to
// `u64`.
unsafe impl Init for Option<NonZero<u64>> {}

// SAFETY: `Option<NonZero<u8>>` is transparent to
// `u8`.
unsafe impl Init for Option<NonZero<u8>> {}

// SAFETY: `Option<NonZero<usize>>` is transparent
// to `usize`.
unsafe impl Init for Option<NonZero<usize>> {}

// SAFETY: `PhantomData<T>` is a ZST.
unsafe impl<T: ?Sized> Init for PhantomData<T> {}

// SAFETY: `PhantomPinned` is a ZST.
unsafe impl Init for PhantomPinned {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly64x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly8x16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::poly8x8x4_t {}

// SAFETY `Reverse<T>` is transparent to `T`.
unsafe impl<T: Init> Init for Reverse<T> {}

// SAFETY: `Saturating<T>` is transparent to `T`.
unsafe impl<T: Init> Init for Saturating<T> {}

// SAFETY: `Simd<T, N>` is transparent to `[T; N]`.
#[cfg(feature = "simd")]
unsafe impl<T: SimdElement + Init, const N: usize> Init for Simd<T, N> {}

// SORT: slice
// SAFETY: Slices have the same representation as
// arrays.
unsafe impl<T: Init> Init for [T] {}

unsafe impl Init for str {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
/// Implemented for homogeneous tuples with up to
/// twelve members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
unsafe impl<T: Init> Init for (T,) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T, T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: Init> Init for (T, T, T, T, T, T, T, T, T, T, T, T) {}

unsafe impl Init for u128 {}

unsafe impl Init for u16 {}

unsafe impl Init for u32 {}

unsafe impl Init for u64 {}

unsafe impl Init for u8 {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint64x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint8x16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl Init for arch::uint8x8x4_t {}

// SORT: unit
unsafe impl Init for () {}

// SAFETY: `UnsafeCell<T>` is transparent to `T`.
unsafe impl<T: Init> Init for UnsafeCell<T> {}

unsafe impl Init for usize {}

#[cfg(target_arch = "wasm32")]
unsafe impl Init for arch::v128 {}

// SAFETY: `Wrapping<T>` is transparent to `T`.
unsafe impl<T: Init> Init for Wrapping<T> {}