Skip to main content

tf_macros/
lib.rs

1use proc_macro::TokenStream;
2use quote::quote;
3use syn::{parse_macro_input, FnArg, ItemFn, PatType, ReturnType};
4
5/// #[serve] -> ServeFn<S, C>
6#[proc_macro_attribute]
7pub fn serve(_attr: TokenStream, item: TokenStream) -> TokenStream {
8    let f = parse_macro_input!(item as ItemFn);
9    expand(f, Kind::Serve)
10}
11
12/// #[accept] -> AcceptFn<S, C>
13#[proc_macro_attribute]
14pub fn accept(_attr: TokenStream, item: TokenStream) -> TokenStream {
15    let f = parse_macro_input!(item as ItemFn);
16    expand(f, Kind::Accept)
17}
18
19enum Kind {
20    Serve,
21    Accept,
22}
23
24fn expand(f: ItemFn, kind: Kind) -> TokenStream {
25    let ItemFn { attrs, vis, sig, block } = f;
26    let name = &sig.ident;
27
28    let inputs: Vec<&PatType> = sig
29        .inputs
30        .iter()
31        .map(|arg| match arg {
32            FnArg::Typed(pt) => pt,
33            FnArg::Receiver(_) => panic!("#[serve]/#[accept] fns can't take self"),
34        })
35        .collect();
36
37    let ret = match &sig.output {
38        ReturnType::Type(_, ty) => quote!(#ty),
39        ReturnType::Default => quote!(()),
40    };
41
42    match kind {
43        Kind::Serve => {
44            assert_eq!(
45                inputs.len(),
46                5,
47                "#[serve] expects (state: Arc<S>, addr: SocketAddr, route_tx: Option<Sender<(AcceptFn<S, C>, Arc<S>)>>, structure: Box<dyn StructureType>, bytes: BytesMut)"
48            );
49            let state_pat = &inputs[0].pat;
50            let state_ty = &inputs[0].ty;
51            let addr_pat = &inputs[1].pat;
52            let addr_ty = &inputs[1].ty;
53            let route_tx_pat = &inputs[2].pat;
54            let route_tx_ty = &inputs[2].ty;
55            let structure_pat = &inputs[3].pat;
56            let structure_ty = &inputs[3].ty;
57            let bytes_pat = &inputs[4].pat;
58            let bytes_ty = &inputs[4].ty;
59
60            quote! {
61                #(#attrs)*
62                #vis fn #name(
63                    #state_pat: #state_ty,
64                    #addr_pat: #addr_ty,
65                    #route_tx_pat: #route_tx_ty,
66                    #structure_pat: #structure_ty,
67                    #bytes_pat: #bytes_ty,
68                ) -> ::futures_util::future::BoxFuture<'static, #ret> {
69                    ::std::boxed::Box::pin(async move #block)
70                }
71            }
72                .into()
73        }
74        Kind::Accept => {
75            assert_eq!(
76                inputs.len(),
77                4,
78                "#[accept] expects (state: Arc<S>, addr: SocketAddr, framed: Framed<Transport, C>, holder: TrafficProcessorHolder<C>)"
79            );
80            let state_pat = &inputs[0].pat;
81            let state_ty = &inputs[0].ty;
82            let addr_pat = &inputs[1].pat;
83            let addr_ty = &inputs[1].ty;
84            let framed_pat = &inputs[2].pat;
85            let framed_ty = &inputs[2].ty;
86            let holder_pat = &inputs[3].pat;
87            let holder_ty = &inputs[3].ty;
88
89            quote! {
90                #(#attrs)*
91                #vis fn #name(
92                    #state_pat: #state_ty,
93                    #addr_pat: #addr_ty,
94                    (#framed_pat, #holder_pat): (#framed_ty, #holder_ty),
95                ) -> ::futures_util::future::BoxFuture<'static, ()> {
96                    ::std::boxed::Box::pin(async move #block)
97                }
98            }
99                .into()
100        }
101    }
102}