erg_parser 0.6.13

The Erg parser
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 erg_common::config::{ErgConfig, Input};
use erg_common::error::MultiErrorDisplay;
use erg_common::spawn::exec_new_thread;
use erg_common::traits::{Runnable, Stream};

use erg_parser::error::ParserRunnerErrors;
use erg_parser::lex::Lexer;
use erg_parser::ParserRunner;

#[test]
fn parse_args() -> Result<(), ()> {
    expect_success("tests/args.er")
}

#[test]
fn parse_containers() -> Result<(), ()> {
    expect_success("tests/containers.er")
}

#[test]
fn parse_dependent() -> Result<(), ()> {
    expect_success("tests/dependent.er")
}

#[test]
fn parse_fib() -> Result<(), ()> {
    expect_success("tests/fib.er")
}

#[test]
fn parse_hello_world() -> Result<(), ()> {
    expect_success("tests/hello_world.er")
}

#[test]
fn parse_simple_if() -> Result<(), ()> {
    expect_success("tests/simple_if.er")
}

#[test]
fn parse_stream() -> Result<(), ()> {
    expect_success("tests/stream.er")
}

#[test]
fn parse_test1_basic_syntax() -> Result<(), ()> {
    expect_success("tests/test1_basic_syntax.er")
}

#[test]
fn parse_test2_advanced_syntax() -> Result<(), ()> {
    expect_success("tests/test2_advanced_syntax.er")
}

#[test]
fn parse_stack() -> Result<(), ()> {
    expect_failure("tests/stack.er", 2)
}

#[test]
fn parse_str_literal() -> Result<(), ()> {
    expect_failure("tests/failed_str_lit.er", 2)
}

#[test]
fn exec_invalid_chunk_prs_err() -> Result<(), ()> {
    expect_failure("tests/invalid_chunk.er", 62)
}

fn _parse_test_from_code(file_path: &'static str) -> Result<(), ParserRunnerErrors> {
    let input = Input::file(file_path.into());
    let cfg = ErgConfig {
        input: input.clone(),
        py_server_timeout: 100,
        ..ErgConfig::default()
    };
    let lexer = Lexer::new(input.clone());
    let mut parser = ParserRunner::new(cfg);
    match parser.parse_token_stream(
        lexer
            .lex()
            .map_err(|errs| ParserRunnerErrors::convert(&input, errs))?,
    ) {
        Ok(module) => {
            println!("{module}");
            Ok(())
        }
        Err(e) => {
            e.fmt_all_stderr();
            Err(e)
        }
    }
}

fn parse_test_from_code(file_path: &'static str) -> Result<(), ParserRunnerErrors> {
    exec_new_thread(move || _parse_test_from_code(file_path), file_path)
}

fn expect_success(file_path: &'static str) -> Result<(), ()> {
    match parse_test_from_code(file_path) {
        Ok(_) => Ok(()),
        Err(_) => Err(()),
    }
}

fn expect_failure(file_path: &'static str, errs_len: usize) -> Result<(), ()> {
    match parse_test_from_code(file_path) {
        Ok(_) => Err(()),
        Err(errs) => {
            if errs.len() == errs_len {
                Ok(())
            } else {
                println!("err: error length is not {errs_len} but {}", errs.len());
                Err(())
            }
        }
    }
}