ic-stable-memory-derive 0.4.2

Derive macros for ic-stable-memory
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use proc_macro2::{self, TokenStream};
use quote::{format_ident, quote};
use syn::{Data, Fields, Generics, Ident, Index};

pub fn derive_stable_type_impl(ident: &Ident, data: &Data, generics: &Generics) -> TokenStream {
    if !generics.params.is_empty() {
        panic!("Generics not supported");
    }

    let (flag_off_body, flag_on_body) = match data {
        Data::Struct(d) => {
            let mut flag_off_body = quote! {};
            let mut flag_on_body = quote! {};

            for (idx, f) in d.fields.iter().enumerate() {
                let t = &f.ty;

                if let Some(i) = f.ident.clone() {
                    flag_off_body = quote! { #flag_off_body <#t as ic_stable_memory::StableType>::stable_drop_flag_off(&mut self.#i); };
                    flag_on_body = quote! { #flag_on_body <#t as ic_stable_memory::StableType>::stable_drop_flag_on(&mut self.#i); };
                } else {
                    let idx = Index::from(idx);

                    flag_off_body = quote! { #flag_off_body <#t as ic_stable_memory::StableType>::stable_drop_flag_off(&mut self.#idx); };
                    flag_on_body = quote! { #flag_on_body <#t as ic_stable_memory::StableType>::stable_drop_flag_on(&mut self.#idx); };
                };
            }

            (flag_off_body, flag_on_body)
        }
        Data::Enum(d) => {
            let mut flag_off_body_total = quote! {};
            let mut flag_on_body_total = quote! {};

            for v in d.variants.iter() {
                let v_name = &v.ident;

                let mut flag_off_body = quote! {};
                let mut flag_on_body = quote! {};

                let mut enum_header = quote! {};

                for (idx, f) in v.fields.iter().enumerate() {
                    let t = &f.ty;

                    if let Some(i) = f.ident.clone() {
                        enum_header = quote! { #enum_header #i, };

                        flag_off_body = quote! { #flag_off_body <#t as ic_stable_memory::StableType>::stable_drop_flag_off(#i); };
                        flag_on_body = quote! { #flag_on_body <#t as ic_stable_memory::StableType>::stable_drop_flag_on(#i); };
                    } else {
                        let val_i = format_ident!("val_{}", idx);

                        enum_header = quote! { #enum_header #val_i, };

                        flag_off_body = quote! { #flag_off_body <#t as ic_stable_memory::StableType>::stable_drop_flag_off(#val_i); };
                        flag_on_body = quote! { #flag_on_body <#t as ic_stable_memory::StableType>::stable_drop_flag_on(#val_i); };
                    };
                }

                (flag_off_body_total, flag_on_body_total) = match &v.fields {
                    Fields::Unit => {
                        let owned = quote! {
                            #flag_off_body_total
                            Self::#v_name => {}
                        };

                        let not_owned = quote! {
                            #flag_on_body_total
                            Self::#v_name => {}
                        };

                        (owned, not_owned)
                    }
                    Fields::Named(_) => {
                        let owned = quote! {
                            #flag_off_body_total
                            Self::#v_name { #enum_header } => {
                                #flag_off_body
                            }
                        };

                        let not_owned = quote! {
                            #flag_on_body_total
                            Self::#v_name { #enum_header } => {
                                #flag_on_body
                            }
                        };

                        (owned, not_owned)
                    }
                    Fields::Unnamed(_) => {
                        let owned = quote! {
                            #flag_off_body_total
                            Self::#v_name(#enum_header) => {
                                #flag_off_body
                            }
                        };

                        let not_owned = quote! {
                            #flag_on_body_total
                            Self::#v_name(#enum_header) => {
                                #flag_on_body
                            }
                        };

                        (owned, not_owned)
                    }
                };
            }

            flag_off_body_total = quote! {
                unsafe {
                    match self {
                        #flag_off_body_total
                    }
                }
            };

            flag_on_body_total = quote! {
                unsafe {
                    match self {
                        #flag_on_body_total
                    }
                }
            };

            (flag_off_body_total, flag_on_body_total)
        }
        _ => panic!("Unions not supported!"),
    };

    quote! {
        impl ic_stable_memory::StableType for #ident {
            #[inline]
            unsafe fn stable_drop_flag_off(&mut self) {
                #flag_off_body
            }

            #[inline]
            unsafe fn stable_drop_flag_on(&mut self) {
                #flag_on_body
            }
        }
    }
}