sark-gen 0.22.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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use crate::{
    app::{serve, spec},
    runtime::paths::Paths,
};

/// Closed generated ownership of every routed H1 continuation.
pub(in crate::app::serve) struct Plan<'source, 'spec> {
    generics: &'spec crate::types::Generics,
    entries: &'source [serve::RouteSpec<'spec, serve::Mode<'spec>>],
    name: syn::Ident,
    route: syn::Ident,
    ready: syn::Ident,
    ready_route: syn::Ident,
    head: syn::Ident,
}

impl<'source, 'spec> Plan<'source, 'spec> {
    pub(in crate::app::serve) fn full(plan: &'source serve::ProtocolPlan<'spec>) -> Self {
        Self {
            generics: &plan.spec.state_generics,
            entries: &plan.entries,
            name: quote::format_ident!("__{}H1Pending", plan.spec.name),
            route: quote::format_ident!("__{}H1Route", plan.spec.name),
            ready: quote::format_ident!("__{}H1Ready", plan.spec.name),
            ready_route: quote::format_ident!("__{}H1ReadyRoute", plan.spec.name),
            head: quote::format_ident!("__{}H1Head", plan.spec.name),
        }
    }

    pub(in crate::app::serve::handle) fn name(&self) -> &syn::Ident {
        &self.name
    }

    pub(in crate::app::serve::handle) fn route(&self) -> &syn::Ident {
        &self.route
    }

    pub(in crate::app::serve) fn head(&self) -> &syn::Ident {
        &self.head
    }

    pub(in crate::app::serve) fn ty(&self) -> proc_macro2::TokenStream {
        let g_id = self.generics.ident("__ID");
        let name = &self.name;
        quote::quote!(#name<'d, #g_id>)
    }

    pub(in crate::app::serve::handle) fn ready(&self) -> &syn::Ident {
        &self.ready
    }

    pub(in crate::app::serve::handle) fn ready_route(&self) -> &syn::Ident {
        &self.ready_route
    }

    pub(in crate::app::serve) fn ready_ty(&self) -> proc_macro2::TokenStream {
        let g_id = self.generics.ident("__ID");
        if !self
            .entries
            .iter()
            .any(|item| item.kind == spec::Kind::Fiber)
        {
            return quote::quote!(::core::convert::Infallible);
        }
        let ready = &self.ready;
        quote::quote!(#ready<'d, #g_id>)
    }

    /// Emits the exact continuation sum stored by each connection.
    pub(in crate::app::serve) fn definitions(&self, paths: &Paths) -> proc_macro2::TokenStream {
        let ns_core = &paths.core;
        let ns_fiber = &paths.fiber;
        let ns_h1 = &paths.h1;
        let ns_http = &paths.http;
        let entries = self.entries.iter().map(|item| {
            let variant = &item.pending_variant;
            let route = &item.entry.route;
            let pending = match item.kind {
                spec::Kind::Sync => {
                    quote::quote!(#ns_h1::route::sync::Pending<'d, #route>)
                }
                spec::Kind::Fiber => {
                    quote::quote!(#ns_h1::route::task::Pending<'d, #route>)
                }
                spec::Kind::Stream => {
                    quote::quote!(#ns_h1::route::stream::Pending<'d, #route>)
                }
                spec::Kind::Duplex => {
                    quote::quote!(#ns_h1::route::duplex::Pending<'d, #route>)
                }
            };
            quote::quote!(#variant(#pending),)
        });
        let name = &self.name;
        let route = &self.route;
        let ready = &self.ready;
        let built = &self.ready_route;
        let head = &self.head;
        let headers = self.entries.iter().map(|item| {
            let variant = &item.pending_variant;
            let route = &item.entry.route;
            let coding = (item.kind == spec::Kind::Sync)
                .then(|| quote::quote!(, #ns_http::h1::head::request::Coding));
            quote::quote!(#variant(#ns_h1::wire::parsing::framing::PendingHead<#route #coding>),)
        });
        let builders: Vec<_> = self
            .entries
            .iter()
            .filter_map(|item| {
                if item.kind != spec::Kind::Fiber {
                    return None;
                }
                let variant = &item.pending_variant;
                let route = &item.entry.route;
                Some(quote::quote!(#variant(#ns_h1::route::task::Ready<'d, #route>),))
            })
            .collect();
        let builds = (!builders.is_empty()).then(|| {
            quote::quote! {
                struct #ready<'d, ID: #ns_fiber::Identity> {
                    exchange: #ns_core::life::exchange::Id<
                        #ns_fiber::dope::manifold::network::listener::conn::Id<'d, ID>,
                        ::core::primitive::u64,
                    >,
                    route: #built<'d>,
                }

                enum #built<'d> {
                    #( #builders )*
                }
            }
        });
        quote::quote! {
            struct #name<'d, ID: #ns_fiber::Identity> {
                exchange: #ns_core::life::exchange::Id<
                    #ns_fiber::dope::manifold::network::listener::conn::Id<
                        'd,
                         ID,
                    >,
                    ::core::primitive::u64,
                >,
                route: #route<'d>,
            }

            enum #route<'d> {
                #( #entries )*
            }

            #builds

            enum #head {
                #( #headers )*
            }
        }
    }
}