html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/zerocopy-derive/tests/ui-nightly/privacy.rs

@@ -9,7 +9,7 @@
 #![allow(unused_braces)]
 
 #[macro_use]
-extern crate zerocopy;
+extern crate zerocopy_renamed;
 
 fn main() {}
 
@@ -19,36 +19,56 @@ fn main() {}
 
 mod private {
     #[derive(TryFromBytes)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     pub struct StructWithNamedFields {
         pub a: u8,
         pub(self) b: u16,
     }
 
     const _: () = {
-        let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-        let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type = 0u16;
+        let _: <StructWithNamedFields as zerocopy_renamed::HasField<
+            _,
+            _,
+            { zerocopy_renamed::ident_id!(a) },
+        >>::Type = 0u8;
+        let _: <StructWithNamedFields as zerocopy_renamed::HasField<
+            _,
+            _,
+            { zerocopy_renamed::ident_id!(b) },
+        >>::Type = 0u16;
     };
 
     #[derive(TryFromBytes)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     pub struct StructWithAnonFields(pub u8, pub(self) u16);
 
     const _: () = {
-        let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(0) }>>::Type = 0u8;
-        let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type = 0u16;
+        let _: <StructWithAnonFields as zerocopy_renamed::HasField<
+            _,
+            _,
+            { zerocopy_renamed::ident_id!(0) },
+        >>::Type = 0u8;
+        let _: <StructWithAnonFields as zerocopy_renamed::HasField<
+            _,
+            _,
+            { zerocopy_renamed::ident_id!(1) },
+        >>::Type = 0u16;
     };
 
     #[derive(TryFromBytes)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     pub struct Union {
         pub a: u8,
         pub(self) b: u16,
     }
 
     const _: () = {
-        let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-        let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type = 0u16;
+        let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(a) }>>::Type = 0u8;
+        let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b) }>>::Type = 0u16;
     };
 
     #[derive(TryFromBytes)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     pub enum Enum {
         A(u8, u16),
@@ -56,14 +76,14 @@ mod private {
     }
 
     const _: () = {
-        let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(0) }>>::Type = 0u8;
-        let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type = 0u16;
+        let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(0) }>>::Type = 0u8;
+        let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(1) }>>::Type = 0u16;
 
-        let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-        let _: <Enum as zerocopy::HasField<
+        let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(a) }>>::Type = 0u8;
+        let _: <Enum as zerocopy_renamed::HasField<
             _,
-            { zerocopy::ident_id!(B) },
-            { zerocopy::ident_id!(b) },
+            { zerocopy_renamed::ident_id!(B) },
+            { zerocopy_renamed::ident_id!(b) },
         >>::Type = 0u16;
     };
 }
@@ -71,32 +91,49 @@ mod private {
 use private::*;
 
 const _: () = {
-    let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type =
-        0u8;
-    let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type =
-        0u16;
+    let _: <StructWithNamedFields as zerocopy_renamed::HasField<
+        _,
+        _,
+        { zerocopy_renamed::ident_id!(a) },
+    >>::Type = 0u8;
+    let _: <StructWithNamedFields as zerocopy_renamed::HasField<
+        _,
+        _,
+        { zerocopy_renamed::ident_id!(b) },
+    >>::Type = 0u16;
 };
 
 const _: () = {
-    let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(0) }>>::Type =
-        0u8;
-    let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type =
-        0u16;
+    let _: <StructWithAnonFields as zerocopy_renamed::HasField<
+        _,
+        _,
+        { zerocopy_renamed::ident_id!(0) },
+    >>::Type = 0u8;
+    let _: <StructWithAnonFields as zerocopy_renamed::HasField<
+        _,
+        _,
+        { zerocopy_renamed::ident_id!(1) },
+    >>::Type = 0u16;
 };
 
 const _: () = {
-    let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-    let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type = 0u16;
+    let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(a) }>>::Type =
+        0u8;
+    let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b) }>>::Type =
+        0u16;
 };
 
 const _: () = {
-    let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(0) }>>::Type = 0u8;
-    let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type = 0u16;
+    let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(0) }>>::Type =
+        0u8;
+    let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(1) }>>::Type =
+        0u16;
 
-    let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-    let _: <Enum as zerocopy::HasField<
+    let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(a) }>>::Type =
+        0u8;
+    let _: <Enum as zerocopy_renamed::HasField<
         _,
-        { zerocopy::ident_id!(B) },
-        { zerocopy::ident_id!(b) },
+        { zerocopy_renamed::ident_id!(B) },
+        { zerocopy_renamed::ident_id!(b) },
     >>::Type = 0u16;
 };

data/rust-vendor/zerocopy-derive/tests/ui-nightly/privacy.stderr

@@ -1,17 +1,17 @@
-error: type `private::_::_::ẕb` is private
-  --> tests/ui-nightly/privacy.rs:76:57
-   |
-76 |     let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type =
-   |                                                         ^ private type
+error: type `private::_::_::_::ẕb` is private
+   --> tests/ui-nightly/privacy.rs:100:9
+    |
+100 |         _,
+    |         ^ private type
 
-error: type `private::_::_::ẕ1` is private
-  --> tests/ui-nightly/privacy.rs:83:56
-   |
-83 |     let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type =
-   |                                                        ^ private type
+error: type `private::_::_::_::ẕ1` is private
+   --> tests/ui-nightly/privacy.rs:113:9
+    |
+113 |         _,
+    |         ^ private type
 
-error: type `private::_::_::ẕb` is private
-  --> tests/ui-nightly/privacy.rs:89:41
-   |
-89 |     let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type = 0u16;
-   |                                         ^ private type
+error: type `private::_::_::_::ẕb` is private
+   --> tests/ui-nightly/privacy.rs:122:49
+    |
+122 |     let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b) }>>::Type =
+    |                                                 ^ private type

data/rust-vendor/zerocopy-derive/tests/ui-nightly/struct.rs

@@ -7,12 +7,12 @@
 // those terms.
 
 #[macro_use]
-extern crate zerocopy;
+extern crate zerocopy_renamed;
 
 #[path = "../include.rs"]
 mod util;
 
-use zerocopy::{IntoBytes, KnownLayout};
+use zerocopy_renamed::{IntoBytes, KnownLayout};
 
 use self::util::util::AU16;
 
@@ -29,22 +29,26 @@ struct NotKnownLayoutDst([u8]);
 // | `repr(C)`? | generic? | `KnownLayout`? | `Sized`? | Type Name |
 // |          N |        N |              N |        N |      KL00 |
 #[derive(KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct KL00(u8, NotKnownLayoutDst);
 
 // | `repr(C)`? | generic? | `KnownLayout`? | `Sized`? | Type Name |
 // |          N |        N |              Y |        N |      KL02 |
 #[derive(KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct KL02(u8, [u8]);
 
 // | `repr(C)`? | generic? | `KnownLayout`? | `Sized`? | Type Name |
 // |          Y |        N |              N |        N |      KL08 |
 #[derive(KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct KL08(u8, NotKnownLayoutDst);
 
 // | `repr(C)`? | generic? | `KnownLayout`? | `Sized`? | Type Name |
 // |          Y |        N |              N |        Y |      KL09 |
 #[derive(KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct KL09(NotKnownLayout, NotKnownLayout);
 
@@ -53,11 +57,13 @@ struct KL09(NotKnownLayout, NotKnownLayout);
 //
 
 #[derive(Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Immutable1 {
     a: core::cell::UnsafeCell<()>,
 }
 
 #[derive(Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Immutable2 {
     a: [core::cell::UnsafeCell<u8>; 0],
 }
@@ -67,24 +73,28 @@ struct Immutable2 {
 //
 
 #[derive(TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(packed)]
 struct TryFromBytesPacked {
     foo: AU16,
 }
 
 #[derive(TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(packed(1))]
 struct TryFromBytesPackedN {
     foo: AU16,
 }
 
 #[derive(TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 struct TryFromBytesCPacked {
     foo: AU16,
 }
 
 #[derive(TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed(1))]
 struct TryFromBytesCPackedN {
     foo: AU16,
@@ -98,6 +108,7 @@ struct TryFromBytesCPackedN {
 // emitted in which each field type is given an `Unaligned` bound. Since `foo`'s
 // type doesn't implement `Unaligned`, this should fail.
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct IntoBytes1<T> {
     foo: AU16,
@@ -105,6 +116,7 @@ struct IntoBytes1<T> {
 }
 
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct IntoBytes2 {
     foo: u8,
@@ -112,6 +124,7 @@ struct IntoBytes2 {
 }
 
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed(2))]
 struct IntoBytes3 {
     foo: u8,
@@ -128,6 +141,7 @@ type SliceU8 = [u8];
 // NOTE(#1708): This exists to ensure that our error messages are good when a
 // field is unsized.
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct IntoBytes4 {
     a: u8,
@@ -137,6 +151,7 @@ struct IntoBytes4 {
 // Padding between `u8` and `[u16]`. `[u16]` is syntactically identifiable as a
 // slice, so this case is handled by our `repr(C)` slice DST support.
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct IntoBytes5 {
     a: u8,
@@ -146,6 +161,7 @@ struct IntoBytes5 {
 // Trailing padding after `[u8]`. `[u8]` is syntactically identifiable as a
 // slice, so this case is handled by our `repr(C)` slice DST support.
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct IntoBytes6 {
     a: u16,
@@ -156,6 +172,7 @@ struct IntoBytes6 {
 // is syntactically identifiable as a slice, so this case is handled by our
 // `repr(C)` slice DST support.
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct IntoBytes7 {
     a: u8,
@@ -164,17 +181,20 @@ struct IntoBytes7 {
 }
 
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, C)] // zerocopy-derive conservatively treats these as conflicting reprs
 struct IntoBytes8 {
     a: u8,
 }
 
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct IntoBytes9<T> {
     t: T,
 }
 
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(packed(2))]
 struct IntoBytes10<T> {
     t: T,
@@ -182,6 +202,7 @@ struct IntoBytes10<T> {
 
 // `repr(C, packed(2))` is not equivalent to `repr(C, packed)`.
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed(2))]
 struct IntoBytes11<T> {
     t0: T,
@@ -198,6 +219,7 @@ fn is_into_bytes_11<T: IntoBytes>() {
 
 // `repr(C, align(2))` is not sufficient to guarantee the layout of this type.
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, align(2))]
 struct IntoBytes12<T> {
     t: T,
@@ -208,31 +230,38 @@ struct IntoBytes12<T> {
 //
 
 #[derive(Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, align(2))]
 struct Unaligned1;
 
 #[derive(Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent, align(2))]
 struct Unaligned2 {
     foo: u8,
 }
 
 #[derive(Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(packed, align(2))]
 struct Unaligned3;
 
 #[derive(Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(align(1), align(2))]
 struct Unaligned4;
 
 #[derive(Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(align(2), align(4))]
 struct Unaligned5;
 
 #[derive(Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Unaligned6;
 
 #[derive(Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(packed(2))]
 struct Unaligned7;
 
@@ -242,13 +271,16 @@ struct Unaligned7;
 #[derive(Copy, Clone)]
 #[repr(packed(2), C)]
 #[derive(Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed(2))]
 struct WeirdReprSpan;
 
 #[derive(SplitAt)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct SplitAtNotKnownLayout([u8]);
 
 #[derive(SplitAt, KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct SplitAtSized(u8);