html-to-markdown 2.23.4 → 2.24.1

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

@@ -26,6 +26,7 @@ macro_rules! test {
 
                     #[deprecated = "do not use"]
                     #[derive(imp::$trait)]
+                    #[zerocopy(crate = "zerocopy_renamed")]
                     $ty
 
                     #[allow(deprecated)]
@@ -53,6 +54,7 @@ mod enum_hash_eq {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::ByteHash, imp::IntoBytes, imp::Immutable)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(u8)]
         enum Enum {
             A,
@@ -67,6 +69,7 @@ mod enum_hash_eq {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::ByteEq, imp::IntoBytes, imp::Immutable)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(u8)]
         enum Enum {
             A,
@@ -84,6 +87,7 @@ mod struct_hash_eq {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::ByteHash, imp::IntoBytes, imp::Immutable)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(C)]
         struct Struct;
 
@@ -96,6 +100,7 @@ mod struct_hash_eq {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::ByteEq, imp::IntoBytes, imp::Immutable)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(C)]
         struct Struct;
 
@@ -112,6 +117,7 @@ mod split_at_test {
         use super::super::*;
         #[deprecated = "do not use"]
         #[derive(imp::SplitAt, imp::KnownLayout)]
+        #[zerocopy(crate = "zerocopy_renamed")]
         #[repr(C)]
         struct Struct {
             a: [u8],

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

@@ -13,6 +13,7 @@
 include!("include.rs");
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum Foo {
     A,
@@ -21,6 +22,7 @@ enum Foo {
 util_assert_impl_all!(Foo: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum Bar {
     A = 0,
@@ -29,6 +31,7 @@ enum Bar {
 util_assert_impl_all!(Bar: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum TwoVariantsHasExplicitZero {
     A = 1,
@@ -38,6 +41,7 @@ enum TwoVariantsHasExplicitZero {
 util_assert_impl_all!(TwoVariantsHasExplicitZero: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i8)]
 enum ImplicitNonFirstVariantIsZero {
     A = -1,
@@ -47,6 +51,7 @@ enum ImplicitNonFirstVariantIsZero {
 util_assert_impl_all!(ImplicitNonFirstVariantIsZero: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u64)]
 enum LargeDiscriminant {
     A = 0xFFFF_FFFF_FFFF_FFFF,
@@ -56,6 +61,7 @@ enum LargeDiscriminant {
 util_assert_impl_all!(LargeDiscriminant: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum FirstVariantIsZeroable {
     A(u32),
@@ -65,6 +71,7 @@ enum FirstVariantIsZeroable {
 util_assert_impl_all!(FirstVariantIsZeroable: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum FirstVariantIsZeroableSecondIsNot {
     A(bool),
@@ -79,6 +86,7 @@ mod msrv_only {
     use super::*;
 
     #[derive(imp::FromZeros)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(u8)]
     enum ImplicitFirstVariantIsZeroable {
         A(bool),
@@ -88,6 +96,7 @@ mod msrv_only {
     util_assert_impl_all!(ImplicitFirstVariantIsZeroable: imp::FromZeros);
 
     #[derive(imp::FromZeros)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(i8)]
     enum ImplicitNonFirstVariantIsZeroable {
         A(::core::num::NonZeroU8) = 1,

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

@@ -13,6 +13,7 @@
 include!("include.rs");
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 enum Foo {
     A,
 }
@@ -20,6 +21,7 @@ enum Foo {
 util_assert_impl_all!(Foo: imp::KnownLayout);
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 enum Bar {
     A = 0,
 }
@@ -27,6 +29,7 @@ enum Bar {
 util_assert_impl_all!(Bar: imp::KnownLayout);
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 enum Baz {
     A = 1,
     B = 0,
@@ -37,6 +40,7 @@ util_assert_impl_all!(Baz: imp::KnownLayout);
 // Deriving `KnownLayout` should work if the enum has bounded parameters.
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::KnownLayout, const N: usize>
 where

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

@@ -13,6 +13,7 @@
 include!("include.rs");
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 enum Foo {
     A,
 }
@@ -20,6 +21,7 @@ enum Foo {
 util_assert_impl_all!(Foo: imp::Immutable);
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 enum Bar {
     A = 0,
 }
@@ -27,6 +29,7 @@ enum Bar {
 util_assert_impl_all!(Bar: imp::Immutable);
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 enum Baz {
     A = 1,
     B = 0,
@@ -37,6 +40,7 @@ util_assert_impl_all!(Baz: imp::Immutable);
 // Deriving `Immutable` should work if the enum has bounded parameters.
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::Immutable, const N: ::core::primitive::usize>
 where

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

@@ -15,6 +15,7 @@ include!("include.rs");
 // An enum is `IntoBytes` if if has a defined repr.
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum C {
     A,
@@ -23,6 +24,7 @@ enum C {
 util_assert_impl_all!(C: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum U8 {
     A,
@@ -31,6 +33,7 @@ enum U8 {
 util_assert_impl_all!(U8: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u16)]
 enum U16 {
     A,
@@ -39,6 +42,7 @@ enum U16 {
 util_assert_impl_all!(U16: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u32)]
 enum U32 {
     A,
@@ -47,6 +51,7 @@ enum U32 {
 util_assert_impl_all!(U32: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u64)]
 enum U64 {
     A,
@@ -55,6 +60,7 @@ enum U64 {
 util_assert_impl_all!(U64: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(usize)]
 enum Usize {
     A,
@@ -63,6 +69,7 @@ enum Usize {
 util_assert_impl_all!(Usize: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i8)]
 enum I8 {
     A,
@@ -71,6 +78,7 @@ enum I8 {
 util_assert_impl_all!(I8: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i16)]
 enum I16 {
     A,
@@ -79,6 +87,7 @@ enum I16 {
 util_assert_impl_all!(I16: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i32)]
 enum I32 {
     A,
@@ -87,6 +96,7 @@ enum I32 {
 util_assert_impl_all!(I32: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i64)]
 enum I64 {
     A,
@@ -95,6 +105,7 @@ enum I64 {
 util_assert_impl_all!(I64: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(isize)]
 enum Isize {
     A,
@@ -103,6 +114,7 @@ enum Isize {
 util_assert_impl_all!(Isize: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum HasData {
     A(u8),
@@ -112,6 +124,7 @@ enum HasData {
 util_assert_impl_all!(HasData: imp::IntoBytes);
 
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u32)]
 enum HasData32 {
     A(u32),
@@ -127,6 +140,7 @@ util_assert_impl_all!(HasData: imp::IntoBytes);
 // Tag { A }`, which is two bytes long, rather than the correct `#[repr(u8)]
 // struct Tag { A }`, which is one byte long.
 #[derive(imp::IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8, align(2))]
 enum BadTagWouldHavePadding {
     A(u8, u16),

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

@@ -13,6 +13,7 @@
 include!("include.rs");
 
 #[derive(Eq, PartialEq, Debug, imp::Immutable, imp::KnownLayout, imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum Foo {
     A,
@@ -29,6 +30,7 @@ fn test_foo() {
 }
 
 #[derive(Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u16)]
 enum Bar {
     A = 0,
@@ -46,6 +48,7 @@ fn test_bar() {
 }
 
 #[derive(Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u32)]
 enum Baz {
     A = 1,
@@ -78,6 +81,7 @@ type i8 = bool;
 const THREE: ::core::primitive::i8 = 3;
 
 #[derive(Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i8)]
 enum Blah {
     A = 1,
@@ -114,6 +118,7 @@ fn test_blah() {
 #[derive(
     Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes, imp::IntoBytes,
 )]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum FieldlessButNotUnitOnly {
     A,
@@ -124,17 +129,17 @@ enum FieldlessButNotUnitOnly {
 #[test]
 fn test_fieldless_but_not_unit_only() {
     const SIZE: usize = ::core::mem::size_of::<FieldlessButNotUnitOnly>();
-    let disc: [u8; SIZE] = ::zerocopy::transmute!(FieldlessButNotUnitOnly::A);
+    let disc: [u8; SIZE] = ::zerocopy_renamed::transmute!(FieldlessButNotUnitOnly::A);
     imp::assert_eq!(
         <FieldlessButNotUnitOnly as imp::TryFromBytes>::try_read_from_bytes(&disc[..]),
         imp::Ok(FieldlessButNotUnitOnly::A)
     );
-    let disc: [u8; SIZE] = ::zerocopy::transmute!(FieldlessButNotUnitOnly::B());
+    let disc: [u8; SIZE] = ::zerocopy_renamed::transmute!(FieldlessButNotUnitOnly::B());
     imp::assert_eq!(
         <FieldlessButNotUnitOnly as imp::TryFromBytes>::try_read_from_bytes(&disc[..]),
         imp::Ok(FieldlessButNotUnitOnly::B())
     );
-    let disc: [u8; SIZE] = ::zerocopy::transmute!(FieldlessButNotUnitOnly::C {});
+    let disc: [u8; SIZE] = ::zerocopy_renamed::transmute!(FieldlessButNotUnitOnly::C {});
     imp::assert_eq!(
         <FieldlessButNotUnitOnly as imp::TryFromBytes>::try_read_from_bytes(&disc[..]),
         imp::Ok(FieldlessButNotUnitOnly::C {})
@@ -148,6 +153,7 @@ fn test_fieldless_but_not_unit_only() {
 #[derive(
     Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes, imp::IntoBytes,
 )]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum WeirdDiscriminants {
     A = -7,
@@ -158,17 +164,17 @@ enum WeirdDiscriminants {
 #[test]
 fn test_weird_discriminants() {
     const SIZE: usize = ::core::mem::size_of::<WeirdDiscriminants>();
-    let disc: [u8; SIZE] = ::zerocopy::transmute!(WeirdDiscriminants::A);
+    let disc: [u8; SIZE] = ::zerocopy_renamed::transmute!(WeirdDiscriminants::A);
     imp::assert_eq!(
         <WeirdDiscriminants as imp::TryFromBytes>::try_read_from_bytes(&disc[..]),
         imp::Ok(WeirdDiscriminants::A)
     );
-    let disc: [u8; SIZE] = ::zerocopy::transmute!(WeirdDiscriminants::B);
+    let disc: [u8; SIZE] = ::zerocopy_renamed::transmute!(WeirdDiscriminants::B);
     imp::assert_eq!(
         <WeirdDiscriminants as imp::TryFromBytes>::try_read_from_bytes(&disc[..]),
         imp::Ok(WeirdDiscriminants::B)
     );
-    let disc: [u8; SIZE] = ::zerocopy::transmute!(WeirdDiscriminants::C);
+    let disc: [u8; SIZE] = ::zerocopy_renamed::transmute!(WeirdDiscriminants::C);
     imp::assert_eq!(
         <WeirdDiscriminants as imp::TryFromBytes>::try_read_from_bytes(&disc[..]),
         imp::Ok(WeirdDiscriminants::C)
@@ -183,6 +189,7 @@ fn test_weird_discriminants() {
 #[derive(
     Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes, imp::IntoBytes,
 )]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum HasFields {
     A(u32),
@@ -193,14 +200,15 @@ enum HasFields {
 fn test_has_fields() {
     const SIZE: usize = ::core::mem::size_of::<HasFields>();
 
-    let bytes: [u8; SIZE] = ::zerocopy::transmute!(HasFields::A(10));
+    let bytes: [u8; SIZE] = ::zerocopy_renamed::transmute!(HasFields::A(10));
     imp::assert_eq!(
         <HasFields as imp::TryFromBytes>::try_read_from_bytes(&bytes[..]),
         imp::Ok(HasFields::A(10)),
     );
 
-    let bytes: [u8; SIZE] =
-        ::zerocopy::transmute!(HasFields::B { foo: ::core::num::NonZeroU32::new(123456).unwrap() });
+    let bytes: [u8; SIZE] = ::zerocopy_renamed::transmute!(HasFields::B {
+        foo: ::core::num::NonZeroU32::new(123456).unwrap()
+    });
     imp::assert_eq!(
         <HasFields as imp::TryFromBytes>::try_read_from_bytes(&bytes[..]),
         imp::Ok(HasFields::B { foo: ::core::num::NonZeroU32::new(123456).unwrap() }),
@@ -208,6 +216,7 @@ fn test_has_fields() {
 }
 
 #[derive(Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, align(16))]
 enum HasFieldsAligned {
     A(u32),
@@ -221,6 +230,7 @@ fn test_has_fields_aligned() {
     const SIZE: usize = ::core::mem::size_of::<HasFieldsAligned>();
 
     #[derive(imp::IntoBytes)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     struct BytesOfHasFieldsAligned {
         has_fields: HasFields,
@@ -229,13 +239,13 @@ fn test_has_fields_aligned() {
 
     let wrap = |has_fields| BytesOfHasFieldsAligned { has_fields, padding: [0; 8] };
 
-    let bytes: [u8; SIZE] = ::zerocopy::transmute!(wrap(HasFields::A(10)));
+    let bytes: [u8; SIZE] = ::zerocopy_renamed::transmute!(wrap(HasFields::A(10)));
     imp::assert_eq!(
         <HasFieldsAligned as imp::TryFromBytes>::try_read_from_bytes(&bytes[..]),
         imp::Ok(HasFieldsAligned::A(10)),
     );
 
-    let bytes: [u8; SIZE] = ::zerocopy::transmute!(wrap(HasFields::B {
+    let bytes: [u8; SIZE] = ::zerocopy_renamed::transmute!(wrap(HasFields::B {
         foo: ::core::num::NonZeroU32::new(123456).unwrap()
     }));
     imp::assert_eq!(
@@ -247,6 +257,7 @@ fn test_has_fields_aligned() {
 #[derive(
     Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes, imp::IntoBytes,
 )]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u32)]
 enum HasFieldsPrimitive {
     A(u32),
@@ -257,13 +268,13 @@ enum HasFieldsPrimitive {
 fn test_has_fields_primitive() {
     const SIZE: usize = ::core::mem::size_of::<HasFieldsPrimitive>();
 
-    let bytes: [u8; SIZE] = ::zerocopy::transmute!(HasFieldsPrimitive::A(10));
+    let bytes: [u8; SIZE] = ::zerocopy_renamed::transmute!(HasFieldsPrimitive::A(10));
     imp::assert_eq!(
         <HasFieldsPrimitive as imp::TryFromBytes>::try_read_from_bytes(&bytes[..]),
         imp::Ok(HasFieldsPrimitive::A(10)),
     );
 
-    let bytes: [u8; SIZE] = ::zerocopy::transmute!(HasFieldsPrimitive::B {
+    let bytes: [u8; SIZE] = ::zerocopy_renamed::transmute!(HasFieldsPrimitive::B {
         foo: ::core::num::NonZeroU32::new(123456).unwrap(),
     });
     imp::assert_eq!(
@@ -273,6 +284,7 @@ fn test_has_fields_primitive() {
 }
 
 #[derive(Eq, PartialEq, Debug, imp::KnownLayout, imp::Immutable, imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u32, align(16))]
 enum HasFieldsPrimitiveAligned {
     A(u32),
@@ -286,6 +298,7 @@ fn test_has_fields_primitive_aligned() {
     const SIZE: usize = ::core::mem::size_of::<HasFieldsPrimitiveAligned>();
 
     #[derive(imp::IntoBytes)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     struct BytesOfHasFieldsPrimitiveAligned {
         has_fields: HasFieldsPrimitive,
@@ -294,13 +307,13 @@ fn test_has_fields_primitive_aligned() {
 
     let wrap = |has_fields| BytesOfHasFieldsPrimitiveAligned { has_fields, padding: [0; 8] };
 
-    let bytes: [u8; SIZE] = ::zerocopy::transmute!(wrap(HasFieldsPrimitive::A(10)));
+    let bytes: [u8; SIZE] = ::zerocopy_renamed::transmute!(wrap(HasFieldsPrimitive::A(10)));
     imp::assert_eq!(
         <HasFieldsPrimitiveAligned as imp::TryFromBytes>::try_read_from_bytes(&bytes[..]),
         imp::Ok(HasFieldsPrimitiveAligned::A(10)),
     );
 
-    let bytes: [u8; SIZE] = ::zerocopy::transmute!(wrap(HasFieldsPrimitive::B {
+    let bytes: [u8; SIZE] = ::zerocopy_renamed::transmute!(wrap(HasFieldsPrimitive::B {
         foo: ::core::num::NonZeroU32::new(123456).unwrap()
     }));
     imp::assert_eq!(
@@ -312,6 +325,7 @@ fn test_has_fields_primitive_aligned() {
 }
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(align(4), u32)]
 enum HasReprAlignFirst {
     A,
@@ -321,6 +335,7 @@ enum HasReprAlignFirst {
 util_assert_impl_all!(HasReprAlignFirst: imp::TryFromBytes);
 
 #[derive(imp::KnownLayout, imp::TryFromBytes, imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum Complex {
     UnitLike,
@@ -331,6 +346,7 @@ enum Complex {
 util_assert_impl_all!(Complex: imp::TryFromBytes);
 
 #[derive(imp::KnownLayout, imp::TryFromBytes, imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum ComplexWithGenerics<X, Y> {
     UnitLike,
@@ -341,6 +357,7 @@ enum ComplexWithGenerics<X, Y> {
 util_assert_impl_all!(ComplexWithGenerics<u16, char>: imp::TryFromBytes);
 
 #[derive(imp::KnownLayout, imp::TryFromBytes, imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum GenericWithLifetimes<'a, 'b, X: 'a, Y: 'b> {
     Foo(::core::marker::PhantomData<&'a X>),
@@ -348,9 +365,11 @@ enum GenericWithLifetimes<'a, 'b, X: 'a, Y: 'b> {
 }
 
 #[derive(Clone, Copy, imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct A;
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 enum B {
     A(A),
@@ -358,6 +377,7 @@ enum B {
 }
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum FooU8 {
     Variant0,
@@ -636,6 +656,7 @@ mod issue_2051 {
     // Prevents regressions of #2051.
     #[repr(u32)]
     #[derive(imp::TryFromBytes)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[allow(non_camel_case_types)]
     pub enum Code {
         I32_ADD,
@@ -645,6 +666,7 @@ mod issue_2051 {
 }
 
 #[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum RawIdentifierVariant {
     r#type,

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

@@ -17,6 +17,7 @@ include!("include.rs");
 // - `repr(u8)` or `repr(i8)`
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8)]
 enum Foo {
     A,
@@ -25,6 +26,7 @@ enum Foo {
 util_assert_impl_all!(Foo: imp::Unaligned);
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i8)]
 enum Bar {
     A,
@@ -33,6 +35,7 @@ enum Bar {
 util_assert_impl_all!(Bar: imp::Unaligned);
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(u8, align(1))]
 enum Baz {
     A,
@@ -41,6 +44,7 @@ enum Baz {
 util_assert_impl_all!(Baz: imp::Unaligned);
 
 #[derive(imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(i8, align(1))]
 enum Blah {
     B,

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

@@ -13,6 +13,7 @@
 include!("include.rs");
 
 #[derive(imp::Debug, imp::IntoBytes, imp::Immutable, imp::ByteEq)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct Struct {
     a: u64,

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

@@ -13,6 +13,7 @@
 include!("include.rs");
 
 #[derive(imp::IntoBytes, imp::Immutable, imp::ByteHash)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct Struct {
     a: u64,

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

@@ -16,9 +16,10 @@
 
 include!("include.rs");
 
-extern crate zerocopy as _zerocopy;
+extern crate zerocopy_renamed as _zerocopy;
 
 #[derive(_zerocopy::KnownLayout, _zerocopy::FromBytes, _zerocopy::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct TypeParams<'a, T, I: imp::Iterator> {
     a: T,
@@ -49,6 +50,7 @@ mod issue_2177 {
     macro_rules! define {
         ($name:ident, $repr:ty) => {
             #[derive(_zerocopy::KnownLayout)]
+            #[zerocopy(crate = "zerocopy_renamed")]
             #[repr(C)]
             pub struct $name($repr);
         };

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

@@ -37,7 +37,7 @@ mod imp {
             primitive::*,
         },
         ::std::{collections::hash_map::DefaultHasher, prelude::v1::*},
-        ::zerocopy::*,
+        ::zerocopy_renamed::*,
     };
 }
 
@@ -59,6 +59,7 @@ pub mod util {
         Copy,
         Clone,
     )]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C, align(2))]
     pub struct AU16(pub u16);
 
@@ -107,6 +108,8 @@ pub mod util {
     // As of this writing, this happens when deriving `TryFromBytes` thanks to a
     // top-level `#[derive(FromBytes)]`.
     pub fn test_trivial_is_bit_valid<T: super::imp::TryFromBytes>() {
+        use super::imp::{MaybeUninit, Ptr, ReadOnly};
+
         // This test works based on the insight that a trivial `is_bit_valid`
         // impl should never load any bytes from memory. Thus, while it is
         // technically a violation of `is_bit_valid`'s safety precondition to
@@ -116,12 +119,31 @@ pub mod util {
         // spuriously generating non-trivial `is_bit_valid` impls, this should
         // cause UB which may be caught by Miri.
 
-        let mut buf = super::imp::MaybeUninit::<T>::uninit();
-        let ptr = super::imp::Ptr::from_mut(&mut buf);
+        let mut buf = MaybeUninit::<T>::uninit();
+        let ptr = Ptr::from_mut(&mut buf);
         // SAFETY: This is intentionally unsound; see the preceding comment.
         let ptr = unsafe { ptr.assume_initialized() };
+        let mut ptr = ptr.transmute::<ReadOnly<MaybeUninit<T>>, _, _>();
+        let ptr = ptr.reborrow_shared();
 
-        let ptr = ptr.cast::<_, ::zerocopy::pointer::cast::CastSized, _>();
+        let ptr = ptr.cast::<_, ::zerocopy_renamed::pointer::cast::CastSized, _>();
         assert!(<T as super::imp::TryFromBytes>::is_bit_valid(ptr));
     }
+
+    pub fn test_is_bit_valid<T: super::imp::TryFromBytes, V: super::imp::IntoBytes>(
+        val: V,
+        is_bit_valid: bool,
+    ) {
+        use super::imp::{
+            pointer::{cast::CastSized, BecauseImmutable},
+            ReadOnly,
+        };
+
+        let ro = ReadOnly::new(val);
+        let candidate = ::zerocopy_renamed::Ptr::from_ref(&ro);
+        let candidate = candidate.recall_validity();
+        let candidate = candidate.cast::<ReadOnly<T>, CastSized, (_, BecauseImmutable)>();
+
+        super::imp::assert_eq!(T::is_bit_valid(candidate), is_bit_valid);
+    }
 }

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

@@ -16,5 +16,6 @@ include!("include.rs");
 // Make sure no unexpected `cfg`s are emitted by our derives (see #2117).
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 pub struct Test(pub [u8; 32]);