macro-compose 0.1.0

macro-compose is a library trying to simplify and organize proc-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
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

use macro_compose::{Collector, Context, Expand, Lint, Nothing};
use syn::{parse_quote, Error, ItemConst};

#[test]
fn basic() {
    let data: ItemConst = parse_quote!(
        const FOO: bool = true;
    );

    let mut collector = Collector::new();
    let mut ctx = Context::new(&mut collector, data);
    ctx.lint(&NoOpLint);
    ctx.expand(&NoOpExpand);
    assert_eq!(collector.has_errors(), false);
}

struct NoOpLint;

impl Lint<ItemConst> for NoOpLint {
    fn lint(&self, _: &ItemConst, _: &mut Collector) {}
}

struct NoOpExpand;

impl Expand<ItemConst> for NoOpExpand {
    type Output = Nothing;

    fn expand(&self, _: &ItemConst, _: &mut Collector) -> Option<Self::Output> {
        None
    }
}

#[test]
fn test_expand_disable() {
    let data: ItemConst = parse_quote!(
        const FOO: bool = true;
    );

    let mut collector = Collector::new();
    let mut ctx = Context::new(&mut collector, data);
    ctx.lint(&AlwaysErrorLint);
    ctx.expand(&PanickingExpand);
    assert_eq!(collector.has_errors(), true);
}

#[test]
#[should_panic]
fn test_panicking() {
    let data: ItemConst = parse_quote!(
        const FOO: bool = true;
    );

    let mut collector = Collector::new();
    let mut ctx = Context::new(&mut collector, data);
    ctx.expand(&PanickingExpand);
}

struct AlwaysErrorLint;

impl Lint<ItemConst> for AlwaysErrorLint {
    fn lint(&self, i: &ItemConst, c: &mut Collector) {
        c.error(Error::new_spanned(i, "some error message"));
    }
}

struct PanickingExpand;

impl Expand<ItemConst> for PanickingExpand {
    type Output = Nothing;

    fn expand(&self, _: &ItemConst, _: &mut Collector) -> Option<Self::Output> {
        unreachable!()
    }
}