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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use air_pass::Pass;
use miden_diagnostics::SourceSpan;

use pretty_assertions::assert_eq;

use crate::{ast::*, transforms::ConstantPropagation};

use super::ParseTest;

#[test]
fn test_constant_propagation() {
    let root = r#"
    def root

    use lib::*;

    trace_columns {
        main: [clk, a, b[2], c],
    }

    public_inputs {
        inputs: [0],
    }

    const A = [2, 4, 6, 8];
    const B = [[1, 1], [2, 2]];
    const TWO = 2;

    integrity_constraints {
        enf test_constraint(b);
        let x = 2^EXP;
        let y = A[0..2];
        enf a + y[1] = c + (x + 1);
    }

    boundary_constraints {
        let x = B[0];
        enf a.first = x[0];
    }
    "#;
    let lib = r#"
    mod lib

    const EXP = 2;

    ev test_constraint([b0, b1]) {
        let x = EXP;
        let y = 2^x;
        enf b0 + x = b1 + y;
    }"#;

    let test = ParseTest::new();
    let path = std::env::current_dir().unwrap().join("lib.air");
    test.add_virtual_file(path, lib.to_string());

    let program = match test.parse_program(root) {
        Err(err) => {
            test.diagnostics.emit(err);
            panic!("expected parsing to succeed, see diagnostics for details");
        }
        Ok(ast) => ast,
    };

    let mut pass = ConstantPropagation::new(&test.diagnostics);
    let program = pass.run(program).unwrap();

    let mut expected = Program::new(ident!(root));
    expected.trace_columns.push(trace_segment!(
        0,
        "$main",
        [(clk, 1), (a, 1), (b, 2), (c, 1)]
    ));
    expected.public_inputs.insert(
        ident!(inputs),
        PublicInput::new_vector(SourceSpan::UNKNOWN, ident!(inputs), 0),
    );
    expected
        .constants
        .insert(ident!(root, A), constant!(A = [2, 4, 6, 8]));
    expected
        .constants
        .insert(ident!(root, B), constant!(B = [[1, 1], [2, 2]]));
    expected
        .constants
        .insert(ident!(lib, EXP), constant!(EXP = 2));
    // When constant propagation is done, the boundary constraints should look like:
    //     enf a.first = 1
    expected.boundary_constraints.push(enforce!(eq!(
        bounded_access!(a, Boundary::First, Type::Felt),
        int!(1)
    )));
    // When constant propagation is done, the integrity constraints should look like:
    //     enf test_constraint(b)
    //     enf a + 4 = c + 5
    expected
        .integrity_constraints
        .push(enforce!(call!(lib::test_constraint(expr!(access!(
            b,
            Type::Vector(2)
        ))))));
    expected.integrity_constraints.push(enforce!(eq!(
        add!(access!(a, Type::Felt), int!(4)),
        add!(access!(c, Type::Felt), int!(5))
    )));
    // The test_constraint function should look like:
    //     enf b0 + 2 = b1 + 4
    let body = vec![enforce!(eq!(
        add!(access!(b0, Type::Felt), int!(2)),
        add!(access!(b1, Type::Felt), int!(4))
    ))];
    expected.evaluators.insert(
        function_ident!(lib, test_constraint),
        EvaluatorFunction::new(
            SourceSpan::UNKNOWN,
            ident!(test_constraint),
            vec![trace_segment!(0, "%0", [(b0, 1), (b1, 1)])],
            body,
        ),
    );

    assert_eq!(program, expected);
}