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

use super::PassAction;
use boa_ast::{
    visitor::{VisitWith, VisitorMut},
    Expression,
};
use std::{convert::Infallible, ops::ControlFlow};

/// The utility structure that traverses the AST.
pub(crate) struct Walker<F>
where
    F: FnMut(&mut Expression) -> PassAction<Expression>,
{
    /// The function to be applied to the node.
    f: F,

    /// Did a change happen while traversing.
    changed: bool,
}

impl<F> Walker<F>
where
    F: FnMut(&mut Expression) -> PassAction<Expression>,
{
    pub(crate) const fn new(f: F) -> Self {
        Self { f, changed: false }
    }

    pub(crate) const fn changed(&self) -> bool {
        self.changed
    }

    /// Walk the AST in postorder.
    pub(crate) fn walk_expression_postorder(&mut self, expr: &mut Expression) {
        self.visit_expression_mut(expr);
    }
}

impl<'ast, F> VisitorMut<'ast> for Walker<F>
where
    F: FnMut(&mut Expression) -> PassAction<Expression>,
{
    type BreakTy = Infallible;

    /// Visits the tree in postorder.
    fn visit_expression_mut(&mut self, expr: &'ast mut Expression) -> ControlFlow<Self::BreakTy> {
        expr.visit_with_mut(self);

        match (self.f)(expr) {
            PassAction::Keep => {}
            PassAction::Modified => self.changed = true,
            PassAction::Replace(new) => {
                *expr = new;
                self.changed = true;
            }
        }

        ControlFlow::Continue(())
    }
}