sark-gen 0.21.0

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

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

pub(super) struct Arms {
    borrow: Vec<proc_macro2::TokenStream>,
    take: Vec<proc_macro2::TokenStream>,
    consume: Vec<proc_macro2::TokenStream>,
}

impl Arms {
    pub(super) fn new() -> Self {
        Self {
            borrow: Vec::new(),
            take: Vec::new(),
            consume: Vec::new(),
        }
    }

    pub(super) fn push_active(
        &mut self,
        action: &syn::Ident,
        open: &syn::Ident,
        done: &syn::Ident,
    ) {
        use quote::quote;

        let [v_body, v_never, v_slot, v_visit] = ["body", "never", "slot", "visit"].map(local);
        let borrow = quote! {
            Self::#open(.., #v_body) => #v_visit.apply(#v_body),
            Self::#done(.., #v_never) => match *#v_never {},
        };
        let take = quote! {
            Self::#open(#v_slot, #v_body) => #v_visit.#action(#v_slot, #v_body),
            Self::#done(.., #v_never) => match #v_never {},
        };
        let consume = quote! {
            Self::#open(.., #v_body) => #v_visit(#v_body),
            Self::#done(.., #v_never) => match #v_never {},
        };
        self.borrow.push(borrow);
        self.take.push(take);
        self.consume.push(consume);
    }

    pub(super) fn push_never(&mut self, open: &syn::Ident, done: &syn::Ident) {
        use quote::quote;

        let v_never = local("never");

        self.borrow.push(quote! {
            Self::#open(.., #v_never) => match *#v_never {},
            Self::#done(.., #v_never) => match *#v_never {},
        });
        let arms = quote! {
            Self::#open(.., #v_never) => match #v_never {},
            Self::#done(.., #v_never) => match #v_never {},
        };
        self.take.push(arms.clone());
        self.consume.push(arms);
    }

    pub(super) fn render(&self, paths: &Paths, prep: &syn::Ident) -> proc_macro2::TokenStream {
        use quote::quote;

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

        let Self {
            borrow,
            take,
            consume,
        } = self;
        quote! {
                fn each_open<'a, V: #ns_core::decode::state::open::Each<F>>(
                    &'a mut self,
                    #v_visit: V,
                ) -> V::Output<'a>
                where F: #ns_core::decode::state::open::Set,
                { match self { #( #borrow )* } }

                fn fold_open<V: #ns_core::decode::state::open::Fold<#prep, F>>(
                    self,
                    #v_visit: V,
                ) -> V::Output
                where F: #ns_core::decode::state::open::Set,
                { match self { #( #take )* } }

                fn consume<O, V: ::core::ops::FnOnce(F::Body) -> O>(
                    self,
                    #v_visit: V,
                ) -> O
                where F: #ns_core::decode::state::open::Set,
                { match self { #( #consume )* } }
        }
    }
}