html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/zerocopy/src/wrappers.rs

@@ -9,6 +9,7 @@
 use core::{fmt, hash::Hash};
 
 use super::*;
+use crate::pointer::{invariant::Valid, SizeEq, TransmuteFrom};
 
 /// A type with no alignment requirement.
 ///
@@ -137,8 +138,8 @@ impl_known_layout!(T => Unalign<T>);
 //   Unaligned`.
 // - `Unalign<T>` has the same bit validity as `T`, and so it is `FromZeros`,
 //   `FromBytes`, or `IntoBytes` exactly when `T` is as well.
-// - `Immutable`: `Unalign<T>` has the same fields as `T`, so it contains
-//   `UnsafeCell`s exactly when `T` does.
+// - `Immutable`: `Unalign<T>` has the same fields as `T`, so it permits
+//   interior mutation exactly when `T` does.
 // - `TryFromBytes`: `Unalign<T>` has the same the same bit validity as `T`, so
 //   `T::is_bit_valid` is a sound implementation of `is_bit_valid`.
 //
@@ -148,7 +149,7 @@ const _: () = unsafe {
     impl_or_verify!(T: Immutable => Immutable for Unalign<T>);
     impl_or_verify!(
         T: TryFromBytes => TryFromBytes for Unalign<T>;
-        |c| T::is_bit_valid(c.transmute())
+        |c| T::is_bit_valid(c.transmute::<_, _, BecauseImmutable>())
     );
     impl_or_verify!(T: FromZeros => FromZeros for Unalign<T>);
     impl_or_verify!(T: FromBytes => FromBytes for Unalign<T>);
@@ -594,6 +595,251 @@ impl<T: ?Sized + KnownLayout> fmt::Debug for MaybeUninit<T> {
     }
 }
 
+#[allow(unreachable_pub)] // False positive on MSRV
+#[doc(hidden)]
+pub use read_only_def::*;
+mod read_only_def {
+    /// A read-only wrapper.
+    ///
+    /// A `ReadOnly<T>` disables any interior mutability in `T`, ensuring that
+    /// a `&ReadOnly<T>` is genuinely read-only. Thus, `ReadOnly<T>` is
+    /// [`Immutable`] regardless of whether `T` is.
+    ///
+    /// Note that `&mut ReadOnly<T>` still permits mutation – the read-only
+    /// property only applies to shared references.
+    ///
+    /// [`Immutable`]: crate::Immutable
+    #[repr(transparent)]
+    pub struct ReadOnly<T: ?Sized> {
+        // INVARIANT: `inner` is never mutated through a `&ReadOnly<T>`
+        // reference.
+        inner: T,
+    }
+
+    impl<T> ReadOnly<T> {
+        /// Creates a new `ReadOnly`.
+        #[must_use]
+        #[inline(always)]
+        pub const fn new(t: T) -> ReadOnly<T> {
+            ReadOnly { inner: t }
+        }
+
+        /// Returns the inner value.
+        #[must_use]
+        #[inline(always)]
+        pub fn into_inner(r: ReadOnly<T>) -> T {
+            r.inner
+        }
+    }
+
+    impl<T: ?Sized> ReadOnly<T> {
+        #[inline(always)]
+        pub(crate) fn as_mut(r: &mut ReadOnly<T>) -> &mut T {
+            // SAFETY: `r: &mut ReadOnly`, so this doesn't violate the invariant
+            // that `inner` is never mutated through a `&ReadOnly<T>` reference.
+            &mut r.inner
+        }
+
+        /// # Safety
+        ///
+        /// The caller promises not to mutate the referent (i.e., via interior
+        /// mutation).
+        pub(crate) const unsafe fn as_ref_unchecked(r: &ReadOnly<T>) -> &T {
+            // SAFETY: The caller promises not to mutate the referent.
+            &r.inner
+        }
+    }
+}
+
+// SAFETY: `ReadOnly<T>` is a `#[repr(transparent)` wrapper around `T`.
+const _: () = unsafe {
+    unsafe_impl_known_layout!(T: ?Sized + KnownLayout => #[repr(T)] ReadOnly<T>);
+};
+
+#[allow(clippy::multiple_unsafe_ops_per_block)]
+// SAFETY:
+// - `ReadOnly<T>` has the same alignment as `T`, and so it is `Unaligned`
+//   exactly when `T` is as well.
+// - `ReadOnly<T>` has the same bit validity as `T`, and so this `is_bit_valid`
+//   implementation is correct, and thus the `TryFromBytes` impl is sound.
+// - `ReadOnly<T>` has the same bit validity as `T`, and so it is `FromZeros`,
+//   `FromBytes`, and `IntoBytes` exactly when `T` is as well.
+const _: () = unsafe {
+    unsafe_impl!(T: ?Sized + Unaligned => Unaligned for ReadOnly<T>);
+    unsafe_impl!(
+        T: ?Sized + TryFromBytes => TryFromBytes for ReadOnly<T>;
+        |c| T::is_bit_valid(c.cast::<_, <ReadOnly<T> as SizeEq<ReadOnly<ReadOnly<T>>>>::CastFrom, _>())
+    );
+    unsafe_impl!(T: ?Sized + FromZeros => FromZeros for ReadOnly<T>);
+    unsafe_impl!(T: ?Sized + FromBytes => FromBytes for ReadOnly<T>);
+    unsafe_impl!(T: ?Sized + IntoBytes => IntoBytes for ReadOnly<T>);
+};
+
+// SAFETY: By invariant, `inner` is never mutated through a `&ReadOnly<T>`
+// reference.
+const _: () = unsafe {
+    unsafe_impl!(T: ?Sized => Immutable for ReadOnly<T>);
+};
+
+const _: () = {
+    use crate::pointer::cast::CastExact;
+
+    // SAFETY: `ReadOnly<T>` has the same layout as `T`.
+    define_cast!(unsafe { pub CastFromReadOnly<T: ?Sized> = ReadOnly<T> => T});
+    // SAFETY: `ReadOnly<T>` has the same layout as `T`.
+    unsafe impl<T: ?Sized> CastExact<ReadOnly<T>, T> for CastFromReadOnly {}
+    // SAFETY: `ReadOnly<T>` has the same layout as `T`.
+    define_cast!(unsafe { pub CastToReadOnly<T: ?Sized> = T => ReadOnly<T>});
+    // SAFETY: `ReadOnly<T>` has the same layout as `T`.
+    unsafe impl<T: ?Sized> CastExact<T, ReadOnly<T>> for CastToReadOnly {}
+
+    impl<T: ?Sized> SizeEq<ReadOnly<T>> for T {
+        type CastFrom = CastFromReadOnly;
+    }
+
+    impl<T: ?Sized> SizeEq<T> for ReadOnly<T> {
+        type CastFrom = CastToReadOnly;
+    }
+};
+
+// SAFETY: `ReadOnly<T>` is a `#[repr(transparent)]` wrapper around `T`, and so
+// it has the same bit validity as `T`.
+unsafe impl<T: ?Sized> TransmuteFrom<T, Valid, Valid> for ReadOnly<T> {}
+
+// SAFETY: `ReadOnly<T>` is a `#[repr(transparent)]` wrapper around `T`, and so
+// it has the same bit validity as `T`.
+unsafe impl<T: ?Sized> TransmuteFrom<ReadOnly<T>, Valid, Valid> for T {}
+
+impl<'a, T: ?Sized + Immutable> From<&'a T> for &'a ReadOnly<T> {
+    #[inline(always)]
+    fn from(t: &'a T) -> &'a ReadOnly<T> {
+        let ro = Ptr::from_ref(t).transmute::<_, _, (_, _)>();
+        // SAFETY: `ReadOnly<T>` has the same alignment as `T`, and
+        // `Ptr::from_ref` produces an aligned `Ptr`.
+        let ro = unsafe { ro.assume_alignment() };
+        ro.as_ref()
+    }
+}
+
+impl<T: ?Sized + Immutable> Deref for ReadOnly<T> {
+    type Target = T;
+
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        // SAFETY: By `T: Immutable`, `&T` doesn't permit interior mutation.
+        unsafe { ReadOnly::as_ref_unchecked(self) }
+    }
+}
+
+impl<T: ?Sized + Immutable> DerefMut for ReadOnly<T> {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        ReadOnly::as_mut(self)
+    }
+}
+
+impl<T: ?Sized + Immutable + Debug> Debug for ReadOnly<T> {
+    #[inline(always)]
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+// SAFETY: See safety comment on `ProjectToTag`.
+unsafe impl<T: HasTag + ?Sized> HasTag for ReadOnly<T> {
+    #[allow(clippy::missing_inline_in_public_items)]
+    fn only_derive_is_allowed_to_implement_this_trait()
+    where
+        Self: Sized,
+    {
+    }
+
+    type Tag = T::Tag;
+
+    // SAFETY: `<T as SizeEq<ReadOnly<T>>>::CastFrom` is a no-op projection that
+    // produces a pointer with the same referent. By invariant, for any `Ptr<'_,
+    // T, I>` it is sound to use `T::ProjectToTag` to project to a `Ptr<'_,
+    // T::Tag, I>`. Since `ReadOnly<T>` has the same layout and validity as `T`,
+    // the same is true of projecting from a `Ptr<'_, ReadOnly<T>, I>`.
+    type ProjectToTag = crate::pointer::cast::TransitiveProject<
+        T,
+        <T as SizeEq<ReadOnly<T>>>::CastFrom,
+        T::ProjectToTag,
+    >;
+}
+
+// SAFETY: `ReadOnly<T>` is a `#[repr(transparent)]` wrapper around `T`, and so
+// has the same fields at the same offsets. Thus, it satisfies the safety
+// invariants of `HasField<Field, VARIANT_ID, FIELD_ID>` for field `f` exactly
+// when `T` does, as guaranteed by the `T: HasField` bound:
+// - If `VARIANT_ID` is `STRUCT_VARIANT_ID` or `UNION_VARIANT_ID`, then `T` has
+//   the layout of a struct or union type. Since `ReadOnly<T>` is a transparent
+//   wrapper around `T`, it does too. Otherwise, if `VARIANT_ID` is an enum
+//   variant index, then `T` has the layout of an enum type, and `ReadOnly<T>`
+//   does too.
+// - By `T: HasField<_, _, FIELD_ID>`:
+//   - `T` has a field `f` with name `n` such that
+//     `FIELD_ID = zerocopy::ident_id!(n)` or at index `i` such that
+//     `FIELD_ID = zerocopy::ident_id!(i)`.
+//   - `Field` has the same visibility as `f`.
+//   - `T::Type` has the same type as `f`. Thus, `ReadOnly<T::Type>` has the
+//     same type as `f`, wrapped in `ReadOnly`.
+//
+// `project` satisfies its post-condition – namely, that the returned pointer
+// refers to a non-strict subset of the bytes of `slf`'s referent, and has the
+// same provenance as `slf` – because all intermediate operations satisfy those
+// same conditions.
+unsafe impl<T, Field, const VARIANT_ID: i128, const FIELD_ID: i128>
+    HasField<Field, VARIANT_ID, FIELD_ID> for ReadOnly<T>
+where
+    T: HasField<Field, VARIANT_ID, FIELD_ID> + ?Sized,
+{
+    #[allow(clippy::missing_inline_in_public_items)]
+    fn only_derive_is_allowed_to_implement_this_trait()
+    where
+        Self: Sized,
+    {
+    }
+
+    type Type = ReadOnly<T::Type>;
+
+    #[inline(always)]
+    fn project(slf: PtrInner<'_, Self>) -> *mut ReadOnly<T::Type> {
+        slf.project::<_, <T as SizeEq<ReadOnly<T>>>::CastFrom>()
+            .project::<_, crate::pointer::cast::Projection<Field, VARIANT_ID, FIELD_ID>>()
+            .project::<_, <ReadOnly<T::Type> as SizeEq<T::Type>>::CastFrom>()
+            .as_non_null()
+            .as_ptr()
+    }
+}
+
+// SAFETY: `ReadOnly<T>` is a `#[repr(transparent)]` wrapper around `T`, and so
+// has the same fields at the same offsets. `is_projectable` simply delegates to
+// `T::is_projectable`, which is sound because a `Ptr<'_, ReadOnly<T>, I>` will
+// be projectable exactly when a `Ptr<'_, T, I>` referent is.
+unsafe impl<T, Field, I, const VARIANT_ID: i128, const FIELD_ID: i128>
+    ProjectField<Field, I, VARIANT_ID, FIELD_ID> for ReadOnly<T>
+where
+    T: ProjectField<Field, I, VARIANT_ID, FIELD_ID> + ?Sized,
+    I: invariant::Invariants,
+{
+    #[allow(clippy::missing_inline_in_public_items)]
+    fn only_derive_is_allowed_to_implement_this_trait()
+    where
+        Self: Sized,
+    {
+    }
+
+    type Invariants = T::Invariants;
+
+    type Error = T::Error;
+
+    #[inline(always)]
+    fn is_projectable<'a>(ptr: Ptr<'a, Self::Tag, I>) -> Result<(), Self::Error> {
+        T::is_projectable(ptr)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use core::panic::AssertUnwindSafe;

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

@@ -0,0 +1,67 @@
+// 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.
+
+extern crate zerocopy;
+
+#[allow(unused)]
+#[cfg(feature = "derive")]
+mod util {
+    /// A type that doesn't implement any zerocopy traits.
+    pub struct NotZerocopy<T = ()>(pub T);
+
+    /// A `u16` with alignment 2.
+    ///
+    /// Though `u16` has alignment 2 on some platforms, it's not guaranteed. By
+    /// contrast, `util::AU16` is guaranteed to have alignment 2.
+    #[derive(
+        zerocopy::KnownLayout,
+        zerocopy::Immutable,
+        zerocopy::FromBytes,
+        zerocopy::IntoBytes,
+        Copy,
+        Clone,
+    )]
+    #[repr(C, align(2))]
+    pub struct AU16(pub u16);
+
+    // Since we can't import these by path (ie, `util::assert_impl_all!`), use a
+    // name prefix to ensure our derive-emitted code isn't accidentally relying
+    // on `assert_impl_all!` being in scope.
+    #[macro_export]
+    macro_rules! util_assert_impl_all {
+        ($type:ty: $($trait:path),+ $(,)?) => {
+            const _: fn() = || {
+                use ::core::prelude::v1::*;
+                ::static_assertions::assert_impl_all!($type: $($trait),+);
+            };
+        };
+    }
+
+    // Since we can't import these by path (ie, `util::assert_not_impl_any!`),
+    // use a name prefix to ensure our derive-emitted code isn't accidentally
+    // relying on `assert_not_impl_any!` being in scope.
+    #[macro_export]
+    macro_rules! util_assert_not_impl_any {
+        ($x:ty: $($t:path),+ $(,)?) => {
+            const _: fn() = || {
+                use ::core::prelude::v1::*;
+                ::static_assertions::assert_not_impl_any!($x: $($t),+);
+            };
+        };
+    }
+
+    #[macro_export]
+    macro_rules! test_trivial_is_bit_valid {
+        ($x:ty => $name:ident) => {
+            #[test]
+            fn $name() {
+                util::test_trivial_is_bit_valid::<$x>();
+            }
+        };
+    }
+}

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-from-bytes.rs

@@ -6,9 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 use zerocopy::FromBytes;

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-from-bytes.stderr

@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `NotZerocopy: zerocopy::FromBytes` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-from-bytes.rs:18:24
+error[E0277]: the trait bound `NotZerocopy: FromBytes` is not satisfied
+  --> tests/ui-msrv/diagnostic-not-implemented-from-bytes.rs:16:24
    |
-18 |     takes_from_bytes::<NotZerocopy>();
-   |                        ^^^^^^^^^^^ the trait `zerocopy::FromBytes` is not implemented for `NotZerocopy`
+16 |     takes_from_bytes::<NotZerocopy>();
+   |                        ^^^^^^^^^^^ the trait `FromBytes` is not implemented for `NotZerocopy`
    |
 note: required by a bound in `takes_from_bytes`
-  --> tests/ui-msrv/diagnostic-not-implemented-from-bytes.rs:21:24
+  --> tests/ui-msrv/diagnostic-not-implemented-from-bytes.rs:19:24
    |
-21 | fn takes_from_bytes<T: FromBytes>() {}
+19 | fn takes_from_bytes<T: FromBytes>() {}
    |                        ^^^^^^^^^ required by this bound in `takes_from_bytes`

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-from-zeros.rs

@@ -6,9 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 use zerocopy::FromZeros;

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-from-zeros.stderr

@@ -1,11 +1,11 @@
 error[E0277]: the trait bound `NotZerocopy: FromZeros` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-from-zeros.rs:18:24
+  --> tests/ui-msrv/diagnostic-not-implemented-from-zeros.rs:16:24
    |
-18 |     takes_from_zeros::<NotZerocopy>();
+16 |     takes_from_zeros::<NotZerocopy>();
    |                        ^^^^^^^^^^^ the trait `FromZeros` is not implemented for `NotZerocopy`
    |
 note: required by a bound in `takes_from_zeros`
-  --> tests/ui-msrv/diagnostic-not-implemented-from-zeros.rs:21:24
+  --> tests/ui-msrv/diagnostic-not-implemented-from-zeros.rs:19:24
    |
-21 | fn takes_from_zeros<T: FromZeros>() {}
+19 | fn takes_from_zeros<T: FromZeros>() {}
    |                        ^^^^^^^^^ required by this bound in `takes_from_zeros`

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-immutable.rs

@@ -6,9 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 use zerocopy::Immutable;

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-immutable.stderr

@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `NotZerocopy: zerocopy::Immutable` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-immutable.rs:18:23
+error[E0277]: the trait bound `NotZerocopy: Immutable` is not satisfied
+  --> tests/ui-msrv/diagnostic-not-implemented-immutable.rs:16:23
    |
-18 |     takes_immutable::<NotZerocopy>();
-   |                       ^^^^^^^^^^^ the trait `zerocopy::Immutable` is not implemented for `NotZerocopy`
+16 |     takes_immutable::<NotZerocopy>();
+   |                       ^^^^^^^^^^^ the trait `Immutable` is not implemented for `NotZerocopy`
    |
 note: required by a bound in `takes_immutable`
-  --> tests/ui-msrv/diagnostic-not-implemented-immutable.rs:21:23
+  --> tests/ui-msrv/diagnostic-not-implemented-immutable.rs:19:23
    |
-21 | fn takes_immutable<T: Immutable>() {}
+19 | fn takes_immutable<T: Immutable>() {}
    |                       ^^^^^^^^^ required by this bound in `takes_immutable`

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-into-bytes.rs

@@ -6,9 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 use zerocopy::IntoBytes;

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-into-bytes.stderr

@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `NotZerocopy: zerocopy::IntoBytes` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-into-bytes.rs:18:24
+error[E0277]: the trait bound `NotZerocopy: IntoBytes` is not satisfied
+  --> tests/ui-msrv/diagnostic-not-implemented-into-bytes.rs:16:24
    |
-18 |     takes_into_bytes::<NotZerocopy>();
-   |                        ^^^^^^^^^^^ the trait `zerocopy::IntoBytes` is not implemented for `NotZerocopy`
+16 |     takes_into_bytes::<NotZerocopy>();
+   |                        ^^^^^^^^^^^ the trait `IntoBytes` is not implemented for `NotZerocopy`
    |
 note: required by a bound in `takes_into_bytes`
-  --> tests/ui-msrv/diagnostic-not-implemented-into-bytes.rs:21:24
+  --> tests/ui-msrv/diagnostic-not-implemented-into-bytes.rs:19:24
    |
-21 | fn takes_into_bytes<T: IntoBytes>() {}
+19 | fn takes_into_bytes<T: IntoBytes>() {}
    |                        ^^^^^^^^^ required by this bound in `takes_into_bytes`

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-issue-1296.rs

@@ -6,9 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 use zerocopy::{Immutable, IntoBytes};

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-issue-1296.stderr

@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `NotZerocopy: zerocopy::Immutable` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-issue-1296.rs:52:19
+error[E0277]: the trait bound `NotZerocopy: Immutable` is not satisfied
+  --> tests/ui-msrv/diagnostic-not-implemented-issue-1296.rs:50:19
    |
-52 |     Foo.write_obj(NotZerocopy(()));
-   |                   ^^^^^^^^^^^^^^^ the trait `zerocopy::Immutable` is not implemented for `NotZerocopy`
+50 |     Foo.write_obj(NotZerocopy(()));
+   |                   ^^^^^^^^^^^^^^^ the trait `Immutable` is not implemented for `NotZerocopy`
 
-error[E0277]: the trait bound `NotZerocopy: zerocopy::IntoBytes` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-issue-1296.rs:52:19
+error[E0277]: the trait bound `NotZerocopy: IntoBytes` is not satisfied
+  --> tests/ui-msrv/diagnostic-not-implemented-issue-1296.rs:50:19
    |
-52 |     Foo.write_obj(NotZerocopy(()));
-   |                   ^^^^^^^^^^^^^^^ the trait `zerocopy::IntoBytes` is not implemented for `NotZerocopy`
+50 |     Foo.write_obj(NotZerocopy(()));
+   |                   ^^^^^^^^^^^^^^^ the trait `IntoBytes` is not implemented for `NotZerocopy`

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-known-layout.rs

@@ -6,9 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 use zerocopy::KnownLayout;

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-known-layout.stderr

@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `NotZerocopy: zerocopy::KnownLayout` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-known-layout.rs:18:26
+error[E0277]: the trait bound `NotZerocopy: KnownLayout` is not satisfied
+  --> tests/ui-msrv/diagnostic-not-implemented-known-layout.rs:16:26
    |
-18 |     takes_known_layout::<NotZerocopy>();
-   |                          ^^^^^^^^^^^ the trait `zerocopy::KnownLayout` is not implemented for `NotZerocopy`
+16 |     takes_known_layout::<NotZerocopy>();
+   |                          ^^^^^^^^^^^ the trait `KnownLayout` is not implemented for `NotZerocopy`
    |
 note: required by a bound in `takes_known_layout`
-  --> tests/ui-msrv/diagnostic-not-implemented-known-layout.rs:21:26
+  --> tests/ui-msrv/diagnostic-not-implemented-known-layout.rs:19:26
    |
-21 | fn takes_known_layout<T: KnownLayout>() {}
+19 | fn takes_known_layout<T: KnownLayout>() {}
    |                          ^^^^^^^^^^^ required by this bound in `takes_known_layout`

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-try-from-bytes.rs

@@ -6,9 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 use zerocopy::TryFromBytes;

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-try-from-bytes.stderr

@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `NotZerocopy: zerocopy::TryFromBytes` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-try-from-bytes.rs:18:28
+error[E0277]: the trait bound `NotZerocopy: TryFromBytes` is not satisfied
+  --> tests/ui-msrv/diagnostic-not-implemented-try-from-bytes.rs:16:28
    |
-18 |     takes_try_from_bytes::<NotZerocopy>();
-   |                            ^^^^^^^^^^^ the trait `zerocopy::TryFromBytes` is not implemented for `NotZerocopy`
+16 |     takes_try_from_bytes::<NotZerocopy>();
+   |                            ^^^^^^^^^^^ the trait `TryFromBytes` is not implemented for `NotZerocopy`
    |
 note: required by a bound in `takes_try_from_bytes`
-  --> tests/ui-msrv/diagnostic-not-implemented-try-from-bytes.rs:21:28
+  --> tests/ui-msrv/diagnostic-not-implemented-try-from-bytes.rs:19:28
    |
-21 | fn takes_try_from_bytes<T: TryFromBytes>() {}
+19 | fn takes_try_from_bytes<T: TryFromBytes>() {}
    |                            ^^^^^^^^^^^^ required by this bound in `takes_try_from_bytes`

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-unaligned.rs

@@ -6,9 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 use zerocopy::Unaligned;

data/rust-vendor/zerocopy/tests/ui-msrv/diagnostic-not-implemented-unaligned.stderr

@@ -1,11 +1,11 @@
 error[E0277]: the trait bound `NotZerocopy: zerocopy::Unaligned` is not satisfied
-  --> tests/ui-msrv/diagnostic-not-implemented-unaligned.rs:18:23
+  --> tests/ui-msrv/diagnostic-not-implemented-unaligned.rs:16:23
    |
-18 |     takes_unaligned::<NotZerocopy>();
+16 |     takes_unaligned::<NotZerocopy>();
    |                       ^^^^^^^^^^^ the trait `zerocopy::Unaligned` is not implemented for `NotZerocopy`
    |
 note: required by a bound in `takes_unaligned`
-  --> tests/ui-msrv/diagnostic-not-implemented-unaligned.rs:21:23
+  --> tests/ui-msrv/diagnostic-not-implemented-unaligned.rs:19:23
    |
-21 | fn takes_unaligned<T: Unaligned>() {}
+19 | fn takes_unaligned<T: Unaligned>() {}
    |                       ^^^^^^^^^ required by this bound in `takes_unaligned`

data/rust-vendor/zerocopy/tests/ui-msrv/include_value_not_from_bytes.rs

@@ -6,14 +6,12 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-include!("../../zerocopy-derive/tests/include.rs");
-
-#[macro_use]
-extern crate zerocopy;
+include!("../include.rs");
 
 use util::NotZerocopy;
 
 fn main() {}
 
 // Should fail because `NotZerocopy<u32>: !FromBytes`.
-const NOT_FROM_BYTES: NotZerocopy<u32> = include_value!("../../testdata/include_value/data");
+const NOT_FROM_BYTES: NotZerocopy<u32> =
+    zerocopy::include_value!("../../testdata/include_value/data");

data/rust-vendor/zerocopy/tests/ui-msrv/include_value_not_from_bytes.stderr

@@ -1,15 +1,15 @@
-error[E0277]: the trait bound `NotZerocopy<u32>: zerocopy::FromBytes` is not satisfied
-  --> tests/ui-msrv/include_value_not_from_bytes.rs:19:42
+error[E0277]: the trait bound `NotZerocopy<u32>: FromBytes` is not satisfied
+  --> tests/ui-msrv/include_value_not_from_bytes.rs:17:5
    |
-19 | const NOT_FROM_BYTES: NotZerocopy<u32> = include_value!("../../testdata/include_value/data");
-   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `zerocopy::FromBytes` is not implemented for `NotZerocopy<u32>`
+17 |     zerocopy::include_value!("../../testdata/include_value/data");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `FromBytes` is not implemented for `NotZerocopy<u32>`
    |
 note: required by a bound in `NOT_FROM_BYTES::transmute`
-  --> tests/ui-msrv/include_value_not_from_bytes.rs:19:42
+  --> tests/ui-msrv/include_value_not_from_bytes.rs:17:5
    |
-19 | const NOT_FROM_BYTES: NotZerocopy<u32> = include_value!("../../testdata/include_value/data");
-   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                                          |
-   |                                          required by a bound in this
-   |                                          required by this bound in `NOT_FROM_BYTES::transmute`
+17 |     zerocopy::include_value!("../../testdata/include_value/data");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     |
+   |     required by a bound in this
+   |     required by this bound in `NOT_FROM_BYTES::transmute`
    = note: this error originates in the macro `$crate::transmute` (in Nightly builds, run with -Z macro-backtrace for more info)

data/rust-vendor/zerocopy/tests/ui-msrv/include_value_wrong_size.rs

@@ -6,10 +6,7 @@
 // This file may not be copied, modified, or distributed except according to
 // those terms.
 
-#[macro_use]
-extern crate zerocopy;
-
 fn main() {}
 
 // Should fail because the file is 4 bytes long, not 8.
-const WRONG_SIZE: u64 = include_value!("../../testdata/include_value/data");
+const WRONG_SIZE: u64 = zerocopy::include_value!("../../testdata/include_value/data");