mkutils-macros 0.1.149

Utility methods, traits, and types.
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

use crate::error::Error;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use syn::{Data, DeriveInput, Error as SynError, Expr, Field, Fields, FieldsNamed, FieldsUnnamed};

pub struct Default;

impl Default {
    const ATTRIBUTE_NAME: &str = "default";

    fn std_default_field_value() -> TokenStream2 {
        quote::quote! { ::std::default::Default::default() }
    }

    fn default_field_value(field: &Field) -> Result<TokenStream2, SynError> {
        for attribute in &field.attrs {
            if attribute.path().is_ident(Self::ATTRIBUTE_NAME) {
                let default_field_value = attribute.parse_args::<Expr>()?;
                let default_field_value = quote::quote! { #default_field_value };

                return Ok(default_field_value);
            }
        }

        Ok(Self::std_default_field_value())
    }

    fn default_field_assignment(field: &Field) -> Result<TokenStream2, SynError> {
        let Some(field_name) = &field.ident else {
            return Err(Error::c_struct_field_missing_name(field));
        };
        let default_field_value = Self::default_field_value(field)?;
        let default_field_assignment = quote::quote! { #field_name: #default_field_value };

        Ok(default_field_assignment)
    }

    fn default_value_for_c_struct(fields_named: &FieldsNamed) -> Result<TokenStream2, SynError> {
        let default_field_assignments = fields_named
            .named
            .iter()
            .map(Self::default_field_assignment)
            .collect::<Result<Vec<TokenStream2>, SynError>>()?;
        let default_value = quote::quote! { Self { #(#default_field_assignments),* } };

        Ok(default_value)
    }

    fn default_value_for_tuple_struct(fields_unnamed: &FieldsUnnamed) -> Result<TokenStream2, SynError> {
        let field_values = fields_unnamed
            .unnamed
            .iter()
            .map(Self::default_field_value)
            .collect::<Result<Vec<TokenStream2>, SynError>>()?;
        let default_value = quote::quote! { Self(#(#field_values),*) };

        Ok(default_value)
    }

    fn default_value_for_unit_struct() -> TokenStream2 {
        quote::quote! { Self }
    }

    fn default_value(input: &DeriveInput) -> Result<TokenStream2, SynError> {
        let Data::Struct(data_struct) = &input.data else {
            return Err(Error::unsupported_item_type(input));
        };
        let default_value = match &data_struct.fields {
            Fields::Named(fields_named) => Self::default_value_for_c_struct(fields_named)?,
            Fields::Unnamed(fields_unnamed) => Self::default_value_for_tuple_struct(fields_unnamed)?,
            Fields::Unit => Self::default_value_for_unit_struct(),
        };

        Ok(default_value)
    }

    fn derive_impl(input: &DeriveInput) -> Result<TokenStream2, SynError> {
        let input_ident = &input.ident;
        let (impl_generics, input_generics, input_where_clause) = input.generics.split_for_impl();
        let default_value = Self::default_value(input)?;
        let default_impl_block_token_stream = quote::quote! {
            impl #impl_generics ::std::default::Default for #input_ident #input_generics #input_where_clause {
                fn default() -> Self {
                    #default_value
                }
            }
        };

        Ok(default_impl_block_token_stream)
    }

    pub fn derive(input_token_stream: TokenStream) -> TokenStream {
        let input = syn::parse_macro_input!(input_token_stream);

        Self::derive_impl(&input)
            .unwrap_or_else(SynError::into_compile_error)
            .into()
    }
}