// Copyright 2024 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.
use dissimilar::Chunk;
use proc_macro2::TokenStream;
use crate ::IntoTokenStream;
macro_rules! use_as_trait_name {
($($alias:ident => $derive:ident),* $(,)?) => {
$(
use super ::$derive
as $alias;)*
};
}
// This permits invocations of `test!` to be more ergonomic, passing the name of
// the trait under test rather than the name of the inner derive function.
use_as_trait_name!(
KnownLayout => derive_known_layout_inner,
Immutable => derive_no_cell_inner,
TryFromBytes => derive_try_from_bytes_inner,
FromZeros => derive_from_zeros_inner,
FromBytes => derive_from_bytes_inner,
IntoBytes => derive_into_bytes_inner,
Unaligned => derive_unaligned_inner,
ByteHash => derive_hash_inner,
ByteEq => derive_eq_inner,
SplitAt => derive_split_at_inner,
);
/// Test that the given derive input expands to the expected output.
///
/// Equality is tested by formatting both token streams using `prettyplease` and
/// performing string equality on the results. This has the effect of making the
/// tests less brittle and robust against meaningless formatting changes.
// Adapted from https://github.com/joshlf/synstructure/blob/400499aaf54840056ff56718beb7810540e6be59/src/macros.rs#L212-L317
macro_rules! test {
($name:ident { $($i:tt)* } expands to { $($o:tt)* }) => {
{
#[ allow(dead_code)]
fn ensure_compiles() {
$($i)*
$($o)*
}
test!($name { $($i)* } expands to { $($o)* } no_build);
}
};
($name:ident { $($i:tt)* } expands to { $($o:tt)* } no_build) => {
{
let ts: proc_macro2::TokenStream = quote::quote!( $($i)* );
let ast = syn::parse2::<syn::DeriveInput>(ts).unwrap();
let res = $name(&ast,
crate ::
Trait ::$name, &syn::parse_quote!(::zerocopy));
let expected_toks = quote::quote!( $($o)* );
assert_eq_streams(expected_toks.into(), res.into_ts().into());
}
};
}
#[ track_caller]
fn assert_eq_streams(expect: TokenStream, res: TokenStream) {
let pretty =
|ts: TokenStream| prettyplease::unparse(&syn::parse_file(&ts.to_string()).unwrap());
let expect = pretty(expect.clone());
let res = pretty(res.clone());
if expect != res {
let diff = dissimilar::diff(&expect, &res)
.into_iter()
.flat_map(|chunk| {
let (prefix, chunk) =
match chunk {
Chunk::Equal(chunk) => (
" " , chunk),
Chunk::Delete(chunk) => (
"-" , chunk),
Chunk::Insert(chunk) => (
"+" , chunk),
};
[prefix, chunk,
"\n" ]
})
.collect::<String>();
panic!(
"\
test failed:
got:
```
{}
```
diff (expected vs got):
```
{}
```\n
",
res, diff
);
}
}
#[ test]
fn test_known_layout() {
test! {
KnownLayout {
struct Foo;
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::KnownLayout
for Foo
where
Self : ::zerocopy::util::macro_util::core_reexport::marker::Sized,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
type PointerMetadata = ();
type MaybeUninit = ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
Self >;
const LAYOUT: ::zerocopy::DstLayout = ::zerocopy::DstLayout::for_type::<
Self >();
#[ inline(always)]
fn raw_from_ptr_len(
bytes: ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<u8>,
_meta: (),
) -> ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<
Self > {
bytes.cast::<
Self >()
}
#[ inline(always)]
fn pointer_to_metadata(_ptr: *
mut Self ) -> () {}
}
} no_build
}
test! {
KnownLayout {
#[ repr(C, align(
2 ))]
struct Foo<T, U>(T, U);
}
expands to {
const _: () = {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl <T, U> ::zerocopy::KnownLayout
for Foo<T, U>
where
U: ::zerocopy::KnownLayout,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
type PointerMetadata = <U
as ::zerocopy::KnownLayout>::PointerMetadata;
type MaybeUninit = __ZerocopyKnownLayoutMaybeUninit<T, U>;
const LAYOUT: ::zerocopy::DstLayout = {
use ::zerocopy::util::macro_util::core_reexport::num::NonZeroUsize;
use ::zerocopy::{DstLayout, KnownLayout};
DstLayout::for_repr_c_struct(
::zerocopy::util::macro_util::core_reexport::num::NonZeroUsize::new(
2 u32
as usize,
),
::zerocopy::util::macro_util::core_reexport::option::Option::None,
&[DstLayout::for_type::<T>(), <U
as KnownLayout>::LAYOUT],
)
};
#[ inline(always)]
fn raw_from_ptr_len(
bytes: ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<u8>,
meta:
Self ::PointerMetadata,
) -> ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<
Self > {
use ::zerocopy::KnownLayout;
let trailing = <U
as KnownLayout>::raw_from_ptr_len(bytes, meta);
let slf = trailing.as_ptr()
as *
mut Self ;
unsafe {
::zerocopy::util::macro_util::core_reexport::ptr::NonNull::new_unchecked(
slf,
)
}
}
#[ inline(always)]
fn pointer_to_metadata(ptr: *
mut Self ) ->
Self ::PointerMetadata {
<U>::pointer_to_metadata(ptr
as *
mut _)
}
}
#[ allow(non_camel_case_types)]
struct __Zerocopy_Field_0;
#[ allow(non_camel_case_types)]
struct __Zerocopy_Field_1;
unsafe impl <T, U> ::zerocopy::util::macro_util::Field<__Zerocopy_Field_0>
for Foo<T, U> {
type Type = T;
}
unsafe impl <T, U> ::zerocopy::util::macro_util::Field<__Zerocopy_Field_1>
for Foo<T, U> {
type Type = U;
}
#[ repr(C)]
#[ repr(align(
2 ))]
#[ doc(hidden)]
#[ allow(private_bounds)]
struct __ZerocopyKnownLayoutMaybeUninit<T, U>(
::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
<Foo<T, U>
as ::zerocopy::util::macro_util::Field<__Zerocopy_Field_0>>::
Type ,
>,
::zerocopy::util::macro_util::core_reexport::mem::ManuallyDrop<
<<Foo<
T,
U,
>
as ::zerocopy::util::macro_util::Field<
__Zerocopy_Field_1,
>>::
Type as ::zerocopy::KnownLayout>::MaybeUninit,
>,
)
where
<Foo<
T,
U,
>
as ::zerocopy::util::macro_util::Field<
__Zerocopy_Field_1,
>>::
Type : ::zerocopy::KnownLayout;
unsafe impl <T, U> ::zerocopy::KnownLayout
for __ZerocopyKnownLayoutMaybeUninit<T, U>
where
<Foo<
T,
U,
>
as ::zerocopy::util::macro_util::Field<
__Zerocopy_Field_1,
>>::
Type : ::zerocopy::KnownLayout,
{
#[ allow(clippy::missing_inline_in_public_items)]
fn only_derive_is_allowed_to_implement_this_trait() {}
type PointerMetadata = <Foo<T, U>
as ::zerocopy::KnownLayout>::PointerMetadata;
type MaybeUninit =
Self ;
const LAYOUT: ::zerocopy::DstLayout = <Foo<
T,
U,
>
as ::zerocopy::KnownLayout>::LAYOUT;
#[ inline(always)]
fn raw_from_ptr_len(
bytes: ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<u8>,
meta:
Self ::PointerMetadata,
) -> ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<
Self > {
use ::zerocopy::KnownLayout;
let trailing = <<<Foo<
T,
U,
>
as ::zerocopy::util::macro_util::Field<
__Zerocopy_Field_1,
>>::
Type as ::zerocopy::KnownLayout>::MaybeUninit
as KnownLayout>::raw_from_ptr_len(
bytes,
meta,
);
let slf = trailing.as_ptr()
as *
mut Self ;
unsafe {
::zerocopy::util::macro_util::core_reexport::ptr::NonNull::new_unchecked(
slf,
)
}
}
#[ inline(always)]
fn pointer_to_metadata(ptr: *
mut Self ) ->
Self ::PointerMetadata {
<<<Foo<
T,
U,
>
as ::zerocopy::util::macro_util::Field<
__Zerocopy_Field_1,
>>::
Type as ::zerocopy::KnownLayout>::MaybeUninit>::pointer_to_metadata(
ptr
as *
mut _,
)
}
}
};
} no_build
}
}
#[ test]
fn test_immutable() {
test! {
Immutable {
struct Foo;
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::Immutable
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
}
#[ test]
fn test_try_from_bytes() {
test! {
TryFromBytes {
struct Foo;
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::TryFromBytes
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
fn is_bit_valid<___ZerocopyAliasing>(
mut candidate: ::zerocopy::Maybe<
Self , ___ZerocopyAliasing>,
) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool
where
___ZerocopyAliasing: ::zerocopy::pointer::invariant::Reference,
{
use ::zerocopy::util::macro_util::core_reexport;
use ::zerocopy::pointer::PtrInner;
true
}
}
} no_build
}
}
#[ test]
fn test_from_zeros() {
test! {
FromZeros {
struct Foo;
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::TryFromBytes
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
fn is_bit_valid<___ZerocopyAliasing>(
mut candidate: ::zerocopy::Maybe<
Self , ___ZerocopyAliasing>,
) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool
where
___ZerocopyAliasing: ::zerocopy::pointer::invariant::Reference,
{
use ::zerocopy::util::macro_util::core_reexport;
use ::zerocopy::pointer::PtrInner;
true
}
}
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::FromZeros
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
}
#[ test]
fn test_from_bytes_struct() {
test! {
FromBytes {
struct Foo;
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::TryFromBytes
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
fn is_bit_valid<___ZerocopyAliasing>(
_candidate: ::zerocopy::Maybe<
Self , ___ZerocopyAliasing>,
) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool
where
___ZerocopyAliasing: ::zerocopy::pointer::invariant::Reference,
{
if false {
fn assert_is_from_bytes<T>()
where
T: ::zerocopy::FromBytes,
T: ?::zerocopy::util::macro_util::core_reexport::marker::Sized,
{}
assert_is_from_bytes::<
Self >();
}
true
}
}
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::FromZeros
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
}
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::FromBytes
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
}
#[ test]
fn test_from_bytes_union() {
test! {
FromBytes {
union Foo {
a: u8,
}
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::TryFromBytes
for Foo
where
u8: ::zerocopy::TryFromBytes + ::zerocopy::Immutable,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
fn is_bit_valid<___ZerocopyAliasing>(
_candidate: ::zerocopy::Maybe<
Self , ___ZerocopyAliasing>,
) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool
where
___ZerocopyAliasing: ::zerocopy::pointer::invariant::Reference,
{
if false {
fn assert_is_from_bytes<T>()
where
T: ::zerocopy::FromBytes,
T: ?::zerocopy::util::macro_util::core_reexport::marker::Sized,
{}
assert_is_from_bytes::<
Self >();
}
true
}
}
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::FromZeros
for Foo
where
u8: ::zerocopy::FromZeros + ::zerocopy::Immutable,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
}
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::FromBytes
for Foo
where
u8: ::zerocopy::FromBytes + ::zerocopy::Immutable,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
}
#[ test]
fn test_into_bytes_struct() {
test! {
IntoBytes {
#[ repr(C)]
struct Foo;
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::IntoBytes
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
test! {
IntoBytes {
#[ repr(C)]
struct Foo {
a: u8,
b: u8,
}
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::IntoBytes
for Foo
where
u8: ::zerocopy::IntoBytes,
u8: ::zerocopy::IntoBytes,
(): ::zerocopy::util::macro_util::PaddingFree<
Self ,
{ ::zerocopy::struct_padding!(
Self , [u8, u8]) },
>,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
test! {
IntoBytes {
#[ repr(C)]
struct Foo {
a: u8,
b: [Trailing],
}
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::IntoBytes
for Foo
where
u8: ::zerocopy::IntoBytes,
[Trailing]: ::zerocopy::IntoBytes,
(): ::zerocopy::util::macro_util::DynamicPaddingFree<
Self ,
{ ::zerocopy::repr_c_struct_has_padding!(
Self , [u8, [Trailing]]) },
>,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
test! {
IntoBytes {
#[ repr(C)]
struct Foo<Trailing> {
a: u8,
b: [Trailing],
}
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl <Trailing> ::zerocopy::IntoBytes
for Foo<Trailing>
where
u8: ::zerocopy::IntoBytes + ::zerocopy::Unaligned,
[Trailing]: ::zerocopy::IntoBytes + ::zerocopy::Unaligned,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
}
#[ test]
fn test_into_bytes_enum() {
macro_rules! test_repr {
($(
#[ $attr:meta])*) => {
$(test! {
IntoBytes {
#[ $attr]
enum Foo {
Bar,
}
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::IntoBytes
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
})*
};
}
test_repr! {
#[ repr(C)]
#[ repr(u8)]
#[ repr(u16)]
#[ repr(u32)]
#[ repr(u64)]
#[ repr(u128)]
#[ repr(usize)]
#[ repr(i8)]
#[ repr(i16)]
#[ repr(i32)]
#[ repr(i64)]
#[ repr(i128)]
#[ repr(isize)]
}
}
#[ test]
fn test_unaligned() {
test! {
Unaligned {
#[ repr(C)]
struct Foo;
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl ::zerocopy::Unaligned
for Foo {
fn only_derive_is_allowed_to_implement_this_trait() {}
}
} no_build
}
}
#[ test]
fn test_try_from_bytes_enum() {
test! {
TryFromBytes {
#[ repr(u8)]
enum ComplexWithGenerics<
'a: ' static ,
const N: usize, X, Y: Deref>
where
X: Deref<Target = &
'a [(X, Y); N]>,
{
UnitLike,
StructLike { a: u8, b: X, c: X::Target, d: Y::Target, e: [(X, Y); N] },
TupleLike(bool, Y, PhantomData<&
'a [(X, Y); N]>),
}
} expands to {
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl <
'a: ' static ,
const N: usize, X, Y: Deref> ::zerocopy::TryFromBytes
for ComplexWithGenerics<
'a, { N }, X, Y>
where
X: Deref<Target = &
'a [(X, Y); N]>,
u8: ::zerocopy::TryFromBytes,
X: ::zerocopy::TryFromBytes,
X::Target: ::zerocopy::TryFromBytes,
Y::Target: ::zerocopy::TryFromBytes,
[(X, Y); N]: ::zerocopy::TryFromBytes,
bool: ::zerocopy::TryFromBytes,
Y: ::zerocopy::TryFromBytes,
PhantomData<&
'a [(X, Y); N]>: ::zerocopy::TryFromBytes,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
fn is_bit_valid<___ZerocopyAliasing>(
mut candidate: ::zerocopy::Maybe<
'_, Self, ___ZerocopyAliasing>,
) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool
where
___ZerocopyAliasing: ::zerocopy::pointer::invariant::Reference,
{
use ::zerocopy::util::macro_util::core_reexport;
#[ repr(u8)]
#[ allow(dead_code, non_camel_case_types)]
enum ___ZerocopyTag {
UnitLike,
StructLike,
TupleLike,
}
type ___ZerocopyTagPrimitive = ::zerocopy::util::macro_util::SizeToTag<
{ core_reexport::mem::size_of::<___ZerocopyTag>() },
>;
#[ allow(non_upper_case_globals)]
const ___ZEROCOPY_TAG_UnitLike: ___ZerocopyTagPrimitive =
___ZerocopyTag::UnitLike
as ___ZerocopyTagPrimitive;
#[ allow(non_upper_case_globals)]
const ___ZEROCOPY_TAG_StructLike: ___ZerocopyTagPrimitive =
___ZerocopyTag::StructLike
as ___ZerocopyTagPrimitive;
#[ allow(non_upper_case_globals)]
const ___ZEROCOPY_TAG_TupleLike: ___ZerocopyTagPrimitive =
___ZerocopyTag::TupleLike
as ___ZerocopyTagPrimitive;
type ___ZerocopyOuterTag = ();
type ___ZerocopyInnerTag = ___ZerocopyTag;
#[ repr(C)]
#[ allow(non_snake_case)]
struct ___ZerocopyVariantStruct_StructLike<
'a: ' static ,
const N: usize, X, Y: Deref>(
core_reexport::mem::MaybeUninit<___ZerocopyInnerTag>,
u8,
X,
X::Target,
Y::Target,
[(X, Y); N],
core_reexport::marker::PhantomData<ComplexWithGenerics<
'a, N, X, Y>>,
)
where
X: Deref<Target = &
'a [(X, Y); N]>;
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl <
'a: ' static ,
const N: usize, X, Y: Deref> ::zerocopy::TryFromBytes
for ___ZerocopyVariantStruct_StructLike<
'a, { N }, X, Y>
where
X: Deref<Target = &
'a [(X, Y); N]>,
core_reexport::mem::MaybeUninit<___ZerocopyInnerTag>: ::zerocopy::TryFromBytes,
u8: ::zerocopy::TryFromBytes,
X: ::zerocopy::TryFromBytes,
X::Target: ::zerocopy::TryFromBytes,
Y::Target: ::zerocopy::TryFromBytes,
[(X, Y); N]: ::zerocopy::TryFromBytes,
core_reexport::marker::PhantomData<ComplexWithGenerics<
'a, N, X, Y>>:
::zerocopy::TryFromBytes,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
fn is_bit_valid<___ZerocopyAliasing>(
mut candidate: ::zerocopy::Maybe<
Self , ___ZerocopyAliasing>,
) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool
where
___ZerocopyAliasing: ::zerocopy::pointer::invariant::Reference,
{
use ::zerocopy::util::macro_util::core_reexport;
use ::zerocopy::pointer::PtrInner;
true && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
0 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<core_reexport::mem::MaybeUninit<
___ZerocopyInnerTag,
>
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
1 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<u8
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
2 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<X
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
3 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<X::Target
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
4 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<Y::Target
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
5 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<[(X, Y); N]
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
6 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<core_reexport::marker::PhantomData<
ComplexWithGenerics<
'a, N, X, Y>,
>
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
}
}
}
#[ repr(C)]
#[ allow(non_snake_case)]
struct ___ZerocopyVariantStruct_TupleLike<
'a: ' static ,
const N: usize, X, Y: Deref>(
core_reexport::mem::MaybeUninit<___ZerocopyInnerTag>,
bool,
Y,
PhantomData<&
'a [(X, Y); N]>,
core_reexport::marker::PhantomData<ComplexWithGenerics<
'a, N, X, Y>>,
)
where
X: Deref<Target = &
'a [(X, Y); N]>;
#[ allow(deprecated)]
#[ automatically_derived]
unsafe impl <
'a: ' static ,
const N: usize, X, Y: Deref> ::zerocopy::TryFromBytes
for ___ZerocopyVariantStruct_TupleLike<
'a, { N }, X, Y>
where
X: Deref<Target = &
'a [(X, Y); N]>,
core_reexport::mem::MaybeUninit<___ZerocopyInnerTag>: ::zerocopy::TryFromBytes,
bool: ::zerocopy::TryFromBytes,
Y: ::zerocopy::TryFromBytes,
PhantomData<&
'a [(X, Y); N]>: ::zerocopy::TryFromBytes,
core_reexport::marker::PhantomData<ComplexWithGenerics<
'a, N, X, Y>>:
::zerocopy::TryFromBytes,
{
fn only_derive_is_allowed_to_implement_this_trait() {}
fn is_bit_valid<___ZerocopyAliasing>(
mut candidate: ::zerocopy::Maybe<
Self , ___ZerocopyAliasing>,
) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool
where
___ZerocopyAliasing: ::zerocopy::pointer::invariant::Reference,
{
use ::zerocopy::util::macro_util::core_reexport;
use ::zerocopy::pointer::PtrInner;
true && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
0 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<core_reexport::mem::MaybeUninit<
___ZerocopyInnerTag,
>
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
1 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<bool
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
2 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<Y
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
3 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<PhantomData<&
'a [(X, Y); N]> as ::zerocopy::TryFromBytes>::is_bit_valid(
field_candidate,
)
} && {
let field_candidate =
unsafe {
let project = |slf: PtrInner<
'_, Self>| {
let slf = slf.as_non_null().as_ptr();
let field = core_reexport::ptr::addr_of_mut!((*slf).
4 );
let ptr =
unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };
unsafe { PtrInner::new(ptr) }
};
candidate.reborrow().cast_unsized_unchecked(project)
};
<core_reexport::marker::PhantomData<
ComplexWithGenerics<
'a, N, X, Y>,
>
as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)
}
}
}
#[ repr(C)]
#[ allow(non_snake_case)]
union ___ZerocopyVariants<
'a: ' static ,
const N: usize, X, Y: Deref> {
__field_StructLike:
core_reexport::mem::ManuallyDrop<___ZerocopyVariantStruct_StructLike<
'a, N, X, Y>>,
__field_TupleLike:
core_reexport::mem::ManuallyDrop<___ZerocopyVariantStruct_TupleLike<
'a, N, X, Y>>,
__nonempty: (),
}
#[ repr(C)]
struct ___ZerocopyRawEnum<
'a: ' static ,
const N: usize, X, Y: Deref> {
tag: ___ZerocopyOuterTag,
variants: ___ZerocopyVariants<
'a, N, X, Y>,
}
let tag = {
let tag_ptr =
unsafe {
candidate.reborrow().cast_unsized_unchecked(|p: ::zerocopy::pointer::PtrInner<
'_, Self>| { p.cast_sized::<___ZerocopyTagPrimitive>() })
};
let tag_ptr =
unsafe { tag_ptr.assume_initialized() };
tag_ptr.recall_validity::<_, (_, (_, _))>().read_unaligned::<::zerocopy::BecauseImmuta
ble>()let raw_enum = unsafe {'_, Self>| { p.cast_sized::<___ZerocopyRawEnum<' a, N, X, Y>>() })let raw_enum = unsafe { raw_enum.assume_initialized() };let variants = unsafe {use ::zerocopy::pointer::PtrInner;'_, ___ZerocopyRawEnum<' a, N, X, Y>>| {let p = p.as_non_null().as_ptr();let ptr = core_reexport::ptr::addr_of_mut!((*p).variants);let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(ptr) };unsafe { PtrInner::new(ptr) }#[ allow(non_upper_case_globals)]match tag {true ,let variant = unsafe {'_, ___ZerocopyVariants<' a, N, X, Y>>| {'a, N, X, Y>>() let variant = unsafe { variant.assume_initialized() };'a, N, X, Y> as ::zerocopy ::TryFromBytes>::is_bit_valid ( let variant = unsafe {'_, ___ZerocopyVariants<' a, N, X, Y>>| {'a, N, X, Y>>() let variant = unsafe { variant.assume_initialized() };'a, N, X, Y> as ::zerocopy ::TryFromBytes>::is_bit_valid ( false ,#[ repr(u32)]enum ComplexWithGenerics<'a: ' static , const N: usize, X, Y: Deref>where 'a [(X, Y); N]>, 'a [(X, Y); N]>), #[ allow(deprecated)]#[ automatically_derived]unsafe impl <'a: ' static , const N: usize, X, Y: Deref> ::zerocopy::TryFromBytesfor ComplexWithGenerics<'a, { N }, X, Y> where 'a [(X, Y); N]>, 'a [(X, Y); N]>: ::zerocopy::TryFromBytes, fn only_derive_is_allowed_to_implement_this_trait() {}fn is_bit_valid<___ZerocopyAliasing>(mut candidate: ::zerocopy::Maybe<'_, Self, ___ZerocopyAliasing>, where use ::zerocopy::util::macro_util::core_reexport;#[ repr(u32)]#[ allow(dead_code, non_camel_case_types)]enum ___ZerocopyTag {type ___ZerocopyTagPrimitive = ::zerocopy::util::macro_util::SizeToTag<#[ allow(non_upper_case_globals)]const ___ZEROCOPY_TAG_UnitLike: ___ZerocopyTagPrimitive =as ___ZerocopyTagPrimitive;#[ allow(non_upper_case_globals)]const ___ZEROCOPY_TAG_StructLike: ___ZerocopyTagPrimitive =as ___ZerocopyTagPrimitive;#[ allow(non_upper_case_globals)]const ___ZEROCOPY_TAG_TupleLike: ___ZerocopyTagPrimitive =as ___ZerocopyTagPrimitive;type ___ZerocopyOuterTag = ();type ___ZerocopyInnerTag = ___ZerocopyTag;#[ repr(C)]#[ allow(non_snake_case)]struct ___ZerocopyVariantStruct_StructLike<'a: ' static , const N: usize, X, Y: Deref>('a, N, X, Y>>, where 'a [(X, Y); N]>; #[ allow(deprecated)]#[ automatically_derived]unsafe impl <'a: ' static , const N: usize, X, Y: Deref> ::zerocopy::TryFromBytesfor ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y> where 'a [(X, Y); N]>, 'a, N, X, Y>>: fn only_derive_is_allowed_to_implement_this_trait() {}fn is_bit_valid<___ZerocopyAliasing>(mut candidate: ::zerocopy::Maybe<Self , ___ZerocopyAliasing>,where use ::zerocopy::util::macro_util::core_reexport;use ::zerocopy::pointer::PtrInner;true && {let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).0 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).1 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).2 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).3 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).4 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).5 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).6 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }'a, N, X, Y>, as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)#[ repr(C)]#[ allow(non_snake_case)]struct ___ZerocopyVariantStruct_TupleLike<'a: ' static , const N: usize, X, Y: Deref>('a [(X, Y); N]>, 'a, N, X, Y>>, where 'a [(X, Y); N]>; #[ allow(deprecated)]#[ automatically_derived]unsafe impl <'a: ' static , const N: usize, X, Y: Deref> ::zerocopy::TryFromBytesfor ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y> where 'a [(X, Y); N]>, 'a [(X, Y); N]>: ::zerocopy::TryFromBytes, 'a, N, X, Y>>: fn only_derive_is_allowed_to_implement_this_trait() {}fn is_bit_valid<___ZerocopyAliasing>(mut candidate: ::zerocopy::Maybe<Self , ___ZerocopyAliasing>,where use ::zerocopy::util::macro_util::core_reexport;use ::zerocopy::pointer::PtrInner;true && {let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).0 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).1 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).2 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).3 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }'a [(X, Y); N]> as ::zerocopy::TryFromBytes>::is_bit_valid( let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).4 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }'a, N, X, Y>, as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)#[ repr(C)]#[ allow(non_snake_case)]'a: ' static , const N: usize, X, Y: Deref> {'a, N, X, Y>>, 'a, N, X, Y>>, #[ repr(C)]struct ___ZerocopyRawEnum<'a: ' static , const N: usize, X, Y: Deref> {'a, N, X, Y>, let tag = {let tag_ptr = unsafe {'_, Self>| { p.cast_sized::<___ZerocopyTagPrimitive> ()}) let tag_ptr = unsafe { tag_ptr.assume_initialized() };ble>()let raw_enum = unsafe {'_, Self>| { p.cast_sized::<___ZerocopyRawEnum<' a, N, X, Y>> ()})let raw_enum = unsafe { raw_enum.assume_initialized() };let variants = unsafe {use ::zerocopy::pointer::PtrInner;'_, ___ZerocopyRawEnum<' a, N, X, Y>>| {let p = p.as_non_null().as_ptr();let ptr = core_reexport::ptr::addr_of_mut!((*p).variants);let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(ptr) };unsafe { PtrInner::new(ptr) }#[ allow(non_upper_case_globals)]match tag {true ,let variant = unsafe {'_, ___ZerocopyVariants<' a, N, X, Y>>| {'a, N, X, Y>>() let variant = unsafe { variant.assume_initialized() };'a, N, X, Y> as ::zerocopy ::TryFromBytes>::is_bit_valid ( let variant = unsafe {'_, ___ZerocopyVariants<' a, N, X, Y>>| {'a, N, X, Y>>() let variant = unsafe { variant.assume_initialized() };'a, N, X, Y> as ::zerocopy ::TryFromBytes>::is_bit_valid ( false ,#[ repr(C)]enum ComplexWithGenerics<'a: ' static , const N: usize, X, Y: Deref>where 'a [(X, Y); N]>, 'a [(X, Y); N]>), #[ allow(deprecated)]#[ automatically_derived]unsafe impl <'a: ' static , const N: usize, X, Y: Deref> ::zerocopy::TryFromBytesfor ComplexWithGenerics<'a, { N }, X, Y> where 'a [(X, Y); N]>, 'a [(X, Y); N]>: ::zerocopy::TryFromBytes, fn only_derive_is_allowed_to_implement_this_trait() {}fn is_bit_valid<___ZerocopyAliasing>(mut candidate: ::zerocopy::Maybe<'_, Self, ___ZerocopyAliasing>, where use ::zerocopy::util::macro_util::core_reexport;#[ repr(C)]#[ allow(dead_code, non_camel_case_types)]enum ___ZerocopyTag {type ___ZerocopyTagPrimitive = ::zerocopy::util::macro_util::SizeToTag<#[ allow(non_upper_case_globals)]const ___ZEROCOPY_TAG_UnitLike: ___ZerocopyTagPrimitive =as ___ZerocopyTagPrimitive;#[ allow(non_upper_case_globals)]const ___ZEROCOPY_TAG_StructLike: ___ZerocopyTagPrimitive =as ___ZerocopyTagPrimitive;#[ allow(non_upper_case_globals)]const ___ZEROCOPY_TAG_TupleLike: ___ZerocopyTagPrimitive =as ___ZerocopyTagPrimitive;type ___ZerocopyOuterTag = ___ZerocopyTag;type ___ZerocopyInnerTag = ();#[ repr(C)]#[ allow(non_snake_case)]struct ___ZerocopyVariantStruct_StructLike<'a: ' static , const N: usize, X, Y: Deref>('a, N, X, Y>>, where 'a [(X, Y); N]>; #[ allow(deprecated)]#[ automatically_derived]unsafe impl <'a: ' static , const N: usize, X, Y: Deref> ::zerocopy::TryFromBytesfor ___ZerocopyVariantStruct_StructLike<'a, { N }, X, Y> where 'a [(X, Y); N]>, 'a, N, X, Y>>: fn only_derive_is_allowed_to_implement_this_trait() {}fn is_bit_valid<___ZerocopyAliasing>(mut candidate: ::zerocopy::Maybe<Self , ___ZerocopyAliasing>,where use ::zerocopy::util::macro_util::core_reexport;use ::zerocopy::pointer::PtrInner;true && {let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).0 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).1 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).2 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).3 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).4 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).5 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).6 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }'a, N, X, Y>, as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)#[ repr(C)]#[ allow(non_snake_case)]struct ___ZerocopyVariantStruct_TupleLike<'a: ' static , const N: usize, X, Y: Deref>('a [(X, Y); N]>, 'a, N, X, Y>>, where 'a [(X, Y); N]>; #[ allow(deprecated)]#[ automatically_derived]unsafe impl <'a: ' static , const N: usize, X, Y: Deref> ::zerocopy::TryFromBytesfor ___ZerocopyVariantStruct_TupleLike<'a, { N }, X, Y> where 'a [(X, Y); N]>, 'a [(X, Y); N]>: ::zerocopy::TryFromBytes, 'a, N, X, Y>>: fn only_derive_is_allowed_to_implement_this_trait() {}fn is_bit_valid<___ZerocopyAliasing>(mut candidate: ::zerocopy::Maybe<Self , ___ZerocopyAliasing>,where use ::zerocopy::util::macro_util::core_reexport;use ::zerocopy::pointer::PtrInner;true && {let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).0 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).1 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).2 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).3 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }'a [(X, Y); N]> as ::zerocopy::TryFromBytes>::is_bit_valid( let field_candidate = unsafe {let project = |slf: PtrInner<'_, Self>| { let slf = slf.as_non_null().as_ptr();let field = core_reexport::ptr::addr_of_mut!((*slf).4 );let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(field) };unsafe { PtrInner::new(ptr) }'a, N, X, Y>, as ::zerocopy::TryFromBytes>::is_bit_valid(field_candidate)#[ repr(C)]#[ allow(non_snake_case)]'a: ' static , const N: usize, X, Y: Deref> {'a, N, X, Y>>, 'a, N, X, Y>>, #[ repr(C)]struct ___ZerocopyRawEnum<'a: ' static , const N: usize, X, Y: Deref> {'a, N, X, Y>, let tag = {let tag_ptr = unsafe {'_, Self>| { p.cast_sized::<___ZerocopyTagPrimitive> ()}) let tag_ptr = unsafe { tag_ptr.assume_initialized() };ble>()let raw_enum = unsafe {'_, Self>| { p.cast_sized::<___ZerocopyRawEnum<' a, N, X, Y>> ()})let raw_enum = unsafe { raw_enum.assume_initialized() };let variants = unsafe {use ::zerocopy::pointer::PtrInner;'_, ___ZerocopyRawEnum<' a, N, X, Y>>| {let p = p.as_non_null().as_ptr();let ptr = core_reexport::ptr::addr_of_mut!((*p).variants);let ptr = unsafe { core_reexport::ptr::NonNull::new_unchecked(ptr) };unsafe { PtrInner::new(ptr) }#[ allow(non_upper_case_globals)]match tag {true ,let variant = unsafe {'_, ___ZerocopyVariants<' a, N, X, Y>>| {'a, N, X, Y>>() let variant = unsafe { variant.assume_initialized() };'a, N, X, Y> as ::zerocopy ::TryFromBytes>::is_bit_valid ( let variant = unsafe {'_, ___ZerocopyVariants<' a, N, X, Y>>| {'a, N, X, Y>>() let variant = unsafe { variant.assume_initialized() };'a, N, X, Y> as ::zerocopy ::TryFromBytes>::is_bit_valid ( false ,// This goes at the bottom because it's so verbose and it makes scrolling past // other code a pain. #[ test]fn test_from_bytes_enum() {#[ repr(u8)]enum Foo {#[ allow(deprecated)]#[ automatically_derived]unsafe impl ::zerocopy::TryFromBytes for Foo {fn only_derive_is_allowed_to_implement_this_trait() {}fn is_bit_valid<___ZerocopyAliasing>(Self , ___ZerocopyAliasing>,where if false {fn assert_is_from_bytes<T>()where Self >();true #[ allow(deprecated)]#[ automatically_derived]unsafe impl ::zerocopy::FromZeros for Foo {fn only_derive_is_allowed_to_implement_this_trait() {}#[ allow(deprecated)]#[ automatically_derived]unsafe impl ::zerocopy::FromBytes for Foo {fn only_derive_is_allowed_to_implement_this_trait() {}#[ test]fn test_try_from_bytes_trivial_is_bit_valid_enum() {// Even when we aren't deriving `FromBytes` as the top-level trait, // `TryFromBytes` on enums still detects whether we *could* derive // `FromBytes`, and if so, performs the same "trivial `is_bit_valid`" // optimization. #[ repr(u8)]enum Foo {#[ allow(deprecated)]#[ automatically_derived]unsafe impl ::zerocopy::TryFromBytes for Foo {fn only_derive_is_allowed_to_implement_this_trait() {}fn is_bit_valid<___ZerocopyAliasing>(Self , ___ZerocopyAliasing>,where true #[ test]fn test_hash() {struct Foo<T: Clone>(T) where Self : Sized;#[ allow(deprecated)]#[ automatically_derived]impl <T: Clone> ::zerocopy::util::macro_util::core_reexport::hash::Hash for Foo<T>where Self : ::zerocopy::IntoBytes + ::zerocopy::Immutable,Self : Sized,fn hash<H>(&self , state: &mut H)where self )fn hash_slice<H>(data: &[Self ], state: &mut H)where #[ test]fn test_eq() {struct Foo<T: Clone>(T) where Self : Sized;#[ allow(deprecated)]#[ automatically_derived]impl <T: Clone> ::zerocopy::util::macro_util::core_reexport::cmp::PartialEq for Foo<T>where Self : ::zerocopy::IntoBytes + ::zerocopy::Immutable,Self : Sized,fn eq(&self , other: &Self ) -> bool {self ),#[ allow(deprecated)]#[ automatically_derived]impl <T: Clone> ::zerocopy::util::macro_util::core_reexport::cmp::Eq for Foo<T>where Self : ::zerocopy::IntoBytes + ::zerocopy::Immutable,Self : Sized,#[ test]fn test_split_at() {#[ repr(C)]struct Foo<T: ?Sized + Copy>(T) where Self : Copy;#[ allow(deprecated)]#[ automatically_derived]unsafe impl <T: ?Sized + Copy> ::zerocopy::SplitAt for Foo<T>where Self : Copy,fn only_derive_is_allowed_to_implement_this_trait() {}type Elem = <T as ::zerocopy::SplitAt>::Elem;#[ repr(transparent)]struct Foo<T: ?Sized + Copy>(T) where Self : Copy;#[ allow(deprecated)]#[ automatically_derived]unsafe impl <T: ?Sized + Copy> ::zerocopy::SplitAt for Foo<T>where Self : Copy,fn only_derive_is_allowed_to_implement_this_trait() {}type Elem = <T as ::zerocopy::SplitAt>::Elem;#[ repr(packed)]struct Foo<T: ?Sized + Copy>(T) where Self : Copy;"must not have #[repr(packed)] attribute" #[ repr(packed(2 ))]struct Foo<T: ?Sized + Copy>(T) where Self : Copy;"must not have #[repr(packed)] attribute" enum Foo {}"can only be applied to structs" "can only be applied to structs" struct Foo<T: ?Sized + Copy>(T) where Self : Copy;"must have #[repr(C)] or #[repr(transparent)] in order to guarantee this type's layout is splitable" Messung V0.5 in Prozent C=100 H=63 G=83
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.62Bemerkung:
(vorverarbeitet am 2026-08-27)
¤ *Bot Zugriff
