diff --git a/src/impls.rs b/src/impls.rs
index 71f407ddd9..2fd771df02 100644
--- a/src/impls.rs
+++ b/src/impls.rs
@@ -109,7 +109,7 @@ assert_unaligned!(bool);
 //   pattern 0x01.
 const _: () = unsafe {
     unsafe_impl!(=> TryFromBytes for bool; |byte| {
-        let byte = byte.transmute_with::<u8, invariant::Valid, CastSizedExact, _>();
+        let byte = byte.transmute_with::<u8, invariant::Safe, CastSizedExact, _>();
         *byte.unaligned_as_ref() < 2
     })
 };
@@ -138,7 +138,7 @@ const _: () = unsafe { unsafe_impl!(char: Immutable, FromZeros, IntoBytes) };
 //   `char`.
 const _: () = unsafe {
     unsafe_impl!(=> TryFromBytes for char; |c| {
-        let c = c.transmute_with::<Unalign<u32>, invariant::Valid, CastSizedExact, _>();
+        let c = c.transmute_with::<Unalign<u32>, invariant::Safe, CastSizedExact, _>();
         let c = c.read_unaligned().into_inner();
         char::from_u32(c).is_some()
     });
@@ -171,7 +171,7 @@ const _: () = unsafe { unsafe_impl!(str: Immutable, FromZeros, IntoBytes, Unalig
 //   Returns `Err` if the slice is not UTF-8.
 const _: () = unsafe {
     unsafe_impl!(=> TryFromBytes for str; |c| {
-        let c = c.transmute_with::<[u8], invariant::Valid, CastUnsized, _>();
+        let c = c.transmute_with::<[u8], invariant::Safe, CastUnsized, _>();
         let c = c.unaligned_as_ref();
         core::str::from_utf8(c).is_ok()
     })
@@ -181,7 +181,7 @@ macro_rules! unsafe_impl_try_from_bytes_for_nonzero {
     ($($nonzero:ident[$prim:ty]),*) => {
         $(
             unsafe_impl!(=> TryFromBytes for $nonzero; |n| {
-                let n = n.transmute_with::<Unalign<$prim>, invariant::Valid, CastSizedExact, _>();
+                let n = n.transmute_with::<Unalign<$prim>, invariant::Safe, CastSizedExact, _>();
                 $nonzero::new(n.read_unaligned().into_inner()).is_some()
             });
         )*
@@ -419,15 +419,15 @@ mod atomics {
         ($($($tyvar:ident)? => $atomic:ty [$prim:ty]),*) => {{
             crate::util::macros::__unsafe();
 
-            use crate::pointer::{SizeEq, TransmuteFrom, invariant::Valid};
+            use crate::pointer::{SizeEq, TransmuteFrom, invariant::Safe};
 
             $(
                 // SAFETY: The caller promised that `$atomic` and `$prim` have
                 // the same size and bit validity.
-                unsafe impl<$($tyvar)?> TransmuteFrom<$atomic, Valid, Valid> for $prim {}
+                unsafe impl<$($tyvar)?> TransmuteFrom<$atomic, Safe, Safe> for $prim {}
                 // SAFETY: The caller promised that `$atomic` and `$prim` have
                 // the same size and bit validity.
-                unsafe impl<$($tyvar)?> TransmuteFrom<$prim, Valid, Valid> for $atomic {}
+                unsafe impl<$($tyvar)?> TransmuteFrom<$prim, Safe, Safe> for $atomic {}
 
                 impl<$($tyvar)?> SizeEq<$atomic> for $prim {
                     type CastFrom = $crate::pointer::cast::CastSizedExact;
@@ -445,9 +445,9 @@ mod atomics {
                 //   `UnsafeCell<T>` has the same in-memory representation as
                 //   its inner type `T`. A consequence of this guarantee is that
                 //   it is possible to convert between `T` and `UnsafeCell<T>`.
-                unsafe impl<$($tyvar)?> TransmuteFrom<$atomic, Valid, Valid> for core::cell::UnsafeCell<$prim> {}
+                unsafe impl<$($tyvar)?> TransmuteFrom<$atomic, Safe, Safe> for core::cell::UnsafeCell<$prim> {}
                 // SAFETY: See previous safety comment.
-                unsafe impl<$($tyvar)?> TransmuteFrom<core::cell::UnsafeCell<$prim>, Valid, Valid> for $atomic {}
+                unsafe impl<$($tyvar)?> TransmuteFrom<core::cell::UnsafeCell<$prim>, Safe, Safe> for $atomic {}
             )*
         }};
     }
@@ -1125,7 +1125,7 @@ mod tuples {
             // SAFETY: See comments on items.
             unsafe impl<Aliasing, Alignment, $($AllT),+> crate::ProjectField<
                 (),
-                (Aliasing, Alignment, crate::invariant::Valid),
+                (Aliasing, Alignment, crate::invariant::Safe),
                 { crate::STRUCT_VARIANT_ID },
                 { crate::ident_id!($CurrI)}
             > for ($($AllT,)+)
@@ -1142,7 +1142,7 @@ mod tuples {
                 // SAFETY: Tuples are product types whose fields are
                 // well-aligned, so projection preserves both the alignment and
                 // validity invariants of the outer pointer.
-                type Invariants = (Aliasing, Alignment, crate::invariant::Valid);
+                type Invariants = (Aliasing, Alignment, crate::invariant::Safe);
 
                 // SAFETY: Tuples are product types and so projection is infallible;
                 type Error = core::convert::Infallible;
diff --git a/src/lib.rs b/src/lib.rs
index 925922b631..c9d05554cf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1231,9 +1231,9 @@ where
                             // cannot be used to discriminate between variants.
                             ValidityKind::Uninit | ValidityKind::Initialized => true,
                             // The projectability of an enum field from an
-                            // `AsInitialized` or `Valid` state is a dynamic
+                            // `AsInitialized` or `Safe` state is a dynamic
                             // property of its tag.
-                            ValidityKind::AsInitialized | ValidityKind::Valid => false,
+                            ValidityKind::AsInitialized | ValidityKind::Safe => false,
                         }
                     }
                 };
@@ -3090,8 +3090,8 @@ unsafe fn try_read_from<S, T: TryFromBytes>(
 
     fn _assert_same_size_and_validity<T>()
     where
-        Wrapping<T>: pointer::TransmuteFrom<T, invariant::Valid, invariant::Valid>,
-        T: pointer::TransmuteFrom<Wrapping<T>, invariant::Valid, invariant::Valid>,
+        Wrapping<T>: pointer::TransmuteFrom<T, invariant::Safe, invariant::Safe>,
+        T: pointer::TransmuteFrom<Wrapping<T>, invariant::Safe, invariant::Safe>,
     {
     }
 
diff --git a/src/pointer/invariant.rs b/src/pointer/invariant.rs
index 804ff984a5..c167f6cfaa 100644
--- a/src/pointer/invariant.rs
+++ b/src/pointer/invariant.rs
@@ -91,7 +91,7 @@ pub enum ValidityKind {
     Uninit,
     AsInitialized,
     Initialized,
-    Valid,
+    Safe,
 }
 
 /// An [`Aliasing`] invariant which is either [`Shared`] or [`Exclusive`].
@@ -195,13 +195,13 @@ unsafe impl Validity for Initialized {
     const KIND: ValidityKind = ValidityKind::Initialized;
 }
 
-/// The referent of a `Ptr<T>` is valid for `T`, upholding bit validity and any
+/// The referent of a `Ptr<T>` is safe for `T`, upholding bit validity and any
 /// library safety invariants.
-pub enum Valid {}
-// SAFETY: `Valid`'s validity is well-defined for all `T: ?Sized`, and is not a
+pub enum Safe {}
+// SAFETY: `Safe`'s validity is well-defined for all `T: ?Sized`, and is not a
 // function of any property of `T` other than its bit validity.
-unsafe impl Validity for Valid {
-    const KIND: ValidityKind = ValidityKind::Valid;
+unsafe impl Validity for Safe {
+    const KIND: ValidityKind = ValidityKind::Safe;
 }
 
 /// # Safety
@@ -261,7 +261,7 @@ mod sealed {
     impl Sealed for Uninit {}
     impl Sealed for AsInitialized {}
     impl Sealed for Initialized {}
-    impl Sealed for Valid {}
+    impl Sealed for Safe {}
 
     impl<A: Sealed, AA: Sealed, V: Sealed> Sealed for (A, AA, V) {}
 
diff --git a/src/pointer/ptr.rs b/src/pointer/ptr.rs
index 57dfd3d2c9..2cdf59d5a6 100644
--- a/src/pointer/ptr.rs
+++ b/src/pointer/ptr.rs
@@ -163,7 +163,7 @@ mod _conversions {
     use crate::pointer::cast::{CastExact, CastSized, IdCast};
 
     /// `&'a T` → `Ptr<'a, T>`
-    impl<'a, T> Ptr<'a, T, (Shared, Aligned, Valid)>
+    impl<'a, T> Ptr<'a, T, (Shared, Aligned, Safe)>
     where
         T: 'a + ?Sized,
     {
@@ -178,7 +178,7 @@ mod _conversions {
             // 1. `ptr`, by invariant on `&'a T`, conforms to the alignment
             //    invariant of `Aligned`.
             // 2. `ptr`'s referent, by invariant on `&'a T`, is a bit-valid `T`.
-            //    This satisfies the requirement that a `Ptr<T, (_, _, Valid)>`
+            //    This satisfies the requirement that a `Ptr<T, (_, _, Safe)>`
             //    point to a bit-valid `T`. Even if `T` permits interior
             //    mutation, this invariant guarantees that the returned `Ptr`
             //    can only ever be used to modify the referent to store
@@ -191,7 +191,7 @@ mod _conversions {
     }
 
     /// `&'a mut T` → `Ptr<'a, T>`
-    impl<'a, T> Ptr<'a, T, (Exclusive, Aligned, Valid)>
+    impl<'a, T> Ptr<'a, T, (Exclusive, Aligned, Safe)>
     where
         T: 'a + ?Sized,
     {
@@ -207,7 +207,7 @@ mod _conversions {
             //    invariant of `Aligned`.
             // 2. `ptr`'s referent, by invariant on `&'a mut T`, is a bit-valid
             //    `T`. This satisfies the requirement that a `Ptr<T, (_, _,
-            //    Valid)>` point to a bit-valid `T`. This invariant guarantees
+            //    Safe)>` point to a bit-valid `T`. This invariant guarantees
             //    that the returned `Ptr` can only ever be used to modify the
             //    referent to store bit-valid `T`s, which ensures that the
             //    returned `Ptr` cannot be used to violate the soundness of the
@@ -220,7 +220,7 @@ mod _conversions {
     impl<'a, T, I> Ptr<'a, T, I>
     where
         T: 'a + ?Sized,
-        I: Invariants<Alignment = Aligned, Validity = Valid>,
+        I: Invariants<Alignment = Aligned, Validity = Safe>,
         I::Aliasing: Reference,
     {
         /// Converts `self` to a shared reference.
@@ -258,7 +258,7 @@ mod _conversions {
             //
             // 3. The pointer must point to a validly-initialized instance of
             //    `T`. This is ensured by-contract on `Ptr`, because the
-            //    `I::Validity` is `Valid`.
+            //    `I::Validity` is `Safe`.
             //
             // 4. You must enforce Rust’s aliasing rules. This is ensured by
             //    contract on `Ptr`, because `I::Aliasing: Reference`. Either it
@@ -326,7 +326,7 @@ mod _conversions {
     }
 
     /// `Ptr<'a, T>` → `&'a mut T`
-    impl<'a, T> Ptr<'a, T, (Exclusive, Aligned, Valid)>
+    impl<'a, T> Ptr<'a, T, (Exclusive, Aligned, Safe)>
     where
         T: 'a + ?Sized,
     {
@@ -361,7 +361,7 @@ mod _conversions {
             //
             // 3. The pointer must point to a validly-initialized instance of
             //    `T`. This is ensured by-contract on `Ptr`, because the
-            //    validity invariant is `Valid`.
+            //    validity invariant is `Safe`.
             //
             // 4. You must enforce Rust’s aliasing rules. This is ensured by
             //    contract on `Ptr`, because the `ALIASING_INVARIANT` is
@@ -505,7 +505,7 @@ mod _conversions {
             // FIXME(#1359): This should be a `transmute_with` call.
             // Unfortunately, to avoid blanket impl conflicts, we only implement
             // `TransmuteFrom<T>` for `Unalign<T>` (and vice versa) specifically
-            // for `Valid` validity, not for all validity types.
+            // for `Safe` validity, not for all validity types.
 
             // SAFETY:
             // - By `CastSized: Cast`, `CastSized` preserves referent address,
@@ -532,7 +532,7 @@ mod _conversions {
     impl<'a, T, I> Ptr<'a, T, I>
     where
         T: ?Sized,
-        I: Invariants<Validity = Valid>,
+        I: Invariants<Validity = Safe>,
         I::Aliasing: Reference,
     {
         /// Reads the referent.
@@ -747,23 +747,23 @@ mod _transitions {
             unsafe { self.assume_validity::<Initialized>() }
         }
 
-        /// A shorthand for `self.assume_validity<Valid>()`.
+        /// A shorthand for `self.assume_validity<Safe>()`.
         ///
         /// # Safety
         ///
         /// The caller promises to uphold the safety preconditions of
-        /// `self.assume_validity<Valid>()`.
+        /// `self.assume_validity<Safe>()`.
         #[doc(hidden)]
         #[must_use]
         #[inline]
-        pub unsafe fn assume_valid(self) -> Ptr<'a, T, (I::Aliasing, I::Alignment, Valid)> {
+        pub unsafe fn assume_safe(self) -> Ptr<'a, T, (I::Aliasing, I::Alignment, Safe)> {
             // SAFETY: The caller has promised to uphold the safety
             // preconditions.
-            unsafe { self.assume_validity::<Valid>() }
+            unsafe { self.assume_validity::<Safe>() }
         }
 
         /// Checks that `self`'s referent is validly initialized for `T`,
-        /// returning a `Ptr` with `Valid` on success.
+        /// returning a `Ptr` with `Safe` on success.
         ///
         /// # Panics
         ///
@@ -777,11 +777,11 @@ mod _transitions {
         #[inline]
         pub(crate) fn try_into_valid<R, S>(
             mut self,
-        ) -> Result<Ptr<'a, T, (I::Aliasing, I::Alignment, Valid)>, ValidityError<Self, T>>
+        ) -> Result<Ptr<'a, T, (I::Aliasing, I::Alignment, Safe)>, ValidityError<Self, T>>
         where
             T: TryFromBytes
                 + Read<I::Aliasing, R>
-                + TryTransmuteFromPtr<T, I::Aliasing, I::Validity, Valid, IdCast, S>,
+                + TryTransmuteFromPtr<T, I::Aliasing, I::Validity, Safe, IdCast, S>,
             I::Aliasing: Reference,
             I: Invariants<Validity = Initialized>,
         {
@@ -791,11 +791,11 @@ mod _transitions {
             if T::is_bit_valid(self.reborrow().forget_aligned()) {
                 // SAFETY: If `T::is_bit_valid`, code may assume that `self`
                 // contains a bit-valid instance of `T`. By `T:
-                // TryTransmuteFromPtr<T, I::Aliasing, I::Validity, Valid>`, so
-                // long as `self`'s referent conforms to the `Valid` validity
+                // TryTransmuteFromPtr<T, I::Aliasing, I::Validity, Safe>`, so
+                // long as `self`'s referent conforms to the `Safe` validity
                 // for `T` (which we just confirmed), then this transmute is
                 // sound.
-                Ok(unsafe { self.assume_valid() })
+                Ok(unsafe { self.assume_safe() })
             } else {
                 Err(ValidityError::new(self))
             }
@@ -925,11 +925,11 @@ mod _casts {
         #[allow(clippy::wrong_self_convention)]
         #[must_use]
         #[inline]
-        pub fn as_bytes<R>(self) -> Ptr<'a, [u8], (I::Aliasing, Aligned, Valid)>
+        pub fn as_bytes<R>(self) -> Ptr<'a, [u8], (I::Aliasing, Aligned, Safe)>
         where
-            [u8]: TransmuteFromPtr<T, I::Aliasing, I::Validity, Valid, AsBytesCast, R>,
+            [u8]: TransmuteFromPtr<T, I::Aliasing, I::Validity, Safe, AsBytesCast, R>,
         {
-            self.transmute_with::<[u8], Valid, AsBytesCast, _>().bikeshed_recall_aligned()
+            self.transmute_with::<[u8], Safe, AsBytesCast, _>().bikeshed_recall_aligned()
         }
     }
 
@@ -979,7 +979,7 @@ mod _casts {
     /// alignment of `[u8]` is 1.
     impl<'a, I> Ptr<'a, [u8], I>
     where
-        I: Invariants<Validity = Valid>,
+        I: Invariants<Validity = Safe>,
     {
         /// Attempts to cast `self` to a `U` using the given cast type.
         ///
@@ -1038,7 +1038,7 @@ mod _casts {
             //    it is derived from `try_cast_into`, which promises that the
             //    object described by `target` is validly aligned for `U`.
             // 2. By trait bound, `self` - and thus `target` - is a bit-valid
-            //    `[u8]`. `Ptr<[u8], (_, _, Valid)>` and `Ptr<_, (_, _,
+            //    `[u8]`. `Ptr<[u8], (_, _, Safe)>` and `Ptr<_, (_, _,
             //    Initialized)>` have the same bit validity, and so neither
             //    `self` nor `res` can be used to write a value to the referent
             //    which violates the other's validity invariant.
@@ -1049,7 +1049,7 @@ mod _casts {
             //    have `UnsafeCell`s at the same locations. Type casting does
             //    not affect aliasing.
             // 1. `[u8]` has no alignment requirement.
-            // 2. `self` has validity `Valid` and has type `[u8]`. Since
+            // 2. `self` has validity `Safe` and has type `[u8]`. Since
             //    `remainder` references a subset of `self`'s referent, it is
             //    also a bit-valid `[u8]`. Thus, neither `self` nor `remainder`
             //    can be used to write a value to the referent which violates
diff --git a/src/pointer/transmute.rs b/src/pointer/transmute.rs
index 9f48b13b61..f1c49d14d3 100644
--- a/src/pointer/transmute.rs
+++ b/src/pointer/transmute.rs
@@ -330,7 +330,7 @@ impl<T: ?Sized> SizeEq<T> for T {
 // SAFETY: Since `Src: IntoBytes`, the set of valid `Src`'s is the set of
 // initialized bit patterns, which is exactly the set allowed in the referent of
 // any `Initialized` `Ptr`.
-unsafe impl<Src, Dst> TransmuteFrom<Src, Valid, Initialized> for Dst
+unsafe impl<Src, Dst> TransmuteFrom<Src, Safe, Initialized> for Dst
 where
     Src: IntoBytes + ?Sized,
     Dst: ?Sized,
@@ -338,9 +338,9 @@ where
 }
 
 // SAFETY: Since `Dst: FromBytes`, any initialized bit pattern may appear in the
-// referent of a `Ptr<Dst, (_, _, Valid)>`. This is exactly equal to the set of
+// referent of a `Ptr<Dst, (_, _, Safe)>`. This is exactly equal to the set of
 // bit patterns which may appear in the referent of any `Initialized` `Ptr`.
-unsafe impl<Src, Dst> TransmuteFrom<Src, Initialized, Valid> for Dst
+unsafe impl<Src, Dst> TransmuteFrom<Src, Initialized, Safe> for Dst
 where
     Src: ?Sized,
     Dst: FromBytes + ?Sized,
@@ -475,7 +475,7 @@ impl_transitive_transmute_from!(T: ?Sized => UnsafeCell<T> => T => Cell<T>);
 // explicitly guaranteed, but it's obvious from `MaybeUninit`'s documentation
 // that this is the intention:
 // https://doc.rust-lang.org/1.85.0/core/mem/union.MaybeUninit.html
-unsafe impl<T> TransmuteFrom<T, Uninit, Valid> for MaybeUninit<T> {}
+unsafe impl<T> TransmuteFrom<T, Uninit, Safe> for MaybeUninit<T> {}
 
 impl<T> SizeEq<T> for MaybeUninit<T> {
     type CastFrom = CastSizedExact;
diff --git a/src/ref.rs b/src/ref.rs
index 6354442b63..0e9d26a553 100644
--- a/src/ref.rs
+++ b/src/ref.rs
@@ -196,7 +196,7 @@ mod def {
 pub use def::Ref;
 
 use crate::pointer::{
-    invariant::{Aligned, BecauseExclusive, Initialized, Unaligned, Valid},
+    invariant::{Aligned, BecauseExclusive, Initialized, Safe, Unaligned},
     BecauseRead, PtrInner,
 };
 
@@ -954,13 +954,13 @@ where
 /// `T: Sized` and `ptr`'s referent must have size `size_of::<T>()`.
 #[inline(always)]
 unsafe fn cast_for_sized<'a, T, A, R, S>(
-    ptr: Ptr<'a, [u8], (A, Aligned, Valid)>,
-) -> Ptr<'a, T, (A, Unaligned, Valid)>
+    ptr: Ptr<'a, [u8], (A, Aligned, Safe)>,
+) -> Ptr<'a, T, (A, Unaligned, Safe)>
 where
     T: FromBytes + KnownLayout + ?Sized,
     A: crate::invariant::Aliasing,
     [u8]: MutationCompatible<T, A, Initialized, Initialized, R>,
-    T: TransmuteFromPtr<T, A, Initialized, Valid, crate::pointer::cast::IdCast, S>,
+    T: TransmuteFromPtr<T, A, Initialized, Safe, crate::pointer::cast::IdCast, S>,
 {
     use crate::pointer::cast::{Cast, Project};
 
@@ -986,7 +986,7 @@ where
 
     ptr.recall_validity::<Initialized, (_, (_, _))>()
         .cast::<_, CastForSized, _>()
-        .recall_validity::<Valid, _>()
+        .recall_validity::<Safe, _>()
 }
 
 #[cfg(test)]
diff --git a/src/split_at.rs b/src/split_at.rs
index 3ba4dd124d..23c8fe6e23 100644
--- a/src/split_at.rs
+++ b/src/split_at.rs
@@ -8,7 +8,7 @@
 // those terms.
 
 use super::*;
-use crate::pointer::invariant::{Aligned, Exclusive, Invariants, Shared, Valid};
+use crate::pointer::invariant::{Aligned, Exclusive, Invariants, Safe, Shared};
 
 /// Types that can be split in two.
 ///
@@ -258,7 +258,7 @@ where
     T: ?Sized + SplitAt,
 {
     #[inline(always)]
-    fn into_ptr(self) -> Split<Ptr<'a, T, (Shared, Aligned, Valid)>> {
+    fn into_ptr(self) -> Split<Ptr<'a, T, (Shared, Aligned, Safe)>> {
         let source = Ptr::from_ref(self.source);
         // SAFETY: `Ptr::from_ref(self.source)` points to exactly `self.source`
         // and thus maintains the invariants of `self` with respect to `l_len`.
@@ -494,7 +494,7 @@ where
     T: ?Sized + SplitAt,
 {
     #[inline(always)]
-    fn into_ptr(self) -> Split<Ptr<'a, T, (Exclusive, Aligned, Valid)>> {
+    fn into_ptr(self) -> Split<Ptr<'a, T, (Exclusive, Aligned, Safe)>> {
         let source = Ptr::from_mut(self.source);
         // SAFETY: `Ptr::from_mut(self.source)` points to exactly `self.source`,
         // and thus maintains the invariants of `self` with respect to `l_len`.
@@ -681,7 +681,7 @@ where
 impl<'a, T, I> Split<Ptr<'a, T, I>>
 where
     T: ?Sized + SplitAt,
-    I: Invariants<Alignment = Aligned, Validity = Valid>,
+    I: Invariants<Alignment = Aligned, Validity = Safe>,
 {
     fn into_ref(self) -> Split<&'a T>
     where
diff --git a/src/util/macro_util.rs b/src/util/macro_util.rs
index 0f18bc7237..31fbe7c5d3 100644
--- a/src/util/macro_util.rs
+++ b/src/util/macro_util.rs
@@ -627,7 +627,7 @@ pub const fn hash_name(name: &str) -> i128 {
 fn try_cast_or_pme<Src, Dst, I, R, S>(
     src: Ptr<'_, Src, I>,
 ) -> Result<
-    Ptr<'_, Dst, (I::Aliasing, invariant::Unaligned, invariant::Valid)>,
+    Ptr<'_, Dst, (I::Aliasing, invariant::Unaligned, invariant::Safe)>,
     ValidityError<Ptr<'_, Src, I>, Dst>,
 >
 where
@@ -636,7 +636,7 @@ where
     Src: invariant::Read<I::Aliasing, R>,
     Dst: TryFromBytes
         + invariant::Read<I::Aliasing, R>
-        + TryTransmuteFromPtr<Dst, I::Aliasing, invariant::Initialized, invariant::Valid, IdCast, S>,
+        + TryTransmuteFromPtr<Dst, I::Aliasing, invariant::Initialized, invariant::Safe, IdCast, S>,
     I: Invariants<Validity = invariant::Initialized>,
     I::Aliasing: invariant::Reference,
 {
@@ -744,7 +744,7 @@ where
             // `try_cast_or_pme` promises to return its original argument, and
             // so we know that we are getting back the same `ptr` that we
             // originally passed, and that `ptr` was a bit-valid `Src`.
-            let ptr = unsafe { ptr.assume_valid() };
+            let ptr = unsafe { ptr.assume_safe() };
             ptr.as_ref()
         })),
     }
@@ -901,7 +901,7 @@ where
         let ptr = Ptr::from_ref(self.0)
             .recall_validity::<invariant::Initialized, _>()
             .transmute_with::<Dst, invariant::Initialized, crate::layout::CastFrom<Dst>, (crate::pointer::BecauseMutationCompatible, _)>()
-            .recall_validity::<invariant::Valid, _>();
+            .recall_validity::<invariant::Safe, _>();
 
         // SAFETY: The preceding `static_assert!` ensures that
         // `Src::LAYOUT.align >= Dst::LAYOUT.align`. Since `self` is
@@ -934,7 +934,7 @@ where
         let ptr = Ptr::from_mut(self.0)
             .recall_validity::<invariant::Initialized, (_, (_, _))>()
             .transmute_with::<Dst, invariant::Initialized, crate::layout::CastFrom<Dst>, _>()
-            .recall_validity::<invariant::Valid, (_, (_, _))>();
+            .recall_validity::<invariant::Safe, (_, (_, _))>();
 
         #[allow(unused_unsafe)]
         // SAFETY: The preceding `static_assert!` ensures that
diff --git a/src/util/macros.rs b/src/util/macros.rs
index 956bdbbaeb..d2483460b5 100644
--- a/src/util/macros.rs
+++ b/src/util/macros.rs
@@ -182,14 +182,14 @@ macro_rules! impl_for_transmute_from {
                 #[allow(dead_code, clippy::missing_inline_in_public_items)]
                 #[cfg_attr(all(coverage_nightly, __ZEROCOPY_INTERNAL_USE_ONLY_NIGHTLY_FEATURES_IN_TESTS), coverage(off))]
                 fn only_derive_is_allowed_to_implement_this_trait() {
-                    use crate::pointer::{*, invariant::Valid};
+                    use crate::pointer::{*, invariant::Safe};
 
                     impl_for_transmute_from!(@assert_is_supported_trait $trait);
 
                     fn is_trait<T, R>()
                     where
-                        T: TransmuteFrom<R, Valid, Valid> + ?Sized,
-                        R: TransmuteFrom<T, Valid, Valid> + ?Sized,
+                        T: TransmuteFrom<R, Safe, Safe> + ?Sized,
+                        R: TransmuteFrom<T, Safe, Safe> + ?Sized,
                         R: $trait,
                     {
                     }
@@ -739,13 +739,13 @@ macro_rules! unsafe_impl_for_transparent_wrapper {
     ($vis:vis T $(: ?$optbound:ident)? => $wrapper:ident<T>) => {{
         crate::util::macros::__unsafe();
 
-        use crate::pointer::{cast::CastExact, TransmuteFrom, SizeEq, invariant::Valid};
+        use crate::pointer::{cast::CastExact, TransmuteFrom, SizeEq, invariant::Safe};
 
         // SAFETY: The caller promises that `T` and `$wrapper<T>` have the same
         // bit validity.
-        unsafe impl<T $(: ?$optbound)?> TransmuteFrom<T, Valid, Valid> for $wrapper<T> {}
+        unsafe impl<T $(: ?$optbound)?> TransmuteFrom<T, Safe, Safe> for $wrapper<T> {}
         // SAFETY: See previous safety comment.
-        unsafe impl<T $(: ?$optbound)?> TransmuteFrom<$wrapper<T>, Valid, Valid> for T {}
+        unsafe impl<T $(: ?$optbound)?> TransmuteFrom<$wrapper<T>, Safe, Safe> for T {}
         // SAFETY: The caller promises that a `T` to `$wrapper<T>` cast is
         // size-preserving.
         define_cast!(unsafe { $vis CastA<T $(: ?$optbound)? > = T => $wrapper<T> });
@@ -770,7 +770,7 @@ macro_rules! unsafe_impl_for_transparent_wrapper {
 macro_rules! impl_transitive_transmute_from {
     ($($tyvar:ident $(: ?$optbound:ident)?)? => $t:ty => $u:ty => $v:ty) => {
         const _: () = {
-            use crate::pointer::{TransmuteFrom, SizeEq, invariant::Valid};
+            use crate::pointer::{TransmuteFrom, SizeEq, invariant::Safe};
 
             impl<$($tyvar $(: ?$optbound)?)?> SizeEq<$t> for $v
             where
@@ -784,14 +784,14 @@ macro_rules! impl_transitive_transmute_from {
                 >;
             }
 
-            // SAFETY: Since `$u: TransmuteFrom<$t, Valid, Valid>`, it is sound
+            // SAFETY: Since `$u: TransmuteFrom<$t, Safe, Safe>`, it is sound
             // to transmute a bit-valid `$t` to a bit-valid `$u`. Since `$v:
-            // TransmuteFrom<$u, Valid, Valid>`, it is sound to transmute that
+            // TransmuteFrom<$u, Safe, Safe>`, it is sound to transmute that
             // bit-valid `$u` to a bit-valid `$v`.
-            unsafe impl<$($tyvar $(: ?$optbound)?)?> TransmuteFrom<$t, Valid, Valid> for $v
+            unsafe impl<$($tyvar $(: ?$optbound)?)?> TransmuteFrom<$t, Safe, Safe> for $v
             where
-                $u: TransmuteFrom<$t, Valid, Valid>,
-                $v: TransmuteFrom<$u, Valid, Valid>,
+                $u: TransmuteFrom<$t, Safe, Safe>,
+                $v: TransmuteFrom<$u, Safe, Safe>,
             {}
         };
     };
diff --git a/src/wrappers.rs b/src/wrappers.rs
index f04f798f8c..1e9367fd0f 100644
--- a/src/wrappers.rs
+++ b/src/wrappers.rs
@@ -9,7 +9,7 @@
 use core::{fmt, hash::Hash};
 
 use super::*;
-use crate::pointer::{invariant::Valid, SizeEq, TransmuteFrom};
+use crate::pointer::{invariant::Safe, SizeEq, TransmuteFrom};
 
 /// A type with no alignment requirement.
 ///
@@ -688,11 +688,11 @@ const _: () = {
 
 // SAFETY: `ReadOnly<T>` is a `#[repr(transparent)]` wrapper around `T`, and so
 // it has the same bit validity as `T`.
-unsafe impl<T: ?Sized> TransmuteFrom<T, Valid, Valid> for ReadOnly<T> {}
+unsafe impl<T: ?Sized> TransmuteFrom<T, Safe, Safe> for ReadOnly<T> {}
 
 // SAFETY: `ReadOnly<T>` is a `#[repr(transparent)]` wrapper around `T`, and so
 // it has the same bit validity as `T`.
-unsafe impl<T: ?Sized> TransmuteFrom<ReadOnly<T>, Valid, Valid> for T {}
+unsafe impl<T: ?Sized> TransmuteFrom<ReadOnly<T>, Safe, Safe> for T {}
 
 impl<'a, T: ?Sized + Immutable> From<&'a T> for &'a ReadOnly<T> {
     #[inline(always)]
diff --git a/tests/ui-msrv/ptr-is-invariant-over-v.stderr b/tests/ui-msrv/ptr-is-invariant-over-v.stderr
index f628f7b4f2..f0833f0297 100644
--- a/tests/ui-msrv/ptr-is-invariant-over-v.stderr
+++ b/tests/ui-msrv/ptr-is-invariant-over-v.stderr
@@ -1,8 +1,8 @@
 error[E0623]: lifetime mismatch
   --> tests/ui-msrv/ptr-is-invariant-over-v.rs:19:14
    |
-16 |     big: Ptr<'small, &'big u32, (Exclusive, Aligned, Valid)>,
-   |          --------------------------------------------------- these two types are declared with different lifetimes...
+16 |     big: Ptr<'small, &'big u32, (Exclusive, Aligned, Safe)>,
+   |          -------------------------------------------------- these two types are declared with different lifetimes...
 ...
 19 |     _small = big;
    |              ^^^ ...but data from `big` flows into `big` here
@@ -10,8 +10,8 @@ error[E0623]: lifetime mismatch
 error[E0623]: lifetime mismatch
   --> tests/ui-msrv/ptr-is-invariant-over-v.rs:26:14
    |
-23 |     big: Ptr<'small, &'big u32, (Shared, Aligned, Valid)>,
-   |          ------------------------------------------------ these two types are declared with different lifetimes...
+23 |     big: Ptr<'small, &'big u32, (Shared, Aligned, Safe)>,
+   |          ----------------------------------------------- these two types are declared with different lifetimes...
 ...
 26 |     _small = big;
    |              ^^^ ...but data from `big` flows into `big` here
diff --git a/tests/ui-nightly/diagnostic-not-implemented-from-bytes.stderr b/tests/ui-nightly/diagnostic-not-implemented-from-bytes.stderr
index 4d8bbf8c79..b9df5edd72 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-from-bytes.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-from-bytes.stderr
@@ -19,7 +19,95 @@ help: the trait `FromBytes` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_from_bytes`
   --> tests/ui-nightly/diagnostic-not-implemented-from-bytes.rs:19:24
    |
diff --git a/tests/ui-nightly/diagnostic-not-implemented-from-zeros.stderr b/tests/ui-nightly/diagnostic-not-implemented-from-zeros.stderr
index a7e8b97fc0..ba5534027f 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-from-zeros.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-from-zeros.stderr
@@ -19,7 +19,158 @@ help: the trait `FromZeros` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<&T>
+             Option<&mut T>
+             Option<Box<T>>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_from_zeros`
   --> tests/ui-nightly/diagnostic-not-implemented-from-zeros.rs:19:24
    |
diff --git a/tests/ui-nightly/diagnostic-not-implemented-immutable.stderr b/tests/ui-nightly/diagnostic-not-implemented-immutable.stderr
index df7294ba7c..1257972aa8 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-immutable.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-immutable.stderr
@@ -19,7 +19,146 @@ help: the trait `Immutable` is not implemented for `NotZerocopy`
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             Box<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_immutable`
   --> tests/ui-nightly/diagnostic-not-implemented-immutable.rs:19:23
    |
diff --git a/tests/ui-nightly/diagnostic-not-implemented-into-bytes.stderr b/tests/ui-nightly/diagnostic-not-implemented-into-bytes.stderr
index dfb29ad454..a68ad6dc41 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-into-bytes.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-into-bytes.stderr
@@ -19,7 +19,85 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_into_bytes`
   --> tests/ui-nightly/diagnostic-not-implemented-into-bytes.rs:19:24
    |
diff --git a/tests/ui-nightly/diagnostic-not-implemented-issue-1296.stderr b/tests/ui-nightly/diagnostic-not-implemented-issue-1296.stderr
index 24453f41b3..624bdc399c 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-issue-1296.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-issue-1296.stderr
@@ -41,7 +41,85 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `Foo::write_obj`
   --> tests/ui-nightly/diagnostic-not-implemented-issue-1296.rs:56:33
    |
diff --git a/tests/ui-nightly/diagnostic-not-implemented-known-layout.stderr b/tests/ui-nightly/diagnostic-not-implemented-known-layout.stderr
index 7fed63a879..10bac2cea6 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-known-layout.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-known-layout.stderr
@@ -19,7 +19,82 @@ help: the trait `KnownLayout` is not implemented for `NotZerocopy`
              AU16
              AtomicBool
              AtomicI16
-           and $N others
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __ZerocopyKnownLayoutMaybeUninit
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
+             zerocopy::doctests::_::_::__ZerocopyKnownLayoutMaybeUninit<T, U>
 note: required by a bound in `takes_known_layout`
   --> tests/ui-nightly/diagnostic-not-implemented-known-layout.rs:19:26
    |
diff --git a/tests/ui-nightly/diagnostic-not-implemented-try-from-bytes.stderr b/tests/ui-nightly/diagnostic-not-implemented-try-from-bytes.stderr
index b5b3691400..2538e2d11c 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-try-from-bytes.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-try-from-bytes.stderr
@@ -19,7 +19,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<Box<T>>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_try_from_bytes`
   --> tests/ui-nightly/diagnostic-not-implemented-try-from-bytes.rs:19:28
    |
diff --git a/tests/ui-nightly/diagnostic-not-implemented-unaligned.stderr b/tests/ui-nightly/diagnostic-not-implemented-unaligned.stderr
index cbb83d2816..720d936bb4 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-unaligned.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-unaligned.stderr
@@ -19,7 +19,32 @@ help: the trait `zerocopy::Unaligned` is not implemented for `NotZerocopy`
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             str
+             u8
 note: required by a bound in `takes_unaligned`
   --> tests/ui-nightly/diagnostic-not-implemented-unaligned.rs:19:23
    |
diff --git a/tests/ui-nightly/include_value_not_from_bytes.stderr b/tests/ui-nightly/include_value_not_from_bytes.stderr
index 1d20b88346..cc91a3b106 100644
--- a/tests/ui-nightly/include_value_not_from_bytes.stderr
+++ b/tests/ui-nightly/include_value_not_from_bytes.stderr
@@ -19,7 +19,95 @@ help: the trait `FromBytes` is not implemented for `NotZerocopy<u32>`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `NOT_FROM_BYTES::transmute`
   --> tests/ui-nightly/include_value_not_from_bytes.rs:17:5
    |
diff --git a/tests/ui-nightly/ptr-is-invariant-over-v.rs b/tests/ui-nightly/ptr-is-invariant-over-v.rs
index b9a76948fb..904455cb38 100644
--- a/tests/ui-nightly/ptr-is-invariant-over-v.rs
+++ b/tests/ui-nightly/ptr-is-invariant-over-v.rs
@@ -8,20 +8,20 @@
 // those terms.
 
 use zerocopy::pointer::{
-    invariant::{Aligned, Exclusive, Shared, Valid},
+    invariant::{Aligned, Exclusive, Safe, Shared},
     Ptr,
 };
 
 fn _when_exclusive<'big: 'small, 'small>(
-    big: Ptr<'small, &'big u32, (Exclusive, Aligned, Valid)>,
-    mut _small: Ptr<'small, &'small u32, (Exclusive, Aligned, Valid)>,
+    big: Ptr<'small, &'big u32, (Exclusive, Aligned, Safe)>,
+    mut _small: Ptr<'small, &'small u32, (Exclusive, Aligned, Safe)>,
 ) {
     _small = big;
 }
 
 fn _when_shared<'big: 'small, 'small>(
-    big: Ptr<'small, &'big u32, (Shared, Aligned, Valid)>,
-    mut _small: Ptr<'small, &'small u32, (Shared, Aligned, Valid)>,
+    big: Ptr<'small, &'big u32, (Shared, Aligned, Safe)>,
+    mut _small: Ptr<'small, &'small u32, (Shared, Aligned, Safe)>,
 ) {
     _small = big;
 }
diff --git a/tests/ui-nightly/ptr-is-invariant-over-v.stderr b/tests/ui-nightly/ptr-is-invariant-over-v.stderr
index aa50070756..f894d471c2 100644
--- a/tests/ui-nightly/ptr-is-invariant-over-v.stderr
+++ b/tests/ui-nightly/ptr-is-invariant-over-v.stderr
@@ -10,7 +10,7 @@ error: lifetime may not live long enough
    |     ^^^^^^^^^^^^ assignment requires that `'small` must outlive `'big`
    |
    = help: consider adding the following bound: `'small: 'big`
-   = note: requirement occurs because of the type `Ptr<'_, &u32, (zerocopy::invariant::Exclusive, zerocopy::invariant::Aligned, zerocopy::invariant::Valid)>`, which makes the generic argument `&u32` invariant
+   = note: requirement occurs because of the type `Ptr<'_, &u32, (zerocopy::invariant::Exclusive, zerocopy::invariant::Aligned, zerocopy::invariant::Safe)>`, which makes the generic argument `&u32` invariant
    = note: the struct `Ptr<'a, T, I>` is invariant over the parameter `T`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
@@ -26,6 +26,6 @@ error: lifetime may not live long enough
    |     ^^^^^^^^^^^^ assignment requires that `'small` must outlive `'big`
    |
    = help: consider adding the following bound: `'small: 'big`
-   = note: requirement occurs because of the type `Ptr<'_, &u32, (zerocopy::invariant::Shared, zerocopy::invariant::Aligned, zerocopy::invariant::Valid)>`, which makes the generic argument `&u32` invariant
+   = note: requirement occurs because of the type `Ptr<'_, &u32, (zerocopy::invariant::Shared, zerocopy::invariant::Aligned, zerocopy::invariant::Safe)>`, which makes the generic argument `&u32` invariant
    = note: the struct `Ptr<'a, T, I>` is invariant over the parameter `T`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
diff --git a/tests/ui-nightly/transmute-dst-not-frombytes.stderr b/tests/ui-nightly/transmute-dst-not-frombytes.stderr
index abe4bf0572..009bcdcab3 100644
--- a/tests/ui-nightly/transmute-dst-not-frombytes.stderr
+++ b/tests/ui-nightly/transmute-dst-not-frombytes.stderr
@@ -19,7 +19,95 @@ help: the trait `FromBytes` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `DST_NOT_FROM_BYTES::transmute`
   --> tests/ui-nightly/transmute-dst-not-frombytes.rs:17:41
    |
diff --git a/tests/ui-nightly/transmute-mut-dst-not-frombytes.stderr b/tests/ui-nightly/transmute-mut-dst-not-frombytes.stderr
index 7f5ddbe90d..37e28471d3 100644
--- a/tests/ui-nightly/transmute-mut-dst-not-frombytes.stderr
+++ b/tests/ui-nightly/transmute-mut-dst-not-frombytes.stderr
@@ -19,7 +19,95 @@ help: the trait `FromBytes` is not implemented for `Dst`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              Src
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-nightly/transmute-mut-dst-not-intobytes.stderr b/tests/ui-nightly/transmute-mut-dst-not-intobytes.stderr
index a33b3b1e9d..c8f216d9b1 100644
--- a/tests/ui-nightly/transmute-mut-dst-not-intobytes.stderr
+++ b/tests/ui-nightly/transmute-mut-dst-not-intobytes.stderr
@@ -19,7 +19,85 @@ help: the trait `IntoBytes` is not implemented for `Dst`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              Src
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-nightly/transmute-mut-src-not-frombytes.stderr b/tests/ui-nightly/transmute-mut-src-not-frombytes.stderr
index 8baf521f35..012a6bdc2a 100644
--- a/tests/ui-nightly/transmute-mut-src-not-frombytes.stderr
+++ b/tests/ui-nightly/transmute-mut-src-not-frombytes.stderr
@@ -19,7 +19,95 @@ help: the trait `FromBytes` is not implemented for `Src`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              Dst
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-nightly/transmute-mut-src-not-intobytes.stderr b/tests/ui-nightly/transmute-mut-src-not-intobytes.stderr
index 76a4a3de62..c4c0cc5bfa 100644
--- a/tests/ui-nightly/transmute-mut-src-not-intobytes.stderr
+++ b/tests/ui-nightly/transmute-mut-src-not-intobytes.stderr
@@ -19,7 +19,85 @@ help: the trait `IntoBytes` is not implemented for `Src`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              Dst
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-nightly/transmute-ref-dst-not-frombytes.stderr b/tests/ui-nightly/transmute-ref-dst-not-frombytes.stderr
index 4cdac53c23..7f8df961aa 100644
--- a/tests/ui-nightly/transmute-ref-dst-not-frombytes.stderr
+++ b/tests/ui-nightly/transmute-ref-dst-not-frombytes.stderr
@@ -22,7 +22,95 @@ help: the trait `FromBytes` is not implemented for `Dst`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertDstIsFromBytes`
   --> tests/ui-nightly/transmute-ref-dst-not-frombytes.rs:21:34
    |
diff --git a/tests/ui-nightly/transmute-ref-dst-not-nocell.stderr b/tests/ui-nightly/transmute-ref-dst-not-nocell.stderr
index ca4b8eb77b..efa8545e6f 100644
--- a/tests/ui-nightly/transmute-ref-dst-not-nocell.stderr
+++ b/tests/ui-nightly/transmute-ref-dst-not-nocell.stderr
@@ -22,7 +22,146 @@ help: the trait `Immutable` is not implemented for `Dst`
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             Box<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertDstIsImmutable`
   --> tests/ui-nightly/transmute-ref-dst-not-nocell.rs:21:33
    |
diff --git a/tests/ui-nightly/transmute-ref-src-not-intobytes.stderr b/tests/ui-nightly/transmute-ref-src-not-intobytes.stderr
index 99c816d803..8d7df64b88 100644
--- a/tests/ui-nightly/transmute-ref-src-not-intobytes.stderr
+++ b/tests/ui-nightly/transmute-ref-src-not-intobytes.stderr
@@ -22,7 +22,85 @@ help: the trait `IntoBytes` is not implemented for `Src`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertSrcIsIntoBytes`
   --> tests/ui-nightly/transmute-ref-src-not-intobytes.rs:21:33
    |
@@ -51,7 +129,85 @@ help: the trait `IntoBytes` is not implemented for `Src`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertSrcIsIntoBytes`
   --> tests/ui-nightly/transmute-ref-src-not-intobytes.rs:21:33
    |
diff --git a/tests/ui-nightly/transmute-ref-src-not-nocell.stderr b/tests/ui-nightly/transmute-ref-src-not-nocell.stderr
index 338ca7e46a..76816e866e 100644
--- a/tests/ui-nightly/transmute-ref-src-not-nocell.stderr
+++ b/tests/ui-nightly/transmute-ref-src-not-nocell.stderr
@@ -22,7 +22,146 @@ help: the trait `Immutable` is not implemented for `Src`
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             Box<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertSrcIsImmutable`
   --> tests/ui-nightly/transmute-ref-src-not-nocell.rs:21:34
    |
@@ -51,7 +190,146 @@ help: the trait `Immutable` is not implemented for `Src`
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             Box<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertSrcIsImmutable`
   --> tests/ui-nightly/transmute-ref-src-not-nocell.rs:21:34
    |
diff --git a/tests/ui-nightly/transmute-src-not-intobytes.stderr b/tests/ui-nightly/transmute-src-not-intobytes.stderr
index 68841b35dc..25d5c322da 100644
--- a/tests/ui-nightly/transmute-src-not-intobytes.stderr
+++ b/tests/ui-nightly/transmute-src-not-intobytes.stderr
@@ -22,7 +22,85 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy<AU16>`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f128
+             f16
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `SRC_NOT_AS_BYTES::transmute`
   --> tests/ui-nightly/transmute-src-not-intobytes.rs:17:32
    |
diff --git a/tests/ui-nightly/try_transmute-dst-not-tryfrombytes.stderr b/tests/ui-nightly/try_transmute-dst-not-tryfrombytes.stderr
index 8747341a90..85504e122b 100644
--- a/tests/ui-nightly/try_transmute-dst-not-tryfrombytes.stderr
+++ b/tests/ui-nightly/try_transmute-dst-not-tryfrombytes.stderr
@@ -19,7 +19,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -47,7 +210,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::try_transmute`
    --> src/util/macro_util.rs
     |
@@ -79,7 +405,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
diff --git a/tests/ui-nightly/try_transmute-src-not-intobytes.stderr b/tests/ui-nightly/try_transmute-src-not-intobytes.stderr
index fe2720d085..64100b949d 100644
--- a/tests/ui-nightly/try_transmute-src-not-intobytes.stderr
+++ b/tests/ui-nightly/try_transmute-src-not-intobytes.stderr
@@ -19,7 +19,85 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy<AU16>`
               AtomicI64
               AtomicI8
               AtomicIsize
-            and $N others
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::try_transmute`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-nightly/try_transmute_mut-dst-not-tryfrombytes.stderr b/tests/ui-nightly/try_transmute_mut-dst-not-tryfrombytes.stderr
index 52a76f183c..7053559a12 100644
--- a/tests/ui-nightly/try_transmute_mut-dst-not-tryfrombytes.stderr
+++ b/tests/ui-nightly/try_transmute_mut-dst-not-tryfrombytes.stderr
@@ -19,7 +19,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -47,11 +210,174 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::try_transmute_mut`
    --> src/util/macro_util.rs
     |
-    | pub fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&mut Src, Dst>>
+    | pub fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&m...
     |        ----------------- required by a bound in this function
 ...
     |     Dst: TryFromBytes + IntoBytes,
@@ -79,11 +405,89 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy`
               AtomicI64
               AtomicI8
               AtomicIsize
-            and $N others
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::try_transmute_mut`
    --> src/util/macro_util.rs
     |
-    | pub fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&mut Src, Dst>>
+    | pub fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&m...
     |        ----------------- required by a bound in this function
 ...
     |     Dst: TryFromBytes + IntoBytes,
@@ -111,7 +515,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
diff --git a/tests/ui-nightly/try_transmute_mut-src-not-frombytes.stderr b/tests/ui-nightly/try_transmute_mut-src-not-frombytes.stderr
index 857ab63a7a..196b0c9a40 100644
--- a/tests/ui-nightly/try_transmute_mut-src-not-frombytes.stderr
+++ b/tests/ui-nightly/try_transmute_mut-src-not-frombytes.stderr
@@ -19,7 +19,94 @@ help: the trait `FromBytes` is not implemented for `Src`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -51,7 +138,94 @@ help: the trait `FromBytes` is not implemented for `Dst`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -83,7 +257,85 @@ help: the trait `IntoBytes` is not implemented for `Dst`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              Src
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-nightly/try_transmute_mut-src-not-intobytes.stderr b/tests/ui-nightly/try_transmute_mut-src-not-intobytes.stderr
index 72639e0ad7..ad1d982006 100644
--- a/tests/ui-nightly/try_transmute_mut-src-not-intobytes.stderr
+++ b/tests/ui-nightly/try_transmute_mut-src-not-intobytes.stderr
@@ -19,7 +19,84 @@ help: the trait `IntoBytes` is not implemented for `Src`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -51,7 +128,95 @@ help: the trait `FromBytes` is not implemented for `Dst`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              Src
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -83,7 +248,84 @@ help: the trait `IntoBytes` is not implemented for `Dst`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-nightly/try_transmute_ref-dst-not-immutable-tryfrombytes.stderr b/tests/ui-nightly/try_transmute_ref-dst-not-immutable-tryfrombytes.stderr
index 1ced94a66d..8b01d6eabb 100644
--- a/tests/ui-nightly/try_transmute_ref-dst-not-immutable-tryfrombytes.stderr
+++ b/tests/ui-nightly/try_transmute_ref-dst-not-immutable-tryfrombytes.stderr
@@ -19,7 +19,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -47,7 +210,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -79,7 +405,146 @@ help: the trait `Immutable` is not implemented for `NotZerocopy`
               (A, B, C, D)
               (A, B, C, D, E)
               (A, B, C, D, E, F)
-            and $N others
+              (A, B, C, D, E, F, G)
+              (A, B, C, D, E, F, G, H)
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              Box<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonNull<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<T>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -111,7 +576,170 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
diff --git a/tests/ui-nightly/try_transmute_ref-src-not-immutable-intobytes.stderr b/tests/ui-nightly/try_transmute_ref-src-not-immutable-intobytes.stderr
index c5e11ff14a..03f3a848ad 100644
--- a/tests/ui-nightly/try_transmute_ref-src-not-immutable-intobytes.stderr
+++ b/tests/ui-nightly/try_transmute_ref-src-not-immutable-intobytes.stderr
@@ -19,7 +19,85 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy<AU16>`
               AtomicI64
               AtomicI8
               AtomicIsize
-            and $N others
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -51,7 +129,146 @@ help: the trait `Immutable` is not implemented for `NotZerocopy<AU16>`
               (A, B, C, D)
               (A, B, C, D, E)
               (A, B, C, D, E, F)
-            and $N others
+              (A, B, C, D, E, F, G)
+              (A, B, C, D, E, F, G, H)
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              Box<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonNull<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<T>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f128
+              f16
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `zerocopy::util::macro_util::try_transmute_ref`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-stable/diagnostic-not-implemented-from-bytes.stderr b/tests/ui-stable/diagnostic-not-implemented-from-bytes.stderr
index f28a0c7f0c..d4a2b22a9c 100644
--- a/tests/ui-stable/diagnostic-not-implemented-from-bytes.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-from-bytes.stderr
@@ -19,7 +19,93 @@ help: the trait `FromBytes` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_from_bytes`
   --> tests/ui-stable/diagnostic-not-implemented-from-bytes.rs:19:24
    |
diff --git a/tests/ui-stable/diagnostic-not-implemented-from-zeros.stderr b/tests/ui-stable/diagnostic-not-implemented-from-zeros.stderr
index 820c3913ed..ce6b20115f 100644
--- a/tests/ui-stable/diagnostic-not-implemented-from-zeros.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-from-zeros.stderr
@@ -19,7 +19,156 @@ help: the trait `FromZeros` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<&T>
+             Option<&mut T>
+             Option<Box<T>>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_from_zeros`
   --> tests/ui-stable/diagnostic-not-implemented-from-zeros.rs:19:24
    |
diff --git a/tests/ui-stable/diagnostic-not-implemented-immutable.stderr b/tests/ui-stable/diagnostic-not-implemented-immutable.stderr
index f225c0c3a6..7e20a86e75 100644
--- a/tests/ui-stable/diagnostic-not-implemented-immutable.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-immutable.stderr
@@ -19,7 +19,144 @@ help: the trait `Immutable` is not implemented for `NotZerocopy`
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             Box<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_immutable`
   --> tests/ui-stable/diagnostic-not-implemented-immutable.rs:19:23
    |
diff --git a/tests/ui-stable/diagnostic-not-implemented-into-bytes.stderr b/tests/ui-stable/diagnostic-not-implemented-into-bytes.stderr
index e8880baa56..3a92bc4581 100644
--- a/tests/ui-stable/diagnostic-not-implemented-into-bytes.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-into-bytes.stderr
@@ -19,7 +19,83 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_into_bytes`
   --> tests/ui-stable/diagnostic-not-implemented-into-bytes.rs:19:24
    |
diff --git a/tests/ui-stable/diagnostic-not-implemented-issue-1296.stderr b/tests/ui-stable/diagnostic-not-implemented-issue-1296.stderr
index 8f17f04479..7b8abf533a 100644
--- a/tests/ui-stable/diagnostic-not-implemented-issue-1296.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-issue-1296.stderr
@@ -41,7 +41,83 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `Foo::write_obj`
   --> tests/ui-stable/diagnostic-not-implemented-issue-1296.rs:56:33
    |
diff --git a/tests/ui-stable/diagnostic-not-implemented-known-layout.stderr b/tests/ui-stable/diagnostic-not-implemented-known-layout.stderr
index acbb9209d6..876fcf3255 100644
--- a/tests/ui-stable/diagnostic-not-implemented-known-layout.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-known-layout.stderr
@@ -19,7 +19,80 @@ help: the trait `KnownLayout` is not implemented for `NotZerocopy`
              AU16
              AtomicBool
              AtomicI16
-           and $N others
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __ZerocopyKnownLayoutMaybeUninit
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             doctests::_::_::__ZerocopyKnownLayoutMaybeUninit<T, U>
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_known_layout`
   --> tests/ui-stable/diagnostic-not-implemented-known-layout.rs:19:26
    |
diff --git a/tests/ui-stable/diagnostic-not-implemented-try-from-bytes.stderr b/tests/ui-stable/diagnostic-not-implemented-try-from-bytes.stderr
index 2ec88bb602..229b852247 100644
--- a/tests/ui-stable/diagnostic-not-implemented-try-from-bytes.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-try-from-bytes.stderr
@@ -19,7 +19,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<Box<T>>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `takes_try_from_bytes`
   --> tests/ui-stable/diagnostic-not-implemented-try-from-bytes.rs:19:28
    |
diff --git a/tests/ui-stable/diagnostic-not-implemented-unaligned.stderr b/tests/ui-stable/diagnostic-not-implemented-unaligned.stderr
index 1203f96044..13ef3c21cb 100644
--- a/tests/ui-stable/diagnostic-not-implemented-unaligned.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-unaligned.stderr
@@ -19,7 +19,32 @@ help: the trait `zerocopy::Unaligned` is not implemented for `NotZerocopy`
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             std::mem::MaybeUninit<T>
+             str
+             u8
 note: required by a bound in `takes_unaligned`
   --> tests/ui-stable/diagnostic-not-implemented-unaligned.rs:19:23
    |
diff --git a/tests/ui-stable/include_value_not_from_bytes.stderr b/tests/ui-stable/include_value_not_from_bytes.stderr
index 32ebe7269a..684e8f4b5c 100644
--- a/tests/ui-stable/include_value_not_from_bytes.stderr
+++ b/tests/ui-stable/include_value_not_from_bytes.stderr
@@ -19,7 +19,93 @@ help: the trait `FromBytes` is not implemented for `NotZerocopy<u32>`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `NOT_FROM_BYTES::transmute`
   --> tests/ui-stable/include_value_not_from_bytes.rs:17:5
    |
diff --git a/tests/ui-stable/ptr-is-invariant-over-v.stderr b/tests/ui-stable/ptr-is-invariant-over-v.stderr
index ddb8c74032..9810f21b27 100644
--- a/tests/ui-stable/ptr-is-invariant-over-v.stderr
+++ b/tests/ui-stable/ptr-is-invariant-over-v.stderr
@@ -10,7 +10,7 @@ error: lifetime may not live long enough
    |     ^^^^^^^^^^^^ assignment requires that `'small` must outlive `'big`
    |
    = help: consider adding the following bound: `'small: 'big`
-   = note: requirement occurs because of the type `Ptr<'_, &u32, (zerocopy::invariant::Exclusive, Aligned, zerocopy::invariant::Valid)>`, which makes the generic argument `&u32` invariant
+   = note: requirement occurs because of the type `Ptr<'_, &u32, (zerocopy::invariant::Exclusive, Aligned, zerocopy::invariant::Safe)>`, which makes the generic argument `&u32` invariant
    = note: the struct `Ptr<'a, T, I>` is invariant over the parameter `T`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
@@ -26,6 +26,6 @@ error: lifetime may not live long enough
    |     ^^^^^^^^^^^^ assignment requires that `'small` must outlive `'big`
    |
    = help: consider adding the following bound: `'small: 'big`
-   = note: requirement occurs because of the type `Ptr<'_, &u32, (Shared, Aligned, zerocopy::invariant::Valid)>`, which makes the generic argument `&u32` invariant
+   = note: requirement occurs because of the type `Ptr<'_, &u32, (Shared, Aligned, zerocopy::invariant::Safe)>`, which makes the generic argument `&u32` invariant
    = note: the struct `Ptr<'a, T, I>` is invariant over the parameter `T`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
diff --git a/tests/ui-stable/transmute-dst-not-frombytes.stderr b/tests/ui-stable/transmute-dst-not-frombytes.stderr
index f8e2b4d872..60bdc4ab53 100644
--- a/tests/ui-stable/transmute-dst-not-frombytes.stderr
+++ b/tests/ui-stable/transmute-dst-not-frombytes.stderr
@@ -19,7 +19,93 @@ help: the trait `FromBytes` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `DST_NOT_FROM_BYTES::transmute`
   --> tests/ui-stable/transmute-dst-not-frombytes.rs:17:41
    |
diff --git a/tests/ui-stable/transmute-mut-dst-not-frombytes.stderr b/tests/ui-stable/transmute-mut-dst-not-frombytes.stderr
index d93ea8aa08..ac97950fd7 100644
--- a/tests/ui-stable/transmute-mut-dst-not-frombytes.stderr
+++ b/tests/ui-stable/transmute-mut-dst-not-frombytes.stderr
@@ -19,7 +19,93 @@ help: the trait `FromBytes` is not implemented for `Dst`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              Src
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-stable/transmute-mut-dst-not-intobytes.stderr b/tests/ui-stable/transmute-mut-dst-not-intobytes.stderr
index 768e8bbb1b..79c5ed2871 100644
--- a/tests/ui-stable/transmute-mut-dst-not-intobytes.stderr
+++ b/tests/ui-stable/transmute-mut-dst-not-intobytes.stderr
@@ -19,7 +19,83 @@ help: the trait `IntoBytes` is not implemented for `Dst`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              Src
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-stable/transmute-mut-src-not-frombytes.stderr b/tests/ui-stable/transmute-mut-src-not-frombytes.stderr
index 87e38e305b..a8faca2289 100644
--- a/tests/ui-stable/transmute-mut-src-not-frombytes.stderr
+++ b/tests/ui-stable/transmute-mut-src-not-frombytes.stderr
@@ -19,7 +19,93 @@ help: the trait `FromBytes` is not implemented for `Src`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              Dst
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-stable/transmute-mut-src-not-intobytes.stderr b/tests/ui-stable/transmute-mut-src-not-intobytes.stderr
index 007edbf8f9..13881d7f0f 100644
--- a/tests/ui-stable/transmute-mut-src-not-intobytes.stderr
+++ b/tests/ui-stable/transmute-mut-src-not-intobytes.stderr
@@ -19,7 +19,83 @@ help: the trait `IntoBytes` is not implemented for `Src`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              Dst
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-stable/transmute-ref-dst-not-frombytes.stderr b/tests/ui-stable/transmute-ref-dst-not-frombytes.stderr
index aecc775520..848a0cc357 100644
--- a/tests/ui-stable/transmute-ref-dst-not-frombytes.stderr
+++ b/tests/ui-stable/transmute-ref-dst-not-frombytes.stderr
@@ -22,7 +22,93 @@ help: the trait `FromBytes` is not implemented for `Dst`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertDstIsFromBytes`
   --> tests/ui-stable/transmute-ref-dst-not-frombytes.rs:21:34
    |
diff --git a/tests/ui-stable/transmute-ref-dst-not-nocell.stderr b/tests/ui-stable/transmute-ref-dst-not-nocell.stderr
index b0e20e0ed1..e357e32384 100644
--- a/tests/ui-stable/transmute-ref-dst-not-nocell.stderr
+++ b/tests/ui-stable/transmute-ref-dst-not-nocell.stderr
@@ -22,7 +22,144 @@ help: the trait `Immutable` is not implemented for `Dst`
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             Box<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertDstIsImmutable`
   --> tests/ui-stable/transmute-ref-dst-not-nocell.rs:21:33
    |
diff --git a/tests/ui-stable/transmute-ref-src-not-intobytes.stderr b/tests/ui-stable/transmute-ref-src-not-intobytes.stderr
index 5eb5496a38..430e1222bd 100644
--- a/tests/ui-stable/transmute-ref-src-not-intobytes.stderr
+++ b/tests/ui-stable/transmute-ref-src-not-intobytes.stderr
@@ -22,7 +22,83 @@ help: the trait `IntoBytes` is not implemented for `Src`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertSrcIsIntoBytes`
   --> tests/ui-stable/transmute-ref-src-not-intobytes.rs:21:33
    |
@@ -51,7 +127,83 @@ help: the trait `IntoBytes` is not implemented for `Src`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertSrcIsIntoBytes`
   --> tests/ui-stable/transmute-ref-src-not-intobytes.rs:21:33
    |
diff --git a/tests/ui-stable/transmute-ref-src-not-nocell.stderr b/tests/ui-stable/transmute-ref-src-not-nocell.stderr
index ca32a513c4..7529fe4b87 100644
--- a/tests/ui-stable/transmute-ref-src-not-nocell.stderr
+++ b/tests/ui-stable/transmute-ref-src-not-nocell.stderr
@@ -22,7 +22,144 @@ help: the trait `Immutable` is not implemented for `Src`
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             Box<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertSrcIsImmutable`
   --> tests/ui-stable/transmute-ref-src-not-nocell.rs:21:34
    |
@@ -51,7 +188,144 @@ help: the trait `Immutable` is not implemented for `Src`
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             Box<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `AssertSrcIsImmutable`
   --> tests/ui-stable/transmute-ref-src-not-nocell.rs:21:34
    |
diff --git a/tests/ui-stable/transmute-src-not-intobytes.stderr b/tests/ui-stable/transmute-src-not-intobytes.stderr
index 5771406132..fb8f69d043 100644
--- a/tests/ui-stable/transmute-src-not-intobytes.stderr
+++ b/tests/ui-stable/transmute-src-not-intobytes.stderr
@@ -22,7 +22,83 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy<AU16>`
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             __m128
+             __m128d
+             __m128i
+             __m256
+             __m256d
+             __m256i
+             __m512
+             __m512bh
+             __m512d
+             __m512i
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required by a bound in `SRC_NOT_AS_BYTES::transmute`
   --> tests/ui-stable/transmute-src-not-intobytes.rs:17:32
    |
diff --git a/tests/ui-stable/try_transmute-dst-not-tryfrombytes.stderr b/tests/ui-stable/try_transmute-dst-not-tryfrombytes.stderr
index bf18912c71..aec901e7ae 100644
--- a/tests/ui-stable/try_transmute-dst-not-tryfrombytes.stderr
+++ b/tests/ui-stable/try_transmute-dst-not-tryfrombytes.stderr
@@ -19,7 +19,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -47,7 +208,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `try_transmute`
    --> src/util/macro_util.rs
     |
@@ -79,7 +401,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
diff --git a/tests/ui-stable/try_transmute-src-not-intobytes.stderr b/tests/ui-stable/try_transmute-src-not-intobytes.stderr
index 2af9510ed9..72931831ef 100644
--- a/tests/ui-stable/try_transmute-src-not-intobytes.stderr
+++ b/tests/ui-stable/try_transmute-src-not-intobytes.stderr
@@ -19,7 +19,83 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy<AU16>`
               AtomicI64
               AtomicI8
               AtomicIsize
-            and $N others
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `try_transmute`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-stable/try_transmute_mut-dst-not-tryfrombytes.stderr b/tests/ui-stable/try_transmute_mut-dst-not-tryfrombytes.stderr
index 3bd6a75451..3b26a08664 100644
--- a/tests/ui-stable/try_transmute_mut-dst-not-tryfrombytes.stderr
+++ b/tests/ui-stable/try_transmute_mut-dst-not-tryfrombytes.stderr
@@ -19,7 +19,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -47,11 +208,172 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `try_transmute_mut`
    --> src/util/macro_util.rs
     |
-    | pub fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&mut Src, Dst>>
+    | pub fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&m...
     |        ----------------- required by a bound in this function
 ...
     |     Dst: TryFromBytes + IntoBytes,
@@ -79,11 +401,87 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy`
               AtomicI64
               AtomicI8
               AtomicIsize
-            and $N others
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `try_transmute_mut`
    --> src/util/macro_util.rs
     |
-    | pub fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&mut Src, Dst>>
+    | pub fn try_transmute_mut<Src, Dst>(src: &mut Src) -> Result<&mut Dst, ValidityError<&m...
     |        ----------------- required by a bound in this function
 ...
     |     Dst: TryFromBytes + IntoBytes,
@@ -111,7 +509,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
diff --git a/tests/ui-stable/try_transmute_mut-src-not-frombytes.stderr b/tests/ui-stable/try_transmute_mut-src-not-frombytes.stderr
index fd5624dada..f03280ad77 100644
--- a/tests/ui-stable/try_transmute_mut-src-not-frombytes.stderr
+++ b/tests/ui-stable/try_transmute_mut-src-not-frombytes.stderr
@@ -19,7 +19,92 @@ help: the trait `FromBytes` is not implemented for `Src`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -51,7 +136,92 @@ help: the trait `FromBytes` is not implemented for `Dst`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -83,7 +253,83 @@ help: the trait `IntoBytes` is not implemented for `Dst`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              Src
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-stable/try_transmute_mut-src-not-intobytes.stderr b/tests/ui-stable/try_transmute_mut-src-not-intobytes.stderr
index 88deb96c9b..21f3ba0f02 100644
--- a/tests/ui-stable/try_transmute_mut-src-not-intobytes.stderr
+++ b/tests/ui-stable/try_transmute_mut-src-not-intobytes.stderr
@@ -19,7 +19,82 @@ help: the trait `IntoBytes` is not implemented for `Src`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -51,7 +126,93 @@ help: the trait `FromBytes` is not implemented for `Dst`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              Src
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -83,7 +244,82 @@ help: the trait `IntoBytes` is not implemented for `Dst`
               AtomicI8
               AtomicIsize
               AtomicU16
-            and $N others
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::transmute_mut`
    --> src/util/macro_util.rs
     |
diff --git a/tests/ui-stable/try_transmute_ref-dst-not-immutable-tryfrombytes.stderr b/tests/ui-stable/try_transmute_ref-dst-not-immutable-tryfrombytes.stderr
index 4457e334df..da7e601149 100644
--- a/tests/ui-stable/try_transmute_ref-dst-not-immutable-tryfrombytes.stderr
+++ b/tests/ui-stable/try_transmute_ref-dst-not-immutable-tryfrombytes.stderr
@@ -19,7 +19,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -47,7 +208,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -79,7 +401,144 @@ help: the trait `Immutable` is not implemented for `NotZerocopy`
               (A, B, C, D)
               (A, B, C, D, E)
               (A, B, C, D, E, F)
-            and $N others
+              (A, B, C, D, E, F, G)
+              (A, B, C, D, E, F, G, H)
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              Box<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonNull<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<T>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -111,7 +570,168 @@ help: the trait `TryFromBytes` is not implemented for `NotZerocopy`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<Box<T>>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
diff --git a/tests/ui-stable/try_transmute_ref-src-not-immutable-intobytes.stderr b/tests/ui-stable/try_transmute_ref-src-not-immutable-intobytes.stderr
index 920bdf4225..88301df79e 100644
--- a/tests/ui-stable/try_transmute_ref-src-not-immutable-intobytes.stderr
+++ b/tests/ui-stable/try_transmute_ref-src-not-immutable-intobytes.stderr
@@ -19,7 +19,83 @@ help: the trait `IntoBytes` is not implemented for `NotZerocopy<AU16>`
               AtomicI64
               AtomicI8
               AtomicIsize
-            and $N others
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -51,7 +127,144 @@ help: the trait `Immutable` is not implemented for `NotZerocopy<AU16>`
               (A, B, C, D)
               (A, B, C, D, E)
               (A, B, C, D, E, F)
-            and $N others
+              (A, B, C, D, E, F, G)
+              (A, B, C, D, E, F, G, H)
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AU16
+              Box<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonNull<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<T>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              __m128
+              __m128d
+              __m128i
+              __m256
+              __m256d
+              __m256i
+              __m512
+              __m512bh
+              __m512d
+              __m512i
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `try_transmute_ref`
    --> src/util/macro_util.rs
     |
diff --git a/tools/update-expected-test-output.sh b/tools/update-expected-test-output.sh
index e1b582f274..3da3f315e8 100755
--- a/tools/update-expected-test-output.sh
+++ b/tools/update-expected-test-output.sh
@@ -11,11 +11,12 @@
 set -eo pipefail
 
 # Update the `.stderr` reference files used to validate our UI tests.
-TRYBUILD=overwrite ./cargo.sh +nightly test ui --test trybuild -p zerocopy --all-features
-TRYBUILD=overwrite ./cargo.sh +stable  test ui --test trybuild -p zerocopy --features=__internal_use_only_features_that_work_on_stable
-TRYBUILD=overwrite ./cargo.sh +msrv test ui --test trybuild -p zerocopy --features=__internal_use_only_features_that_work_on_stable
+# `--verbose` is useful here, as it avoids writing long type names to unpredictable files.
+RUSTFLAGS="--verbose" TRYBUILD=overwrite ./cargo.sh +nightly test ui --test trybuild -p zerocopy --all-features
+RUSTFLAGS="--verbose" TRYBUILD=overwrite ./cargo.sh +stable  test ui --test trybuild -p zerocopy --features=__internal_use_only_features_that_work_on_stable
+RUSTFLAGS="--verbose" TRYBUILD=overwrite ./cargo.sh +msrv test ui --test trybuild -p zerocopy --features=__internal_use_only_features_that_work_on_stable
 
-TRYBUILD=overwrite ./cargo.sh +all test ui --test trybuild -p zerocopy-derive
+RUSTFLAGS="--verbose" TRYBUILD=overwrite ./cargo.sh +all test ui --test trybuild -p zerocopy-derive
 
 # Update zerocopy-derive's `.expected.rs` files used to validate derive output.
 ZEROCOPY_BLESS=1 ./cargo.sh +nightly test -p zerocopy-derive --lib
diff --git a/zerocopy-derive/tests/ui-nightly/derive_transparent.stderr b/zerocopy-derive/tests/ui-nightly/derive_transparent.stderr
index 487070f009..30a7ced7f1 100644
--- a/zerocopy-derive/tests/ui-nightly/derive_transparent.stderr
+++ b/zerocopy-derive/tests/ui-nightly/derive_transparent.stderr
@@ -19,7 +19,158 @@ help: the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZero
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::TryFromBytes`
   --> tests/ui-nightly/derive_transparent.rs:24:21
    |
@@ -58,7 +209,146 @@ help: the trait `FromZeros` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `TransparentStruct<NotZerocopy>` to implement `FromZeros`
   --> tests/ui-nightly/derive_transparent.rs:24:21
    |
@@ -97,7 +387,84 @@ help: the trait `zerocopy_renamed::FromBytes` is not implemented for `NotZerocop
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::FromBytes`
   --> tests/ui-nightly/derive_transparent.rs:24:21
    |
@@ -136,7 +503,74 @@ help: the trait `zerocopy_renamed::IntoBytes` is not implemented for `NotZerocop
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::IntoBytes`
   --> tests/ui-nightly/derive_transparent.rs:24:10
    |
@@ -175,7 +609,33 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `NotZerocop
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             str
+             u8
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::Unaligned`
   --> tests/ui-nightly/derive_transparent.rs:24:32
    |
diff --git a/zerocopy-derive/tests/ui-nightly/enum.stderr b/zerocopy-derive/tests/ui-nightly/enum.stderr
index 5d6f4a92cb..471cd4c60c 100644
--- a/zerocopy-derive/tests/ui-nightly/enum.stderr
+++ b/zerocopy-derive/tests/ui-nightly/enum.stderr
@@ -326,7 +326,141 @@ error[E0277]: the trait bound `UnsafeCell<()>: Immutable` is not satisfied
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Immutable2
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Never
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::<impl IntoBytes for IntoBytes1>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes2>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes3>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes6<T>>::{constant#0}::___ZerocopyTag
+             _::_::<impl TryFromBytes for FromZeros6>::is_bit_valid::___ZerocopyTag
+             _::_::<impl TryFromBytes for TryFromBytes3>::is_bit_valid::___ZerocopyTag
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -350,7 +484,141 @@ error[E0277]: the trait bound `UnsafeCell<u8>: Immutable` is not satisfied
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Immutable2
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Never
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::<impl IntoBytes for IntoBytes1>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes2>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes3>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes6<T>>::{constant#0}::___ZerocopyTag
+             _::_::<impl TryFromBytes for FromZeros6>::is_bit_valid::___ZerocopyTag
+             _::_::<impl TryFromBytes for TryFromBytes3>::is_bit_valid::___ZerocopyTag
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -379,7 +647,161 @@ help: the trait `TryFromBytes` is not implemented for `NotTryFromBytes`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FooU8
+             FromZeros6
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TryFromBytes3
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::<impl TryFromBytes for FromZeros6>::is_bit_valid::___ZerocopyVariantStruct_A
+             _::_::<impl TryFromBytes for TryFromBytes3>::is_bit_valid::___ZerocopyVariantStruct_A
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `TryFromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -408,7 +830,161 @@ help: the trait `TryFromBytes` is not implemented for `NotFromZeros`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              FooU8
+              FromZeros6
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              TryFromBytes3
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              _::_::<impl TryFromBytes for FromZeros6>::is_bit_valid::___ZerocopyVariantStruct_A
+              _::_::<impl TryFromBytes for TryFromBytes3>::is_bit_valid::___ZerocopyVariantStruct_A
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
     = help: see issue #48214
     = note: this error originates in the derive macro `FromZeros` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -437,7 +1013,146 @@ help: the trait `FromZeros` is not implemented for `NotFromZeros`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              FooU8
+              FromZeros6
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              Option<&T>
+              Option<&mut T>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
     = help: see issue #48214
     = note: this error originates in the derive macro `FromZeros` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -461,7 +1176,83 @@ error[E0277]: the trait bound `bool: FromBytes` is not satisfied
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              FooU8
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
     = help: see issue #48214
     = note: this error originates in the derive macro `FromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -564,7 +1355,83 @@ error[E0277]: the trait bound `bool: FromBytes` is not satisfied
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              FooU8
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required for `FooU8` to implement `FromBytes`
    --> tests/ui-nightly/enum.rs:217:10
     |
diff --git a/zerocopy-derive/tests/ui-nightly/late_compile_pass.stderr b/zerocopy-derive/tests/ui-nightly/late_compile_pass.stderr
index 0512a443e3..8abe1ecaae 100644
--- a/zerocopy-derive/tests/ui-nightly/late_compile_pass.stderr
+++ b/zerocopy-derive/tests/ui-nightly/late_compile_pass.stderr
@@ -27,7 +27,160 @@ help: the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZero
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TryFromBytes1
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `TryFromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -56,7 +209,160 @@ help: the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZero
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TryFromBytes1
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromZeros` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -85,7 +391,147 @@ help: the trait `FromZeros` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromZeros` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -114,7 +560,160 @@ help: the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZero
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TryFromBytes1
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -143,7 +742,147 @@ help: the trait `FromZeros` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -172,7 +911,84 @@ help: the trait `zerocopy_renamed::FromBytes` is not implemented for `NotZerocop
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -201,7 +1017,74 @@ help: the trait `zerocopy_renamed::IntoBytes` is not implemented for `NotZerocop
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             IntoBytes1
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -230,7 +1113,35 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Unaligned1
+             Unaligned2
+             Unaligned3
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             str
+             u8
    = help: see issue #48214
    = note: this error originates in the derive macro `Unaligned` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -259,7 +1170,35 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Unaligned1
+             Unaligned2
+             Unaligned3
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             str
+             u8
    = help: see issue #48214
    = note: this error originates in the derive macro `Unaligned` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -288,7 +1227,35 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Unaligned1
+             Unaligned2
+             Unaligned3
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             str
+             u8
    = help: see issue #48214
    = note: this error originates in the derive macro `Unaligned` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -317,7 +1284,84 @@ help: the trait `zerocopy_renamed::FromBytes` is not implemented for `NotZerocop
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `FromBytes1` to implement `zerocopy_renamed::FromBytes`
   --> tests/ui-nightly/late_compile_pass.rs:49:10
    |
diff --git a/zerocopy-derive/tests/ui-nightly/privacy.stderr b/zerocopy-derive/tests/ui-nightly/privacy.stderr
index 43aecbdd84..f4e951056a 100644
--- a/zerocopy-derive/tests/ui-nightly/privacy.stderr
+++ b/zerocopy-derive/tests/ui-nightly/privacy.stderr
@@ -13,5 +13,5 @@ error: type `private::_::_::_::ẕ1` is private
 error: type `private::_::_::_::ẕb` is private
    --> tests/ui-nightly/privacy.rs:122:49
     |
-122 |     let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b) }>>::Type =
+122 |     let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b)...
     |                                                 ^ private type
diff --git a/zerocopy-derive/tests/ui-nightly/struct.stderr b/zerocopy-derive/tests/ui-nightly/struct.stderr
index 30fcb20fb1..c8e94b1a90 100644
--- a/zerocopy-derive/tests/ui-nightly/struct.stderr
+++ b/zerocopy-derive/tests/ui-nightly/struct.stderr
@@ -149,7 +149,78 @@ help: the trait `zerocopy_renamed::KnownLayout` is not implemented for `NotKnown
              AU16
              AtomicBool
              AtomicI16
-           and $N others
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             KL00
+             KL02
+             KL08
+             KL09
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             PhantomData<T>
+             ReadOnly<T>
+             SplitAtSized
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
+             util::util::_::_::__ZerocopyKnownLayoutMaybeUninit
+             zerocopy_renamed::doctests::_::_::__ZerocopyKnownLayoutMaybeUninit<T, U>
    = help: see issue #48214
    = note: this error originates in the derive macro `KnownLayout` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -178,7 +249,78 @@ help: the trait `zerocopy_renamed::KnownLayout` is not implemented for `NotKnown
              AU16
              AtomicBool
              AtomicI16
-           and $N others
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             KL00
+             KL02
+             KL08
+             KL09
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             PhantomData<T>
+             ReadOnly<T>
+             SplitAtSized
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
+             util::util::_::_::__ZerocopyKnownLayoutMaybeUninit
+             zerocopy_renamed::doctests::_::_::__ZerocopyKnownLayoutMaybeUninit<T, U>
    = help: see issue #48214
    = note: this error originates in the derive macro `KnownLayout` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -202,7 +344,135 @@ error[E0277]: the trait bound `UnsafeCell<()>: zerocopy_renamed::Immutable` is n
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Immutable2
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -226,7 +496,135 @@ error[E0277]: the trait bound `UnsafeCell<u8>: zerocopy_renamed::Immutable` is n
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Immutable2
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = note: required for `[UnsafeCell<u8>; 0]` to implement `zerocopy_renamed::Immutable`
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -304,7 +702,32 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
               F32<O>
               F64<O>
               I128<O>
-            and $N others
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i8>
+              NonZero<u8>
+              Option<NonZero<i8>>
+              Option<NonZero<u8>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              bool
+              i8
+              str
+              u8
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@@ -485,7 +908,78 @@ help: the trait `zerocopy_renamed::KnownLayout` is not implemented for `SplitAtN
               AU16
               AtomicBool
               AtomicI16
-            and $N others
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              KL00
+              KL02
+              KL08
+              KL09
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<T>
+              PhantomData<T>
+              ReadOnly<T>
+              SplitAtSized
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              _::_::__ZerocopyKnownLayoutMaybeUninit
+              _::_::__ZerocopyKnownLayoutMaybeUninit
+              _::_::__ZerocopyKnownLayoutMaybeUninit
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
+              util::util::_::_::__ZerocopyKnownLayoutMaybeUninit
+              zerocopy_renamed::doctests::_::_::__ZerocopyKnownLayoutMaybeUninit<T, U>
 note: required by a bound in `SplitAt`
    --> $WORKSPACE/src/split_at.rs
     |
@@ -541,7 +1035,32 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
               F32<O>
               F64<O>
               I128<O>
-            and $N others
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              MaybeUninit<T>
+              NonZero<i8>
+              NonZero<u8>
+              Option<NonZero<i8>>
+              Option<NonZero<u8>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              bool
+              i8
+              str
+              u8
 note: required for `IntoBytes11<AU16>` to implement `zerocopy_renamed::IntoBytes`
    --> tests/ui-nightly/struct.rs:204:10
     |
diff --git a/zerocopy-derive/tests/ui-nightly/union.stderr b/zerocopy-derive/tests/ui-nightly/union.stderr
index bf167cbc86..9d2539c192 100644
--- a/zerocopy-derive/tests/ui-nightly/union.stderr
+++ b/zerocopy-derive/tests/ui-nightly/union.stderr
@@ -92,7 +92,134 @@ error[E0277]: the trait bound `UnsafeCell<()>: zerocopy_renamed::Immutable` is n
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Isize<O>
+             ManuallyDrop<T>
+             MaybeUninit<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = note: required for `ManuallyDrop<UnsafeCell<()>>` to implement `zerocopy_renamed::Immutable`
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/zerocopy-derive/tests/ui-stable/derive_transparent.stderr b/zerocopy-derive/tests/ui-stable/derive_transparent.stderr
index 24cf210786..af00a32599 100644
--- a/zerocopy-derive/tests/ui-stable/derive_transparent.stderr
+++ b/zerocopy-derive/tests/ui-stable/derive_transparent.stderr
@@ -19,7 +19,158 @@ help: the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZero
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::TryFromBytes`
   --> tests/ui-stable/derive_transparent.rs:24:21
    |
@@ -53,7 +204,146 @@ help: the trait `FromZeros` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `TransparentStruct<NotZerocopy>` to implement `FromZeros`
   --> tests/ui-stable/derive_transparent.rs:24:21
    |
@@ -87,7 +377,84 @@ help: the trait `zerocopy_renamed::FromBytes` is not implemented for `NotZerocop
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::FromBytes`
   --> tests/ui-stable/derive_transparent.rs:24:21
    |
@@ -121,7 +488,74 @@ help: the trait `zerocopy_renamed::IntoBytes` is not implemented for `NotZerocop
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::IntoBytes`
   --> tests/ui-stable/derive_transparent.rs:24:10
    |
@@ -155,7 +589,33 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `NotZerocop
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             TransparentStruct<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             std::mem::MaybeUninit<T>
+             str
+             u8
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::Unaligned`
   --> tests/ui-stable/derive_transparent.rs:24:32
    |
diff --git a/zerocopy-derive/tests/ui-stable/enum.stderr b/zerocopy-derive/tests/ui-stable/enum.stderr
index 24d0c42799..022a7ddf04 100644
--- a/zerocopy-derive/tests/ui-stable/enum.stderr
+++ b/zerocopy-derive/tests/ui-stable/enum.stderr
@@ -307,7 +307,141 @@ error[E0277]: the trait bound `UnsafeCell<()>: Immutable` is not satisfied
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Immutable2
+             Isize<O>
+             ManuallyDrop<T>
+             Never
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::<impl IntoBytes for IntoBytes1>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes2>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes3>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes6<T>>::{constant#0}::___ZerocopyTag
+             _::_::<impl TryFromBytes for FromZeros6>::is_bit_valid::___ZerocopyTag
+             _::_::<impl TryFromBytes for TryFromBytes3>::is_bit_valid::___ZerocopyTag
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -327,7 +461,141 @@ error[E0277]: the trait bound `UnsafeCell<u8>: Immutable` is not satisfied
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Immutable2
+             Isize<O>
+             ManuallyDrop<T>
+             Never
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::<impl IntoBytes for IntoBytes1>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes2>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes3>::{constant#0}::___ZerocopyTag
+             _::_::<impl IntoBytes for IntoBytes6<T>>::{constant#0}::___ZerocopyTag
+             _::_::<impl TryFromBytes for FromZeros6>::is_bit_valid::___ZerocopyTag
+             _::_::<impl TryFromBytes for TryFromBytes3>::is_bit_valid::___ZerocopyTag
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -352,7 +620,161 @@ help: the trait `TryFromBytes` is not implemented for `NotTryFromBytes`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FooU8
+             FromZeros6
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TryFromBytes3
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::<impl TryFromBytes for FromZeros6>::is_bit_valid::___ZerocopyVariantStruct_A
+             _::_::<impl TryFromBytes for TryFromBytes3>::is_bit_valid::___ZerocopyVariantStruct_A
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `TryFromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -377,7 +799,161 @@ help: the trait `TryFromBytes` is not implemented for `NotFromZeros`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              FooU8
+              FromZeros6
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<&T>
+              Option<&mut T>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              TryFromBytes3
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              _::_::<impl TryFromBytes for FromZeros6>::is_bit_valid::___ZerocopyVariantStruct_A
+              _::_::<impl TryFromBytes for TryFromBytes3>::is_bit_valid::___ZerocopyVariantStruct_A
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
     = help: see issue #48214
     = note: this error originates in the derive macro `FromZeros` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -402,7 +978,146 @@ help: the trait `FromZeros` is not implemented for `NotFromZeros`
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              *const T
+              *mut T
+              AtomicBool
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              FooU8
+              FromZeros6
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              Option<&T>
+              Option<&mut T>
+              Option<NonNull<T>>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              Option<extern "C" fn() -> M>
+              Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<extern "C" fn(H, I, J, K, L) -> M>
+              Option<extern "C" fn(I, J, K, L) -> M>
+              Option<extern "C" fn(J, K, L) -> M>
+              Option<extern "C" fn(K, L) -> M>
+              Option<extern "C" fn(L) -> M>
+              Option<fn() -> M>
+              Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<fn(E, F, G, H, I, J, K, L) -> M>
+              Option<fn(F, G, H, I, J, K, L) -> M>
+              Option<fn(G, H, I, J, K, L) -> M>
+              Option<fn(H, I, J, K, L) -> M>
+              Option<fn(I, J, K, L) -> M>
+              Option<fn(J, K, L) -> M>
+              Option<fn(K, L) -> M>
+              Option<fn(L) -> M>
+              Option<unsafe extern "C" fn() -> M>
+              Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(I, J, K, L) -> M>
+              Option<unsafe extern "C" fn(J, K, L) -> M>
+              Option<unsafe extern "C" fn(K, L) -> M>
+              Option<unsafe extern "C" fn(L) -> M>
+              Option<unsafe fn() -> M>
+              Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+              Option<unsafe fn(G, H, I, J, K, L) -> M>
+              Option<unsafe fn(H, I, J, K, L) -> M>
+              Option<unsafe fn(I, J, K, L) -> M>
+              Option<unsafe fn(J, K, L) -> M>
+              Option<unsafe fn(K, L) -> M>
+              Option<unsafe fn(L) -> M>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              bool
+              char
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
     = help: see issue #48214
     = note: this error originates in the derive macro `FromZeros` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -422,7 +1137,83 @@ error[E0277]: the trait bound `bool: FromBytes` is not satisfied
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              FooU8
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
     = help: see issue #48214
     = note: this error originates in the derive macro `FromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -509,7 +1300,83 @@ error[E0277]: the trait bound `bool: FromBytes` is not satisfied
               (A, B, C, D, E, F)
               (A, B, C, D, E, F, G)
               (A, B, C, D, E, F, G, H)
-            and $N others
+              (A, B, C, D, E, F, G, H, I)
+              (A, B, C, D, E, F, G, H, I, J)
+              (A, B, C, D, E, F, G, H, I, J, K)
+              (A, B, C, D, E, F, G, H, I, J, K, L)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+              (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+              (A,)
+              AtomicI16
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              FooU8
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              Option<NonZero<i128>>
+              Option<NonZero<i16>>
+              Option<NonZero<i32>>
+              Option<NonZero<i64>>
+              Option<NonZero<i8>>
+              Option<NonZero<isize>>
+              Option<NonZero<u128>>
+              Option<NonZero<u16>>
+              Option<NonZero<u32>>
+              Option<NonZero<u64>>
+              Option<NonZero<u8>>
+              Option<NonZero<usize>>
+              PhantomData<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required for `FooU8` to implement `FromBytes`
    --> tests/ui-stable/enum.rs:217:10
     |
diff --git a/zerocopy-derive/tests/ui-stable/late_compile_pass.stderr b/zerocopy-derive/tests/ui-stable/late_compile_pass.stderr
index 32cb5fb17a..702edd86b5 100644
--- a/zerocopy-derive/tests/ui-stable/late_compile_pass.stderr
+++ b/zerocopy-derive/tests/ui-stable/late_compile_pass.stderr
@@ -27,7 +27,160 @@ help: the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZero
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TryFromBytes1
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `TryFromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -52,7 +205,160 @@ help: the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZero
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TryFromBytes1
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromZeros` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -77,7 +383,147 @@ help: the trait `FromZeros` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromZeros` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -102,7 +548,160 @@ help: the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZero
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             TryFromBytes1
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -127,7 +726,147 @@ help: the trait `FromZeros` is not implemented for `NotZerocopy`
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             AtomicBool
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             FromZeros1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<&T>
+             Option<&mut T>
+             Option<NonNull<T>>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -152,7 +891,84 @@ help: the trait `zerocopy_renamed::FromBytes` is not implemented for `NotZerocop
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `FromBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -177,7 +993,74 @@ help: the trait `zerocopy_renamed::IntoBytes` is not implemented for `NotZerocop
              AtomicI64
              AtomicI8
              AtomicIsize
-           and $N others
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             IntoBytes1
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -202,7 +1085,35 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Unaligned1
+             Unaligned2
+             Unaligned3
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             std::mem::MaybeUninit<T>
+             str
+             u8
    = help: see issue #48214
    = note: this error originates in the derive macro `Unaligned` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -227,7 +1138,35 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Unaligned1
+             Unaligned2
+             Unaligned3
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             std::mem::MaybeUninit<T>
+             str
+             u8
    = help: see issue #48214
    = note: this error originates in the derive macro `Unaligned` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -252,7 +1191,35 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
              F32<O>
              F64<O>
              I128<O>
-           and $N others
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             NonZero<i8>
+             NonZero<u8>
+             Option<NonZero<i8>>
+             Option<NonZero<u8>>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Unaligned1
+             Unaligned2
+             Unaligned3
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             i8
+             std::mem::MaybeUninit<T>
+             str
+             u8
    = help: see issue #48214
    = note: this error originates in the derive macro `Unaligned` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -277,7 +1244,84 @@ help: the trait `zerocopy_renamed::FromBytes` is not implemented for `NotZerocop
              (A, B, C, D, E, F)
              (A, B, C, D, E, F, G)
              (A, B, C, D, E, F, G, H)
-           and $N others
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             AU16
+             AtomicI16
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             FromBytes1
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             ManuallyDrop<T>
+             Option<NonZero<i128>>
+             Option<NonZero<i16>>
+             Option<NonZero<i32>>
+             Option<NonZero<i64>>
+             Option<NonZero<i8>>
+             Option<NonZero<isize>>
+             Option<NonZero<u128>>
+             Option<NonZero<u16>>
+             Option<NonZero<u32>>
+             Option<NonZero<u64>>
+             Option<NonZero<u8>>
+             Option<NonZero<usize>>
+             PhantomData<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
 note: required for `FromBytes1` to implement `zerocopy_renamed::FromBytes`
   --> tests/ui-stable/late_compile_pass.rs:49:10
    |
diff --git a/zerocopy-derive/tests/ui-stable/privacy.stderr b/zerocopy-derive/tests/ui-stable/privacy.stderr
index c03b376f87..1b2c31f88c 100644
--- a/zerocopy-derive/tests/ui-stable/privacy.stderr
+++ b/zerocopy-derive/tests/ui-stable/privacy.stderr
@@ -13,5 +13,5 @@ error: type `private::_::_::_::ẕ1` is private
 error: type `private::_::_::_::ẕb` is private
    --> tests/ui-stable/privacy.rs:122:49
     |
-122 |     let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b) }>>::Type =
+122 |     let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b)...
     |                                                 ^ private type
diff --git a/zerocopy-derive/tests/ui-stable/struct.stderr b/zerocopy-derive/tests/ui-stable/struct.stderr
index 4adff4acef..6aece0a666 100644
--- a/zerocopy-derive/tests/ui-stable/struct.stderr
+++ b/zerocopy-derive/tests/ui-stable/struct.stderr
@@ -137,7 +137,78 @@ help: the trait `zerocopy_renamed::KnownLayout` is not implemented for `NotKnown
              AU16
              AtomicBool
              AtomicI16
-           and $N others
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             KL00
+             KL02
+             KL08
+             KL09
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             PhantomData<T>
+             ReadOnly<T>
+             SplitAtSized
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             bool
+             char
+             doctests::_::_::__ZerocopyKnownLayoutMaybeUninit<T, U>
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
+             util::util::_::_::__ZerocopyKnownLayoutMaybeUninit
    = help: see issue #48214
    = note: this error originates in the derive macro `KnownLayout` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -162,7 +233,78 @@ help: the trait `zerocopy_renamed::KnownLayout` is not implemented for `NotKnown
              AU16
              AtomicBool
              AtomicI16
-           and $N others
+             AtomicI32
+             AtomicI64
+             AtomicI8
+             AtomicIsize
+             AtomicPtr<T>
+             AtomicU16
+             AtomicU32
+             AtomicU64
+             AtomicU8
+             AtomicUsize
+             Cell<T>
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Isize<O>
+             KL00
+             KL02
+             KL08
+             KL09
+             ManuallyDrop<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             PhantomData<T>
+             ReadOnly<T>
+             SplitAtSized
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             UnsafeCell<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             _::_::__ZerocopyKnownLayoutMaybeUninit
+             bool
+             char
+             doctests::_::_::__ZerocopyKnownLayoutMaybeUninit<T, U>
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
+             util::util::_::_::__ZerocopyKnownLayoutMaybeUninit
    = help: see issue #48214
    = note: this error originates in the derive macro `KnownLayout` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -182,7 +324,135 @@ error[E0277]: the trait bound `UnsafeCell<()>: zerocopy_renamed::Immutable` is n
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Immutable2
+             Isize<O>
+             ManuallyDrop<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -202,7 +472,135 @@ error[E0277]: the trait bound `UnsafeCell<u8>: zerocopy_renamed::Immutable` is n
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Immutable2
+             Isize<O>
+             ManuallyDrop<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = note: required for `[UnsafeCell<u8>; 0]` to implement `zerocopy_renamed::Immutable`
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -276,7 +674,32 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
               F32<O>
               F64<O>
               I128<O>
-            and $N others
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i8>
+              NonZero<u8>
+              Option<NonZero<i8>>
+              Option<NonZero<u8>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              bool
+              i8
+              std::mem::MaybeUninit<T>
+              str
+              u8
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -433,7 +856,78 @@ help: the trait `zerocopy_renamed::KnownLayout` is not implemented for `SplitAtN
               AU16
               AtomicBool
               AtomicI16
-            and $N others
+              AtomicI32
+              AtomicI64
+              AtomicI8
+              AtomicIsize
+              AtomicPtr<T>
+              AtomicU16
+              AtomicU32
+              AtomicU64
+              AtomicU8
+              AtomicUsize
+              Cell<T>
+              F32<O>
+              F64<O>
+              I128<O>
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              KL00
+              KL02
+              KL08
+              KL09
+              ManuallyDrop<T>
+              NonZero<i128>
+              NonZero<i16>
+              NonZero<i32>
+              NonZero<i64>
+              NonZero<i8>
+              NonZero<isize>
+              NonZero<u128>
+              NonZero<u16>
+              NonZero<u32>
+              NonZero<u64>
+              NonZero<u8>
+              NonZero<usize>
+              Option<T>
+              PhantomData<T>
+              ReadOnly<T>
+              SplitAtSized
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              _::_::__ZerocopyKnownLayoutMaybeUninit
+              _::_::__ZerocopyKnownLayoutMaybeUninit
+              _::_::__ZerocopyKnownLayoutMaybeUninit
+              bool
+              char
+              doctests::_::_::__ZerocopyKnownLayoutMaybeUninit<T, U>
+              f32
+              f64
+              i128
+              i16
+              i32
+              i64
+              i8
+              isize
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
+              util::util::_::_::__ZerocopyKnownLayoutMaybeUninit
 note: required by a bound in `SplitAt`
    --> $WORKSPACE/src/split_at.rs
     |
@@ -485,7 +979,32 @@ help: the trait `zerocopy_renamed::Unaligned` is not implemented for `AU16`
               F32<O>
               F64<O>
               I128<O>
-            and $N others
+              I16<O>
+              I32<O>
+              I64<O>
+              Isize<O>
+              ManuallyDrop<T>
+              NonZero<i8>
+              NonZero<u8>
+              Option<NonZero<i8>>
+              Option<NonZero<u8>>
+              PhantomData<T>
+              ReadOnly<T>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              bool
+              i8
+              std::mem::MaybeUninit<T>
+              str
+              u8
 note: required for `IntoBytes11<AU16>` to implement `zerocopy_renamed::IntoBytes`
    --> tests/ui-stable/struct.rs:204:10
     |
diff --git a/zerocopy-derive/tests/ui-stable/union.stderr b/zerocopy-derive/tests/ui-stable/union.stderr
index b49ca51e0f..d939301715 100644
--- a/zerocopy-derive/tests/ui-stable/union.stderr
+++ b/zerocopy-derive/tests/ui-stable/union.stderr
@@ -92,7 +92,134 @@ error[E0277]: the trait bound `UnsafeCell<()>: zerocopy_renamed::Immutable` is n
              (A, B, C, D)
              (A, B, C, D, E)
              (A, B, C, D, E, F)
-           and $N others
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
+             (A, B, C, D, E, F, G, H, I, J)
+             (A, B, C, D, E, F, G, H, I, J, K)
+             (A, B, C, D, E, F, G, H, I, J, K, L)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
+             (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
+             (A,)
+             *const T
+             *mut T
+             AU16
+             F32<O>
+             F64<O>
+             I128<O>
+             I16<O>
+             I32<O>
+             I64<O>
+             Immutable1
+             Isize<O>
+             ManuallyDrop<T>
+             NonNull<T>
+             NonZero<i128>
+             NonZero<i16>
+             NonZero<i32>
+             NonZero<i64>
+             NonZero<i8>
+             NonZero<isize>
+             NonZero<u128>
+             NonZero<u16>
+             NonZero<u32>
+             NonZero<u64>
+             NonZero<u8>
+             NonZero<usize>
+             Option<T>
+             Option<extern "C" fn() -> M>
+             Option<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<extern "C" fn(H, I, J, K, L) -> M>
+             Option<extern "C" fn(I, J, K, L) -> M>
+             Option<extern "C" fn(J, K, L) -> M>
+             Option<extern "C" fn(K, L) -> M>
+             Option<extern "C" fn(L) -> M>
+             Option<fn() -> M>
+             Option<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<fn(E, F, G, H, I, J, K, L) -> M>
+             Option<fn(F, G, H, I, J, K, L) -> M>
+             Option<fn(G, H, I, J, K, L) -> M>
+             Option<fn(H, I, J, K, L) -> M>
+             Option<fn(I, J, K, L) -> M>
+             Option<fn(J, K, L) -> M>
+             Option<fn(K, L) -> M>
+             Option<fn(L) -> M>
+             Option<unsafe extern "C" fn() -> M>
+             Option<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(G, H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(H, I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(I, J, K, L) -> M>
+             Option<unsafe extern "C" fn(J, K, L) -> M>
+             Option<unsafe extern "C" fn(K, L) -> M>
+             Option<unsafe extern "C" fn(L) -> M>
+             Option<unsafe fn() -> M>
+             Option<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(B, C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(C, D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(D, E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(E, F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(F, G, H, I, J, K, L) -> M>
+             Option<unsafe fn(G, H, I, J, K, L) -> M>
+             Option<unsafe fn(H, I, J, K, L) -> M>
+             Option<unsafe fn(I, J, K, L) -> M>
+             Option<unsafe fn(J, K, L) -> M>
+             Option<unsafe fn(K, L) -> M>
+             Option<unsafe fn(L) -> M>
+             PhantomData<T>
+             ReadOnly<T>
+             U128<O>
+             U16<O>
+             U32<O>
+             U64<O>
+             Unalign<T>
+             Usize<O>
+             Wrapping<T>
+             [T; N]
+             [T]
+             bool
+             char
+             f32
+             f64
+             i128
+             i16
+             i32
+             i64
+             i8
+             isize
+             std::mem::MaybeUninit<T>
+             str
+             u128
+             u16
+             u32
+             u64
+             u8
+             usize
    = note: required for `ManuallyDrop<UnsafeCell<()>>` to implement `zerocopy_renamed::Immutable`
    = help: see issue #48214
    = note: this error originates in the derive macro `Immutable` (in Nightly builds, run with -Z macro-backtrace for more info)