reflect 0.0.15

The "but I thought Rust doesn't have reflection?" memorial brand new way of defining procedural macros.
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

#![allow(non_upper_case_globals)] // rustc bug: https://github.com/rust-lang/rust/issues/110573
#![allow(clippy::wildcard_imports)]

use quote::quote;
use reflect::*;

library! {
    use tuple {
        type One;
        type Two;

        trait Tuple {
            fn swap((One, Two)) -> (Two, One);
        }
    }
}

fn derive(ex: Execution) {
    ex.make_trait_impl(RUNTIME::tuple::Tuple, ex.target_type(), |block| {
        block.make_function(RUNTIME::tuple::Tuple::swap, |make_function| {
            let tuple = make_function.arg(0);
            let (i, u) = (tuple.get_tuple_value(0), tuple.get_tuple_value(1));
            Value::tuple(&[u, i])
        });
    });
}

#[test]
fn test_tuple() {
    let input = quote! {
        pub(super) struct TupleStruct;
    };

    let expected = quote! {
        impl ::tuple::Tuple for TupleStruct
        {
            fn swap(__arg0: (::tuple::One, ::tuple::Two)) -> (::tuple::Two, ::tuple::One) {
                let __v0 = __arg0;
                let __v1 = &__v0.0;
                let __v2 = &__v0.1;
                let __v3 = (__v2, __v1);
                __v3
            }
        }
    };

    let output = reflect::derive(input, derive);
    assert_eq!(output.to_string(), expected.to_string());
}