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

use proc_macro2::{TokenTree, TokenStream, Span, Spacing};
use quote::{quote, ToTokens};
use syn::Ident;

/// Analog to Option<TokenStream>, except when put into the quote!
/// macro, `MaybeVoid::Void` will produce `()`
#[derive(Clone)]
pub enum MaybeVoid {
    Some(TokenStream),
    Void
}

impl Default for MaybeVoid {
    fn default() -> MaybeVoid {
        MaybeVoid::Void
    }
}

impl MaybeVoid {
    pub fn replace(&mut self, stream: TokenStream) -> MaybeVoid {
        std::mem::replace(self, MaybeVoid::Some(stream))
    }

    pub fn take(&mut self) -> MaybeVoid {
        std::mem::replace(self, MaybeVoid::Void)
    }
}

impl ToTokens for MaybeVoid {
    fn to_tokens(&self, out: &mut TokenStream) {
        match self {
            MaybeVoid::Some(stream) => out.extend(stream.clone()),
            MaybeVoid::Void => out.extend(quote!(())),
        }
    }

    fn to_token_stream(&self) -> TokenStream {
        match self {
            MaybeVoid::Some(stream) => stream.clone(),
            MaybeVoid::Void => quote!(()),
        }
    }

    fn into_token_stream(self) -> TokenStream {
        match self {
            MaybeVoid::Some(stream) => stream,
            MaybeVoid::Void => quote!(()),
        }
    }
}

pub fn is_punct(tt: &TokenTree, expect: char) -> bool {
    match tt {
        TokenTree::Punct(punct) if punct.as_char() == expect && punct.spacing() == Spacing::Alone => true,
        _ => false,
    }
}

/// If supplied `tt` is a punct matching a char, returns `None`, else returns `tt`
pub fn expect_punct(tt: Option<TokenTree>, expect: char) -> Option<TokenTree> {
    tt.filter(|tt| !is_punct(&tt, expect))
}

pub trait ToIdent {
    fn to_ident(&self) -> Ident;
}

impl ToIdent for str {
    fn to_ident(&self) -> Ident {
        Ident::new(self, Span::call_site())
    }
}