parse-js 0.2.5

JavaScript parsing library
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

use crate::error::SyntaxErrorType::{self, *};
use crate::lex::{lex_next, LexMode, Lexer};
use crate::token::TokenType::{self, *};

fn check(code: &str, expecteds: &[TokenType], expected_err: Option<SyntaxErrorType>) -> () {
    let mut lexer = Lexer::new(code.as_bytes().to_vec());
    for expected in expecteds {
        match lex_next(&mut lexer, LexMode::Standard) {
            Err(e) => panic!("Failed to parse code with error {:?}: {}", e.typ(), code),
            Ok(t) => assert_eq!(t.typ(), *expected),
        };
    }
    match lex_next(&mut lexer, LexMode::Standard) {
        Err(e) => match expected_err {
            Some(expected) => assert_eq!(e.typ(), expected),
            None => panic!("Failed to parse code with error {:?}: {}", e.typ(), code),
        },
        Ok(t) => match expected_err {
            Some(_) => panic!("Code parsed successfully: {}", code),
            None => assert_eq!(EOF, t.typ()),
        },
    };
}

#[test]
fn test_lex_keywords() {
    check("class", &[KeywordClass], None);
    check("instanceof", &[KeywordInstanceof], None);
}

#[test]
fn test_lex_identifiers() {
    check("h929", &[Identifier], None);
}

#[test]
fn test_lex_literal_numbers() {
    check("1", &[LiteralNumber], None);
    check("929", &[LiteralNumber], None);
    check(".929", &[LiteralNumber], None);
    check(". 929", &[Dot, LiteralNumber], None);
    check(". 929.2.", &[Dot, LiteralNumber, Dot], None);
    check(".929.2..", &[LiteralNumber, LiteralNumber, Dot, Dot], None);
    check(".929. 2..", &[LiteralNumber, Dot, LiteralNumber, Dot], None);
    check("?.929", &[Question, LiteralNumber], None);
    check("?..929", &[QuestionDot, LiteralNumber], None);
    check("?...929", &[QuestionDot, Dot, LiteralNumber], None);
    check("?...929.", &[QuestionDot, Dot, LiteralNumber, Dot], None);
}

#[test]
fn test_lex_literal_strings() {
    check("'hello world'", &[LiteralString], None);
    check("'hello world\n'", &[], Some(LineTerminatorInString));
}

#[test]
fn test_lex_import_statement() {
    check(
        "import * as a from \"./a\";",
        &[
            KeywordImport,
            Asterisk,
            KeywordAs,
            Identifier,
            KeywordFrom,
            LiteralString,
            Semicolon,
        ],
        None,
    );
    check(
        "import * as a from './a';",
        &[
            KeywordImport,
            Asterisk,
            KeywordAs,
            Identifier,
            KeywordFrom,
            LiteralString,
            Semicolon,
        ],
        None,
    );
}