diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 17f782d7d9..3cc68eb286 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,7 +21,7 @@ concurrency:
 
 env:
   CARGO_TERM_COLOR: always
-  RUSTFLAGS: -Dwarnings
+  RUSTFLAGS: -Dwarnings --verbose
   RUSTDOCFLAGS: -Dwarnings
   # `ZC_NIGHTLY_XXX` are flags that we add to `XXX` only on the nightly
   # toolchain.
diff --git a/Cargo.lock b/Cargo.lock
index 7fcec7e7b3..0635845bdd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -477,7 +477,7 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.36"
+version = "0.8.37"
 dependencies = [
  "elain",
  "itertools",
@@ -491,7 +491,7 @@ dependencies = [
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.36"
+version = "0.8.37"
 dependencies = [
  "dissimilar",
  "prettyplease",
diff --git a/src/impls.rs b/src/impls.rs
index 615d3ddda9..3e238755bf 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, BecauseImmutable>();
+        let byte = byte.transmute_with::<u8, invariant::Safe, CastSizedExact, BecauseImmutable>();
         *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, BecauseImmutable>();
+        let c = c.transmute_with::<Unalign<u32>, invariant::Safe, CastSizedExact, BecauseImmutable>();
         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, BecauseImmutable>();
+        let c = c.transmute_with::<[u8], invariant::Safe, CastUnsized, BecauseImmutable>();
         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, BecauseImmutable>();
+                let n = n.transmute_with::<Unalign<$prim>, invariant::Safe, CastSizedExact, BecauseImmutable>();
                 $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<ReadOnly<$atomic>> for ReadOnly<$prim> {
                     type CastFrom = $crate::pointer::cast::CastSizedExact;
@@ -442,9 +442,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 {}
             )*
         }};
     }
@@ -1152,7 +1152,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,)+)
@@ -1169,7 +1169,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 74fb9c6632..118dc9fddd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1277,9 +1277,9 @@ where
                             // type – the type itself is irrelevant.
                             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,
                         }
                     }
                 };
@@ -3101,8 +3101,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 8de46bbe7c..9f87a40ac9 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
@@ -371,7 +371,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,
     {
@@ -406,7 +406,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
@@ -552,7 +552,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,
@@ -579,7 +579,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.
@@ -728,23 +728,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
         ///
@@ -758,11 +758,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>,
             ReadOnly<T>: Read<I::Aliasing, R>,
             I::Aliasing: Reference,
             I: Invariants<Validity = Initialized>,
@@ -773,11 +773,11 @@ mod _transitions {
             if T::is_bit_valid(self.reborrow().transmute::<_, _, _>().reborrow_shared()) {
                 // 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))
             }
@@ -1007,11 +1007,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()
         }
     }
 
@@ -1061,7 +1061,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.
         ///
@@ -1120,7 +1120,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.
@@ -1131,7 +1131,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 2a5097e10b..8d52f9d0ae 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 f105a95d0e..c14b25d260 100644
--- a/src/util/macro_util.rs
+++ b/src/util/macro_util.rs
@@ -27,7 +27,7 @@ use core::{marker::PhantomData, mem, num::Wrapping};
 use crate::{
     pointer::{
         cast::CastSized,
-        invariant::{Aligned, Initialized, Valid},
+        invariant::{Aligned, Initialized, Safe},
         BecauseImmutable,
     },
     FromBytes, Immutable, IntoBytes, KnownLayout, Ptr, ReadOnly, TryFromBytes, ValidityError,
@@ -857,7 +857,7 @@ where
         let ptr = Ptr::from_ref(self.0)
             .recall_validity::<Initialized, _>()
             .transmute_with::<Dst, Initialized, crate::layout::CastFrom<Dst>, (crate::pointer::BecauseMutationCompatible, _)>()
-            .recall_validity::<Valid, _>();
+            .recall_validity::<Safe, _>();
 
         static_assert!(Src: ?Sized + KnownLayout, Dst: ?Sized + KnownLayout => {
             Src::LAYOUT.align.get() >= Dst::LAYOUT.align.get()
@@ -890,7 +890,7 @@ where
         let ptr = Ptr::from_mut(self.0)
             .recall_validity::<Initialized, (_, (_, _))>()
             .transmute_with::<Dst, Initialized, crate::layout::CastFrom<Dst>, _>()
-            .recall_validity::<Valid, (_, (_, _))>();
+            .recall_validity::<Safe, (_, (_, _))>();
 
         static_assert!(Src: ?Sized + KnownLayout, Dst: ?Sized + KnownLayout => {
             Src::LAYOUT.align.get() >= Dst::LAYOUT.align.get()
diff --git a/src/util/macros.rs b/src/util/macros.rs
index a9ea373c82..1fe67638c2 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,
                     {
                     }
@@ -724,14 +724,14 @@ macro_rules! unsafe_impl_for_transparent_wrapper {
     ($vis:vis T $(: ?$optbound:ident)? => $wrapper:ident<T>) => {{
         crate::util::macros::__unsafe();
 
-        use crate::pointer::{TransmuteFrom, cast::{CastExact, TransitiveProject}, SizeEq, invariant::Valid};
+        use crate::pointer::{TransmuteFrom, cast::{CastExact, TransitiveProject}, SizeEq, invariant::Safe};
         use crate::wrappers::ReadOnly;
 
         // 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 CastToWrapper<T $(: ?$optbound)? > = T => $wrapper<T> });
@@ -787,7 +787,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
@@ -801,14 +801,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/util/mod.rs b/src/util/mod.rs
index ccc5166fdd..961a73d368 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -21,7 +21,7 @@ use core::{
 
 use super::*;
 use crate::pointer::{
-    invariant::{Exclusive, Shared, Valid},
+    invariant::{Exclusive, Shared, Safe},
     SizeEq, TransmuteFromPtr,
 };
 
@@ -332,7 +332,7 @@ pub(crate) unsafe fn transmute_ref<Src, Dst, R>(src: &Src) -> &Dst
 where
     Src: ?Sized,
     Dst: SizeEq<Src>
-        + TransmuteFromPtr<Src, Shared, Valid, Valid, <Dst as SizeEq<Src>>::CastFrom, R>
+        + TransmuteFromPtr<Src, Shared, Safe, Safe, <Dst as SizeEq<Src>>::CastFrom, R>
         + ?Sized,
 {
     let dst = Ptr::from_ref(src).transmute();
@@ -349,7 +349,7 @@ pub(crate) unsafe fn transmute_mut<Src, Dst, R>(src: &mut Src) -> &mut Dst
 where
     Src: ?Sized,
     Dst: SizeEq<Src>
-        + TransmuteFromPtr<Src, Exclusive, Valid, Valid, <Dst as SizeEq<Src>>::CastFrom, R>
+        + TransmuteFromPtr<Src, Exclusive, Safe, Safe, <Dst as SizeEq<Src>>::CastFrom, R>
         + ?Sized,
 {
     let dst = Ptr::from_mut(src).transmute();
diff --git a/src/wrappers.rs b/src/wrappers.rs
index 5f2414b0c6..bf120451e8 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.
 ///
@@ -704,11 +704,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..c5c910c590 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-from-bytes.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-from-bytes.stderr
@@ -19,7 +19,96 @@ 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>
+             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
+             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..c031258373 100644
--- a/tests/ui-nightly/diagnostic-not-implemented-from-zeros.stderr
+++ b/tests/ui-nightly/diagnostic-not-implemented-from-zeros.stderr
@@ -19,7 +19,159 @@ 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>
+             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_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..a235191f2a 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,171 @@ 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>
+             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_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..6446cb8e6c 100644
--- a/tests/ui-nightly/include_value_not_from_bytes.stderr
+++ b/tests/ui-nightly/include_value_not_from_bytes.stderr
@@ -19,7 +19,96 @@ 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>
+             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
+             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..07d2ed629c 100644
--- a/tests/ui-nightly/transmute-dst-not-frombytes.stderr
+++ b/tests/ui-nightly/transmute-dst-not-frombytes.stderr
@@ -19,7 +19,96 @@ 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>
+             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
+             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..a538fc68b0 100644
--- a/tests/ui-nightly/transmute-mut-dst-not-frombytes.stderr
+++ b/tests/ui-nightly/transmute-mut-dst-not-frombytes.stderr
@@ -19,7 +19,96 @@ 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>
+              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
+              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..6d20adf3fe 100644
--- a/tests/ui-nightly/transmute-mut-src-not-frombytes.stderr
+++ b/tests/ui-nightly/transmute-mut-src-not-frombytes.stderr
@@ -19,7 +19,96 @@ 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>
+              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
+              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..612c2769ff 100644
--- a/tests/ui-nightly/transmute-ref-dst-not-frombytes.stderr
+++ b/tests/ui-nightly/transmute-ref-dst-not-frombytes.stderr
@@ -22,7 +22,96 @@ 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>
+             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
+             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..b01e01797d 100644
--- a/tests/ui-nightly/try_transmute-dst-not-tryfrombytes.stderr
+++ b/tests/ui-nightly/try_transmute-dst-not-tryfrombytes.stderr
@@ -19,7 +19,171 @@ 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>
+              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 `ValidityError`
    --> src/error.rs
     |
@@ -47,7 +211,171 @@ 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>
+              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
     |
@@ -79,7 +407,171 @@ 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>
+              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 `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 64b8218af2..dfbca27a16 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,171 @@ 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>
+              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>::try_transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -51,7 +215,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 `zerocopy::util::macro_util::Wrap::<&'a mut Src, &'a mut Dst>::try_transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -83,7 +325,171 @@ 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>
+              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 `ValidityError`
    --> src/error.rs
     |
@@ -111,7 +517,171 @@ 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>
+              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 `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..bdbf34a52a 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,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>
+              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>
+              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
+              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 +139,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>
+              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
+              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 +259,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..cf5e971926 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,96 @@ 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>
+              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
+              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 +249,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 86cdc4dbc1..b0337f9bcf 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,171 @@ 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>
+              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 Src, &'a Dst>::try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -51,7 +215,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::Wrap::<&'a Src, &'a Dst>::try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -83,7 +386,171 @@ 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>
+              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 `ValidityError`
    --> src/error.rs
     |
@@ -111,7 +578,171 @@ 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>
+              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 `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 09ffdf2b61..5be065940b 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::Wrap::<&'a Src, &'a Dst>::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::Wrap::<&'a Src, &'a Dst>::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..2827852bfc 100644
--- a/tests/ui-stable/diagnostic-not-implemented-from-bytes.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-from-bytes.stderr
@@ -19,7 +19,94 @@ 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>
+             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
+             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..e5e39ba72e 100644
--- a/tests/ui-stable/diagnostic-not-implemented-from-zeros.stderr
+++ b/tests/ui-stable/diagnostic-not-implemented-from-zeros.stderr
@@ -19,7 +19,157 @@ 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>
+             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
+             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..2963698e56 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,169 @@ 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>
+             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
+             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..9afa8833e2 100644
--- a/tests/ui-stable/include_value_not_from_bytes.stderr
+++ b/tests/ui-stable/include_value_not_from_bytes.stderr
@@ -19,7 +19,94 @@ 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>
+             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
+             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..9e1f4ce8e2 100644
--- a/tests/ui-stable/transmute-dst-not-frombytes.stderr
+++ b/tests/ui-stable/transmute-dst-not-frombytes.stderr
@@ -19,7 +19,94 @@ 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>
+             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
+             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..9b1fe27241 100644
--- a/tests/ui-stable/transmute-mut-dst-not-frombytes.stderr
+++ b/tests/ui-stable/transmute-mut-dst-not-frombytes.stderr
@@ -19,7 +19,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>
+              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
+              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..3b930aa748 100644
--- a/tests/ui-stable/transmute-mut-src-not-frombytes.stderr
+++ b/tests/ui-stable/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>
+              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>
+              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
+              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..7a00916093 100644
--- a/tests/ui-stable/transmute-ref-dst-not-frombytes.stderr
+++ b/tests/ui-stable/transmute-ref-dst-not-frombytes.stderr
@@ -22,7 +22,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,)
+             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>
+             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
+             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..4690dca719 100644
--- a/tests/ui-stable/try_transmute-dst-not-tryfrombytes.stderr
+++ b/tests/ui-stable/try_transmute-dst-not-tryfrombytes.stderr
@@ -19,7 +19,169 @@ 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>
+              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
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -47,7 +209,169 @@ 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>
+              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
+              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 +403,169 @@ 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>
+              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
+              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 29376d344b..4eb1b59ef7 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,169 @@ 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>
+              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
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a mut Src, &'a mut Dst>::try_transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -51,7 +213,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 `Wrap::<&'a mut Src, &'a mut Dst>::try_transmute_mut`
    --> src/util/macro_util.rs
     |
@@ -83,7 +321,169 @@ 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>
+              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
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -111,7 +511,169 @@ 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>
+              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
+              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..b267f8dbb8 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,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>
+              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>
+              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
+              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 +137,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>
+              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
+              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 +255,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..7dee0d55ff 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,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>
+              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
+              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 +245,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 d3bb0aa08c..d8b636cbd8 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,169 @@ 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>
+              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
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `Wrap::<&'a Src, &'a Dst>::try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -51,7 +213,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 `Wrap::<&'a Src, &'a Dst>::try_transmute_ref`
    --> src/util/macro_util.rs
     |
@@ -83,7 +382,169 @@ 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>
+              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
+              std::mem::MaybeUninit<T>
+              str
+              u128
+              u16
+              u32
+              u64
+              u8
+              usize
 note: required by a bound in `ValidityError`
    --> src/error.rs
     |
@@ -111,7 +572,169 @@ 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>
+              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
+              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 812ce13503..dced189bee 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 `Wrap::<&'a Src, &'a Dst>::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 `Wrap::<&'a Src, &'a Dst>::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..f4a1613307 100755
--- a/tools/update-expected-test-output.sh
+++ b/tools/update-expected-test-output.sh
@@ -11,11 +11,13 @@
 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..92f43b99c8 100644
--- a/zerocopy-derive/tests/ui-nightly/derive_transparent.stderr
+++ b/zerocopy-derive/tests/ui-nightly/derive_transparent.stderr
@@ -19,7 +19,159 @@ 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
+             zerocopy_renamed::ReadOnly<T>
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::TryFromBytes`
   --> tests/ui-nightly/derive_transparent.rs:24:21
    |
@@ -58,7 +210,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
 note: required for `TransparentStruct<NotZerocopy>` to implement `FromZeros`
   --> tests/ui-nightly/derive_transparent.rs:24:21
    |
@@ -97,7 +389,85 @@ 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
+             zerocopy_renamed::ReadOnly<T>
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::FromBytes`
   --> tests/ui-nightly/derive_transparent.rs:24:21
    |
@@ -136,7 +506,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::IntoBytes`
   --> tests/ui-nightly/derive_transparent.rs:24:10
    |
@@ -175,7 +612,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
 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 b948d84bc7..f3169067a6 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,162 @@ 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>
+             ReadOnly<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 +831,162 @@ 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>
+              ReadOnly<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 +1015,147 @@ 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>
+              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 `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 +1179,84 @@ 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>
+              ReadOnly<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 +1359,84 @@ 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>
+              ReadOnly<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..66f792c16c 100644
--- a/zerocopy-derive/tests/ui-nightly/late_compile_pass.stderr
+++ b/zerocopy-derive/tests/ui-nightly/late_compile_pass.stderr
@@ -27,7 +27,161 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +210,161 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +393,148 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +563,161 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +746,148 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +916,85 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1023,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1119,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1176,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1233,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1290,85 @@ 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
+             zerocopy_renamed::ReadOnly<T>
 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/struct.stderr b/zerocopy-derive/tests/ui-nightly/struct.stderr
index 5eb87eb390..a80a86d076 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>
+             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::ReadOnly<T>
+             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>
+             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::ReadOnly<T>
+             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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              bool
+              i8
+              str
+              u8
+              zerocopy_renamed::ReadOnly<T>
     = 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>
+              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::ReadOnly<T>
+              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>
+              U128<O>
+              U16<O>
+              U32<O>
+              U64<O>
+              Unalign<T>
+              UnsafeCell<T>
+              Usize<O>
+              Wrapping<T>
+              [T; N]
+              [T]
+              bool
+              i8
+              str
+              u8
+              zerocopy_renamed::ReadOnly<T>
 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..95e6c1cafd 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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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..d1fb216269 100644
--- a/zerocopy-derive/tests/ui-stable/derive_transparent.stderr
+++ b/zerocopy-derive/tests/ui-stable/derive_transparent.stderr
@@ -19,7 +19,159 @@ 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
+             zerocopy_renamed::ReadOnly<T>
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::TryFromBytes`
   --> tests/ui-stable/derive_transparent.rs:24:21
    |
@@ -53,7 +205,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
 note: required for `TransparentStruct<NotZerocopy>` to implement `FromZeros`
   --> tests/ui-stable/derive_transparent.rs:24:21
    |
@@ -87,7 +379,85 @@ 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
+             zerocopy_renamed::ReadOnly<T>
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::FromBytes`
   --> tests/ui-stable/derive_transparent.rs:24:21
    |
@@ -121,7 +491,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
 note: required for `TransparentStruct<NotZerocopy>` to implement `zerocopy_renamed::IntoBytes`
   --> tests/ui-stable/derive_transparent.rs:24:10
    |
@@ -155,7 +592,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
 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 38810d6159..d4f862912b 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,162 @@ 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>
+             ReadOnly<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 +800,162 @@ 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>
+              ReadOnly<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 +980,147 @@ 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>
+              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
+              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 +1140,84 @@ 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>
+              ReadOnly<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 +1304,84 @@ 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>
+              ReadOnly<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..79ca252ca2 100644
--- a/zerocopy-derive/tests/ui-stable/late_compile_pass.stderr
+++ b/zerocopy-derive/tests/ui-stable/late_compile_pass.stderr
@@ -27,7 +27,161 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +206,161 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +385,148 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +551,161 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +730,148 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +896,85 @@ 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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +999,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1091,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1144,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1197,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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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 +1250,85 @@ 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
+             zerocopy_renamed::ReadOnly<T>
 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/struct.stderr b/zerocopy-derive/tests/ui-stable/struct.stderr
index 1d73c95052..ff2a71b085 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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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>
+              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
+              zerocopy_renamed::ReadOnly<T>
     = 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>
+              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
+              zerocopy_renamed::ReadOnly<T>
 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>
+              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
+              zerocopy_renamed::ReadOnly<T>
 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..9224097843 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>
+             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
+             zerocopy_renamed::ReadOnly<T>
    = 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)