cgp-macro-lib 0.7.0

Context-generic programming core component macros implemented as a library.
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

use quote::quote;
use syn::punctuated::Punctuated;
use syn::token::Comma;
use syn::{FieldValue, GenericArgument, Ident, ItemImpl, ItemStruct, Type, parse2};

use crate::derive_builder::{
    field_to_member, field_to_tag, field_value_expr, index_to_generic_ident, to_generic_args,
};

pub fn derive_update_field_impls(
    context_struct: &ItemStruct,
    builder_ident: &Ident,
) -> syn::Result<Vec<ItemImpl>> {
    let mut item_impls = Vec::new();

    let base_generic_args = to_generic_args(&context_struct.generics)?;

    for (current_index, current_field) in context_struct.fields.iter().enumerate() {
        let value_type = &current_field.ty;

        let mut generics = context_struct.generics.clone();
        let mut source_generic_args = base_generic_args.args.clone();
        let mut output_generic_args = base_generic_args.args.clone();
        let mut builder_fields = <Punctuated<FieldValue, Comma>>::new();

        for (other_index, other_field) in context_struct.fields.iter().enumerate() {
            let field_member = field_to_member(other_index, other_field);

            if other_index != current_index {
                let generic_param_name = index_to_generic_ident(other_index);

                generics.params.push(parse2(quote! {
                    #generic_param_name: MapType
                })?);

                let generic_arg: GenericArgument = parse2(quote! { #generic_param_name })?;
                source_generic_args.push(generic_arg.clone());
                output_generic_args.push(generic_arg);

                builder_fields.push(field_value_expr(
                    field_member.clone(),
                    quote! { self. #field_member },
                )?);
            } else {
                source_generic_args.push(parse2(quote! { __M1__ })?);
                output_generic_args.push(parse2(quote! { __M2__ })?);

                generics.params.push(parse2(quote! {
                    __M1__: MapType
                })?);

                generics.params.push(parse2(quote! {
                    __M2__: MapType
                })?);

                builder_fields.push(field_value_expr(field_member, quote! { value })?);
            }
        }

        let source_type: Type = parse2(quote! {
            #builder_ident < #source_generic_args >
        })?;

        let output_type: Type = parse2(quote! {
            #builder_ident < #output_generic_args >
        })?;

        let tag_type = field_to_tag(current_index, current_field)?;

        let (impl_generics, _, where_clause) = generics.split_for_impl();

        let member = field_to_member(current_index, current_field);

        let item_impl = parse2(quote! {
            impl #impl_generics UpdateField< #tag_type, __M2__ >
                for #source_type
            #where_clause
            {
                type Value = #value_type;

                type Mapper = __M1__;

                type Output = #output_type;

                fn update_field(
                    self,
                    _tag: ::core::marker::PhantomData< #tag_type >,
                    value: __M2__::Map<Self::Value>,
                ) -> (__M1__::Map<Self::Value>, Self::Output) {
                    (
                        self. #member,
                        #builder_ident {
                            #builder_fields
                        },
                    )
                }
            }
        })?;

        item_impls.push(item_impl);
    }

    Ok(item_impls)
}