dyn_safe-proc_macros 0.0.1

`::dyn_safe`'s internal crate.
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

/// mini-`syn`
macro_rules! unwrap_next_token {(
    if let $($pat:pat)|+ = $mb_token:expr,
        $(if ($($guard:tt)*))?
        $expr:block
    else {
        failwith!($err_msg:expr $(, $($($rest:tt)+)?)? );
    }
) => (
    match $mb_token {
        $( | Some($pat) )+
        $(if $($guard)*)?
        => $expr,
        | Some(bad_token) => return Err((
            (bad_token.span(), None),
            {
                #[allow(unused_macros)]
                macro_rules! it {() => ($err_msg)}
                {
                    $($(
                        macro_rules! it {() => (
                            format!($err_msg, $($rest)+)
                        )}
                    )?)?
                    it!().into()
                }
            },
        )),
        | None => return Err((
            (Span::call_site(), None),
            {
                #[allow(unused_macros)]
                macro_rules! it {() => (
                    concat!("Unexpected end of input: ", $err_msg)
                )}
                {
                    $($(
                        macro_rules! it {() => (
                            format!(
                                concat!("Unexpected end of input: ", $err_msg),
                                $($rest)+
                            )
                        )}
                    )?)?
                    it!().into()
                }
            },
        ))
    }
)}

/// mini-`quote`
macro_rules! ts {
    ( ($($input:tt)*) ) => (
        Group::new(Delimiter::Parenthesis, ts![$($input)*])
    );
    ( [$($input:tt)*] ) => (
        Group::new(Delimiter::Bracket, ts![$($input)*])
    );
    ( {$($input:tt)*} ) => (
        Group::new(Delimiter::Brace, ts![$($input)*])
    );

    (
        $($expr:expr),* $(,)?
    ) => (
        <TokenStream as ::core::iter::FromIterator<TT>>::from_iter(vec![
            $($expr.into() ,)*
        ])
    );
}

macro_rules! ite {(
    ($($something:tt)+) $($ignored:tt)?
) => (
    $($something)*
)}

macro_rules! error {(
    $err_msg:expr $(
        => $span:expr $(, $end_span:expr)?
    )? $(,)?
) => (
    return Err((
        (
            ite! {
                $((
                    $span
                ))? (
                    Span::call_site()
                )
            },
            ite! {
                $($((
                    Some($end_span)
                ))?)? (
                    None
                )
            },
        ),
        $err_msg
    ))
)}