cgp-macro-lib 0.6.1

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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use quote::quote;
use syn::{Arm, GenericArgument, Ident, ItemEnum, ItemImpl, Type, parse2};

use crate::derive_builder::{index_to_generic_ident, to_generic_args};
use crate::derive_extractor::get_variant_type;
use crate::symbol::symbol_from_string;

pub fn derive_extract_field_impls(
    context_enum: &ItemEnum,
    extractor_ident: &Ident,
    is_ref: bool,
) -> syn::Result<Vec<ItemImpl>> {
    let mut item_impls = Vec::new();

    let generics = {
        let mut generics = context_enum.generics.clone();

        if is_ref {
            generics.params.insert(
                0,
                parse2(quote! {
                    '__a__
                })?,
            );

            generics.params.insert(
                1,
                parse2(quote! {
                    __R__: MapTypeRef
                })?,
            );
        }

        generics
    };

    let base_generic_args = to_generic_args(&generics)?;

    for (current_index, current_variant) in context_enum.variants.iter().enumerate() {
        let mut generics = generics.clone();
        let mut source_generic_args = base_generic_args.args.clone();
        let mut output_generic_args = base_generic_args.args.clone();
        let mut match_arms = Vec::<Arm>::new();

        for (other_index, other_variant) in context_enum.variants.iter().enumerate() {
            let variant_ident = &other_variant.ident;

            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);

                match_arms.push(parse2(quote! {
                    #extractor_ident :: #variant_ident ( value ) => {
                        Err(#extractor_ident :: #variant_ident ( value ))
                    }
                })?);
            } else {
                source_generic_args.push(parse2(quote! { IsPresent })?);
                output_generic_args.push(parse2(quote! { IsVoid })?);

                match_arms.push(parse2(quote! {
                    #extractor_ident :: #variant_ident ( value ) => {
                        Ok( value )
                    }
                })?);
            }
        }

        let value_type = {
            let value_type = get_variant_type(current_variant)?;

            if is_ref {
                parse2(quote! { <__R__ as MapTypeRef>::Map<'__a__, #value_type> })?
            } else {
                value_type.clone()
            }
        };

        let tag_type = symbol_from_string(&current_variant.ident.to_string());

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

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

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

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

                type Remainder = #output_type;

                fn extract_field(self, _tag: ::core::marker::PhantomData< #tag_type >) -> Result<Self::Value, Self::Remainder> {
                    match self {
                        #(#match_arms)*
                    }
                }
            }
        })?;

        item_impls.push(item_impl);
    }

    Ok(item_impls)
}