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

use std::collections::BTreeMap;
use std::collections::btree_map::Entry;

use proc_macro2::TokenStream;
use quote::{ToTokens, quote};
use syn::{Ident, ItemTrait, Type, parse_quote, parse2};

use crate::derive_component::{derive_component_with_ast, preprocess_consumer_trait};
use crate::derive_getter::{
    GetterField, derive_use_field_impl, derive_use_fields_impl, derive_with_provider_impl,
    parse_getter_fields,
};
use crate::derive_provider::derive_is_provider_for;
use crate::parse::{ComponentSpec, Entries};

pub fn cgp_getter(attr: TokenStream, body: TokenStream) -> syn::Result<TokenStream> {
    let mut entries = if let Ok(provider_ident) = parse2::<Ident>(attr.clone()) {
        BTreeMap::from([("provider".to_owned(), provider_ident.to_token_stream())])
    } else {
        parse2::<Entries>(attr)?.entries
    };

    let mut consumer_trait: ItemTrait = syn::parse2(body)?;

    preprocess_consumer_trait(&mut consumer_trait)?;

    let provider_entry = entries.entry("provider".to_owned());

    if let Entry::Vacant(entry) = provider_entry {
        let consumer_name = consumer_trait.ident.to_string();
        if let Some(field_name) = consumer_name.strip_prefix("Has")
            && !field_name.is_empty()
        {
            let provider_name =
                Ident::new(&format!("{field_name}Getter"), consumer_trait.ident.span());
            entry.insert(parse2(provider_name.to_token_stream())?);
        }
    }

    let spec = ComponentSpec::from_entries(&entries)?;

    let derived_component = derive_component_with_ast(&spec, consumer_trait.clone())?;

    let (fields, field_assoc_type) = parse_getter_fields(&spec.context_type, &consumer_trait)?;

    let use_fields_impl = derive_use_fields_impl(
        &spec,
        &derived_component.provider_trait,
        &fields,
        &field_assoc_type,
    )?;

    let component_name_type: Type = {
        let component_name = &spec.component_name;
        let component_params = &spec.component_params;
        parse_quote!( #component_name < #component_params > )
    };

    let is_provider_use_fields_impl =
        derive_is_provider_for(&component_name_type, &use_fields_impl)?;

    let m_field: Option<[GetterField; 1]> = fields.try_into().ok();

    let mut derived = quote! {
        #derived_component

        #use_fields_impl

        #is_provider_use_fields_impl
    };

    if let Some([field]) = m_field {
        let use_field_impl = derive_use_field_impl(
            &spec,
            &derived_component.provider_trait,
            &field,
            &field_assoc_type,
        )?;

        let is_provider_use_field_impl =
            derive_is_provider_for(&component_name_type, &use_field_impl)?;

        let use_provider_impl = derive_with_provider_impl(
            &spec,
            &derived_component.provider_trait,
            &field,
            &field_assoc_type,
        )?;

        let is_provider_use_provider_impl =
            derive_is_provider_for(&component_name_type, &use_provider_impl)?;

        derived.extend(quote! {
            #use_field_impl
            #is_provider_use_field_impl

            #use_provider_impl
            #is_provider_use_provider_impl
        });
    }

    Ok(derived)
}