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

use super::*;

#[test]
fn array_literals_lower_dense_fixed_hole_and_spread_phases() {
    let dense = compile_unlinked_script("[1,2,3]").unwrap();
    assert!(
        dense
            .code()
            .iter()
            .any(|instruction| matches!(instruction, Instruction::ArrayFrom(3)))
    );
    assert!(!dense.code().iter().any(|instruction| matches!(
        instruction,
        Instruction::DefineField(_) | Instruction::DefineArrayEl | Instruction::Append
    )));

    let large_source = format!(
        "[{}]",
        (0..33)
            .map(|value| value.to_string())
            .collect::<Vec<_>>()
            .join(",")
    );
    let large = compile_unlinked_script(&large_source).unwrap();
    assert!(
        large
            .code()
            .iter()
            .any(|instruction| matches!(instruction, Instruction::ArrayFrom(32)))
    );
    let fixed_key = large
        .code()
        .iter()
        .find_map(|instruction| match instruction {
            Instruction::DefineField(index) => Some(*index),
            _ => None,
        })
        .expect("33rd Array element must use DefineField");
    assert!(matches!(
        large.constants()[usize::try_from(fixed_key).unwrap()].as_primitive(),
        Some(crate::engine::value::PrimitiveValue::String(value)) if value == &JsString::from_static("32")
    ));

    let holes = compile_unlinked_script("[,1,,]").unwrap();
    let hole_code = holes.code();
    assert!(
        hole_code
            .iter()
            .any(|instruction| matches!(instruction, Instruction::ArrayFrom(0)))
    );
    assert!(
        hole_code
            .iter()
            .any(|instruction| matches!(instruction, Instruction::DefineField(_)))
    );
    assert!(hole_code.windows(3).any(|window| matches!(
        window,
        [
            Instruction::Dup,
            Instruction::PushI32(3),
            Instruction::PutField(_)
        ]
    )));

    let spread = compile_unlinked_script("[1,...'ab',,4]").unwrap();
    assert!(
        spread
            .code()
            .iter()
            .any(|instruction| matches!(instruction, Instruction::Append))
    );
    assert!(spread.code().windows(3).any(|window| matches!(
        window,
        [
            Instruction::DefineArrayEl,
            Instruction::Inc,
            Instruction::Drop
        ]
    )));
}

#[test]
fn array_literal_grammar_keeps_quickjs_boundaries_and_reference_state() {
    for source in [
        "[]",
        "[,]",
        "[,,]",
        "[1,]",
        "[...'',]",
        "for([1 in Function];false;);",
    ] {
        compile_unlinked_script(source)
            .unwrap_or_else(|error| panic!("valid Array literal {source:?}: {error}"));
    }
    assert_eq!(
        compile_unlinked_script("[1 2]").unwrap_err().message(),
        "expecting ']'"
    );
    compile_unlinked_script("[/a/]").unwrap();
    for source in ["[... ]", "[1,, 2 3]"] {
        assert!(
            compile_unlinked_script(source).is_err(),
            "invalid Array literal unexpectedly compiled: {source}"
        );
    }

    let named = compile_unlinked_script("var named=[function(){}]").unwrap();
    assert!(
        !named
            .code()
            .iter()
            .any(|instruction| matches!(instruction, Instruction::SetName(_)))
    );
    let child = named
        .constants()
        .iter()
        .find_map(|constant| constant.as_child())
        .expect("Array element function child");
    assert_eq!(child.func_name(), None);
}