zerocopy-derive 0.8.50

Custom derive for traits from the zerocopy crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

// 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.

// See comment in `include.rs` for why we disable the prelude.
#![no_implicit_prelude]
#![allow(warnings)]
#![deny(deprecated)]

include!("include.rs");

// Make sure no deprecation warnings are generated from our derives (see #553).

#[macro_export]
macro_rules! test {
    ($name:ident => $ty:item => $($trait:ident),*) => {
        #[allow(non_snake_case)]
        mod $name {
            $(
                mod $trait {
                    use super::super::*;

                    #[deprecated = "do not use"]
                    #[derive(imp::$trait)]
                    #[zerocopy(crate = "zerocopy_renamed")]
                    $ty

                    #[allow(deprecated)]
                    fn _allow_deprecated() {
                        util_assert_impl_all!($name: imp::$trait);
                    }
                }
            )*
        }
    };
}

// NOTE: `FromBytes` is tested separately in `enum_from_bytes.rs` since it
// requires 256-variant enums which are extremely verbose; such enums are
// already in that file.
test!(Enum => #[repr(u8)] enum Enum { A, } => TryFromBytes, FromZeros, KnownLayout, Immutable, IntoBytes, Unaligned);

test!(Struct => #[repr(C)] struct Struct; => TryFromBytes, FromZeros, FromBytes, KnownLayout, Immutable, IntoBytes, Unaligned);

test!(Union => #[repr(C)] union Union{ a: (), } => TryFromBytes, FromZeros, FromBytes, KnownLayout, Immutable, IntoBytes, Unaligned);

// Tests for ByteHash and ByteEq which require IntoBytes + Immutable
mod enum_hash_eq {
    mod ByteHash {
        use super::super::*;
        #[deprecated = "do not use"]
        #[derive(imp::ByteHash, imp::IntoBytes, imp::Immutable)]
        #[zerocopy(crate = "zerocopy_renamed")]
        #[repr(u8)]
        enum Enum {
            A,
        }

        #[allow(deprecated)]
        fn _allow_deprecated() {
            util_assert_impl_all!(Enum: ::core::hash::Hash);
        }
    }
    mod ByteEq {
        use super::super::*;
        #[deprecated = "do not use"]
        #[derive(imp::ByteEq, imp::IntoBytes, imp::Immutable)]
        #[zerocopy(crate = "zerocopy_renamed")]
        #[repr(u8)]
        enum Enum {
            A,
        }

        #[allow(deprecated)]
        fn _allow_deprecated() {
            util_assert_impl_all!(Enum: ::core::cmp::PartialEq, ::core::cmp::Eq);
        }
    }
}

mod struct_hash_eq {
    mod ByteHash {
        use super::super::*;
        #[deprecated = "do not use"]
        #[derive(imp::ByteHash, imp::IntoBytes, imp::Immutable)]
        #[zerocopy(crate = "zerocopy_renamed")]
        #[repr(C)]
        struct Struct;

        #[allow(deprecated)]
        fn _allow_deprecated() {
            util_assert_impl_all!(Struct: ::core::hash::Hash);
        }
    }
    mod ByteEq {
        use super::super::*;
        #[deprecated = "do not use"]
        #[derive(imp::ByteEq, imp::IntoBytes, imp::Immutable)]
        #[zerocopy(crate = "zerocopy_renamed")]
        #[repr(C)]
        struct Struct;

        #[allow(deprecated)]
        fn _allow_deprecated() {
            util_assert_impl_all!(Struct: ::core::cmp::PartialEq, ::core::cmp::Eq);
        }
    }
}

// Tests for SplitAt which requires repr(C) and at least one field
mod split_at_test {
    mod SplitAt {
        use super::super::*;
        #[deprecated = "do not use"]
        #[derive(imp::SplitAt, imp::KnownLayout)]
        #[zerocopy(crate = "zerocopy_renamed")]
        #[repr(C)]
        struct Struct {
            a: [u8],
        }

        #[allow(deprecated)]
        fn _allow_deprecated() {
            util_assert_impl_all!(Struct: imp::SplitAt);
        }
    }
}