cfsolve 0.1.1 → 0.1.2

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

@@ -3,8 +3,7 @@
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use swc_core::atoms::Atom;
-
+use super::frozen::{self, Frozen};
 use crate::vm::HashMap;
 use crate::vm::value::{Callable, Env, Scope, Value};
 
@@ -17,135 +16,248 @@ pub(super) struct Copies<'ast> {
 }
 
 /// Deep-copies mutable state in `value`. Uses original addresses in `copies` to preserve shared
-/// references and avoid copying twice.
-pub(super) fn copy<'a>(value: &Value<'a>, copies: &mut Copies<'a>) -> Value<'a> {
-    let address = match value {
-        Value::Array(elements) => Rc::as_ptr(elements).addr(),
-        Value::Object(properties) => Rc::as_ptr(properties).addr(),
-        Value::Set(members) => Rc::as_ptr(members).addr(),
-        Value::Map(entries) => Rc::as_ptr(entries).addr(),
-        Value::Function(callable) => Rc::as_ptr(callable).addr(),
-        _ => return value.clone(),
-    };
-    if let Some(copy) = copies.values.get(&address) {
-        return copy.clone();
-    }
-    match value {
-        Value::Array(elements) => copy_elements(elements, address, copies, Value::Array, copy),
-        Value::Set(members) => copy_elements(members, address, copies, Value::Set, copy),
-        Value::Map(entries) => copy_elements(
-            entries,
-            address,
-            copies,
-            Value::Map,
-            |(key, value), copies| (copy(key, copies), copy(value, copies)),
-        ),
-        Value::Object(properties) => copy_elements(
-            properties,
-            address,
-            copies,
-            Value::Object,
-            |(name, value), copies| (name.clone(), copy(value, copies)),
-        ),
-        Value::Function(callable) => {
-            let copied = match &**callable {
-                Callable::Script {
-                    name,
-                    function,
-                    scope: Some(scope),
-                } => match copy_scope(scope, copies) {
-                    // The function captures no mutable state.
-                    None => return value.clone(),
-                    scope => Callable::Script {
-                        name: name.clone(),
+/// references and avoid copying twice. Objects in `frozen` stay shared.
+pub(super) fn copy<'a>(
+    value: &Value<'a>,
+    copies: &mut Copies<'a>,
+    frozen: Option<&Frozen>,
+) -> Value<'a> {
+    Isolation { copies, frozen }.copy(value)
+}
+
+/// The deep copy shared by [`copy`] and [`Fork`], which differ in the scopes they copy.
+trait Copier<'ast>: Sized {
+    /// Shared session objects, which are not copied.
+    fn frozen(&self) -> Option<&Frozen>;
+    /// Copies by original address.
+    fn values(&mut self) -> &mut HashMap<usize, Value<'ast>>;
+    /// Copies a function's captured scope, or returns `None` if it needs no copy.
+    fn captured(&mut self, scope: &Scope<'ast>) -> Option<Scope<'ast>>;
+
+    fn copy(&mut self, value: &Value<'ast>) -> Value<'ast> {
+        if let Some(frozen) = self.frozen()
+            && let Some(address) = frozen::address(value)
+            && frozen.contains(address)
+        {
+            return value.clone();
+        }
+        let address = match (value, frozen::address(value)) {
+            (Value::Function(callable), _) => Rc::as_ptr(callable).addr(),
+            (_, Some(address)) => address,
+            (_, None) => return value.clone(),
+        };
+        if let Some(copy) = self.values().get(&address) {
+            return copy.clone();
+        }
+        match value {
+            Value::Array(elements) => self.elements(elements, address, Value::Array, Self::copy),
+            Value::Set(members) => self.elements(members, address, Value::Set, Self::copy),
+            Value::Map(entries) => {
+                self.elements(entries, address, Value::Map, |copier, (key, value)| {
+                    (copier.copy(key), copier.copy(value))
+                })
+            }
+            Value::Object(properties) => self.elements(
+                properties,
+                address,
+                Value::Object,
+                |copier, (name, value)| (name.clone(), copier.copy(value)),
+            ),
+            Value::Function(callable) => {
+                let copied = match &**callable {
+                    Callable::Script {
+                        name,
                         function,
-                        scope,
+                        scope: Some(scope),
+                    } => match self.captured(scope) {
+                        // The function captures no mutable state.
+                        None => return value.clone(),
+                        scope => Callable::Script {
+                            name: name.clone(),
+                            function,
+                            scope,
+                        },
+                    },
+                    Callable::Script { scope: None, .. }
+                    | Callable::Builtin(_)
+                    | Callable::Standard(_) => return value.clone(),
+                    Callable::Arrow { arrow, this, scope } => Callable::Arrow {
+                        arrow,
+                        this: self.copy(this),
+                        scope: scope.as_ref().and_then(|scope| self.captured(scope)),
+                    },
+                    Callable::Call(target) => Callable::Call(self.copy(target)),
+                    Callable::Apply(target) => Callable::Apply(self.copy(target)),
+                    Callable::Bind(target) => Callable::Bind(self.copy(target)),
+                    Callable::Bound {
+                        target,
+                        this,
+                        arguments,
+                    } => Callable::Bound {
+                        target: self.copy(target),
+                        this: self.copy(this),
+                        arguments: arguments
+                            .iter()
+                            .map(|argument| self.copy(argument))
+                            .collect(),
                     },
-                },
-                Callable::Script { scope: None, .. }
-                | Callable::Builtin(_)
-                | Callable::Standard(_) => return value.clone(),
-                Callable::Arrow { arrow, this, scope } => Callable::Arrow {
-                    arrow,
-                    this: copy(this, copies),
-                    scope: scope.as_ref().and_then(|scope| copy_scope(scope, copies)),
-                },
-                Callable::Call(target) => Callable::Call(copy(target, copies)),
-                Callable::Apply(target) => Callable::Apply(copy(target, copies)),
-                Callable::Bind(target) => Callable::Bind(copy(target, copies)),
-                Callable::Bound {
-                    target,
-                    this,
-                    arguments,
-                } => Callable::Bound {
-                    target: copy(target, copies),
-                    this: copy(this, copies),
-                    arguments: arguments
-                        .iter()
-                        .map(|argument| copy(argument, copies))
-                        .collect(),
-                },
-            };
-            // A captured value may refer back to this function and copy it first.
-            if let Some(copy) = copies.values.get(&address) {
-                return copy.clone();
+                };
+                // A captured value may refer back to this function and copy it first.
+                if let Some(copy) = self.values().get(&address) {
+                    return copy.clone();
+                }
+                let copied = Value::function(copied);
+                self.values().insert(address, copied.clone());
+                copied
             }
-            let copied = Value::function(copied);
-            copies.values.insert(address, copied.clone());
-            copied
+            _ => unreachable!("only objects have addresses"),
         }
-        _ => unreachable!("only objects have addresses"),
+    }
+
+    /// Copies the elements of an array, set, map, or object with `copy_element`.
+    fn elements<T>(
+        &mut self,
+        elements: &RefCell<Vec<T>>,
+        address: usize,
+        wrap: fn(Rc<RefCell<Vec<T>>>) -> Value<'ast>,
+        copy_element: impl Fn(&mut Self, &T) -> T,
+    ) -> Value<'ast> {
+        // Cache before copying elements because they may refer back to this object.
+        let copied = Rc::new(RefCell::new(Vec::new()));
+        self.values().insert(address, wrap(copied.clone()));
+        let elements: Vec<T> = elements
+            .borrow()
+            .iter()
+            .map(|element| copy_element(self, element))
+            .collect();
+        *copied.borrow_mut() = elements;
+        wrap(copied)
     }
 }
 
-/// Copies the elements of an array, set, or object with `copy_element`.
-fn copy_elements<'a, T>(
-    elements: &RefCell<Vec<T>>,
-    address: usize,
-    copies: &mut Copies<'a>,
-    wrap: fn(Rc<RefCell<Vec<T>>>) -> Value<'a>,
-    copy_element: impl Fn(&T, &mut Copies<'a>) -> T,
-) -> Value<'a> {
-    // Cache before copying elements because they may refer back to this object.
-    let copied = Rc::new(RefCell::new(Vec::new()));
-    copies.values.insert(address, wrap(copied.clone()));
-    let elements: Vec<T> = elements
-        .borrow()
-        .iter()
-        .map(|element| copy_element(element, copies))
-        .collect();
-    *copied.borrow_mut() = elements;
-    wrap(copied)
+/// The state of a [`copy`].
+struct Isolation<'copies, 'frozen, 'ast> {
+    copies: &'copies mut Copies<'ast>,
+    frozen: Option<&'frozen Frozen>,
 }
 
-/// Copies `scope` and its parents. Omits chains with no variables: completed session calls
-/// cannot add variables to those scopes.
-fn copy_scope<'a>(scope: &Scope<'a>, copies: &mut Copies<'a>) -> Option<Scope<'a>> {
-    let address = Rc::as_ptr(scope).addr();
-    if let Some(copy) = copies.scopes.get(&address) {
-        return copy.clone();
+impl<'ast> Copier<'ast> for Isolation<'_, '_, 'ast> {
+    fn frozen(&self) -> Option<&Frozen> {
+        self.frozen
+    }
+
+    fn values(&mut self) -> &mut HashMap<usize, Value<'ast>> {
+        &mut self.copies.values
     }
-    let original = scope.borrow();
-    if original.variables.is_empty() {
-        let copied = original
+
+    /// Copies `scope` and its parents. Omits chains with no variables: completed session calls
+    /// cannot add variables to those scopes.
+    fn captured(&mut self, scope: &Scope<'ast>) -> Option<Scope<'ast>> {
+        let address = Rc::as_ptr(scope).addr();
+        if let Some(copy) = self.copies.scopes.get(&address) {
+            return copy.clone();
+        }
+        let original = scope.borrow();
+        if original.variables.is_empty() {
+            let copied = original
+                .outer
+                .as_ref()
+                .and_then(|outer| self.captured(outer));
+            self.copies.scopes.insert(address, copied.clone());
+            return copied;
+        }
+        // Cache before copying variables because they may hold functions capturing this scope.
+        let copied = Env::scope(HashMap::default(), None);
+        self.copies.scopes.insert(address, Some(copied.clone()));
+        let outer = original
             .outer
             .as_ref()
-            .and_then(|outer| copy_scope(outer, copies));
-        copies.scopes.insert(address, copied.clone());
-        return copied;
+            .and_then(|outer| self.captured(outer));
+        let variables = original
+            .variables
+            .iter()
+            .map(|(name, value)| (name.clone(), self.copy(value)))
+            .collect();
+        *copied.borrow_mut() = Env { variables, outer };
+        Some(copied)
+    }
+}
+
+/// Deep-copies a run's state for another path to resume from (see
+/// [`super::run::Snapshot`]). Unlike [`copy`], it copies every scope, since the run may still
+/// add variables to them, and it clones maps before copying their values so they keep the
+/// original's layout and iteration order.
+pub(super) struct Fork<'frozen, 'ast> {
+    frozen: Option<&'frozen Frozen>,
+    values: HashMap<usize, Value<'ast>>,
+    scopes: HashMap<usize, Scope<'ast>>,
+    /// Every scope copied, for breaking cycles when the copy is dropped.
+    pub(super) copied: Vec<Scope<'ast>>,
+}
+
+impl<'ast> Copier<'ast> for Fork<'_, 'ast> {
+    fn frozen(&self) -> Option<&Frozen> {
+        self.frozen
+    }
+
+    fn values(&mut self) -> &mut HashMap<usize, Value<'ast>> {
+        &mut self.values
+    }
+
+    fn captured(&mut self, scope: &Scope<'ast>) -> Option<Scope<'ast>> {
+        Some(self.scope(scope))
+    }
+}
+
+impl<'frozen, 'ast> Fork<'frozen, 'ast> {
+    pub(super) fn new(frozen: Option<&'frozen Frozen>) -> Self {
+        Self {
+            frozen,
+            values: HashMap::default(),
+            scopes: HashMap::default(),
+            copied: Vec::new(),
+        }
+    }
+
+    pub(super) fn value(&mut self, value: &Value<'ast>) -> Value<'ast> {
+        self.copy(value)
+    }
+
+    pub(super) fn scope(&mut self, scope: &Scope<'ast>) -> Scope<'ast> {
+        let address = Rc::as_ptr(scope).addr();
+        if let Some(copy) = self.scopes.get(&address) {
+            return copy.clone();
+        }
+        // Cache before copying variables because they may hold functions capturing this scope.
+        let copied = Env::scope(HashMap::default(), None);
+        self.scopes.insert(address, copied.clone());
+        self.copied.push(copied.clone());
+        let original = scope.borrow();
+        let outer = original.outer.as_ref().map(|outer| self.scope(outer));
+        let variables = self.map(&original.variables);
+        *copied.borrow_mut() = Env { variables, outer };
+        copied
+    }
+
+    /// Copies a map's values, keeping its layout.
+    pub(super) fn map<K: Clone>(
+        &mut self,
+        map: &HashMap<K, Value<'ast>>,
+    ) -> HashMap<K, Value<'ast>> {
+        let mut copied = map.clone();
+        for value in copied.values_mut() {
+            *value = self.copy(value);
+        }
+        copied
+    }
+
+    /// Copies the run's [`Copies`], mapping session objects to copies of their run copies.
+    pub(super) fn copies(&mut self, copies: &Copies<'ast>) -> Copies<'ast> {
+        let values = self.map(&copies.values);
+        let mut scopes = copies.scopes.clone();
+        for scope in scopes.values_mut().flatten() {
+            *scope = self.scope(scope);
+        }
+        Copies { values, scopes }
     }
-    // Cache before copying variables because they may hold functions capturing this scope.
-    let copied = Env::scope(HashMap::default(), None);
-    copies.scopes.insert(address, Some(copied.clone()));
-    let outer = original
-        .outer
-        .as_ref()
-        .and_then(|outer| copy_scope(outer, copies));
-    let variables: HashMap<Atom, Value<'a>> = original
-        .variables
-        .iter()
-        .map(|(name, value)| (name.clone(), copy(value, copies)))
-        .collect();
-    *copied.borrow_mut() = Env { variables, outer };
-    Some(copied)
 }

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

@@ -4,17 +4,58 @@ use swc_core::atoms::Atom;
 use swc_core::ecma::ast::BinaryOp;
 
 use crate::js::ast;
-use crate::vm::extract;
 use crate::vm::interpret::plan::FunctionPlan;
 use crate::vm::interpret::run::Stop;
 use crate::vm::interpret::{Run, semantics};
-use crate::vm::output::Term;
-use crate::vm::session::Session;
+use crate::vm::output::{Effect, Position, Term};
+use crate::vm::session::{Layout, Session};
 use crate::vm::value::{Callable, Value};
+use crate::vm::{disassemble, extract};
+
+#[test]
+fn concrete_register_stack_keeps_its_exception_continuation() {
+    let parsed = ast::parse_iframe_javascript("function f(stack) { stack.push([42, 9, [], 0]); }")
+        .expect("the source parses");
+    let mut session = Session::empty();
+    session.functions = extract::functions(&parsed.script.body);
+    session.layout = Layout {
+        pc: 240,
+        key: 241,
+        program: 242,
+        cells: 243,
+    };
+    session.initial = vec![(7, Value::array(Vec::new()))];
+    let mut run = Run::method(&session);
+    run.start_at(0, 0);
+    let stack = Value::array(Vec::new());
+    run.registers.insert(7, stack.clone());
+    let function = Callable::Script {
+        name: None,
+        function: session.functions[&Atom::from("f")],
+        scope: None,
+    };
+    let result = run.invoke(&function, Value::Undefined, vec![stack]);
+    let path = run.finish(result).expect("the call completes");
+    let catches = |frame: &Term| {
+        matches!(frame, Term::Array(values)
+            if disassemble::catch_frame(values) == Some(Position::new(42, 9)))
+    };
+    assert!(
+        path.effects.iter().any(|effect| matches!(effect,
+            Effect::Set(7, Term::Array(frames)) if frames.iter().any(catches))),
+        "the pushed catch frame is kept as a register effect: {:?}",
+        path.effects
+    );
+}
 
 /// Compares results, exceptions, symbolic effects, branches, and global writes. Each execution
-/// has independent mutable state.
-fn compare(source: &str, arguments: Vec<Value<'static>>, decisions: Vec<bool>, slots: bool) {
+/// has independent mutable state. Returns the shared outcome, starting with the result.
+fn compare(
+    source: &str,
+    arguments: Vec<Value<'static>>,
+    decisions: Vec<bool>,
+    slots: bool,
+) -> String {
     // Leak the script text so arguments can be prepared before parsing it.
     let parsed: &_ = Box::leak(Box::new(ast::parse_iframe_javascript(source).unwrap()));
     let mut session = Session::empty();
@@ -56,7 +97,9 @@ fn compare(source: &str, arguments: Vec<Value<'static>>, decisions: Vec<bool>, s
             run.effects, run.branches.decisions
         )
     };
-    assert_eq!(execute(false), execute(true), "{source}");
+    let outcome = execute(false);
+    assert_eq!(outcome, execute(true), "{source}");
+    outcome
 }
 
 #[test]
@@ -122,13 +165,37 @@ fn branches_and_loops_match() {
     }
 }
 
+#[test]
+fn functions_declared_in_blocks_are_bound_on_entry() {
+    // A function declared after a block's `return` is callable from the start of the block,
+    // including one that reads the enclosing function's locals.
+    for (source, slots, result) in [
+        (
+            "function f(a) { { return g(a) + 1; function g(x) { return x * 3; } } }",
+            true,
+            "return Const(Number(7.0))",
+        ),
+        (
+            "function f(a) { { var b = 4; return g(1); function g(x) { return a + b + x; } } }",
+            true,
+            "return Const(Number(7.0))",
+        ),
+        (
+            "function f(a) { try { return g(a); function g(x) { return x + 1; } } finally {} }",
+            true,
+            "return Const(Number(3.0))",
+        ),
+    ] {
+        let outcome = compare(source, vec![Value::Number(2.0)], vec![], slots);
+        assert!(outcome.starts_with(result), "{source}: {outcome}");
+    }
+}
+
 #[test]
 fn rejected_functions_use_scoped_plans() {
     for source in [
         "function f(a) { return (function() { return a; })(); }",
-        "function f(a) { var g = () => a; return g(); }",
         "function f(a) { var g = () => arguments[0]; return g(); }",
-        "function f(a) { var g = function() { return a; }; return g(); }",
         "function f(arguments) { return arguments; }",
         "function f(a) { return {[a]: 1}; }",
         "function f(a) { try { return a; } catch ({ e }) { return 0; } }",
@@ -137,6 +204,27 @@ fn rejected_functions_use_scoped_plans() {
     }
 }
 
+/// Locals that nested functions mention stay in the call's scope, and both the outer
+/// function and its closures keep slot plans.
+#[test]
+fn closures_share_captured_locals() {
+    for source in [
+        "function f(a) { var g = () => a; return g(); }",
+        "function f(a) { var g = function() { return a; }; return g(); }",
+        "function f(a) { var s = 0; function g(x) { return k + x; } var k = a * 3; s = g(1) + g(2); return s; }",
+        "function f(a) { var n = 0; var inc = function() { n += a; return n; }; inc(); inc(); return n; }",
+        "function f(a) { var mk = function(b) { return function(c) { return a + b + c; }; }; return mk(1)(2); }",
+        "function f(a) { a = a + 1; var g = function() { return a; }; a = a * 10; return g(); }",
+        "function f(a) { var t = [a]; var g = function(i) { return t[i] + outer; }; return g(0); }",
+        "function f(a) { function r(n) { return n ? r(n - 1) + a : 0; } return r(3); }",
+        "function f(a) { var s = ''; for (var i = 0; i < a; i++) { s += c(i); } return s; function c(j) { var x = j * 2; return k[x]; } var k; }",
+        "function f(a) { var k = 'abcdef', s = ''; for (var i = 0; i < a; i++) { s += c(i); } return s; function c(j) { var x = j * 2; return k[x]; } }",
+        "function f(a) { var o = {}; o.h = function(x, y) { return x ^ y; }; var h = o.h; return h(a, 6); }",
+    ] {
+        compare(source, vec![Value::Number(2.0)], vec![], true);
+    }
+}
+
 #[test]
 fn numeric_operands_and_effects_match() {
     for source in [