diman_unit_system 0.2.0

Internal procedural macros for diman.
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use syn::{
    parse::{Parse, ParseStream},
    token::Paren,
    *,
};

use crate::expression::Expr;
use crate::expression::Factor;

impl<T: Parse> Parse for Factor<T> {
    fn parse(input: ParseStream) -> Result<Self> {
        let lookahead = input.lookahead1();
        if lookahead.peek(Paren) {
            let content;
            let _: token::Paren = parenthesized!(content in input);
            Ok(Self::ParenExpr(Box::new(content.parse()?)))
        } else {
            Ok(Self::Value(input.parse()?))
        }
    }
}

impl<T: Parse> Parse for Expr<T> {
    fn parse(input: ParseStream) -> Result<Self> {
        let first_factor: Factor<T> = input.parse()?;
        let lookahead = input.lookahead1();
        if input.is_empty() || lookahead.peek(Token![,]) {
            Ok(Self::Value(first_factor))
        } else if lookahead.peek(Token![*]) {
            let _: Token![*] = input.parse().unwrap();
            let second_expr: Expr<T> = input.parse()?;
            Ok(Self::Times(first_factor, Box::new(second_expr)))
        } else if lookahead.peek(Token![/]) {
            let _: Token![/] = input.parse().unwrap();
            let second_expr: Expr<T> = input.parse()?;
            Ok(Self::Over(first_factor, Box::new(second_expr)))
        } else {
            Err(lookahead.error())
        }
    }
}

#[cfg(test)]
pub mod tests {
    use proc_macro2::TokenStream;
    use quote::quote;

    use super::Expr;
    use syn::{
        parse::{self, Parse},
        Lit, Result,
    };

    #[derive(Debug, PartialEq, Eq, Clone)]
    pub struct MyInt(pub isize);

    impl Parse for MyInt {
        fn parse(input: parse::ParseStream) -> Result<Self> {
            let val: Lit = input.parse()?;
            match val {
                Lit::Int(x) => Ok(MyInt(x.base10_parse().unwrap())),
                _ => panic!(),
            }
        }
    }

    pub fn parse_expr(input: TokenStream) -> Expr<MyInt> {
        syn::parse2(input).unwrap()
    }

    #[test]
    fn parse_exprs() {
        use super::Expr::{Over, Times};
        use super::Factor::*;
        let x = parse_expr(quote! { 1 });
        assert_eq!(x, Expr::Value(Value(MyInt(1))));
        let x = parse_expr(quote! { 1 * 2 });
        assert_eq!(
            x,
            Times(Value(MyInt(1)), Box::new(Expr::Value(Value(MyInt(2)))))
        );
        let x = parse_expr(quote! { 1 / 2 });
        assert_eq!(
            x,
            Over(Value(MyInt(1)), Box::new(Expr::Value(Value(MyInt(2)))))
        );
        let x = parse_expr(quote! { 1 / (2 * 3) });
        assert_eq!(
            x,
            Over(
                Value(MyInt(1)),
                Box::new(Expr::Value(ParenExpr(Box::new(Times(
                    Value(MyInt(2)),
                    Box::new(Expr::Value(Value(MyInt(3)))),
                )))))
            )
        );
    }

    #[test]
    fn parse_expr_with_multiple_factors() {
        use super::Expr::Times;
        use super::Factor::*;
        let x = parse_expr(quote! { 1 * 2 * 3 });
        assert_eq!(
            x,
            Times(
                Value(MyInt(1)),
                Box::new(Times(
                    Value(MyInt(2)),
                    Box::new(Expr::Value(Value(MyInt(3))))
                ))
            )
        );
    }
}