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

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use crate::util::{add_predicate, fmap2_match, parse_field_attrs, parse_input_attrs};
use darling::{FromDeriveInput, FromField};
use proc_macro2::TokenStream;
use quote::quote;
use syn::{self, parse_quote};
use synstructure::{BindStyle, Structure};

pub fn derive(mut input: syn::DeriveInput) -> TokenStream {
    let mut where_clause = input.generics.where_clause.take();
    let attrs = parse_input_attrs::<ShmemInputAttrs>(&input);
    if !attrs.no_bounds {
        for param in input.generics.type_params() {
            add_predicate(&mut where_clause, parse_quote!(#param: ::to_shmem::ToShmem));
        }
    }
    for variant in Structure::new(&input).variants() {
        for binding in variant.bindings() {
            let attrs = parse_field_attrs::<ShmemFieldAttrs>(&binding.ast());
            if attrs.field_bound {
                let ty = &binding.ast().ty;
                add_predicate(&mut where_clause, parse_quote!(#ty: ::to_shmem::ToShmem))
            }
        }
    }

    input.generics.where_clause = where_clause;

    // Do all of the `to_shmem()?` calls before the `ManuallyDrop::into_inner()`
    // calls, so that we don't drop a value in the shared memory buffer if one
    // of the `to_shmem`s fails.
    let match_body = fmap2_match(
        &input,
        BindStyle::Ref,
        |binding| {
            quote! {
                ::to_shmem::ToShmem::to_shmem(#binding, builder)?
            }
        },
        |binding| {
            Some(quote! {
                ::std::mem::ManuallyDrop::into_inner(#binding)
            })
        },
    );

    let name = &input.ident;
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();

    quote! {
        impl #impl_generics ::to_shmem::ToShmem for #name #ty_generics #where_clause {
            #[allow(unused_variables, unreachable_code)]
            fn to_shmem(
                &self,
                builder: &mut ::to_shmem::SharedMemoryBuilder,
            ) -> ::to_shmem::Result<Self> {
                Ok(::std::mem::ManuallyDrop::new(
                    match *self {
                        #match_body
                    }
                ))
            }
        }
    }
}

#[derive(Default, FromDeriveInput)]
#[darling(attributes(shmem), default)]
pub struct ShmemInputAttrs {
    pub no_bounds: bool,
}

#[derive(Default, FromField)]
#[darling(attributes(shmem), default)]
pub struct ShmemFieldAttrs {
    pub field_bound: bool,
}