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

use miden_diagnostics::{SourceSpan, Span};

use crate::{ast::*, parser::ParseError};

use super::ParseTest;

// PUBLIC INPUTS
// ================================================================================================

#[test]
fn public_inputs_vec() {
    let source = "
    def test

    trace_columns {
        main: [clk],
    }

    public_inputs {
        program_hash: [4],
        stack_inputs: [16],
    }

    boundary_constraints {
        enf clk.first = 0;
    }

    integrity_constraints {
        enf clk = 0;
    }";

    let mut expected = Module::new(ModuleType::Root, SourceSpan::UNKNOWN, ident!(test));
    expected
        .trace_columns
        .push(trace_segment!(0, "$main", [(clk, 1)]));
    expected.public_inputs.insert(
        ident!(program_hash),
        PublicInput::new_vector(SourceSpan::UNKNOWN, ident!(program_hash), 4),
    );
    expected.public_inputs.insert(
        ident!(stack_inputs),
        PublicInput::new_vector(SourceSpan::UNKNOWN, ident!(stack_inputs), 16),
    );
    expected.boundary_constraints = Some(Span::new(
        SourceSpan::UNKNOWN,
        vec![enforce!(eq!(
            bounded_access!(clk, Boundary::First),
            int!(0)
        ))],
    ));
    expected.integrity_constraints = Some(Span::new(
        SourceSpan::UNKNOWN,
        vec![enforce!(eq!(access!(clk), int!(0)))],
    ));
    ParseTest::new().expect_module_ast(source, expected);
}

#[test]
fn public_inputs_table() {
    let source = "
    def test

    trace_columns {
        main: [clk],
    }

    public_inputs {
        a: [[4]],
        b: [[32]],
    }

    boundary_constraints {
        enf clk.first = 0;
    }

    integrity_constraints {
        enf clk = 0;
    }";

    let mut expected = Module::new(ModuleType::Root, SourceSpan::UNKNOWN, ident!(test));
    expected
        .trace_columns
        .push(trace_segment!(0, "$main", [(clk, 1)]));
    expected.public_inputs.insert(
        ident!(a),
        PublicInput::new_table(SourceSpan::UNKNOWN, ident!(a), 4),
    );
    expected.public_inputs.insert(
        ident!(b),
        PublicInput::new_table(SourceSpan::UNKNOWN, ident!(b), 32),
    );
    expected.boundary_constraints = Some(Span::new(
        SourceSpan::UNKNOWN,
        vec![enforce!(eq!(
            bounded_access!(clk, Boundary::First),
            int!(0)
        ))],
    ));
    expected.integrity_constraints = Some(Span::new(
        SourceSpan::UNKNOWN,
        vec![enforce!(eq!(access!(clk), int!(0)))],
    ));
    ParseTest::new().expect_module_ast(source, expected);
}

#[test]
fn error_no_public_input() {
    let source = "
    def test

    trace_columns {
        main: [clk]
    }

    public_inputs { }
    ";
    assert_module_error!(source, ParseError::UnrecognizedToken { .. });
}