cfsolve 0.1.1 → 0.1.2

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

@@ -2,6 +2,7 @@
 //! journal that undoes speculative attempts.
 
 use std::borrow::Cow;
+use std::cell::RefCell;
 use std::hash::Hash;
 use std::mem;
 use std::rc::Rc;
@@ -10,12 +11,13 @@ use swc_core::atoms::Atom;
 use swc_core::ecma::ast::{BinaryOp, UnaryOp};
 
 use super::builtin;
-use super::copies::{self, Copies};
+use super::copies::{self, Copies, Fork};
 use super::explore::Invocation;
+use super::frozen::{self, Frozen};
 use crate::vm::output::{Constant, Effect, Exit, Path, Position, Term};
 use crate::vm::session::Session;
 use crate::vm::value::{Callable, Env, Scope, Value};
-use crate::vm::{HashMap, convert};
+use crate::vm::{HashMap, convert, disassemble};
 
 /// Why evaluation stopped before completing normally.
 pub(crate) enum Stop<'ast> {
@@ -51,6 +53,8 @@ pub(crate) struct Run<'ast, 'session> {
     pub(super) program: &'session [u8],
     /// Instance fields derived from program bytes by the constructor, once known.
     constructed: Option<&'session HashMap<String, Value<'ast>>>,
+    /// Strings decrypted from the program's records, once a program is loaded.
+    pub(super) decrypted: Option<&'session Decrypted<'ast>>,
     pub(super) registers: HashMap<u8, Value<'ast>>,
     /// Tags written before their register values; see [`crate::vm::registers`].
     pub(super) tags: HashMap<u8, Value<'ast>>,
@@ -76,6 +80,23 @@ pub(crate) struct Run<'ast, 'session> {
     facts: Vec<(Term, Value<'ast>)>,
     journal: Journal<'ast>,
     pub(super) spare: Spare<'ast>,
+    /// Whether the run shares [`Frozen`] session objects instead of copying them.
+    pub(super) sharing: bool,
+    /// Whether the run wrote to a shared object, thawing it. Its results are discarded.
+    pub(super) thawed: bool,
+}
+
+/// Strings decrypted from a program's string records, by record contents (see
+/// [`RecordKey`]).
+pub(crate) type Decrypted<'ast> = RefCell<HashMap<RecordKey, Value<'ast>>>;
+
+/// The contents of a string record after the program: numbers and arrays of numbers, as bits.
+pub(crate) type RecordKey = Vec<RecordPart>;
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub(crate) enum RecordPart {
+    Number(u64),
+    Numbers(Vec<u64>),
 }
 
 /// Cleared buffers from completed calls. Handler runs take them from the session and
@@ -222,6 +243,7 @@ impl<'ast, 'session> Run<'ast, 'session> {
             session,
             program,
             constructed: None,
+            decrypted: None,
             registers: HashMap::default(),
             tags: HashMap::default(),
             fields: HashMap::default(),
@@ -240,21 +262,15 @@ impl<'ast, 'session> Run<'ast, 'session> {
             facts: Vec::new(),
             journal: Journal::default(),
             spare: Spare::default(),
+            sharing: false,
+            thawed: false,
         }
     }
 
     /// A handler run that follows `decisions`, then takes any further symbolic branch as true.
     pub(super) fn handler(invocation: &Invocation<'session, 'ast>, decisions: Vec<bool>) -> Self {
-        let session = invocation.session;
-        let mut run = Self::new(
-            session,
-            invocation.program,
-            decisions,
-            Some(Copies::default()),
-        );
-        run.constructed = Some(invocation.fields);
-        run.spare = session.spare.take();
-        for (register, value) in &session.initial {
+        let mut run = Self::invoked(invocation, decisions, Some(Copies::default()));
+        for (register, value) in &invocation.session.initial {
             let value = run.isolate(value);
             run.registers.insert(*register, value);
         }
@@ -263,6 +279,20 @@ impl<'ast, 'session> Run<'ast, 'session> {
         run
     }
 
+    /// A run of `invocation`'s handler with no registers set, sharing frozen session objects.
+    fn invoked(
+        invocation: &Invocation<'session, 'ast>,
+        decisions: Vec<bool>,
+        copies: Option<Copies<'ast>>,
+    ) -> Self {
+        let mut run = Self::new(invocation.session, invocation.program, decisions, copies);
+        run.constructed = Some(invocation.fields);
+        run.decrypted = Some(invocation.decrypted);
+        run.spare = invocation.session.spare.take();
+        run.sharing = true;
+        run
+    }
+
     /// Sets the program counter to `pc` and the dispatch key to `key`.
     pub(super) fn start_at(&mut self, pc: u32, key: u8) {
         let layout = self.session.layout;
@@ -311,6 +341,19 @@ impl<'ast, 'session> Run<'ast, 'session> {
                 },
             },
         };
+        // A catch handler can be pushed onto a constructor-created register stack.
+        // Native array operations mutate that stack without producing an effect; retain
+        // its frame so disassembly can also visit the exception continuation.
+        for (register, _) in &self.session.initial {
+            if let Some(value @ Value::Array(elements)) = self.registers.get(register)
+                && elements.borrow().iter().any(|element| {
+                    matches!(element.expr(), Term::Array(ref frame)
+                        if disassemble::catch_frame(frame).is_some())
+                })
+            {
+                self.effects.push(Effect::Set(*register, value.expr()));
+            }
+        }
         // The listing retains every path, so release unused vector capacity.
         let mut conditions = self.branches.conditions;
         conditions.shrink_to_fit();
@@ -578,10 +621,156 @@ impl<'ast, 'session> Run<'ast, 'session> {
 
     /// Copies a session value for use by this run, preserving run-local sharing.
     pub(super) fn isolate(&mut self, value: &Value<'ast>) -> Value<'ast> {
+        let frozen = self.frozen();
         let Some(copies) = &mut self.copies else {
             return value.clone();
         };
-        copies::copy(value, copies)
+        copies::copy(value, copies, frozen)
+    }
+
+    /// The session objects this run shares, if it shares them.
+    fn frozen(&self) -> Option<&'session Frozen> {
+        self.sharing.then_some(&self.session.frozen)
+    }
+
+    /// Checks that the run may write to `object`. A write to a shared session object thaws its
+    /// group and stops the run, whose caller reruns the instruction with the group copied.
+    pub(super) fn writable(&mut self, object: &Value<'ast>) -> Evaluation<'ast, ()> {
+        if let Some(frozen) = self.frozen()
+            && let Some(address) = frozen::address(object)
+            && frozen.contains(address)
+        {
+            frozen.thaw(address);
+            self.thawed = true;
+            return Err(Stop::unsupported("a write to a shared session object"));
+        }
+        Ok(())
+    }
+
+    /// Takes a snapshot of a handler run before top-level statement `statement`, with the
+    /// handler's `locals`. Returns `None` if the run is inside a speculative attempt or setup
+    /// changed which names are unavailable, which a snapshot does not restore.
+    pub(super) fn snapshot(
+        &self,
+        statement: usize,
+        locals: &[Option<Value<'ast>>],
+    ) -> Option<Snapshot<'ast>> {
+        if self.journal.recording()
+            || matches!(self.unavailable, Cow::Owned(_))
+            || self.frames.len() != 1
+            || self.setup.is_some()
+            || self.constructed.is_none()
+        {
+            return None;
+        }
+        let mut fork = Fork::new(self.frozen());
+        let frame = self.frame();
+        Some(Snapshot {
+            statement,
+            decided: self.branches.decisions[..self.branches.decided].to_vec(),
+            registers: fork.map(&self.registers),
+            tags: fork.map(&self.tags),
+            fields: fork.map(&self.fields),
+            globals: fork.map(&self.globals),
+            copies: self.copies.as_ref().map(|copies| fork.copies(copies)),
+            closed: self.closed.iter().map(|scope| fork.scope(scope)).collect(),
+            effects: self.effects.clone(),
+            temps: self.temps,
+            conditions: self.branches.conditions.clone(),
+            facts: self
+                .facts
+                .iter()
+                .map(|(term, value)| (term.clone(), fork.value(value)))
+                .collect(),
+            this: fork.value(&frame.this),
+            scope: fork.scope(&frame.scope),
+            locals: locals
+                .iter()
+                .map(|local| local.as_ref().map(|value| fork.value(value)))
+                .collect(),
+            copied: fork.copied,
+        })
+    }
+
+    /// A handler run resumed from `snapshot`, following `decisions`, whose first decisions are
+    /// the snapshot's. Returns the run, the handler's locals, and the scopes copied for it,
+    /// which the caller clears when the run ends.
+    pub(super) fn resume(
+        invocation: &Invocation<'session, 'ast>,
+        snapshot: &Snapshot<'ast>,
+        decisions: Vec<bool>,
+    ) -> (Self, Vec<Option<Value<'ast>>>, Vec<Scope<'ast>>) {
+        let mut fork = Fork::new(Some(&invocation.session.frozen));
+        let copies = snapshot.copies.as_ref().map(|copies| fork.copies(copies));
+        let mut run = Self::invoked(invocation, decisions, copies);
+        run.registers = fork.map(&snapshot.registers);
+        run.tags = fork.map(&snapshot.tags);
+        run.fields = fork.map(&snapshot.fields);
+        run.globals = fork.map(&snapshot.globals);
+        run.closed = snapshot
+            .closed
+            .iter()
+            .map(|scope| fork.scope(scope))
+            .collect();
+        run.effects = snapshot.effects.clone();
+        run.temps = snapshot.temps;
+        run.branches.decided = snapshot.decided.len();
+        run.branches.conditions = snapshot.conditions.clone();
+        run.facts = snapshot
+            .facts
+            .iter()
+            .map(|(term, value)| (term.clone(), fork.value(value)))
+            .collect();
+        run.frames.push(Frame {
+            this: fork.value(&snapshot.this),
+            scope: fork.scope(&snapshot.scope),
+        });
+        let locals = snapshot
+            .locals
+            .iter()
+            .map(|local| local.as_ref().map(|value| fork.value(value)))
+            .collect();
+        (run, locals, fork.copied)
+    }
+}
+
+/// A handler run's state before one of the top-level statements of its body. Paths that share
+/// the decisions made before that statement resume here instead of rerunning the statements
+/// before it.
+pub(super) struct Snapshot<'ast> {
+    /// The top-level statement to resume at.
+    pub(super) statement: usize,
+    /// The decisions consumed before the statement.
+    decided: Vec<bool>,
+    registers: HashMap<u8, Value<'ast>>,
+    tags: HashMap<u8, Value<'ast>>,
+    fields: HashMap<String, Value<'ast>>,
+    globals: HashMap<Atom, Value<'ast>>,
+    copies: Option<Copies<'ast>>,
+    closed: Vec<Scope<'ast>>,
+    effects: Vec<Effect>,
+    temps: usize,
+    conditions: Vec<(Term, bool)>,
+    facts: Vec<(Term, Value<'ast>)>,
+    this: Value<'ast>,
+    scope: Scope<'ast>,
+    locals: Vec<Option<Value<'ast>>>,
+    /// Every scope the snapshot holds, cleared when it is dropped to break cycles.
+    copied: Vec<Scope<'ast>>,
+}
+
+impl Drop for Snapshot<'_> {
+    fn drop(&mut self) {
+        for scope in &self.copied {
+            scope.borrow_mut().variables.clear();
+        }
+    }
+}
+
+impl<'ast> Snapshot<'ast> {
+    /// Whether a run following `decisions` makes the same decisions before the statement.
+    pub(super) fn resumes(&self, decisions: &[bool]) -> bool {
+        decisions.starts_with(&self.decided)
     }
 }
 

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

@@ -11,16 +11,21 @@
 mod access;
 mod builtin;
 mod call;
+mod compile;
 mod copies;
 mod evaluate;
 mod explore;
+mod frozen;
+mod intrinsic;
 mod plan;
 mod run;
 mod semantics;
 mod setup;
 
 pub(crate) use builtin::Builtin;
-pub(crate) use explore::{Invocation, MAXIMUM_PATHS, Way, decode, explore};
+pub(crate) use explore::{Branching, Invocation, MAXIMUM_PATHS, Way, decode, explore};
+pub(crate) use frozen::Frozen;
+pub(crate) use intrinsic::{Intrinsics, intrinsics};
 pub(crate) use plan::Plans;
-pub(crate) use run::{Run, Spare};
+pub(crate) use run::{Decrypted, Run, Spare};
 pub(crate) use setup::setup;

data/vendor/cfsolve/src/vm/machine.rs

@@ -6,7 +6,7 @@ use swc_core::ecma::ast::{BlockStmt, Class, Script, Stmt};
 use super::HashMap;
 use super::dispatch::{Decoded, Dispatch};
 use super::extract::{self, Finder};
-use super::interpret::{self, Invocation, MAXIMUM_PATHS, Way};
+use super::interpret::{self, Decrypted, Invocation, MAXIMUM_PATHS, Way};
 use super::output::{Cause, Failure, Instruction, Position};
 use super::session::Session;
 use super::value::Value;
@@ -48,11 +48,13 @@ pub struct Machine<'definition> {
     pub(super) session: Session<'definition>,
 }
 
-/// A program, with the instance fields the constructor derives from it.
+/// A program, with the instance fields the constructor derives from it and the strings
+/// decrypted from it so far.
 #[derive(Clone)]
 pub(super) struct Loaded<'program, 'definition> {
     program: &'program [u8],
     pub(super) fields: HashMap<String, Value<'definition>>,
+    decrypted: Decrypted<'definition>,
 }
 
 impl<'definition> Machine<'definition> {
@@ -69,6 +71,7 @@ impl<'definition> Machine<'definition> {
         Loaded {
             program,
             fields: self.session.constructed(program),
+            decrypted: Decrypted::default(),
         }
     }
 
@@ -144,6 +147,7 @@ impl<'definition> Machine<'definition> {
             session: &self.session,
             program: loaded.program,
             fields: &loaded.fields,
+            decrypted: &loaded.decrypted,
             pc: pc + 1,
             key: next,
             handler,

data/vendor/cfsolve/src/vm/packed_names.rs

@@ -0,0 +1,307 @@
+//! Folds names the program unpacks at run time. Some programs store a name as
+//! `"\0\x19" + name + NUL padding` and unpack it with
+//! `text.slice(2, 256 * text.charCodeAt(0) + text.charCodeAt(1) + 2)`. Folding `charCodeAt`,
+//! `slice`, `+` and `*` on constant registers rewrites each unpacking call to the resulting
+//! string, so readers of the listing see an ordinary string load.
+
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::convert::Infallible;
+use std::ops::ControlFlow;
+use std::rc::Rc;
+
+use swc_core::ecma::ast::BinaryOp;
+
+use super::output::{Constant, Effect, Listing, Path, Term};
+use super::{dataflow, disassemble};
+
+/// Constant registers on entry to an instruction, shared as the dataflow copies them per path.
+type Registers = BTreeMap<u8, Rc<Constant>>;
+
+/// Constants held by temporaries.
+type Temporaries = HashMap<usize, Rc<Constant>>;
+
+pub(super) fn fold(listing: &mut Listing) {
+    // Unrecorded entries, such as functions and hidden targets, start with nothing known.
+    let functions = listing.functions.iter().map(|function| function.pc);
+    let hidden = listing.hidden.iter().map(|hidden| hidden.target.pc);
+    let incoming = forward(listing, functions.chain(hidden));
+    // A catch path must not erase facts already recovered on the normal path.
+    // Fold its exclusive instructions separately with unknown entry registers.
+    let exceptional = forward(listing, disassemble::exception_entries(listing));
+    for (pc, instruction) in &mut listing.instructions {
+        let Some(entry) = incoming.get(pc).or_else(|| exceptional.get(pc)) else {
+            continue;
+        };
+        for path in &mut instruction.paths {
+            rewrite(path, entry.clone());
+        }
+    }
+}
+
+/// The constant registers on entry to each instruction reachable from `entries`.
+fn forward(listing: &Listing, entries: impl IntoIterator<Item = u32>) -> BTreeMap<u32, Registers> {
+    let entries = entries.into_iter().map(|pc| (pc, Registers::new()));
+    let ControlFlow::Continue(incoming) = dataflow::forward(listing, entries, |_, path, known| {
+        let mut temporaries = Temporaries::new();
+        for effect in &path.effects {
+            step(effect, known, &mut temporaries);
+        }
+        ControlFlow::<Infallible, bool>::Continue(true)
+    });
+    incoming
+}
+
+/// Rewrites folded string-method results in `path` to constants.
+fn rewrite(path: &mut Path, mut known: Registers) {
+    let mut temporaries = Temporaries::new();
+    // Temporaries holding a folded call.
+    let mut folded_temporaries = HashSet::new();
+    for effect in &mut path.effects {
+        let folded = match &*effect {
+            // Only `charCodeAt` and `slice` calls fold.
+            Effect::Let(_, term @ Term::Call { .. }) | Effect::Set(_, term @ Term::Call { .. }) => {
+                value(term, &known, &temporaries)
+            }
+            Effect::Set(_, Term::Temp(temporary)) if folded_temporaries.contains(temporary) => {
+                temporaries.get(temporary).cloned()
+            }
+            _ => None,
+        };
+        step(effect, &mut known, &mut temporaries);
+        if let Effect::Let(temporary, _) = effect {
+            if folded.is_some() {
+                folded_temporaries.insert(*temporary);
+            } else {
+                folded_temporaries.remove(temporary);
+            }
+        }
+        if let (Some(constant), Effect::Let(_, term) | Effect::Set(_, term)) = (folded, effect) {
+            *term = Term::Const(Rc::unwrap_or_clone(constant));
+        }
+    }
+}
+
+/// Records the constant an effect writes, if any. As in the other listing folds, calls leave the
+/// caller's registers alone.
+fn step(effect: &Effect, known: &mut Registers, temporaries: &mut Temporaries) {
+    match effect {
+        Effect::Let(temporary, term) => match value(term, known, temporaries) {
+            Some(constant) => temporaries.insert(*temporary, constant),
+            None => temporaries.remove(temporary),
+        },
+        Effect::Set(register, term) => match value(term, known, temporaries) {
+            Some(constant) => known.insert(*register, constant),
+            None => known.remove(register),
+        },
+        _ => None,
+    };
+}
+
+/// The string or number `term` evaluates to, if constant.
+fn value(term: &Term, known: &Registers, temporaries: &Temporaries) -> Option<Rc<Constant>> {
+    let value = |term| value(term, known, temporaries);
+    let number = |term| match *value(term)? {
+        Constant::Number(number) => Some(number),
+        _ => None,
+    };
+    let number_constant = |number| Some(Rc::new(Constant::Number(number)));
+    match term {
+        Term::Const(constant @ (Constant::String(_) | Constant::Number(_))) => {
+            Some(Rc::new(constant.clone()))
+        }
+        Term::Reg(register) => known.get(register).cloned(),
+        Term::Temp(temporary) => temporaries.get(temporary).cloned(),
+        Term::Binary(BinaryOp::Add, left, right) => number_constant(number(left)? + number(right)?),
+        Term::Binary(BinaryOp::Mul, left, right) => number_constant(number(left)? * number(right)?),
+        Term::Call {
+            callee,
+            this: None,
+            arguments,
+        } => {
+            let Term::Get(receiver, method) = &**callee else {
+                return None;
+            };
+            let receiver = value(receiver)?;
+            let (Constant::String(text), Term::Const(Constant::String(method))) =
+                (&*receiver, &**method)
+            else {
+                return None;
+            };
+            let text: Vec<u16> = text.encode_utf16().collect();
+            // Negative and fractional indexes never occur in the unpacking.
+            let index = |term| {
+                let index = number(term)?;
+                (index >= 0.0 && index.fract() == 0.0).then_some(index as usize)
+            };
+            match (method.as_str(), arguments.as_slice()) {
+                ("charCodeAt", [position]) => {
+                    number_constant(f64::from(*text.get(index(position)?)?))
+                }
+                ("slice", [start, end]) => {
+                    let end = index(end)?.min(text.len());
+                    let start = index(start)?.min(end);
+                    Some(Rc::new(Constant::String(
+                        String::from_utf16(&text[start..end]).ok()?,
+                    )))
+                }
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vm::output::{Exit, Instruction, Position};
+
+    fn string(text: &str) -> Term {
+        Term::Const(Constant::String(text.into()))
+    }
+
+    fn number(value: f64) -> Term {
+        Term::Const(Constant::Number(value))
+    }
+
+    fn method(receiver: u8, name: &str, arguments: Vec<Term>) -> Term {
+        Term::Call {
+            callee: Box::new(Term::Get(
+                Box::new(Term::Reg(receiver)),
+                Box::new(string(name)),
+            )),
+            this: None,
+            arguments,
+        }
+    }
+
+    fn binary(op: BinaryOp, left: u8, right: u8) -> Term {
+        Term::Binary(op, Box::new(Term::Reg(left)), Box::new(Term::Reg(right)))
+    }
+
+    fn insert(listing: &mut Listing, pc: u32, effects: Vec<Effect>, exit: Exit) {
+        let path = Path {
+            conditions: Vec::new(),
+            effects,
+            exit,
+        };
+        let instruction = Instruction {
+            pc,
+            key: 0,
+            opcode: 0,
+            paths: vec![path],
+        };
+        listing.instructions.insert(pc, instruction);
+    }
+
+    #[test]
+    fn folds_unpacked_names_to_string_loads() {
+        // r1 = packed; r2 = 0; r3 = 1; r4 = 2; r5 = 256;
+        // r6 = r1.charCodeAt(r2); r2 = r1.charCodeAt(r3); r6 = r6 * r5 + r2 + r4;
+        // r1 = r1.slice(r4, r6); payload[r1] = 0
+        let effects = vec![
+            vec![Effect::Set(1, string("\0\u{3}abc\0\0\0\0"))],
+            vec![
+                Effect::Set(2, number(0.0)),
+                Effect::Set(3, number(1.0)),
+                Effect::Set(4, number(2.0)),
+                Effect::Set(5, number(256.0)),
+            ],
+            vec![
+                Effect::Let(0, method(1, "charCodeAt", vec![Term::Reg(2)])),
+                Effect::Set(6, Term::Temp(0)),
+            ],
+            vec![
+                Effect::Let(0, method(1, "charCodeAt", vec![Term::Reg(3)])),
+                Effect::Set(2, Term::Temp(0)),
+            ],
+            vec![Effect::Set(6, binary(BinaryOp::Mul, 6, 5))],
+            vec![Effect::Set(6, binary(BinaryOp::Add, 6, 2))],
+            vec![Effect::Set(6, binary(BinaryOp::Add, 6, 4))],
+            vec![
+                Effect::Let(0, method(1, "slice", vec![Term::Reg(4), Term::Reg(6)])),
+                Effect::Set(1, Term::Temp(0)),
+            ],
+        ];
+        let count = u32::try_from(effects.len()).unwrap();
+        let mut listing = Listing {
+            functions: vec![Position::new(0, 0)],
+            ..Listing::default()
+        };
+        for (pc, effects) in (0..).zip(effects) {
+            let exit = if pc + 1 == count {
+                Exit::Return
+            } else {
+                Exit::Next { pc: pc + 1, key: 0 }
+            };
+            insert(&mut listing, pc, effects, exit);
+        }
+        fold(&mut listing);
+        let last = &listing.instructions[&(count - 1)].paths[0].effects;
+        assert_eq!(
+            last,
+            &[Effect::Let(0, string("abc")), Effect::Set(1, string("abc"))]
+        );
+        let first_code = &listing.instructions[&2].paths[0].effects;
+        assert_eq!(
+            first_code,
+            &[Effect::Let(0, number(0.0)), Effect::Set(6, number(0.0))]
+        );
+    }
+
+    #[test]
+    fn catch_names_fold_without_erasing_normal_path_names() {
+        let mut listing = Listing {
+            functions: vec![Position::new(0, 0)],
+            ..Listing::default()
+        };
+        insert(
+            &mut listing,
+            0,
+            vec![
+                Effect::Set(1, string("\0\u{3}abc\0")),
+                Effect::Set(2, number(2.0)),
+                Effect::Set(3, number(5.0)),
+                Effect::Set(
+                    9,
+                    Term::Array(vec![Term::Array(vec![
+                        number(100.0),
+                        number(0.0),
+                        Term::Cells,
+                        number(0.0),
+                    ])]),
+                ),
+            ],
+            Exit::Next { pc: 1, key: 0 },
+        );
+        insert(
+            &mut listing,
+            1,
+            vec![Effect::Set(
+                1,
+                method(1, "slice", vec![Term::Reg(2), Term::Reg(3)]),
+            )],
+            Exit::Return,
+        );
+        insert(
+            &mut listing,
+            100,
+            vec![
+                Effect::Set(1, string("\0\u{3}xyz\0")),
+                Effect::Set(2, number(2.0)),
+                Effect::Set(3, number(5.0)),
+                Effect::Set(4, method(1, "slice", vec![Term::Reg(2), Term::Reg(3)])),
+            ],
+            Exit::Next { pc: 1, key: 0 },
+        );
+        fold(&mut listing);
+        assert_eq!(
+            listing.instructions[&1].paths[0].effects[0],
+            Effect::Set(1, string("abc"))
+        );
+        assert_eq!(
+            listing.instructions[&100].paths[0].effects[3],
+            Effect::Set(4, string("xyz"))
+        );
+    }
+}