html-to-markdown 2.23.4 → 2.24.1

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

@@ -6,10 +6,11 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-use zerocopy::{IntoBytes, Unalign};
+use zerocopy_renamed::{IntoBytes, Unalign};
 
 #[allow(unused)]
 #[derive(IntoBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct Struct {
     leading: Unalign<u32>,

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

@@ -0,0 +1,292 @@
+// Copyright 2026 The Fuchsia Authors
+//
+// Licensed under a BSD-style license <LICENSE-BSD>, Apache License, Version 2.0
+// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0>, or the MIT
+// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your option.
+// This file may not be copied, modified, or distributed except according to
+// those terms.
+
+#![no_implicit_prelude]
+#![deny(non_ascii_idents)]
+#![allow(dead_code)]
+
+include!("include.rs");
+
+// FIXME(#2880): Derive `FromBytes` in all types once we support non-ASCII
+// idents.
+
+#[derive(imp::KnownLayout, imp::IntoBytes, imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
+#[repr(C)]
+struct TestStruct {
+    a: u8,
+}
+
+#[derive(imp::KnownLayout, imp::IntoBytes, imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
+#[repr(C)]
+union TestUnion {
+    a: u8,
+}
+
+#[derive(imp::KnownLayout, imp::FromBytes, imp::IntoBytes, imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
+#[repr(u8)]
+enum FooU8 {
+    Variant0,
+    Variant1,
+    Variant2,
+    Variant3,
+    Variant4,
+    Variant5,
+    Variant6,
+    Variant7,
+    Variant8,
+    Variant9,
+    Variant10,
+    Variant11,
+    Variant12,
+    Variant13,
+    Variant14,
+    Variant15,
+    Variant16,
+    Variant17,
+    Variant18,
+    Variant19,
+    Variant20,
+    Variant21,
+    Variant22,
+    Variant23,
+    Variant24,
+    Variant25,
+    Variant26,
+    Variant27,
+    Variant28,
+    Variant29,
+    Variant30,
+    Variant31,
+    Variant32,
+    Variant33,
+    Variant34,
+    Variant35,
+    Variant36,
+    Variant37,
+    Variant38,
+    Variant39,
+    Variant40,
+    Variant41,
+    Variant42,
+    Variant43,
+    Variant44,
+    Variant45,
+    Variant46,
+    Variant47,
+    Variant48,
+    Variant49,
+    Variant50,
+    Variant51,
+    Variant52,
+    Variant53,
+    Variant54,
+    Variant55,
+    Variant56,
+    Variant57,
+    Variant58,
+    Variant59,
+    Variant60,
+    Variant61,
+    Variant62,
+    Variant63,
+    Variant64,
+    Variant65,
+    Variant66,
+    Variant67,
+    Variant68,
+    Variant69,
+    Variant70,
+    Variant71,
+    Variant72,
+    Variant73,
+    Variant74,
+    Variant75,
+    Variant76,
+    Variant77,
+    Variant78,
+    Variant79,
+    Variant80,
+    Variant81,
+    Variant82,
+    Variant83,
+    Variant84,
+    Variant85,
+    Variant86,
+    Variant87,
+    Variant88,
+    Variant89,
+    Variant90,
+    Variant91,
+    Variant92,
+    Variant93,
+    Variant94,
+    Variant95,
+    Variant96,
+    Variant97,
+    Variant98,
+    Variant99,
+    Variant100,
+    Variant101,
+    Variant102,
+    Variant103,
+    Variant104,
+    Variant105,
+    Variant106,
+    Variant107,
+    Variant108,
+    Variant109,
+    Variant110,
+    Variant111,
+    Variant112,
+    Variant113,
+    Variant114,
+    Variant115,
+    Variant116,
+    Variant117,
+    Variant118,
+    Variant119,
+    Variant120,
+    Variant121,
+    Variant122,
+    Variant123,
+    Variant124,
+    Variant125,
+    Variant126,
+    Variant127,
+    Variant128,
+    Variant129,
+    Variant130,
+    Variant131,
+    Variant132,
+    Variant133,
+    Variant134,
+    Variant135,
+    Variant136,
+    Variant137,
+    Variant138,
+    Variant139,
+    Variant140,
+    Variant141,
+    Variant142,
+    Variant143,
+    Variant144,
+    Variant145,
+    Variant146,
+    Variant147,
+    Variant148,
+    Variant149,
+    Variant150,
+    Variant151,
+    Variant152,
+    Variant153,
+    Variant154,
+    Variant155,
+    Variant156,
+    Variant157,
+    Variant158,
+    Variant159,
+    Variant160,
+    Variant161,
+    Variant162,
+    Variant163,
+    Variant164,
+    Variant165,
+    Variant166,
+    Variant167,
+    Variant168,
+    Variant169,
+    Variant170,
+    Variant171,
+    Variant172,
+    Variant173,
+    Variant174,
+    Variant175,
+    Variant176,
+    Variant177,
+    Variant178,
+    Variant179,
+    Variant180,
+    Variant181,
+    Variant182,
+    Variant183,
+    Variant184,
+    Variant185,
+    Variant186,
+    Variant187,
+    Variant188,
+    Variant189,
+    Variant190,
+    Variant191,
+    Variant192,
+    Variant193,
+    Variant194,
+    Variant195,
+    Variant196,
+    Variant197,
+    Variant198,
+    Variant199,
+    Variant200,
+    Variant201,
+    Variant202,
+    Variant203,
+    Variant204,
+    Variant205,
+    Variant206,
+    Variant207,
+    Variant208,
+    Variant209,
+    Variant210,
+    Variant211,
+    Variant212,
+    Variant213,
+    Variant214,
+    Variant215,
+    Variant216,
+    Variant217,
+    Variant218,
+    Variant219,
+    Variant220,
+    Variant221,
+    Variant222,
+    Variant223,
+    Variant224,
+    Variant225,
+    Variant226,
+    Variant227,
+    Variant228,
+    Variant229,
+    Variant230,
+    Variant231,
+    Variant232,
+    Variant233,
+    Variant234,
+    Variant235,
+    Variant236,
+    Variant237,
+    Variant238,
+    Variant239,
+    Variant240,
+    Variant241,
+    Variant242,
+    Variant243,
+    Variant244,
+    Variant245,
+    Variant246,
+    Variant247,
+    Variant248,
+    Variant249,
+    Variant250,
+    Variant251,
+    Variant252,
+    Variant253,
+    Variant254,
+    Variant255,
+}

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

@@ -0,0 +1,78 @@
+// Copyright 2026 The Fuchsia Authors
+//
+// Licensed under a BSD-style license <LICENSE-BSD>, Apache License, Version 2.0
+// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0>, or the MIT
+// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your option.
+// This file may not be copied, modified, or distributed except according to
+// those terms.
+
+#![no_implicit_prelude]
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+include!("include.rs");
+
+// Original reproducer from #2915
+#[derive(imp::TryFromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
+#[repr(u8)]
+enum MyEnum {
+    Type,
+    OtherWithData(u8),
+}
+
+// Tests for all other associated types which may be problematic in our codebase
+// as of this commit.
+
+#[derive(imp::FromBytes, imp::IntoBytes, imp::Unaligned, imp::Immutable, imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
+#[repr(C)]
+pub struct StructCollision {
+    pub Type: u8,
+    pub LAYOUT: u8,
+    pub PointerMetadata: u8,
+    pub Tag: u8,
+    pub tag: u8,
+    pub variants: u8,
+}
+
+impl StructCollision {
+    pub const Type: () = ();
+    pub const LAYOUT: () = ();
+    pub const PointerMetadata: () = ();
+}
+
+#[derive(imp::FromZeros, imp::Immutable, imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
+#[repr(C)]
+pub enum EnumCollision {
+    Type { x: u8 },
+    LAYOUT { x: u8 },
+    PointerMetadata { x: u8 },
+    Tag { x: u8 },
+    tag { x: u8 },
+    variants { x: u8 },
+}
+
+// Case where generic parameter has associated type colliding with internal usage
+pub trait AmbiguousTrait {
+    type Type;
+    const LAYOUT: usize;
+    type PointerMetadata;
+}
+
+#[derive(imp::FromBytes, imp::IntoBytes, imp::Unaligned, imp::Immutable, imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
+#[repr(C)]
+pub struct GenericCollision<T: AmbiguousTrait> {
+    pub field: u8,
+    pub typ: T::Type,
+    pub pointer_metadata: T::PointerMetadata,
+    pub _marker: imp::PhantomData<T>,
+}
+
+#[test]
+fn test_compilation() {
+    // If the derives compile, we are good.
+    let _ = StructCollision { Type: 0, LAYOUT: 0, PointerMetadata: 0, Tag: 0, tag: 0, variants: 0 };
+    let _ = EnumCollision::Type { x: 0 };
+}

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

@@ -18,12 +18,14 @@ mod foo {
     use super::*;
 
     #[derive(imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     pub struct Foo {
         foo: u8,
     }
 
     #[derive(imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     pub struct Bar {
         bar: u8,
@@ -33,6 +35,7 @@ mod foo {
 use foo::Foo;
 
 #[derive(imp::FromBytes, imp::IntoBytes, imp::Unaligned)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct Baz {
     foo: Foo,

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

@@ -25,10 +25,12 @@ mod test {
     // types).
 
     #[derive(imp::KnownLayout, imp::IntoBytes, imp::FromZeros, imp::FromBytes, imp::Unaligned)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     pub struct Public(Private);
 
     #[derive(imp::KnownLayout, imp::IntoBytes, imp::FromZeros, imp::FromBytes, imp::Unaligned)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     struct Private(());
 }

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

@@ -16,12 +16,14 @@ include!("include.rs");
 // - all fields are `FromBytes`
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Zst;
 
 util_assert_impl_all!(Zst: imp::FromBytes);
 test_trivial_is_bit_valid!(Zst => test_zst_trivial_is_bit_valid);
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct One {
     a: u8,
 }
@@ -30,6 +32,7 @@ util_assert_impl_all!(One: imp::FromBytes);
 test_trivial_is_bit_valid!(One => test_one_trivial_is_bit_valid);
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Two {
     a: u8,
     b: Zst,
@@ -39,6 +42,7 @@ util_assert_impl_all!(Two: imp::FromBytes);
 test_trivial_is_bit_valid!(Two => test_two_trivial_is_bit_valid);
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Unsized {
     a: [u8],
 }
@@ -46,6 +50,7 @@ struct Unsized {
 util_assert_impl_all!(Unsized: imp::FromBytes);
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct TypeParams<'a, T: ?imp::Sized, I: imp::Iterator> {
     a: I::Item,
     b: u8,
@@ -63,6 +68,7 @@ test_trivial_is_bit_valid!(TypeParams<'static, (), imp::IntoIter<()>> => test_ty
 // Deriving `FromBytes` should work if the struct has bounded parameters.
 
 #[derive(imp::FromBytes)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::FromBytes, const N: usize>(
     [T; N],

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

@@ -16,11 +16,13 @@ include!("include.rs");
 // - all fields are `FromZeros`
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Zst;
 
 util_assert_impl_all!(Zst: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct One {
     a: bool,
 }
@@ -28,6 +30,7 @@ struct One {
 util_assert_impl_all!(One: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Two {
     a: bool,
     b: Zst,
@@ -36,6 +39,7 @@ struct Two {
 util_assert_impl_all!(Two: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Unsized {
     a: [u8],
 }
@@ -43,6 +47,7 @@ struct Unsized {
 util_assert_impl_all!(Unsized: imp::FromZeros);
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct TypeParams<'a, T: ?imp::Sized, I: imp::Iterator> {
     a: I::Item,
     b: u8,
@@ -59,6 +64,7 @@ util_assert_impl_all!(TypeParams<'static, [util::AU16], imp::IntoIter<()>>: imp:
 // Deriving `FromZeros` should work if the struct has bounded parameters.
 
 #[derive(imp::FromZeros)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(transparent)]
 struct WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::FromZeros, const N: usize>(
     [T; N],

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

@@ -15,11 +15,13 @@ extern crate rustversion;
 include!("include.rs");
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Zst;
 
 util_assert_impl_all!(Zst: imp::KnownLayout);
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct One {
     a: bool,
 }
@@ -27,6 +29,7 @@ struct One {
 util_assert_impl_all!(One: imp::KnownLayout);
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Two {
     a: bool,
     b: Zst,
@@ -35,6 +38,7 @@ struct Two {
 util_assert_impl_all!(Two: imp::KnownLayout);
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct TypeParams<'a, T, I: imp::Iterator> {
     a: I::Item,
     b: u8,
@@ -55,6 +59,7 @@ util_assert_impl_all!(TypeParams<'static, util::AU16, imp::IntoIter<()>>: imp::K
 #[rustversion::since(1.62)]
 const _: () = {
     #[derive(imp::KnownLayout)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     struct WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::KnownLayout, const N: usize>(
         [T; N],
@@ -73,6 +78,7 @@ const _: () = {
     // only static lifetimes. This is exercisable on all supported toolchains.
 
     #[derive(imp::KnownLayout)]
+    #[zerocopy(crate = "zerocopy_renamed")]
     #[repr(C)]
     struct WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::KnownLayout, const N: usize>(
         &'a &'b [T; N],
@@ -90,6 +96,7 @@ const _: () = {
 // #2116.
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct WithSelfReference {
     leading: [u8; Self::N],
@@ -106,6 +113,7 @@ util_assert_impl_all!(WithSelfReference: imp::KnownLayout);
 // #2302.
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C, packed)]
 struct Packet<P> {
     payload: P,
@@ -114,6 +122,7 @@ struct Packet<P> {
 util_assert_impl_all!(Packet<imp::u8>: imp::KnownLayout);
 
 #[derive(imp::KnownLayout)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct RawIdentifier {
     r#type: u8,

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

@@ -13,11 +13,13 @@
 include!("include.rs");
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Zst;
 
 util_assert_impl_all!(Zst: imp::Immutable);
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct One {
     a: bool,
 }
@@ -25,6 +27,7 @@ struct One {
 util_assert_impl_all!(One: imp::Immutable);
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Two {
     a: bool,
     b: Zst,
@@ -33,6 +36,7 @@ struct Two {
 util_assert_impl_all!(Two: imp::Immutable);
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Three {
     a: [u8],
 }
@@ -40,6 +44,7 @@ struct Three {
 util_assert_impl_all!(Three: imp::Immutable);
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct Four<'a> {
     field: &'a imp::UnsafeCell<u8>,
 }
@@ -47,6 +52,7 @@ struct Four<'a> {
 util_assert_impl_all!(Four<'static>: imp::Immutable);
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct TypeParams<'a, T, U, I: imp::Iterator> {
     a: I::Item,
     b: u8,
@@ -73,6 +79,7 @@ impl<T> Trait for imp::UnsafeCell<T> {
 }
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 struct WithAssocType<T: Trait> {
     field: <T as Trait>::Assoc,
 }
@@ -82,6 +89,7 @@ util_assert_impl_all!(WithAssocType<imp::UnsafeCell<u8>>: imp::Immutable);
 // Deriving `Immutable` should work if the struct has bounded parameters.
 
 #[derive(imp::Immutable)]
+#[zerocopy(crate = "zerocopy_renamed")]
 #[repr(C)]
 struct WithParams<'a: 'b, 'b: 'a, T: 'a + 'b + imp::Immutable, const N: usize>(
     [T; N],