// 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.32Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-10-01)
¤ *Eine klare Vorstellung vom Zielzustand
