prop_tune_macro 0.2.0

The procedural macro crate for proc_tune
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

use proc_macro::{Group, Ident, Punct, Span, TokenStream, TokenTree};
use prop_tune_core::operators::{self, Condition, Proposition};

#[derive(Debug, Clone)]
pub struct MacroProp(Proposition);

impl MacroProp {
    pub fn new(prop: impl Into<Proposition>) -> Self {
        MacroProp(prop.into())
    }
}

impl Into<TokenTree> for MacroProp {
    fn into(self) -> TokenTree {
        match self.0 {
            Proposition::Condition(cond) => TokenTree::Ident(match cond {
                Condition::True => Ident::new("true", Span::call_site()),
                Condition::False => Ident::new("false", Span::call_site()),
            }),
            Proposition::Predicate(pred) => {
                TokenTree::Ident(Ident::new(pred.as_str(), Span::call_site()))
            }
            Proposition::Composition(comp) => TokenTree::Group(match *comp {
                operators::Operator::And(a, b) => {
                    let mut stream = TokenStream::new();
                    let toks = vec![
                        MacroProp(a).into(),
                        TokenTree::Punct(Punct::new('&', proc_macro::Spacing::Joint)),
                        TokenTree::Punct(Punct::new('&', proc_macro::Spacing::Alone)),
                        MacroProp(b).into(),
                    ];
                    stream.extend(toks);
                    Group::new(proc_macro::Delimiter::Parenthesis, stream)
                }
                operators::Operator::Or(a, b) => {
                    let mut stream = TokenStream::new();
                    let toks = vec![
                        MacroProp(a).into(),
                        TokenTree::Punct(Punct::new('|', proc_macro::Spacing::Joint)),
                        TokenTree::Punct(Punct::new('|', proc_macro::Spacing::Alone)),
                        MacroProp(b).into(),
                    ];
                    stream.extend(toks);
                    Group::new(proc_macro::Delimiter::Parenthesis, stream)
                }
                operators::Operator::Not(a) => {
                    let mut stream = TokenStream::new();
                    let toks = vec![
                        TokenTree::Punct(Punct::new('!', proc_macro::Spacing::Alone)),
                        MacroProp(a).into(),
                    ];
                    stream.extend(toks);
                    Group::new(proc_macro::Delimiter::None, stream)
                }
                _ => unimplemented!("converting \"implies\" into TokenTree is not supported"),
            }),
        }
    }
}