nova_vm 1.0.0

Nova Virtual Machine
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

use ahash::AHashMap;

use crate::{
    ecmascript::{OrdinaryObject, Value, execution::WeakKey},
    engine::bindable_handle,
    heap::{CompactionLists, HeapMarkAndSweep, HeapSweepWeakReference, WorkQueues},
};

#[derive(Debug, Default)]
pub(crate) struct WeakMapRecord<'a> {
    pub(crate) weak_map_data: AHashMap<WeakKey<'a>, Value<'a>>,
    pub(super) object_index: Option<OrdinaryObject<'a>>,
}
bindable_handle!(WeakMapRecord);

impl<'a> WeakMapRecord<'a> {
    pub(super) fn delete(&mut self, key: WeakKey<'a>) -> bool {
        // 4. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
        // a. If p.[[Key]] is not EMPTY and SameValue(p.[[Key]], key) is true, then
        // i. Set p.[[Key]] to EMPTY.
        // ii. Set p.[[Value]] to EMPTY.
        // iii. Return true.
        // 5. Return false.
        self.weak_map_data.remove(&key).is_some()
    }

    pub(super) fn get(&mut self, key: WeakKey<'a>) -> Option<Value<'a>> {
        // 4. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
        // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return p.[[Value]].
        // 5. Return undefined.
        self.weak_map_data.get(&key).cloned()
    }

    pub(super) fn has(&mut self, key: WeakKey<'a>) -> bool {
        // 4. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
        // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return true.
        // 5. Return false.
        self.weak_map_data.contains_key(&key)
    }

    pub(super) fn set(&mut self, key: WeakKey<'a>, value: Value<'a>) {
        // 4. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
        // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
        // i. Set p.[[Value]] to value.
        // ii. Return M.
        // 5. Let p be the Record { [[Key]]: key, [[Value]]: value }.
        // 6. Append p to M.[[WeakMapData]].
        self.weak_map_data.insert(key, value);
    }
}

impl HeapMarkAndSweep for WeakMapRecord<'static> {
    fn mark_values(&self, queues: &mut WorkQueues) {
        let Self {
            weak_map_data: map,
            object_index,
        } = self;
        for (key, value) in map.iter() {
            if queues.bits.is_marked(key) {
                value.mark_values(queues);
            } else {
                queues.pending_ephemerons.push((*key, *value));
            }
        }
        object_index.mark_values(queues);
    }

    fn sweep_values(&mut self, compactions: &CompactionLists) {
        let Self {
            weak_map_data: map,
            object_index,
        } = self;
        let old_map = core::mem::replace(map, AHashMap::with_capacity(map.len()));
        for (key, mut value) in old_map {
            if let Some(key) = key.sweep_weak_reference(compactions) {
                value.sweep_values(compactions);
                map.insert(key, value);
            }
        }
        object_index.sweep_values(compactions);
    }
}