html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/zerocopy-derive/tests/struct_to_bytes.rs

@@ -19,12 +19,14 @@ include!("include.rs");
 // - `repr(packed)`
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct CZst;
 
 util_assert_impl_all!(CZst: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct C {
     a: u8,
@@ -35,6 +37,7 @@ struct C {
 util_assert_impl_all!(C: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct SyntacticUnsized {
     a: u8,
@@ -45,6 +48,7 @@ struct SyntacticUnsized {
 util_assert_impl_all!(C: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct Transparent {
     a: u8,
@@ -54,6 +58,7 @@ struct Transparent {
 util_assert_impl_all!(Transparent: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct TransparentGeneric<T: ?imp::Sized> {
     a: (),
@@ -64,12 +69,14 @@ util_assert_impl_all!(TransparentGeneric<u64>: imp::IntoBytes);
 util_assert_impl_all!(TransparentGeneric<[u64]>: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 struct CZstPacked;
 
 util_assert_impl_all!(CZstPacked: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 struct CPacked {
     a: u8,
@@ -86,6 +93,7 @@ struct CPacked {
 util_assert_impl_all!(CPacked: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed(2))]
 // The same caveats as for CPacked apply - we're assuming u64 is at least
 // 4-byte aligned by default. Without packed(2), this should fail, as there
@@ -98,6 +106,7 @@ struct CPacked2 {
 util_assert_impl_all!(CPacked2: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 struct CPackedGeneric<T, U: ?imp::Sized> {
     t: T,
@@ -113,6 +122,7 @@ util_assert_impl_all!(CPackedGeneric<u8, util::AU16>: imp::IntoBytes);
 util_assert_impl_all!(CPackedGeneric<u8, [util::AU16]>: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(packed)]
 struct PackedGeneric<T, U: ?imp::Sized> {
     t: T,
@@ -130,6 +140,7 @@ util_assert_impl_all!(PackedGeneric<u8, [util::AU16]>: imp::IntoBytes);
 // This test is non-portable, but works so long as Rust happens to lay this
 // struct out with no padding.
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Unpacked {
     a: u8,
     b: u8,
@@ -138,6 +149,7 @@ struct Unpacked {
 util_assert_impl_all!(Unpacked: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct ReprCGenericOneField<T: ?imp::Sized> {
     t: T,
@@ -149,6 +161,7 @@ util_assert_impl_all!(ReprCGenericOneField<util::AU16>: imp::IntoBytes);
 util_assert_impl_all!(ReprCGenericOneField<[util::AU16]>: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct ReprCGenericMultipleFields<T, U: ?imp::Sized> {
     t: T,
@@ -163,6 +176,7 @@ util_assert_not_impl_any!(ReprCGenericMultipleFields<u8, util::AU16>: imp::IntoB
 util_assert_not_impl_any!(ReprCGenericMultipleFields<u8, [util::AU16]>: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct Unsized {
     a: [u8],
@@ -173,6 +187,7 @@ util_assert_impl_all!(Unsized: imp::IntoBytes);
 // Deriving `IntoBytes` should work if the struct has bounded parameters.
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::IntoBytes, const N: usize>(
     [T; N],
@@ -188,10 +203,12 @@ util_assert_impl_all!(WithParams<'static, 'static, u8, 42>: imp::IntoBytes);
 // Test for the failure reported in #1182.
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 pub struct IndexEntryFlags(u8);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 pub struct IndexEntry<const SIZE_BLOCK_ID: usize> {
     block_number: imp::native_endian::U64,

data/rust-vendor/zerocopy-derive/tests/struct_try_from_bytes.rs

@@ -17,16 +17,11 @@ include!("include.rs");
 
 #[test]
 fn zst() {
-    // FIXME(#5): Use `try_transmute` in this test once it's available.
-    let candidate = ::zerocopy::Ptr::from_ref(&());
-    let candidate = candidate.forget_aligned();
-    // SAFETY: `&()` trivially consists entirely of initialized bytes.
-    let candidate = unsafe { candidate.assume_initialized() };
-    let is_bit_valid = <() as imp::TryFromBytes>::is_bit_valid(candidate);
-    imp::assert!(is_bit_valid);
+    crate::util::test_is_bit_valid::<(), _>((), true);
 }
 
-#[derive(imp::TryFromBytes)]
+#[derive(imp::TryFromBytes, imp::Immutable, imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct One {
     a: u8,
@@ -36,16 +31,12 @@ util_assert_impl_all!(One: imp::TryFromBytes);
 
 #[test]
 fn one() {
-    // FIXME(#5): Use `try_transmute` in this test once it's available.
-    let candidate = ::zerocopy::Ptr::from_ref(&One { a: 42 });
-    let candidate = candidate.forget_aligned();
-    // SAFETY: `&One` consists entirely of initialized bytes.
-    let candidate = unsafe { candidate.assume_initialized() };
-    let is_bit_valid = <One as imp::TryFromBytes>::is_bit_valid(candidate);
-    imp::assert!(is_bit_valid);
+    crate::util::test_is_bit_valid::<One, _>(One { a: 42 }, true);
+    crate::util::test_is_bit_valid::<One, _>(One { a: 43 }, true);
 }
 
-#[derive(imp::TryFromBytes)]
+#[derive(imp::TryFromBytes, imp::Immutable, imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct Two {
     a: bool,
@@ -56,37 +47,13 @@ util_assert_impl_all!(Two: imp::TryFromBytes);
 
 #[test]
 fn two() {
-    // FIXME(#5): Use `try_transmute` in this test once it's available.
-    let candidate = ::zerocopy::Ptr::from_ref(&Two { a: false, b: () });
-    let candidate = candidate.forget_aligned();
-    // SAFETY: `&Two` consists entirely of initialized bytes.
-    let candidate = unsafe { candidate.assume_initialized() };
-    let is_bit_valid = <Two as imp::TryFromBytes>::is_bit_valid(candidate);
-    imp::assert!(is_bit_valid);
-}
-
-#[test]
-fn two_bad() {
-    // FIXME(#5): Use `try_transmute` in this test once it's available.
-    let mut buf = [2u8; 1];
-    let candidate = ::zerocopy::Ptr::from_mut(&mut buf);
-    let candidate = candidate.forget_aligned();
-    // SAFETY: `&Two` consists entirely of initialized bytes.
-    let candidate = unsafe { candidate.assume_initialized() };
-
-    let candidate = {
-        use imp::pointer::{cast::CastSized, BecauseExclusive};
-        candidate.cast::<_, CastSized, (_, (BecauseExclusive, BecauseExclusive))>()
-    };
-
-    // SAFETY: `candidate`'s referent is as-initialized as `Two`.
-    let candidate = unsafe { candidate.assume_initialized() };
-
-    let is_bit_valid = <Two as imp::TryFromBytes>::is_bit_valid(candidate);
-    imp::assert!(!is_bit_valid);
+    crate::util::test_is_bit_valid::<Two, _>(Two { a: false, b: () }, true);
+    crate::util::test_is_bit_valid::<Two, _>(Two { a: true, b: () }, true);
+    crate::util::test_is_bit_valid::<Two, _>([2u8], false);
 }
 
 #[derive(imp::KnownLayout, imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct Unsized {
     a: [u8],
@@ -98,23 +65,23 @@ util_assert_impl_all!(Unsized: imp::TryFromBytes);
 fn un_sized() {
     // FIXME(#5): Use `try_transmute` in this test once it's available.
     let mut buf = [16u8, 12, 42];
-    let candidate = ::zerocopy::Ptr::from_mut(&mut buf[..]);
-    let candidate = candidate.forget_aligned();
+    let candidate = ::zerocopy_renamed::Ptr::from_mut(&mut buf[..]);
     // SAFETY: `&Unsized` consists entirely of initialized bytes.
     let candidate = unsafe { candidate.assume_initialized() };
 
-    let candidate = {
+    let mut candidate = {
         use imp::pointer::{cast::CastUnsized, BecauseExclusive};
-        candidate.cast::<_, CastUnsized, (_, (BecauseExclusive, BecauseExclusive))>()
+        candidate.cast::<_, CastUnsized, (_, BecauseExclusive)>()
     };
 
     // SAFETY: `candidate`'s referent is as-initialized as `Two`.
-    let candidate = unsafe { candidate.assume_initialized() };
-    let is_bit_valid = <Unsized as imp::TryFromBytes>::is_bit_valid(candidate);
+    let mut candidate = unsafe { candidate.assume_initialized() };
+    let is_bit_valid = <Unsized as imp::TryFromBytes>::is_bit_valid(candidate.reborrow_shared());
     imp::assert!(is_bit_valid);
 }
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct TypeParams<'a, T: ?imp::Sized, I: imp::Iterator> {
     a: I::Item,
@@ -133,6 +100,7 @@ util_assert_impl_all!(TypeParams<'static, [util::AU16], imp::IntoIter<()>>: imp:
 // parameters.
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::TryFromBytes, const N: usize>(
     imp::PhantomData<&'a &'b ()>,
@@ -145,7 +113,8 @@ where
 
 util_assert_impl_all!(WithParams<'static, 'static, u8, 42>: imp::TryFromBytes);
 
-#[derive(imp::FromBytes)]
+#[derive(imp::FromBytes, imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct MaybeFromBytes<T>(T);
 
@@ -155,23 +124,13 @@ fn test_maybe_from_bytes() {
     // trivial `is_bit_valid` impl that always returns true. This test confirms
     // that we *don't* spuriously do that when generic parameters are present.
 
-    let mut buf = [2u8];
-    let candidate = ::zerocopy::Ptr::from_mut(&mut buf);
-    let candidate = candidate.bikeshed_recall_initialized_from_bytes();
-
-    let candidate = {
-        use imp::pointer::{cast::CastSized, BecauseExclusive};
-        candidate
-            .cast::<MaybeFromBytes<bool>, CastSized, (_, (BecauseExclusive, BecauseExclusive))>()
-    };
-
-    // SAFETY: `[u8]` consists entirely of initialized bytes.
-    let candidate = unsafe { candidate.assume_initialized() };
-    let is_bit_valid = <MaybeFromBytes<bool> as imp::TryFromBytes>::is_bit_valid(candidate);
-    imp::assert!(!is_bit_valid);
+    crate::util::test_is_bit_valid::<MaybeFromBytes<bool>, _>(MaybeFromBytes(false), true);
+    crate::util::test_is_bit_valid::<MaybeFromBytes<bool>, _>(MaybeFromBytes(true), true);
+    crate::util::test_is_bit_valid::<MaybeFromBytes<bool>, _>([2u8], false);
 }
 
 #[derive(Debug, PartialEq, Eq, imp::TryFromBytes, imp::Immutable, imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 struct CPacked {
     a: u8,
@@ -193,6 +152,7 @@ fn c_packed() {
 }
 
 #[derive(imp::TryFromBytes, imp::KnownLayout, imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 struct CPackedUnsized {
     a: u8,
@@ -214,6 +174,7 @@ fn c_packed_unsized() {
 }
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(packed)]
 struct PackedUnsized {
     a: u8,
@@ -243,14 +204,17 @@ fn packed_unsized() {
 }
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct A;
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct B {
     a: A,
 }
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct RawIdent {
     r#type: u8,

data/rust-vendor/zerocopy-derive/tests/struct_unaligned.rs

@@ -19,6 +19,7 @@ include!("include.rs");
 //   - `repr(packed)`
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct Foo {
     a: u8,
@@ -27,6 +28,7 @@ struct Foo {
 util_assert_impl_all!(Foo: imp::Unaligned);
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct Bar {
     a: u8,
@@ -35,6 +37,7 @@ struct Bar {
 util_assert_impl_all!(Bar: imp::Unaligned);
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(packed)]
 struct Baz {
     // NOTE: The `u16` type is not guaranteed to have alignment 2, although it
@@ -50,6 +53,7 @@ struct Baz {
 util_assert_impl_all!(Baz: imp::Unaligned);
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, align(1))]
 struct FooAlign {
     a: u8,
@@ -58,6 +62,7 @@ struct FooAlign {
 util_assert_impl_all!(FooAlign: imp::Unaligned);
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct Unsized {
     a: [u8],
@@ -66,6 +71,7 @@ struct Unsized {
 util_assert_impl_all!(Unsized: imp::Unaligned);
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct TypeParams<'a, T: ?imp::Sized, I: imp::Iterator> {
     a: I::Item,
@@ -83,6 +89,7 @@ util_assert_impl_all!(TypeParams<'static, [::core::primitive::u8], imp::IntoIter
 // Deriving `Unaligned` should work if the struct has bounded parameters.
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::Unaligned, const N: usize>(
     [T; N],

data/rust-vendor/zerocopy-derive/tests/ui-msrv/derive_transparent.rs

@@ -6,14 +6,14 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-extern crate zerocopy;
+extern crate zerocopy_renamed;
 
 #[path = "../include.rs"]
 mod util;
 
 use core::marker::PhantomData;
 
-use zerocopy::{FromBytes, FromZeros, IntoBytes, TryFromBytes, Unaligned};
+use zerocopy_renamed::{FromBytes, FromZeros, IntoBytes, TryFromBytes, Unaligned};
 
 use self::util::util::NotZerocopy;
 
@@ -22,6 +22,7 @@ fn main() {}
 // Test generic transparent structs
 
 #[derive(IntoBytes, FromBytes, Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct TransparentStruct<T> {
     inner: T,

data/rust-vendor/zerocopy-derive/tests/ui-msrv/derive_transparent.stderr

@@ -1,25 +1,25 @@
-error[E0277]: the trait bound `NotZerocopy: zerocopy::TryFromBytes` is not satisfied
-  --> tests/ui-msrv/derive_transparent.rs:34:1
+error[E0277]: the trait bound `NotZerocopy: zerocopy_renamed::TryFromBytes` is not satisfied
+  --> tests/ui-msrv/derive_transparent.rs:35:1
    |
-34 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: TryFromBytes);
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy::TryFromBytes` is not implemented for `NotZerocopy`
+35 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: TryFromBytes);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy_renamed::TryFromBytes` is not implemented for `NotZerocopy`
    |
-note: required because of the requirements on the impl of `zerocopy::TryFromBytes` for `TransparentStruct<NotZerocopy>`
+note: required because of the requirements on the impl of `zerocopy_renamed::TryFromBytes` for `TransparentStruct<NotZerocopy>`
   --> tests/ui-msrv/derive_transparent.rs:24:21
    |
 24 | #[derive(IntoBytes, FromBytes, Unaligned)]
    |                     ^^^^^^^^^
 note: required by a bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
-  --> tests/ui-msrv/derive_transparent.rs:34:1
+  --> tests/ui-msrv/derive_transparent.rs:35:1
    |
-34 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: TryFromBytes);
+35 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: TryFromBytes);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
    = note: this error originates in the macro `::static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0277]: the trait bound `NotZerocopy: FromZeros` is not satisfied
-  --> tests/ui-msrv/derive_transparent.rs:35:1
+  --> tests/ui-msrv/derive_transparent.rs:36:1
    |
-35 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: FromZeros);
+36 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: FromZeros);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `FromZeros` is not implemented for `NotZerocopy`
    |
 note: required because of the requirements on the impl of `FromZeros` for `TransparentStruct<NotZerocopy>`
@@ -28,62 +28,62 @@ note: required because of the requirements on the impl of `FromZeros` for `Trans
 24 | #[derive(IntoBytes, FromBytes, Unaligned)]
    |                     ^^^^^^^^^
 note: required by a bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
-  --> tests/ui-msrv/derive_transparent.rs:35:1
+  --> tests/ui-msrv/derive_transparent.rs:36:1
    |
-35 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: FromZeros);
+36 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: FromZeros);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
    = note: this error originates in the macro `::static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0277]: the trait bound `NotZerocopy: zerocopy::FromBytes` is not satisfied
-  --> tests/ui-msrv/derive_transparent.rs:36:1
+error[E0277]: the trait bound `NotZerocopy: zerocopy_renamed::FromBytes` is not satisfied
+  --> tests/ui-msrv/derive_transparent.rs:37:1
    |
-36 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: FromBytes);
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy::FromBytes` is not implemented for `NotZerocopy`
+37 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: FromBytes);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy_renamed::FromBytes` is not implemented for `NotZerocopy`
    |
-note: required because of the requirements on the impl of `zerocopy::FromBytes` for `TransparentStruct<NotZerocopy>`
+note: required because of the requirements on the impl of `zerocopy_renamed::FromBytes` for `TransparentStruct<NotZerocopy>`
   --> tests/ui-msrv/derive_transparent.rs:24:21
    |
 24 | #[derive(IntoBytes, FromBytes, Unaligned)]
    |                     ^^^^^^^^^
 note: required by a bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
-  --> tests/ui-msrv/derive_transparent.rs:36:1
+  --> tests/ui-msrv/derive_transparent.rs:37:1
    |
-36 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: FromBytes);
+37 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: FromBytes);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
    = note: this error originates in the macro `::static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0277]: the trait bound `NotZerocopy: zerocopy::IntoBytes` is not satisfied
-  --> tests/ui-msrv/derive_transparent.rs:37:1
+error[E0277]: the trait bound `NotZerocopy: zerocopy_renamed::IntoBytes` is not satisfied
+  --> tests/ui-msrv/derive_transparent.rs:38:1
    |
-37 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: IntoBytes);
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy::IntoBytes` is not implemented for `NotZerocopy`
+38 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: IntoBytes);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy_renamed::IntoBytes` is not implemented for `NotZerocopy`
    |
-note: required because of the requirements on the impl of `zerocopy::IntoBytes` for `TransparentStruct<NotZerocopy>`
+note: required because of the requirements on the impl of `zerocopy_renamed::IntoBytes` for `TransparentStruct<NotZerocopy>`
   --> tests/ui-msrv/derive_transparent.rs:24:10
    |
 24 | #[derive(IntoBytes, FromBytes, Unaligned)]
    |          ^^^^^^^^^
 note: required by a bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
-  --> tests/ui-msrv/derive_transparent.rs:37:1
+  --> tests/ui-msrv/derive_transparent.rs:38:1
    |
-37 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: IntoBytes);
+38 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: IntoBytes);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
    = note: this error originates in the macro `::static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0277]: the trait bound `NotZerocopy: zerocopy::Unaligned` is not satisfied
-  --> tests/ui-msrv/derive_transparent.rs:38:1
+error[E0277]: the trait bound `NotZerocopy: zerocopy_renamed::Unaligned` is not satisfied
+  --> tests/ui-msrv/derive_transparent.rs:39:1
    |
-38 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: Unaligned);
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy::Unaligned` is not implemented for `NotZerocopy`
+39 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: Unaligned);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy_renamed::Unaligned` is not implemented for `NotZerocopy`
    |
-note: required because of the requirements on the impl of `zerocopy::Unaligned` for `TransparentStruct<NotZerocopy>`
+note: required because of the requirements on the impl of `zerocopy_renamed::Unaligned` for `TransparentStruct<NotZerocopy>`
   --> tests/ui-msrv/derive_transparent.rs:24:32
    |
 24 | #[derive(IntoBytes, FromBytes, Unaligned)]
    |                                ^^^^^^^^^
 note: required by a bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
-  --> tests/ui-msrv/derive_transparent.rs:38:1
+  --> tests/ui-msrv/derive_transparent.rs:39:1
    |
-38 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: Unaligned);
+39 | util_assert_impl_all!(TransparentStruct<NotZerocopy>: Unaligned);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `_::{closure#0}::_::{closure#0}::assert_impl_all`
    = note: this error originates in the macro `::static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info)