asynchelp-macros 0.1.0

Proc macros for asynchelp
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 proc_macro::TokenStream;
use quote::quote;
use syn::ext::IdentExt;
use syn::{parse_quote, Ident, ImplItemMethod, ReturnType, AttributeArgs};
use darling::FromMeta;

#[derive(Debug, FromMeta)]
struct StackfutureArgs {
    #[darling(default)]
    size: usize,
}

#[allow(unused)]
fn snake_to_camel(ident_str: &str) -> String {
    let mut camel_ty = String::with_capacity(ident_str.len());

    let mut last_char_was_underscore = true;
    for c in ident_str.chars() {
        match c {
            '_' => last_char_was_underscore = true,
            c if last_char_was_underscore => {
                camel_ty.extend(c.to_uppercase());
                last_char_was_underscore = false;
            }
            c => camel_ty.extend(c.to_lowercase()),
        }
    }

    camel_ty.shrink_to_fit();
    camel_ty
}

#[allow(unused)]
fn associated_type_for_rpc(method: &ImplItemMethod) -> String {
    snake_to_camel(&method.sig.ident.unraw().to_string()) + "Fut"
}

#[cfg(feature = "stackfuture")]
#[proc_macro_attribute]
pub fn tarpc_stackfuture(attr: TokenStream, input: TokenStream) -> TokenStream {
    let attr_args = syn::parse_macro_input!(attr as AttributeArgs);
    let mut method = syn::parse_macro_input!(input as ImplItemMethod);

    let StackfutureArgs { size } = match StackfutureArgs::from_list(&attr_args) {
        Ok(v) => v,
        Err(e) => { return TokenStream::from(e.write_errors()); }
    };


    method.sig.asyncness = None;

    // get either the return type or ().
    let ret = match &method.sig.output {
        ReturnType::Default => quote!(()),
        ReturnType::Type(_, ret) => quote!(#ret),
    };

    let fut_name = associated_type_for_rpc(&method);
    let fut_name_ident = Ident::new(&fut_name, method.sig.ident.span());

    // generate the updated return signature.
    method.sig.output = parse_quote! {
        -> ::stackfuture::StackFuture<'static, #ret, #size>
    };

    // transform the body of the method into Box::pin(async move { body }).
    let block = method.block.clone();
    method.block = parse_quote! [{
        ::stackfuture::StackFuture::from(async move
            #block
        )
    }];

    // generate and return type declaration for return type.
    TokenStream::from(quote! {
        type #fut_name_ident = ::stackfuture::StackFuture<'static, #ret, #size>;
        #method
    })
}