light-zero-copy-derive 0.7.0

Proc macro for zero-copy deserialization
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

use syn::parse_quote;

use crate::shared::utils::*;

// Helper function to check if a struct implements Copy
fn check_struct_implements_copy(input: syn::DeriveInput) -> bool {
    struct_implements_copy(&input)
}

#[test]
fn test_struct_implements_copy() {
    // Ensure the cache is cleared for testing
    if let Ok(mut cache) = COPY_IMPL_CACHE.lock() {
        cache.clear();
    }
    // Test case 1: Empty struct with #[derive(Copy)]
    let input: syn::DeriveInput = parse_quote! {
        #[derive(Copy, Clone)]
        struct EmptyStruct {}
    };
    assert!(
        check_struct_implements_copy(input),
        "EmptyStruct should implement Copy with #[derive(Copy)]"
    );

    // Test case 2: Simple struct with #[derive(Copy)]
    let input: syn::DeriveInput = parse_quote! {
        #[derive(Copy, Clone)]
        struct SimpleStruct {
            a: u8,
            b: u16,
        }
    };
    assert!(
        check_struct_implements_copy(input),
        "SimpleStruct should implement Copy with #[derive(Copy)]"
    );

    // Test case 3: Struct with #[derive(Clone)] but not Copy
    let input: syn::DeriveInput = parse_quote! {
        #[derive(Clone)]
        struct StructWithoutCopy {
            a: u8,
            b: u16,
        }
    };
    assert!(
        !check_struct_implements_copy(input),
        "StructWithoutCopy should not implement Copy without #[derive(Copy)]"
    );

    // Test case 4: Struct with a non-Copy field but with derive(Copy)
    // Note: In real Rust code, this would not compile, but for our test we only check attributes
    let input: syn::DeriveInput = parse_quote! {
        #[derive(Copy, Clone)]
        struct StructWithVec {
            a: u8,
            b: Vec<u8>,
        }
    };
    assert!(
        check_struct_implements_copy(input),
        "StructWithVec has #[derive(Copy)] so our function returns true"
    );

    // Test case 5: Struct with all Copy fields but without #[derive(Copy)]
    let input: syn::DeriveInput = parse_quote! {
        struct StructWithCopyFields {
            a: u8,
            b: u16,
            c: i32,
            d: bool,
        }
    };
    assert!(
        !check_struct_implements_copy(input),
        "StructWithCopyFields should not implement Copy without #[derive(Copy)]"
    );

    // Test case 6: Unit struct without #[derive(Copy)]
    let input: syn::DeriveInput = parse_quote! {
        struct UnitStructWithoutCopy;
    };
    assert!(
        !check_struct_implements_copy(input),
        "UnitStructWithoutCopy should not implement Copy without #[derive(Copy)]"
    );

    // Test case 7: Unit struct with #[derive(Copy)]
    let input: syn::DeriveInput = parse_quote! {
        #[derive(Copy, Clone)]
        struct UnitStructWithCopy;
    };
    assert!(
        check_struct_implements_copy(input),
        "UnitStructWithCopy should implement Copy with #[derive(Copy)]"
    );

    // Test case 8: Tuple struct with #[derive(Copy)]
    let input: syn::DeriveInput = parse_quote! {
        #[derive(Copy, Clone)]
        struct TupleStruct(u32, bool, char);
    };
    assert!(
        check_struct_implements_copy(input),
        "TupleStruct should implement Copy with #[derive(Copy)]"
    );

    // Test case 9: Multiple derives including Copy
    let input: syn::DeriveInput = parse_quote! {
        #[derive(Debug, PartialEq, Copy, Clone)]
        struct MultipleDerivesStruct {
            a: u8,
        }
    };
    assert!(
        check_struct_implements_copy(input),
        "MultipleDerivesStruct should implement Copy with #[derive(Copy)]"
    );
}