Skip to main content

parse_module

Function parse_module 

Source
pub fn parse_module(src: &str) -> Result<Module>
Examples found in repository?
examples/depth.rs (line 46)
39fn probe() -> bool {
40    let depth = tla_syntax::DEFAULT_NESTING_LIMIT + 44;
41    let src = format!(
42        "---- MODULE M ----\nX == {}1{}\n====",
43        "(".repeat(depth),
44        ")".repeat(depth)
45    );
46    parse_module(&src).is_err()
47}
48
49fn report_corpus_depth() {
50    let mut deepest = (0usize, String::new());
51    let mut files = 0usize;
52    for path in std::env::args().skip(1) {
53        let Ok(src) = std::fs::read_to_string(&path) else {
54            continue;
55        };
56        let Ok(module) = parse_module(&src) else {
57            continue;
58        };
59        files += 1;
60        for unit in &module.units {
61            if let Unit::Def(def) = unit {
62                let d = depth(&def.body);
63                if d > deepest.0 {
64                    deepest = (d, format!("{}: {}", module.name, def.name));
65                }
66            }
67        }
68    }
69    println!(
70        "{files} modules; deepest expression nests {} ({})",
71        deepest.0, deepest.1
72    );
73}
More examples
Hide additional examples
examples/audit.rs (line 24)
16fn main() {
17    let mut parsed = 0usize;
18    let mut by_reason: BTreeMap<String, Vec<Failure>> = BTreeMap::new();
19
20    for path in std::env::args().skip(1) {
21        let Ok(src) = std::fs::read_to_string(&path) else {
22            continue;
23        };
24        match tla_syntax::parse_module(&src) {
25            Ok(_) => parsed += 1,
26            Err(e) => {
27                let source_line = src
28                    .lines()
29                    .nth(e.line as usize - 1)
30                    .unwrap_or("")
31                    .trim()
32                    .chars()
33                    .take(96)
34                    .collect();
35                by_reason.entry(reason(&e)).or_default().push(Failure {
36                    path,
37                    line: e.line,
38                    source_line,
39                });
40            }
41        }
42    }
43
44    let total = parsed + by_reason.values().map(Vec::len).sum::<usize>();
45    println!("parsed {parsed} / {total}");
46
47    let mut groups: Vec<_> = by_reason.into_iter().collect();
48    groups.sort_by_key(|(_, failures)| std::cmp::Reverse(failures.len()));
49    for (reason, failures) in groups {
50        println!("\n{:>4}  {reason}", failures.len());
51        for f in failures.iter().take(4) {
52            let file = f.path.rsplit('/').next().unwrap_or(&f.path);
53            println!("      {file}:{}  {}", f.line, f.source_line);
54        }
55    }
56}