Skip to main content

tpt_telos_parser/
lib.rs

1//! tpt-telos parser: lexer, AST, and recursive-descent parser.
2
3pub mod ast;
4pub mod lexer;
5pub mod parser;
6pub mod span;
7
8pub use ast::*;
9pub use parser::parse;
10pub use span::Span;
11
12#[cfg(test)]
13mod proptests {
14    use super::*;
15
16    /// Generate a well-formed minimal telos module that always parses.
17    fn gen_telos_source(name: &str, func_name: &str, field: &str) -> String {
18        format!(
19            r#"module {name} {{
20    invariant T {{ {field} >= 0 }}
21    func {func_name}(x: T)
22        requires {field} >= 0
23        ensures {field} >= 0
24    {{ }}
25}}"#,
26        )
27    }
28
29    #[test]
30    fn generated_modules_parse() {
31        let cases = vec![
32            ("M1", "f1", "a"),
33            ("M2", "f2", "balance"),
34            ("Wallet", "deposit", "amount"),
35            ("Bank", "transfer", "v"),
36        ];
37        for (mod_name, func_name, field) in cases {
38            let src = gen_telos_source(mod_name, func_name, field);
39            let result = parse(&src);
40            assert!(
41                result.is_ok(),
42                "Failed to parse generated source for {mod_name}: {:?}\nSource:\n{src}",
43                result.err()
44            );
45            let modules = result.unwrap();
46            assert_eq!(modules.len(), 1);
47            assert_eq!(modules[0].name, mod_name);
48        }
49    }
50
51    #[test]
52    fn disjunction_parses() {
53        let src = r#"
54            module M {
55                func f(x: Int)
56                    requires x == 1 || x == 2
57                    ensures x >= 1 || x <= 0
58                { }
59            }
60        "#;
61        let result = parse(src);
62        assert!(
63            result.is_ok(),
64            "disjunction should parse: {:?}",
65            result.err()
66        );
67    }
68
69    #[test]
70    fn array_types_parse() {
71        let src = r#"
72            module M {
73                func f(data: [Int; 5]) { }
74            }
75        "#;
76        let result = parse(src);
77        assert!(
78            result.is_ok(),
79            "array types should parse: {:?}",
80            result.err()
81        );
82    }
83
84    #[test]
85    fn float_types_parse() {
86        let src = r#"
87            module M {
88                func f(x: Float32, y: Float64) { }
89            }
90        "#;
91        let result = parse(src);
92        assert!(
93            result.is_ok(),
94            "float types should parse: {:?}",
95            result.err()
96        );
97    }
98}