quip 0.2.0

Quasi-quoting macros with expression interpolation
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

use quip::quip;
use quote::quote;
use utilities::compare::token_streams_eq;

// This test verifies Quip expands to an identical token stream if no expression
// interpolations are found.
#[test]
fn no_expression_interpolations() {
    let output = quip! {
        impl Shape for Triangle {
            const SIDES: usize = 3;
        }
    };

    let expected = quip! {
        impl Shape for Triangle {
            const SIDES: usize = 3;
        }
    };

    assert!(token_streams_eq(output, expected));
}

// This test verifies Quip works properly when there is only one expression
// interpolation.
#[test]
fn single_expression_interpolation() {
    let shape = quote!(Triangle);

    let output = quip! {
        impl Shape for #{shape} {
            const SIDES: usize = 3;
        }
    };

    let expected = quip! {
        impl Shape for Triangle {
            const SIDES: usize = 3;
        }
    };

    assert!(token_streams_eq(output, expected));
}

// This test verifies Quip works properly when there are multiple expression
// interpolations.
#[test]
fn multiple_expression_interpolations() {
    let shape = quote!(Triangle);
    let sides = quote!(3);

    let output = quip! {
        impl Shape for #{shape} {
            const SIDES: usize = #{sides};
        }
    };

    let expected = quip! {
        impl Shape for Triangle {
            const SIDES: usize = 3;
        }
    };

    assert!(token_streams_eq(output, expected));
}

// This test verifies temporary values aren't dropped prior to being
// interpolated.
//
// The code below fails to compile.
//
// ```rust
// let output = {
//     let x = &[&String::new()][0];
//     quote!(#x)
// };
// ```
//
// Quip uses `match`, which naturally extends the lifetime of `x` to the end of
// the statement. The code below successfully compiles.
//
// ```rust
// let output = match (&[&String::new()][0],) {
//     (x,) => {
//          quote!(#x)
//      }
// };
// ```
#[test]
fn expression_interpolation_contains_temporary_value() {
    let output = quip!(#{[&String::new()][0]});
    let expected = quote!("");

    assert!(token_streams_eq(output, expected));
}