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
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

use derive_more::From;
use proc_macro2::Span;
use syn::{
    Error, Ident, LitStr, Path, PathSegment, Token,
    parse::{Parse, ParseStream},
};

pub struct TwoIdents {
    pub sync_ident: Ident,
    pub async_ident: Ident,
}

pub fn split_idents(name: &Ident) -> TwoIdents {
    TwoIdents {
        sync_ident: proc_macro2::Ident::new(&format!("sync_{name}"), Span::call_site()),
        async_ident: proc_macro2::Ident::new(&format!("async_{name}"), Span::call_site()),
    }
}

#[derive(From)]
pub struct SplitArgs(pub TwoIdents);

fn parse_ident_or_litstr(input: &ParseStream) -> syn::Result<Ident> {
    let input_span = input.span();
    if input.peek(Ident) {
        input.parse()
    } else if input.peek(LitStr) {
        let s: LitStr = input.parse()?;
        Ok(Ident::new(&s.value(), s.span()))
    } else {
        Err(syn::Error::new(
            input_span,
            "expected an identifier or a string literal",
        ))
    }
}

impl Parse for SplitArgs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let ident1 = parse_ident_or_litstr(&input)?;

        if input.peek(Token![,]) {
            let _: Token![,] = input.parse()?;
            if !input.is_empty() {
                let ident2 = parse_ident_or_litstr(&input)?;

                if ident1 == ident2 {
                    return Err(Error::new_spanned(ident2, "repeated identifier"));
                }

                let _: Option<Token![,]> = input.parse()?;

                if !input.is_empty() {
                    return Err(input.error("unexpected token"));
                }

                return Ok(Self(TwoIdents {
                    sync_ident: ident1,
                    async_ident: ident2,
                }));
            }
        }

        if !input.is_empty() {
            return Err(input.error("unexpected token"));
        }

        Ok(Self(split_idents(&ident1)))
    }
}

pub struct ChooseArgs {
    pub sync_path: Path,
    pub async_path: Path,
}

fn parse_path_or_litstr(input: &ParseStream) -> syn::Result<Path> {
    let input_span = input.span();
    if input.peek(Token![::]) || input.peek(Ident) {
        input.parse()
    } else if input.peek(LitStr) {
        let s: LitStr = input.parse()?;
        Ok(Ident::new(&s.value(), s.span()).into())
    } else {
        Err(syn::Error::new(
            input_span,
            "expected an identifier or a string literal",
        ))
    }
}

fn split_path(path: &Path) -> syn::Result<ChooseArgs> {
    let tail_segment = path
        .segments
        .last()
        .ok_or_else(|| Error::new_spanned(path, "bad path"))?;
    if !tail_segment.arguments.is_empty() {
        return Err(Error::new_spanned(tail_segment, "must be an identifier"));
    }
    let TwoIdents {
        sync_ident,
        async_ident,
    } = split_idents(&tail_segment.ident);
    let mut sync_path = path.clone();
    *sync_path.segments.last_mut().unwrap() = PathSegment::from(sync_ident);
    let mut async_path = path.clone();
    *async_path.segments.last_mut().unwrap() = PathSegment::from(async_ident);
    Ok(ChooseArgs {
        sync_path,
        async_path,
    })
}

impl Parse for ChooseArgs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let path1 = parse_path_or_litstr(&input)?;

        if input.peek(Token![,]) {
            let _: Token![,] = input.parse()?;
            if !input.is_empty() {
                let path2 = parse_path_or_litstr(&input)?;

                if path1 == path2 {
                    return Err(Error::new_spanned(path2, "repeated identifier"));
                }

                let _: Option<Token![,]> = input.parse()?;

                if !input.is_empty() {
                    return Err(input.error("unexpected token"));
                }

                return Ok(Self {
                    sync_path: path1,
                    async_path: path2,
                });
            }
        }

        if !input.is_empty() {
            return Err(input.error("unexpected token"));
        }

        split_path(&path1)
    }
}