html-to-markdown 2.23.4 → 2.24.1

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

@@ -1,143 +1,143 @@
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:74:60
+  --> tests/ui-msrv/privacy.rs:96:9
    |
-74 |     let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type =
-   |                                                            ^
+96 |         _,
+   |         ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:76:60
-   |
-76 |     let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type =
-   |                                                            ^
-   |
-   = help: const arguments cannot yet be inferred with `_`
+   --> tests/ui-msrv/privacy.rs:101:9
+    |
+101 |         _,
+    |         ^
+    |
+    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:81:59
-   |
-81 |     let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(0) }>>::Type =
-   |                                                           ^
-   |
-   = help: const arguments cannot yet be inferred with `_`
+   --> tests/ui-msrv/privacy.rs:109:9
+    |
+109 |         _,
+    |         ^
+    |
+    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:83:59
-   |
-83 |     let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type =
-   |                                                           ^
-   |
-   = help: const arguments cannot yet be inferred with `_`
+   --> tests/ui-msrv/privacy.rs:114:9
+    |
+114 |         _,
+    |         ^
+    |
+    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:88:44
-   |
-88 |     let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-   |                                            ^
-   |
-   = help: const arguments cannot yet be inferred with `_`
+   --> tests/ui-msrv/privacy.rs:120:52
+    |
+120 |     let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(a) }>>::Type =
+    |                                                    ^
+    |
+    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:89:44
-   |
-89 |     let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type = 0u16;
-   |                                            ^
-   |
-   = help: const arguments cannot yet be inferred with `_`
+   --> tests/ui-msrv/privacy.rs:122:52
+    |
+122 |     let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b) }>>::Type =
+    |                                                    ^
+    |
+    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:93:43
-   |
-93 |     let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(0) }>>::Type = 0u8;
-   |                                           ^
-   |
-   = help: const arguments cannot yet be inferred with `_`
+   --> tests/ui-msrv/privacy.rs:127:51
+    |
+127 |     let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(0) }>>::Type =
+    |                                                   ^
+    |
+    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:94:43
-   |
-94 |     let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type = 0u16;
-   |                                           ^
-   |
-   = help: const arguments cannot yet be inferred with `_`
+   --> tests/ui-msrv/privacy.rs:129:51
+    |
+129 |     let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(1) }>>::Type =
+    |                                                   ^
+    |
+    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:96:43
-   |
-96 |     let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-   |                                           ^
-   |
-   = help: const arguments cannot yet be inferred with `_`
+   --> tests/ui-msrv/privacy.rs:132:51
+    |
+132 |     let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(a) }>>::Type =
+    |                                                   ^
+    |
+    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:28:64
+  --> tests/ui-msrv/privacy.rs:31:13
    |
-28 |         let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-   |                                                                ^
+31 |             _,
+   |             ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:29:64
+  --> tests/ui-msrv/privacy.rs:36:13
    |
-29 |         let _: <StructWithNamedFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type = 0u16;
-   |                                                                ^
+36 |             _,
+   |             ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:36:63
+  --> tests/ui-msrv/privacy.rs:48:13
    |
-36 |         let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(0) }>>::Type = 0u8;
-   |                                                               ^
+48 |             _,
+   |             ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:37:63
+  --> tests/ui-msrv/privacy.rs:53:13
    |
-37 |         let _: <StructWithAnonFields as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type = 0u16;
-   |                                                               ^
+53 |             _,
+   |             ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:47:48
+  --> tests/ui-msrv/privacy.rs:66:56
    |
-47 |         let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-   |                                                ^
+66 |         let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(a) }>>::Type = 0u8;
+   |                                                        ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:48:48
+  --> tests/ui-msrv/privacy.rs:67:56
    |
-48 |         let _: <Union as zerocopy::HasField<_, _, { zerocopy::ident_id!(b) }>>::Type = 0u16;
-   |                                                ^
+67 |         let _: <Union as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(b) }>>::Type = 0u16;
+   |                                                        ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:59:47
+  --> tests/ui-msrv/privacy.rs:79:55
    |
-59 |         let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(0) }>>::Type = 0u8;
-   |                                               ^
+79 |         let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(0) }>>::Type = 0u8;
+   |                                                       ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:60:47
+  --> tests/ui-msrv/privacy.rs:80:55
    |
-60 |         let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(1) }>>::Type = 0u16;
-   |                                               ^
+80 |         let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(1) }>>::Type = 0u16;
+   |                                                       ^
    |
    = help: const arguments cannot yet be inferred with `_`
 
 error[E0747]: type provided when a constant was expected
-  --> tests/ui-msrv/privacy.rs:62:47
+  --> tests/ui-msrv/privacy.rs:82:55
    |
-62 |         let _: <Enum as zerocopy::HasField<_, _, { zerocopy::ident_id!(a) }>>::Type = 0u8;
-   |                                               ^
+82 |         let _: <Enum as zerocopy_renamed::HasField<_, _, { zerocopy_renamed::ident_id!(a) }>>::Type = 0u8;
+   |                                                       ^
    |
    = help: const arguments cannot yet be inferred with `_`

data/rust-vendor/zerocopy-derive/tests/ui-msrv/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);