darling_core/codegen/
from_meta_impl.rs

Help
1use proc_macro2::TokenStream;
2use quote::{quote, ToTokens};
3
4use crate::ast::{Data, Fields, Style};
5use crate::codegen::{Field, OuterFromImpl, TraitImpl, Variant};
6
7pub struct FromMetaImpl<'a> {
8    pub base: TraitImpl<'a>,
9}
10
11impl<'a> ToTokens for FromMetaImpl<'a> {
12    fn to_tokens(&self, tokens: &mut TokenStream) {
13        let base = &self.base;
14
15        let impl_block = match base.data {
16            // Unit structs allow empty bodies only.
17            Data::Struct(ref vd) if vd.style.is_unit() => {
18                let ty_ident = base.ident;
19                quote!(
20                    fn from_word() -> ::darling::Result<Self> {
21                        ::darling::export::Ok(#ty_ident)
22                    }
23                )
24            }
25
26            // Newtype structs proxy to the sole value they contain.
27            Data::Struct(Fields {
28                ref fields,
29                style: Style::Tuple,
30                ..
31            }) if fields.len() == 1 => {
32                let ty_ident = base.ident;
33                quote!(
34                    fn from_meta(__item: &::darling::export::syn::Meta) -> ::darling::Result<Self> {
35                        ::darling::FromMeta::from_meta(__item)
36                            .map_err(|e| e.with_span(&__item))
37                            .map(#ty_ident)
38                    }
39                )
40            }
41            Data::Struct(Fields {
42                style: Style::Tuple,
43                ..
44            }) => {
45                panic!("Multi-field tuples are not supported");
46            }
47            Data::Struct(ref data) => {
48                let inits = data.fields.iter().map(Field::as_initializer);
49                let declare_errors = base.declare_errors();
50                let require_fields = base.require_fields();
51                let check_errors = base.check_errors();
52                let decls = base.local_declarations();
53                let core_loop = base.core_loop();
54                let default = base.fallback_decl();
55                let post_transform = base.post_transform_call();
56
57                quote!(
58                    fn from_list(__items: &[::darling::export::NestedMeta]) -> ::darling::Result<Self> {
59
60                        #decls
61
62                        #declare_errors
63
64                        #core_loop
65
66                        #require_fields
67
68                        #check_errors
69
70                        #default
71
72                        ::darling::export::Ok(Self {
73                            #(#inits),*
74                        }) #post_transform
75                    }
76                )
77            }
78            Data::Enum(ref variants) => {
79                let unit_arms = variants.iter().map(Variant::as_unit_match_arm);
80
81                let unknown_variant_err = if !variants.is_empty() {
82                    let names = variants.iter().map(Variant::as_name);
83                    quote! {
84                        unknown_field_with_alts(__other, &[#(#names),*])
85                    }
86                } else {
87                    quote! {
88                        unknown_field(__other)
89                    }
90                };
91
92                let word_or_err = variants
93                    .iter()
94                    .find_map(|variant| {
95                        if variant.word {
96                            let ty_ident = variant.ty_ident;
97                            let variant_ident = variant.variant_ident;
98                            Some(quote!(::darling::export::Ok(#ty_ident::#variant_ident)))
99                        } else {
100                            None
101                        }
102                    })
103                    .unwrap_or_else(|| {
104                        quote!(::darling::export::Err(
105                            ::darling::Error::unsupported_format("word")
106                        ))
107                    });
108
109                quote!(
110                    fn from_list(__outer: &[::darling::export::NestedMeta]) -> ::darling::Result<Self> {
111                        // An enum must have exactly one value inside the parentheses if it's not a unit
112                        // match arm.
113                        match __outer.len() {
114                            0 => ::darling::export::Err(::darling::Error::too_few_items(1)),
115                            1 => {
116                                if let ::darling::export::NestedMeta::Meta(ref __nested) = __outer[0] {
117                                    match ::darling::util::path_to_string(__nested.path()).as_ref() {
118                                        #(#variants)*
119                                        __other => ::darling::export::Err(::darling::Error::#unknown_variant_err.with_span(__nested))
120                                    }
121                                } else {
122                                    ::darling::export::Err(::darling::Error::unsupported_format("literal"))
123                                }
124                            }
125                            _ => ::darling::export::Err(::darling::Error::too_many_items(1)),
126                        }
127                    }
128
129                    fn from_string(lit: &str) -> ::darling::Result<Self> {
130                        match lit {
131                            #(#unit_arms)*
132                            __other => ::darling::export::Err(::darling::Error::unknown_value(__other))
133                        }
134                    }
135
136                    fn from_word() -> ::darling::Result<Self> {
137                        #word_or_err
138                    }
139                )
140            }
141        };
142
143        self.wrap(impl_block, tokens);
144    }
145}
146
147impl<'a> OuterFromImpl<'a> for FromMetaImpl<'a> {
148    fn trait_path(&self) -> syn::Path {
149        path!(::darling::FromMeta)
150    }
151
152    fn base(&'a self) -> &'a TraitImpl<'a> {
153        &self.base
154    }
155}
darling_core/codegen/from_meta_impl.rs

darling_core/codegen/
from_meta_impl.rs
