inheritance-proc-macro 0.0.1-alpha.2

Avoiding code repetition in Rust with OOP inheritance
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

#[cfg(not(feature = "verbose-expansions"))]
macro_rules! debug {(
    $($tt:tt)*
) => (
)}
#[cfg(feature = "verbose-expansions")]
macro_rules! debug {(
    $($tt:tt)*
) => (
    eprintln!($($tt)*)
)}

macro_rules! error {
    (
        $span:expr, $msg:expr $(,)?
    ) => ({
        let span: Span = $span;
        let msg = LitStr::new(&$msg, span);
        return TokenStream::from(quote_spanned! {span =>
            compile_error!(#msg);
        });
    });

    (
        $msg:expr $(,)?
    ) => (
        error! { Span::call_site()=>
            $msg
        }
    );
}

macro_rules! parse_error {
    (
        $span:expr, $msg:expr $(,)?
    ) => (
        return Err(Error::new($span, $msg));
    );

    (
        $msg:expr $(,)?
    ) => (
        parse_error! { Span::call_site()=>
            $msg
        }
    );
}

macro_rules! set_output {
    (@with_dollar![$dol:tt]
        $render:ident => $ret:ident
    ) => (
        #[allow(unused_mut)]
        let mut $ret = TokenStream::new();

        macro_rules! $render {
            ($dol span:expr =>
                $dol($dol tt:tt)*
            ) => ({
                let span: Span = $dol span;
                $ret.extend(TokenStream::from(quote_spanned! { span=>
                    $dol($dol tt)*
                }));
            });

            (
                $dol($dol tt:tt)*
            ) => ($render! { Span::call_site() =>
                $dol($dol tt)*
            });
        }

    );

    (
        $($tt:tt)*
    ) => (set_output!(@with_dollar![$]
        $($tt)*
    ));
}