air-parser 0.4.0

Parser for the AirScript language
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

use miden_diagnostics::SourceSpan;

use crate::ast::*;

use super::ParseTest;

#[test]
fn call_fold_identifier() {
    let source = "
    mod test

    ev test([a, c[2]]) {
        let x = sum(c);
        let y = prod(c);
        enf a = x + y;
    }";

    let mut expected = Module::new(ModuleType::Library, SourceSpan::UNKNOWN, ident!(test));
    let body = vec![let_!(x = expr!(call!(sum(expr!(access!(c))))) =>
                  let_!(y = expr!(call!(prod(expr!(access!(c))))) =>
                        enforce!(eq!(access!(a), add!(access!(x), access!(y))))))];
    expected.evaluators.insert(
        ident!(test),
        EvaluatorFunction::new(
            SourceSpan::UNKNOWN,
            ident!(test),
            vec![trace_segment!(0, "%0", [(a, 1), (c, 2)])],
            body,
        ),
    );

    ParseTest::new().expect_module_ast(source, expected);
}

#[test]
fn call_fold_vector_literal() {
    let source = "
    mod test

    ev test([a, b, c[4]]) {
        let x = sum([a, b, c[0]]);
        let y = prod([a, b, c[0]]);
        enf a = x + y;
    }";

    let mut expected = Module::new(ModuleType::Library, SourceSpan::UNKNOWN, ident!(test));
    let body = vec![
        let_!(x = expr!(call!(sum(vector!(access!(a), access!(b), access!(c[0]))))) =>
                  let_!(y = expr!(call!(prod(vector!(access!(a), access!(b), access!(c[0]))))) =>
                        enforce!(eq!(access!(a), add!(access!(x), access!(y)))))),
    ];
    expected.evaluators.insert(
        ident!(test),
        EvaluatorFunction::new(
            SourceSpan::UNKNOWN,
            ident!(test),
            vec![trace_segment!(0, "%0", [(a, 1), (b, 1), (c, 4)])],
            body,
        ),
    );

    ParseTest::new().expect_module_ast(source, expected);
}

#[test]
fn call_fold_list_comprehension() {
    let source = "
    mod test

    ev test([a, b, c[4]]) {
        let x = sum([col^7 for col in c]);
        let y = prod([col^7 for col in c]);
        enf a = x + y;
    }";

    let mut expected = Module::new(ModuleType::Library, SourceSpan::UNKNOWN, ident!(test));
    let body = vec![
        let_!(x = expr!(call!(sum(lc!(((col, expr!(access!(c)))) => exp!(access!(col), int!(7))).into()))) =>
                  let_!(y = expr!(call!(prod(lc!(((col, expr!(access!(c)))) => exp!(access!(col), int!(7))).into()))) =>
                        enforce!(eq!(access!(a), add!(access!(x), access!(y)))))),
    ];
    expected.evaluators.insert(
        ident!(test),
        EvaluatorFunction::new(
            SourceSpan::UNKNOWN,
            ident!(test),
            vec![trace_segment!(0, "%0", [(a, 1), (b, 1), (c, 4)])],
            body,
        ),
    );

    ParseTest::new().expect_module_ast(source, expected);
}