better_default 1.0.5

The std Default derive, but it allows to constomize the default fields values and has some upgrades.
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
147
148
149
150
151
152
153
154

use quote::quote;
use syn::{
    spanned::Spanned, Attribute, DataEnum, DataStruct, DeriveInput,
    Fields,
};

use crate::{
    attrs, default,
    top_attribute,
    Span2, TokenStream2, constants::{self, DefaultTraitPath}
};

fn search_and_mark_default_attribute_on_fields(
    fields: &Fields,
    error_tokens: &mut Vec<TokenStream2>,
) {
    for field in fields {
        if let Some(attribute) = attrs::find_attribute_unique(
            &field.attrs,
            constants::DEFAULT_IDENT,
            error_tokens,
        ) {
            error!(
                error_tokens,
                attribute.meta.span(),
                "You can't use the default attribute on variant fields if the variant is not declared as default."
            );
        }
    }
}

fn get_fields_name(fields: &Fields) -> Vec<String> {
    match fields {
        Fields::Named(named) => named
            .named
            .iter()
            .map(|i| i.ident.as_ref().unwrap().to_string())
            .collect(),
        Fields::Unnamed(_) => (0..fields.len()).map(|i| i.to_string()).collect(),
        Fields::Unit => Vec::new(),
    }
}

fn derive_struct(
    top_attribute: Option<&Attribute>,
    data: &DataStruct,
    error_tokens: &mut Vec<TokenStream2>,
) -> TokenStream2 {
    let field_names = get_fields_name(&data.fields);
    let top_attribute =
        top_attribute.and_then(|attr| top_attribute::get_default_values(attr, &field_names, true, error_tokens));

    let body_tokens = default::derive_body(top_attribute.as_ref(), &data.fields, error_tokens);

    quote! { Self #body_tokens }
}

fn derive_enum(
    top_attribute: Option<&Attribute>,
    data: &DataEnum,
    error_tokens: &mut Vec<TokenStream2>,
) -> TokenStream2 {
    if let Some(attr) = top_attribute {
        error!(
            error_tokens,
            attr.meta.span(),
            "top default attributes are not allowed on enums."
        );
    }

    let mut default_variant = None;
    for variant in &data.variants {
        let Some(attr) = attrs::find_attribute_unique(
            &variant.attrs,
            constants::DEFAULT_IDENT,
            error_tokens,
        ) else {
            search_and_mark_default_attribute_on_fields(&variant.fields, error_tokens);

            continue;
        };

        if let Some((ident, _)) = default_variant.as_ref() {
            error!(
                error_tokens,
                attr.meta.span(),
                "the default value is already assigned to `{}`",
                ident
            );

            continue;
        }

        let field_names = get_fields_name(&variant.fields);
        let top_attribute = top_attribute::get_default_values(attr, &field_names, false, error_tokens);

        let headless_default_tokens =
            default::derive_body(top_attribute.as_ref(), &variant.fields, error_tokens);
        let ident = variant.ident.clone();
        // FIXME: for some reason the "value holding a reference to a value owned by the current function"
        //  error has the Span::call_site() span, and idk why.
        let default_tokens: TokenStream2 = quote! { Self::#ident #headless_default_tokens };

        default_variant = Some((ident, default_tokens));
    }

    if let Some((_, tokens)) = default_variant {
        tokens
    } else {
        error!(
            error_tokens,
            Span2::call_site(),
            "the default variant has not been set."
        );

        quote! { panic!() }
    }
}

pub fn derive(input: &DeriveInput) -> TokenStream2 {
    let mut error_tokens = Vec::new();

    let top_attribute = attrs::find_attribute_unique(
        &input.attrs,
        constants::DEFAULT_IDENT,
        &mut error_tokens,
    );

    let tokens = match &input.data {
        syn::Data::Struct(data) => derive_struct(top_attribute, data, &mut error_tokens),
        syn::Data::Enum(data) => derive_enum(top_attribute, data, &mut error_tokens),
        syn::Data::Union(data) => {
            return error!(
                data.union_token.span(),
                "this derive is not implemented for unions."
            )
            .into_compile_error();
        }
    };

    let ident = &input.ident;
    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
    let error_tokens: TokenStream2 = error_tokens.into_iter().collect();

    quote! {
        impl #impl_generics #DefaultTraitPath for #ident #type_generics #where_clause {
            fn default() -> Self {
                #tokens
            }
        }

        #error_tokens
    }
}