boa_engine 0.21.1

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
105
106
107
108
109

use crate::{
    Context, JsResult,
    builtins::function::OrdinaryFunction,
    object::JsFunction,
    vm::opcode::{Operation, VaryingOperand},
};

/// `PushClassField` implements the Opcode Operation for `Opcode::PushClassField`
///
/// Operation:
///  - Push a field to a class.
#[derive(Debug, Clone, Copy)]
pub(crate) struct PushClassField;

impl PushClassField {
    #[inline(always)]
    pub(crate) fn operation(
        (class, name, function, is_anonyms_function): (
            VaryingOperand,
            VaryingOperand,
            VaryingOperand,
            VaryingOperand,
        ),
        context: &mut Context,
    ) -> JsResult<()> {
        let class = context.vm.get_register(class.into()).clone();
        let name = context.vm.get_register(name.into()).clone();
        let function = context.vm.get_register(function.into()).clone();
        let is_anonyms_function = u32::from(is_anonyms_function) != 0;

        let name = name.to_property_key(context)?;
        let function = function
            .as_object()
            .expect("field value must be function object");
        let class = class.as_object().expect("class must be function object");

        function
            .downcast_mut::<OrdinaryFunction>()
            .expect("field value must be function object")
            .set_home_object(class.clone());

        class
            .downcast_mut::<OrdinaryFunction>()
            .expect("class must be function object")
            .push_field(
                name.clone(),
                JsFunction::from_object_unchecked(function.clone()),
                if is_anonyms_function {
                    Some(name)
                } else {
                    None
                },
            );
        Ok(())
    }
}

impl Operation for PushClassField {
    const NAME: &'static str = "PushClassField";
    const INSTRUCTION: &'static str = "INST - PushClassField";
    const COST: u8 = 6;
}

/// `PushClassFieldPrivate` implements the Opcode Operation for `Opcode::PushClassFieldPrivate`
///
/// Operation:
///  - Push a private field to the class.
#[derive(Debug, Clone, Copy)]
pub(crate) struct PushClassFieldPrivate;

impl PushClassFieldPrivate {
    #[inline(always)]
    pub(crate) fn operation(
        (class, function, index): (VaryingOperand, VaryingOperand, VaryingOperand),
        context: &mut Context,
    ) {
        let class = context.vm.get_register(class.into());
        let function = context.vm.get_register(function.into());
        let name = context
            .vm
            .frame()
            .code_block()
            .constant_string(index.into());

        let function = function
            .as_object()
            .expect("field value must be function object");
        let class = class.as_object().expect("class must be function object");

        function
            .downcast_mut::<OrdinaryFunction>()
            .expect("field value must be function object")
            .set_home_object(class.clone());

        class
            .downcast_mut::<OrdinaryFunction>()
            .expect("class must be function object")
            .push_field_private(
                class.private_name(name),
                JsFunction::from_object_unchecked(function.clone()),
            );
    }
}

impl Operation for PushClassFieldPrivate {
    const NAME: &'static str = "PushClassFieldPrivate";
    const INSTRUCTION: &'static str = "INST - PushClassFieldPrivate";
    const COST: u8 = 3;
}