split-async 0.1.1

A procedural macro to generate sync and async versions of a function
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

use proc_macro2::Span;
use syn::{
    Attribute, Error, ItemFn, ItemImpl, ItemTrait,
    parse::{Parse, ParseStream, Result, discouraged::Speculative},
};

#[derive(Clone)]
pub enum Item {
    Trait(ItemTrait),
    Impl(ItemImpl),
    Fn(ItemFn),
    // Static(ItemStatic),
}

macro_rules! fork {
    ($fork:ident = $input:ident) => {{
        $fork = $input.fork();
        &$fork
    }};
}

impl Parse for Item {
    fn parse(input: ParseStream) -> Result<Self> {
        let attrs = input.call(Attribute::parse_outer)?;
        let mut fork;
        let item = if let Ok(mut item) = fork!(fork = input).parse::<ItemImpl>() {
            item.attrs = attrs;
            Item::Impl(item)
        } else if let Ok(mut item) = fork!(fork = input).parse::<ItemTrait>() {
            item.attrs = attrs;
            Item::Trait(item)
        } else if let Ok(mut item) = fork!(fork = input).parse::<ItemFn>() {
            item.attrs = attrs;
            Item::Fn(item)
        }
        // else if let Ok(mut item) = fork!(fork = input).parse::<ItemStatic>() {
        //     item.attrs = attrs;
        //     Item::Static(item)
        // }
        else {
            return Err(Error::new(Span::call_site(), "expected impl, trait or fn"));
        };
        input.advance_to(&fork);
        Ok(item)
    }
}