tf-macros 0.1.1

A set of macros for the fourth server
Documentation
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, FnArg, ItemFn, PatType, ReturnType};

/// #[serve] -> ServeFn<S, C>
#[proc_macro_attribute]
pub fn serve(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let f = parse_macro_input!(item as ItemFn);
    expand(f, Kind::Serve)
}

/// #[accept] -> AcceptFn<S, C>
#[proc_macro_attribute]
pub fn accept(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let f = parse_macro_input!(item as ItemFn);
    expand(f, Kind::Accept)
}

enum Kind {
    Serve,
    Accept,
}

fn expand(f: ItemFn, kind: Kind) -> TokenStream {
    let ItemFn { attrs, vis, sig, block } = f;
    let name = &sig.ident;

    let inputs: Vec<&PatType> = sig
        .inputs
        .iter()
        .map(|arg| match arg {
            FnArg::Typed(pt) => pt,
            FnArg::Receiver(_) => panic!("#[serve]/#[accept] fns can't take self"),
        })
        .collect();

    let ret = match &sig.output {
        ReturnType::Type(_, ty) => quote!(#ty),
        ReturnType::Default => quote!(()),
    };

    match kind {
        Kind::Serve => {
            assert_eq!(
                inputs.len(),
                5,
                "#[serve] expects (state: Arc<S>, addr: SocketAddr, route_tx: Option<Sender<(AcceptFn<S, C>, Arc<S>)>>, structure: Box<dyn StructureType>, bytes: BytesMut)"
            );
            let state_pat = &inputs[0].pat;
            let state_ty = &inputs[0].ty;
            let addr_pat = &inputs[1].pat;
            let addr_ty = &inputs[1].ty;
            let route_tx_pat = &inputs[2].pat;
            let route_tx_ty = &inputs[2].ty;
            let structure_pat = &inputs[3].pat;
            let structure_ty = &inputs[3].ty;
            let bytes_pat = &inputs[4].pat;
            let bytes_ty = &inputs[4].ty;

            quote! {
                #(#attrs)*
                #vis fn #name(
                    #state_pat: #state_ty,
                    #addr_pat: #addr_ty,
                    #route_tx_pat: #route_tx_ty,
                    #structure_pat: #structure_ty,
                    #bytes_pat: #bytes_ty,
                ) -> ::futures_util::future::BoxFuture<'static, #ret> {
                    ::std::boxed::Box::pin(async move #block)
                }
            }
                .into()
        }
        Kind::Accept => {
            assert_eq!(
                inputs.len(),
                4,
                "#[accept] expects (state: Arc<S>, addr: SocketAddr, framed: Framed<Transport, C>, holder: TrafficProcessorHolder<C>)"
            );
            let state_pat = &inputs[0].pat;
            let state_ty = &inputs[0].ty;
            let addr_pat = &inputs[1].pat;
            let addr_ty = &inputs[1].ty;
            let framed_pat = &inputs[2].pat;
            let framed_ty = &inputs[2].ty;
            let holder_pat = &inputs[3].pat;
            let holder_ty = &inputs[3].ty;

            quote! {
                #(#attrs)*
                #vis fn #name(
                    #state_pat: #state_ty,
                    #addr_pat: #addr_ty,
                    (#framed_pat, #holder_pat): (#framed_ty, #holder_ty),
                ) -> ::futures_util::future::BoxFuture<'static, ()> {
                    ::std::boxed::Box::pin(async move #block)
                }
            }
                .into()
        }
    }
}