boa_engine 0.17.0

Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
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

use crate::{
    builtins::array::Array,
    object::IntegrityLevel,
    property::PropertyDescriptor,
    vm::{opcode::Operation, CompletionType},
    Context, JsResult,
};
use boa_macros::utf16;

/// `TemplateLookup` implements the Opcode Operation for `Opcode::TemplateLookup`
///
/// Operation:
///  - Lookup if a tagged template object is cached and skip the creation if it is.
#[derive(Debug, Clone, Copy)]
pub(crate) struct TemplateLookup;

impl Operation for TemplateLookup {
    const NAME: &'static str = "TemplateLookup";
    const INSTRUCTION: &'static str = "INST - TemplateLookup";

    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
        let jump = context.vm.read::<u32>();
        let site = context.vm.read::<u64>();

        if let Some(template) = context.realm().lookup_template(site) {
            context.vm.push(template);
            context.vm.frame_mut().pc = jump;
        }

        Ok(CompletionType::Normal)
    }
}

/// `TemplateCreate` implements the Opcode Operation for `Opcode::TemplateCreate`
///
/// Operation:
///  - Create a new tagged template object and cache it.
#[derive(Debug, Clone, Copy)]
pub(crate) struct TemplateCreate;

impl Operation for TemplateCreate {
    const NAME: &'static str = "TemplateCreate";
    const INSTRUCTION: &'static str = "INST - TemplateCreate";

    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
        let count = context.vm.read::<u32>();
        let site = context.vm.read::<u64>();

        let template =
            Array::array_create(count.into(), None, context).expect("cannot fail per spec");
        let raw_obj =
            Array::array_create(count.into(), None, context).expect("cannot fail per spec");

        for index in (0..count).rev() {
            let raw_value = context.vm.pop();
            let cooked_value = context.vm.pop();
            template
                .define_property_or_throw(
                    index,
                    PropertyDescriptor::builder()
                        .value(cooked_value)
                        .writable(false)
                        .enumerable(true)
                        .configurable(false),
                    context,
                )
                .expect("should not fail on new array");
            raw_obj
                .define_property_or_throw(
                    index,
                    PropertyDescriptor::builder()
                        .value(raw_value)
                        .writable(false)
                        .enumerable(true)
                        .configurable(false),
                    context,
                )
                .expect("should not fail on new array");
        }

        raw_obj
            .set_integrity_level(IntegrityLevel::Frozen, context)
            .expect("should never fail per spec");
        template
            .define_property_or_throw(
                utf16!("raw"),
                PropertyDescriptor::builder()
                    .value(raw_obj)
                    .writable(false)
                    .enumerable(false)
                    .configurable(false),
                context,
            )
            .expect("should never fail per spec");
        template
            .set_integrity_level(IntegrityLevel::Frozen, context)
            .expect("should never fail per spec");

        context.realm().push_template(site, template.clone());

        context.vm.push(template);
        Ok(CompletionType::Normal)
    }
}