quickjs-oxide 0.4.1

A safe Rust JavaScript engine targeting semantic parity with QuickJS
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use super::*;

/// Early errors whose message and position follow pinned QuickJS: the name
/// checks that QuickJS runs after advancing past a token report the token
/// that follows it.
#[test]
fn early_error_messages_and_positions_follow_quickjs() {
    for (module, source, message, line, column) in [
        (
            false,
            "\"use strict\";07;",
            "octal literals are deprecated in strict mode",
            1,
            14,
        ),
        (false, "/*/", "unexpected end of comment", 1, 1),
        (
            false,
            "for(\n    false\n) {\n  break;\n}",
            "invalid for in/of left hand-side",
            3,
            1,
        ),
        (
            false,
            "for(\n) {\n  break;\n}",
            "unexpected token in expression: ')'",
            2,
            1,
        ),
        (
            false,
            "for (var x o\\u0066 []) ;",
            "expected 'of' or 'in' in for control expression",
            1,
            12,
        ),
        (
            false,
            "for (const let in {}) {}",
            "invalid lexical variable name",
            1,
            16,
        ),
        (
            false,
            "var af = enum => 1;",
            "unexpected token in expression: 'enum'",
            1,
            10,
        ),
        (
            false,
            "\"use strict\";var af = arguments => 1;",
            "invalid argument name in strict code",
            1,
            36,
        ),
        (
            false,
            "var af = (eval) => { \"use strict\"; };",
            "invalid argument name in strict code",
            1,
            22,
        ),
        (
            false,
            "{ async function f() {} class f {} }",
            "invalid redefinition of lexical identifier",
            1,
            36,
        ),
        (
            false,
            "{ var f; class f {} }",
            "invalid redefinition of global identifier",
            1,
            21,
        ),
        (
            false,
            "var f = () => super.x;",
            "'super' is only valid in a method",
            1,
            20,
        ),
        (false, "var f = super;", "invalid use of 'super'", 1, 14),
        (
            false,
            "var af = (x, [x]) => 1;",
            "duplicate parameter names not allowed in this context",
            1,
            15,
        ),
        (
            false,
            "function g(x, {a: x}) {}",
            "duplicate parameter names not allowed in this context",
            1,
            19,
        ),
        (
            false,
            "function g(x, {...x}) {}",
            "duplicate parameter names not allowed in this context",
            1,
            19,
        ),
        (
            true,
            "let f; let f;",
            "invalid redefinition of global identifier",
            1,
            13,
        ),
        (
            true,
            "let f; class f {}",
            "invalid redefinition of global identifier",
            1,
            18,
        ),
    ] {
        let error = if module {
            compile_unlinked_module_with_filename(source, "t.mjs", DebugInfoMode::StripDebug)
                .map(|_| ())
                .unwrap_err()
        } else {
            compile_unlinked_script(source).map(|_| ()).unwrap_err()
        };
        assert_eq!(error.kind(), ErrorKind::Syntax, "{source}");
        assert_eq!(error.message(), message, "{source}");
        let span = error.span().expect("syntax error lost its source span");
        assert_eq!(
            (span.start.line, span.start.column),
            (line, column),
            "{source}"
        );
    }
}