cfsolve 0.1.1 → 0.1.2

data/vendor/cfsolve/src/vm/interpret/evaluate.rs

@@ -11,13 +11,14 @@ use swc_core::ecma::ast::{BinaryOp, Expr, Stmt, UpdateOp};
 use super::access::{self, Key};
 use super::plan::{self, Case, Expression, FunctionPlan, Name, Property, Statement, Target};
 use super::run::{Evaluation, Flow, Frame, Run, Stop};
-use super::semantics;
+use super::{compile, semantics};
+use crate::vm::HashMap;
 use crate::vm::output::Term;
-use crate::vm::value::{Env, Value};
+use crate::vm::value::{Env, Scope, Value};
 
 /// Maximum handler loop count. Valid constants require fewer iterations; exceeding it indicates
 /// invalid instruction bytes.
-const MAXIMUM_ITERATIONS: usize = 1 << 16;
+pub(super) const MAXIMUM_ITERATIONS: usize = 1 << 16;
 
 impl<'ast> Run<'ast, '_> {
     pub(super) fn statement(&mut self, statement: &'ast Stmt) -> Evaluation<'ast, Flow<'ast>> {
@@ -28,31 +29,96 @@ impl<'ast> Run<'ast, '_> {
         self.evaluate(&plan::scoped_expression(expr), &mut [])
     }
 
+    /// Calls a slot plan. Its scope holds the locals nested functions mention, inside `closed`,
+    /// the scope the function captured, if any.
     pub(super) fn call_plan(
         &mut self,
         plan: &FunctionPlan<'ast>,
+        closed: Option<&Scope<'ast>>,
         this: Value<'ast>,
-        mut arguments: Vec<Value<'ast>>,
+        arguments: Vec<Value<'ast>>,
+    ) -> Evaluation<'ast, Value<'ast>> {
+        let mut locals = self.enter_plan(plan, closed, this, arguments);
+        let result = compile::run_all(&plan.code, self, &mut locals).map(returned);
+        self.frames.pop();
+        self.release_locals(locals);
+        result
+    }
+
+    /// Calls a handler's slot plan as [`Run::call_plan`] does, with no captured scope. Before
+    /// each top-level statement, `before` sees the statement's index and the locals.
+    pub(super) fn call_handler(
+        &mut self,
+        plan: &FunctionPlan<'ast>,
+        this: Value<'ast>,
+        arguments: Vec<Value<'ast>>,
+        before: &mut dyn FnMut(&Self, usize, &Locals<'ast>),
     ) -> Evaluation<'ast, Value<'ast>> {
+        let mut locals = self.enter_plan(plan, None, this, arguments);
+        let result = self.handler_statements(plan, 0, &mut locals, before);
+        self.release_locals(locals);
+        result
+    }
+
+    /// Binds a slot plan's parameters and pushes its frame. Returns the call's locals.
+    #[inline]
+    fn enter_plan(
+        &mut self,
+        plan: &FunctionPlan<'ast>,
+        closed: Option<&Scope<'ast>>,
+        this: Value<'ast>,
+        mut arguments: Vec<Value<'ast>>,
+    ) -> Vec<Option<Value<'ast>>> {
         let mut locals = self.spare.locals.pop().unwrap_or_default();
         locals.resize(plan.locals, None);
         if let Some(slot) = plan.arguments {
             locals[slot] = Some(Value::array(arguments.clone()));
         }
+        let scope = Env::scope(HashMap::default(), closed.cloned());
         let mut values = arguments.drain(..);
-        for &slot in &plan.parameters {
-            locals[slot] = Some(values.next().unwrap_or(Value::Undefined));
+        for parameter in &plan.parameters {
+            let value = values.next().unwrap_or(Value::Undefined);
+            match *parameter {
+                Name::Local(slot, _) => locals[slot] = Some(value),
+                Name::Global(name) => {
+                    scope.borrow_mut().variables.insert(name.clone(), value);
+                }
+            }
         }
         drop(values);
         self.spare.arguments.push(arguments);
-        let result = self.body(Frame::new(this), &plan.body, &mut locals);
+        self.frames.push(Frame { this, scope });
+        locals
+    }
+
+    /// Runs a handler's top-level statements from `start` in the frame the run holds, then
+    /// leaves that frame, as [`Run::body`] does.
+    pub(super) fn handler_statements(
+        &mut self,
+        plan: &FunctionPlan<'ast>,
+        start: usize,
+        locals: &mut Locals<'ast>,
+        before: &mut dyn FnMut(&Self, usize, &Locals<'ast>),
+    ) -> Evaluation<'ast, Value<'ast>> {
+        let mut flow = Ok(Flow::Normal);
+        for (index, statement) in plan.code.iter().enumerate().skip(start) {
+            before(self, index, locals);
+            flow = statement(self, locals);
+            if !matches!(flow, Ok(Flow::Normal)) {
+                break;
+            }
+        }
+        self.frames.pop();
+        flow.map(returned)
+    }
+
+    /// Returns a call's locals to the spare buffers.
+    fn release_locals(&mut self, mut locals: Vec<Option<Value<'ast>>>) {
         // Numeric locals need no destructor call.
-        let assigned = locals.drain(..).flatten();
-        for local in assigned {
+        for local in locals.drain(..).flatten() {
             local.discard();
         }
         self.spare.locals.push(locals);
-        result
     }
 
     /// Runs a function body in `frame`.
@@ -65,10 +131,7 @@ impl<'ast> Run<'ast, '_> {
         self.frames.push(frame);
         let flow = self.execute_all(body, locals);
         self.frames.pop();
-        match flow? {
-            Flow::Return(value) => Ok(value),
-            _ => Ok(Value::Undefined),
-        }
+        flow.map(returned)
     }
 
     fn execute_all(
@@ -86,7 +149,7 @@ impl<'ast> Run<'ast, '_> {
     }
 
     /// Checks whether `name` has already been declared in the current function.
-    fn declared(&self, name: Name<'ast>, locals: &Locals<'ast>) -> bool {
+    pub(super) fn declared(&self, name: Name<'ast>, locals: &Locals<'ast>) -> bool {
         match name {
             Name::Local(slot, _) => locals[slot].is_some(),
             Name::Global(name) => self.frame().scope.borrow().variables.contains_key(name),
@@ -94,7 +157,7 @@ impl<'ast> Run<'ast, '_> {
     }
 
     /// Declares `name` with `value`.
-    fn bind(&mut self, name: Name<'ast>, value: Value<'ast>, locals: &mut Locals<'ast>) {
+    pub(super) fn bind(&mut self, name: Name<'ast>, value: Value<'ast>, locals: &mut Locals<'ast>) {
         match name {
             Name::Local(slot, _) => locals[slot] = Some(value),
             Name::Global(name) => self.declare(name.clone(), value),
@@ -130,25 +193,14 @@ impl<'ast> Run<'ast, '_> {
                 handler,
                 finalizer,
             } => {
-                let mut outcome = self.execute_all(block, locals);
-                if let Some(handler) = handler
-                    && let Err(stop) = &mut outcome
-                    && let Stop::Throw(exception) = &mut **stop
-                {
-                    let exception = mem::replace(exception, Value::Undefined);
-                    if let Some(parameter) = parameter {
-                        self.bind(*parameter, exception, locals);
-                    }
-                    outcome = self.execute_all(handler, locals);
-                }
-                // A jump from `finally` overrides the previous completion of the block.
-                if let Some(finalizer) = finalizer {
-                    match self.execute_all(finalizer, locals)? {
-                        Flow::Normal => {}
-                        flow => return Ok(flow),
-                    }
-                }
-                return outcome;
+                return self.attempt(
+                    block.as_slice(),
+                    *parameter,
+                    handler.as_deref(),
+                    finalizer.as_deref(),
+                    locals,
+                    Self::execute_all,
+                );
             }
             Statement::Block(statements) => return self.execute_all(statements, locals),
             Statement::If(test, yes, no) => {
@@ -216,6 +268,39 @@ impl<'ast> Run<'ast, '_> {
         Ok(Flow::Normal)
     }
 
+    /// Runs a `try` statement whose bodies `run` executes: `block`, then `handler` with an
+    /// exception bound to `parameter`, then `finalizer`.
+    #[inline]
+    pub(super) fn attempt<Body: ?Sized>(
+        &mut self,
+        block: &Body,
+        parameter: Option<Name<'ast>>,
+        handler: Option<&Body>,
+        finalizer: Option<&Body>,
+        locals: &mut Locals<'ast>,
+        run: impl Fn(&mut Self, &Body, &mut Locals<'ast>) -> Evaluation<'ast, Flow<'ast>>,
+    ) -> Evaluation<'ast, Flow<'ast>> {
+        let mut outcome = run(self, block, locals);
+        if let Some(handler) = handler
+            && let Err(stop) = &mut outcome
+            && let Stop::Throw(exception) = &mut **stop
+        {
+            let exception = mem::replace(exception, Value::Undefined);
+            if let Some(parameter) = parameter {
+                self.bind(parameter, exception, locals);
+            }
+            outcome = run(self, handler, locals);
+        }
+        // A jump from `finally` overrides the previous completion of the block.
+        if let Some(finalizer) = finalizer {
+            match run(self, finalizer, locals)? {
+                Flow::Normal => {}
+                flow => return Ok(flow),
+            }
+        }
+        outcome
+    }
+
     /// Runs from the first case strictly equal to `discriminant`, or else from the default.
     fn switch(
         &mut self,
@@ -504,35 +589,52 @@ impl<'ast> Run<'ast, '_> {
         locals: &mut Locals<'ast>,
     ) -> Evaluation<'ast, Value<'ast>> {
         let target = self.locate(target, locals)?;
-        let value = match operator {
-            None => self.evaluate(right, locals)?,
-            Some(BinaryOp::LogicalAnd | BinaryOp::LogicalOr | BinaryOp::NullishCoalescing) => {
-                return Err(Stop::unsupported("a logical assignment"));
-            }
-            // The script reapplies a new rolling mask to the program counter or key. The
-            // interpreter keeps that mask at zero; see `crate::vm::registers`.
-            Some(_) if matches!(&target, Location::Member(Value::Registers, Key::Name(_))) => {
-                self.evaluate(right, locals)?;
-                return self.read(&target, locals);
+        let Some(operator) = operator else {
+            let value = self.evaluate(right, locals)?;
+            self.write(target, value.clone(), locals)?;
+            return Ok(value);
+        };
+        self.compound(target, operator, locals, |run, locals| {
+            run.evaluate(right, locals)
+        })
+    }
+
+    /// Assigns to `target` with `operator`, as in `target += right`, where `right` evaluates
+    /// the right side.
+    #[inline]
+    pub(super) fn compound(
+        &mut self,
+        target: Location<'ast>,
+        operator: BinaryOp,
+        locals: &mut Locals<'ast>,
+        right: impl FnOnce(&mut Self, &mut Locals<'ast>) -> Evaluation<'ast, Value<'ast>>,
+    ) -> Evaluation<'ast, Value<'ast>> {
+        if matches!(
+            operator,
+            BinaryOp::LogicalAnd | BinaryOp::LogicalOr | BinaryOp::NullishCoalescing
+        ) {
+            return Err(Stop::unsupported("a logical assignment"));
+        }
+        // The script reapplies a new rolling mask to the program counter or key. The
+        // interpreter keeps that mask at zero; see `crate::vm::registers`.
+        if matches!(&target, Location::Member(Value::Registers, Key::Name(_))) {
+            right(self, locals)?;
+            return self.read(&target, locals);
+        }
+        // The target's old value is read before the right side runs.
+        let old = self.read(&target, locals)?;
+        let right = right(self, locals)?;
+        // Release the old value before overwriting it, allowing `s += c` to append in place.
+        match &target {
+            Location::Name(Name::Local(slot, _)) if locals[*slot].is_some() => {
+                locals[*slot] = Some(Value::Undefined);
             }
-            // The target's old value is read before the right side runs.
-            Some(operator) => {
-                let old = self.read(&target, locals)?;
-                let right = self.evaluate(right, locals)?;
-                // Release the old value before overwriting it, allowing `s += c` to append in
-                // place.
-                match &target {
-                    Location::Name(Name::Local(slot, _)) if locals[*slot].is_some() => {
-                        locals[*slot] = Some(Value::Undefined);
-                    }
-                    Location::Name(name) => {
-                        Env::assign(&self.frame().scope, name.atom(), Value::Undefined);
-                    }
-                    Location::Member(..) => {}
-                }
-                binary_value(operator, old, right)
+            Location::Name(name) => {
+                Env::assign(&self.frame().scope, name.atom(), Value::Undefined);
             }
-        };
+            Location::Member(..) => {}
+        }
+        let value = binary_value(operator, old, right);
         self.write(target, value.clone(), locals)?;
         Ok(value)
     }
@@ -549,18 +651,27 @@ impl<'ast> Run<'ast, '_> {
         if let Target::Name(Name::Local(slot, _)) = target
             && let Some(Value::Number(number)) = &mut locals[*slot]
         {
-            let change = updated(operator, prefix, *number);
-            *number = change.written;
-            return Ok(Value::Number(change.value));
+            return Ok(Value::Number(step(operator, prefix, number)));
         }
         let target = self.locate(target, locals)?;
+        self.update_location(target, operator, prefix, locals)
+    }
+
+    /// Applies `++` or `--` to the number at `target`.
+    pub(super) fn update_location(
+        &mut self,
+        target: Location<'ast>,
+        operator: UpdateOp,
+        prefix: bool,
+        locals: &mut Locals<'ast>,
+    ) -> Evaluation<'ast, Value<'ast>> {
         let old = self.read(&target, locals)?;
-        let old = old
+        let mut number = old
             .number()
             .ok_or_else(|| Stop::unsupported(&format!("incrementing {}", old.expr())))?;
-        let change = updated(operator, prefix, old);
-        self.write(target, Value::Number(change.written), locals)?;
-        Ok(Value::Number(change.value))
+        let value = step(operator, prefix, &mut number);
+        self.write(target, Value::Number(number), locals)?;
+        Ok(Value::Number(value))
     }
 
     /// Evaluates `&&`, `||`, or `??`, evaluating `right` only when needed.
@@ -574,6 +685,22 @@ impl<'ast> Run<'ast, '_> {
         locals: &mut Locals<'ast>,
     ) -> Evaluation<'ast, Value<'ast>> {
         let left = self.evaluate(left, locals)?;
+        self.short_circuit(operator, left, pure, locals, |run, locals| {
+            run.evaluate(right, locals)
+        })
+    }
+
+    /// Finishes `&&`, `||`, or `??` after its left side, calling `right` to evaluate the right
+    /// side only when needed.
+    #[inline]
+    pub(super) fn short_circuit(
+        &mut self,
+        operator: BinaryOp,
+        left: Value<'ast>,
+        pure: bool,
+        locals: &mut Locals<'ast>,
+        right: impl Fn(&mut Self, &mut Locals<'ast>) -> Evaluation<'ast, Value<'ast>>,
+    ) -> Evaluation<'ast, Value<'ast>> {
         // Condition controlling right-operand evaluation and the branch direction that
         // evaluates it.
         let (test, runs_right) = match operator {
@@ -588,7 +715,7 @@ impl<'ast> Run<'ast, '_> {
             // An effect-free right operand may become a symbolic term only if evaluating it
             // cannot introduce an exception on a skipped path.
             let effects = self.effects.len();
-            if let Ok(right) = self.evaluate(right, locals) {
+            if let Ok(right) = right(self, locals) {
                 debug_assert_eq!(
                     effects,
                     self.effects.len(),
@@ -602,7 +729,7 @@ impl<'ast> Run<'ast, '_> {
             }
         }
         if self.decide(&test) == runs_right {
-            self.evaluate(right, locals)
+            right(self, locals)
         } else {
             Ok(left)
         }
@@ -624,7 +751,7 @@ impl<'ast> Run<'ast, '_> {
         })
     }
 
-    fn read(
+    pub(super) fn read(
         &mut self,
         target: &Location<'ast>,
         locals: &Locals<'ast>,
@@ -641,7 +768,7 @@ impl<'ast> Run<'ast, '_> {
 
     /// Writes declared locals directly, since they are the most common assignment target.
     #[inline]
-    fn write(
+    pub(super) fn write(
         &mut self,
         target: Location<'ast>,
         value: Value<'ast>,
@@ -667,7 +794,7 @@ impl<'ast> Run<'ast, '_> {
 
 /// Clones a value, using a fast path for numbers.
 #[inline(always)]
-fn copied<'a>(value: &Value<'a>) -> Value<'a> {
+pub(super) fn copied<'a>(value: &Value<'a>) -> Value<'a> {
     match value {
         Value::Number(number) => Value::Number(*number),
         value => value.clone(),
@@ -676,21 +803,21 @@ fn copied<'a>(value: &Value<'a>) -> Value<'a> {
 
 /// Extracts the value from a [`Run::number`] result.
 #[inline(always)]
-fn number_value(number: Result<f64, Value<'_>>) -> Value<'_> {
+pub(super) fn number_value(number: Result<f64, Value<'_>>) -> Value<'_> {
     number.map_or_else(|value| value, Value::Number)
 }
 
 /// Slot-indexed call locals; `None` until declared or written.
-type Locals<'ast> = [Option<Value<'ast>>];
+pub(super) type Locals<'ast> = [Option<Value<'ast>>];
 
-enum Location<'ast> {
+pub(super) enum Location<'ast> {
     Name(Name<'ast>),
     Member(Value<'ast>, Key<'ast, 'ast>),
 }
 
 /// Applies [`semantics::binary_value`] to numeric operands without coercion or symbolic terms.
 #[inline(always)]
-fn binary_value<'a>(operator: BinaryOp, left: Value<'a>, right: Value<'a>) -> Value<'a> {
+pub(super) fn binary_value<'a>(operator: BinaryOp, left: Value<'a>, right: Value<'a>) -> Value<'a> {
     let (&Value::Number(a), &Value::Number(b)) = (&left, &right) else {
         return semantics::binary_value(operator, left, right);
     };
@@ -710,24 +837,24 @@ fn binary_value<'a>(operator: BinaryOp, left: Value<'a>, right: Value<'a>) -> Va
     })
 }
 
-/// Values produced and stored by an increment or decrement.
-struct Updated {
-    /// The number written back.
-    written: f64,
-    /// Expression result: the new number for prefix form, or the old number for postfix form.
-    value: f64,
-}
-
-/// Computes the result and stored value for `++` or `--` applied to `old`.
+/// Applies `++` or `--` to `number` in place. Returns the expression's result: the new number
+/// in prefix form, or the old number in postfix form.
 #[inline(always)]
-fn updated(operator: UpdateOp, prefix: bool, old: f64) -> Updated {
-    let new = match operator {
+pub(super) fn step(operator: UpdateOp, prefix: bool, number: &mut f64) -> f64 {
+    let old = *number;
+    *number = match operator {
         UpdateOp::PlusPlus => old + 1.0,
         UpdateOp::MinusMinus => old - 1.0,
     };
-    Updated {
-        written: new,
-        value: if prefix { new } else { old },
+    if prefix { *number } else { old }
+}
+
+/// The result of a call whose body completed with `flow`.
+#[inline]
+fn returned(flow: Flow<'_>) -> Value<'_> {
+    match flow {
+        Flow::Return(value) => value,
+        _ => Value::Undefined,
     }
 }