xmlity-derive 0.0.9

Derive proc-macros for xmlity.
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

mod none;

use std::borrow::Cow;

pub use none::{DeriveEnum, RecordSerializeValueBuilder};
mod element;
pub use element::{RecordSerializeElementBuilder, SingleChildSerializeElementBuilder};
mod variant;

use quote::ToTokens;
use syn::{DeriveInput, Ident};

use crate::common::{self, RecordInput};
use crate::options::{enums, records};
use crate::{DeriveError, DeriveMacro};

use super::builders::{SerializeBuilder, SerializeBuilderExt};

pub struct RecordSerializeBuilder<'a, T: Fn(syn::Expr) -> syn::Expr> {
    pub input: &'a RecordInput<'a, T>,
    pub options: &'a records::roots::SerializeRootOpts,
}

impl<'a, T: Fn(syn::Expr) -> syn::Expr> RecordSerializeBuilder<'a, T> {
    pub fn new(
        input: &'a RecordInput<'a, T>,
        options: &'a records::roots::SerializeRootOpts,
    ) -> Self {
        Self { input, options }
    }
}

impl<T: Fn(syn::Expr) -> syn::Expr> SerializeBuilder for RecordSerializeBuilder<'_, T> {
    fn serialize_fn_body(
        &self,
        serializer_access: &Ident,
        serializer_type: &syn::Type,
    ) -> Result<Vec<syn::Stmt>, DeriveError> {
        use records::roots::SerializeRootOpts;
        match &self.options {
            SerializeRootOpts::Element(opts) => {
                RecordSerializeElementBuilder::new(self.input, opts)
                    .serialize_fn_body(serializer_access, serializer_type)
            }
            SerializeRootOpts::Value(opts) => {
                RecordSerializeValueBuilder::new(self.input, Some(opts))
                    .serialize_fn_body(serializer_access, serializer_type)
            }
            SerializeRootOpts::None => RecordSerializeValueBuilder::new(self.input, None)
                .serialize_fn_body(serializer_access, serializer_type),
        }
    }

    fn ident(&self) -> Cow<'_, syn::Ident> {
        Cow::Borrowed(self.input.impl_for_ident.as_ref())
    }

    fn generics(&self) -> Cow<'_, syn::Generics> {
        Cow::Borrowed(self.input.generics.as_ref())
    }
}

pub struct DeriveSerialize;

impl DeriveMacro for DeriveSerialize {
    fn input_to_derive(ast: &DeriveInput) -> Result<proc_macro2::TokenStream, DeriveError> {
        match &ast.data {
            syn::Data::Struct(_) => {
                let record = common::parse_struct_derive_input(ast)?;
                let opts = records::roots::SerializeRootOpts::parse(&ast.attrs)?;
                match opts {
                    records::roots::SerializeRootOpts::Element(opts) => {
                        RecordSerializeElementBuilder::new(&record, &opts)
                            .serialize_trait_impl()
                            .map(|a| a.to_token_stream())
                    }
                    records::roots::SerializeRootOpts::Value(opts) => {
                        RecordSerializeValueBuilder::new(&record, Some(&opts))
                            .serialize_trait_impl()
                            .map(|a| a.to_token_stream())
                    }
                    records::roots::SerializeRootOpts::None => {
                        RecordSerializeValueBuilder::new(&record, None)
                            .serialize_trait_impl()
                            .map(|a| a.to_token_stream())
                    }
                }
            }
            syn::Data::Enum(_) => {
                let opts = enums::roots::RootOpts::parse(ast)?;

                match opts {
                    enums::roots::RootOpts::Value(opts) => DeriveEnum::new(ast, Some(&opts))
                        .serialize_trait_impl()
                        .map(|a| a.to_token_stream()),
                    enums::roots::RootOpts::None => DeriveEnum::new(ast, None)
                        .serialize_trait_impl()
                        .map(|a| a.to_token_stream()),
                }
            }
            syn::Data::Union(_) => Err(DeriveError::custom(
                "Unions are not supported for serialization.",
            )),
        }
    }
}