boa-cat 0.2.0

Tree-walking ECMAScript interpreter built on ecma-syntax-cat. Evaluates Script programs to Values with a persistent heap and lexical environment, plus native (Rust-implemented) callables for embedder-supplied built-ins. No mut, no Rc/Arc, no interior mutability, no panics, exhaustive matches. Comp-cat-rs reformulation of the Boa engine core, targeting Tauri integration.
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

//! Persistent lexical environments.
//!
//! The environment is a cons list of `(name, CellId)` bindings.  Cells
//! live in the [`Heap`] so assignment can mutate variables without
//! rebuilding the surrounding environment.
//!
//! [`Heap`]: crate::heap::Heap

use crate::value::{CellId, Value};

/// A binding's reference: either a heap-allocated cell (for variables and
/// parameters) or a direct value (used for the implicit `__this__`
/// binding which is value-typed and never assigned).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Binding {
    /// A mutable or immutable variable cell.
    Cell(CellId),
    /// A direct value binding (e.g. `__this__`).
    Direct(Value),
}

/// A persistent lexical environment.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub enum Env {
    /// The empty environment.
    #[default]
    Empty,
    /// A binding atop a smaller environment.
    Cons {
        /// The bound name.
        name: String,
        /// The binding -- a cell reference or direct value.
        binding: Binding,
        /// The environment underneath this binding.
        rest: Box<Env>,
    },
}

impl Env {
    /// The empty environment.
    #[must_use]
    pub fn empty() -> Self {
        Self::Empty
    }

    /// Extend `self` with a cell-backed binding.
    #[must_use]
    pub fn extend_cell(&self, name: impl Into<String>, cell: CellId) -> Self {
        Self::Cons {
            name: name.into(),
            binding: Binding::Cell(cell),
            rest: Box::new(self.clone()),
        }
    }

    /// Extend `self` with a direct value binding.  Used for the implicit
    /// `__this__` binding which is value-typed.
    #[must_use]
    pub fn extend_direct(&self, name: impl Into<String>, value: Value) -> Self {
        Self::Cons {
            name: name.into(),
            binding: Binding::Direct(value),
            rest: Box::new(self.clone()),
        }
    }

    /// Look up `name`, returning the most recently bound binding.
    #[must_use]
    pub fn lookup(&self, name: &str) -> Option<&Binding> {
        match self {
            Self::Empty => None,
            Self::Cons {
                name: n,
                binding,
                rest,
            } => {
                if n == name {
                    Some(binding)
                } else {
                    rest.lookup(name)
                }
            }
        }
    }
}