sark-gen 0.28.1

Sark proc-macro generators
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

use crate::{macros::tokens::local, runtime::paths::Paths};

pub(super) struct Body {
    core: Vec<proc_macro2::TokenStream>,
    plain: Vec<proc_macro2::TokenStream>,
    guard: Vec<proc_macro2::TokenStream>,
}

impl Body {
    pub(super) const fn new() -> Self {
        Self {
            core: Vec::new(),
            plain: Vec::new(),
            guard: Vec::new(),
        }
    }

    pub(super) fn push(
        &mut self,
        paths: &Paths,
        open_ty: &proc_macro2::TokenStream,
        done_ty: &proc_macro2::TokenStream,
        open: &syn::Ident,
        done: &syn::Ident,
        guarded: bool,
    ) {
        use quote::quote;

        let ns_core = &paths.core;
        let [v_body, v_visit] = ["body", "visit"].map(local);

        let arms = quote! {
            Self::#open(.., #v_body) => #v_visit.apply(
                #ns_core::decode::state::body::Value::#open_ty(#v_body),
            ),
            Self::#done(.., #v_body) => #v_visit.apply(
                #ns_core::decode::state::body::Value::#done_ty(#v_body),
            ),
        };
        self.core.push(arms.clone());
        if guarded {
            self.guard.push(arms);
        } else {
            self.plain.push(arms);
        }
    }

    pub(super) fn render(
        self,
        paths: &Paths,
        core: &syn::Ident,
        plain: &syn::Ident,
        guard: &syn::Ident,
    ) -> [proc_macro2::TokenStream; 3] {
        use quote::quote;

        let ns_core = &paths.core;
        let v_visit = local("visit");

        let Self {
            core: c,
            plain: p,
            guard: g,
        } = self;
        let render = |arms: Vec<proc_macro2::TokenStream>, state: &syn::Ident| {
            quote! {
                impl<F: #ns_core::decode::state::Set>
                    #ns_core::decode::state::body::Flow<F> for #state<F>
                {
                    fn fold<V: #ns_core::decode::state::body::Fold<F>>(
                        self,
                        #v_visit: V,
                    ) -> V::Output { match self { #( #arms )* } }
                }
            }
        };
        [render(c, core), render(p, plain), render(g, guard)]
    }
}