cfsolve 0.1.1 → 0.1.2

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

@@ -21,7 +21,7 @@ use super::interpret::Way;
 use super::machine::{Loaded, Machine};
 use super::output::{Constant, Effect, Exit, Hidden, Instruction, Listing, Path, Position, Term};
 use super::value::Value;
-use super::{HashMap, convert, dataflow};
+use super::{HashMap, convert, dataflow, packed_names};
 use crate::candidates;
 
 impl Machine<'_> {
@@ -57,7 +57,7 @@ impl Machine<'_> {
                     Err(failure) => walk.listing.failures.push(failure),
                 }
             }
-            if !walk.retry(self, &loaded)? && !walk.drop_shortcuts() {
+            if !(walk.retry(self, &loaded)? || walk.drop_shortcuts()) {
                 break;
             }
         }
@@ -69,6 +69,7 @@ impl Machine<'_> {
         });
         listing.failures.sort_unstable_by_key(|failure| failure.pc);
         fuse_method_calls(&mut listing);
+        packed_names::fold(&mut listing);
         Ok(listing)
     }
 }
@@ -387,6 +388,23 @@ pub fn catch_frame(elements: &[Term]) -> Option<Position> {
     }
 }
 
+/// Exception continuations enter without the registers known on the normal path.
+pub(super) fn exception_entries(listing: &Listing) -> BTreeSet<u32> {
+    let mut entries = BTreeSet::new();
+    for instruction in listing.instructions.values() {
+        for effect in instruction.effects() {
+            effect.visit_terms(&mut |term| {
+                if let Term::Array(frame) = term
+                    && let Some(position) = catch_frame(frame)
+                {
+                    entries.insert(position.pc);
+                }
+            });
+        }
+    }
+    entries
+}
+
 /// Rewrites method calls to the form listing readers expect. Some builds call `object[key]`
 /// directly; others load the method into a register and later call that register with `object`
 /// as receiver.
@@ -394,15 +412,11 @@ fn fuse_method_calls(listing: &mut Listing) {
     // Unrecorded entries, such as functions and hidden targets, start with no known loads.
     let functions = listing.functions.iter().map(|function| function.pc);
     let hidden = listing.hidden.iter().map(|hidden| hidden.target.pc);
-    let entries = functions.chain(hidden).map(|pc| (pc, Loads::default()));
-    let ControlFlow::Continue(incoming) = dataflow::forward(listing, entries, |_, path, loads| {
-        for effect in &path.effects {
-            update_loads(loads, effect);
-        }
-        ControlFlow::<Infallible, bool>::Continue(true)
-    });
+    let incoming = incoming_loads(listing, functions.chain(hidden));
+    // Exception continuations also start with no known loads, without erasing the normal path's.
+    let exceptional = incoming_loads(listing, exception_entries(listing));
     for (pc, instruction) in &mut listing.instructions {
-        let Some(entry) = incoming.get(pc) else {
+        let Some(entry) = incoming.get(pc).or_else(|| exceptional.get(pc)) else {
             continue;
         };
         for path in &mut instruction.paths {
@@ -417,6 +431,21 @@ fn fuse_method_calls(listing: &mut Listing) {
     }
 }
 
+/// The loads known on entry to each instruction reachable from `entries`.
+fn incoming_loads(
+    listing: &Listing,
+    entries: impl IntoIterator<Item = u32>,
+) -> BTreeMap<u32, Loads> {
+    let entries = entries.into_iter().map(|pc| (pc, Loads::default()));
+    let ControlFlow::Continue(incoming) = dataflow::forward(listing, entries, |_, path, loads| {
+        for effect in &path.effects {
+            update_loads(loads, effect);
+        }
+        ControlFlow::<Infallible, bool>::Continue(true)
+    });
+    incoming
+}
+
 /// Tracks registers holding `object[key]` while the object and key registers remain unchanged.
 /// Saves facts at each instruction's entry. Uses a vector because these sets are small.
 #[derive(Clone, Default)]

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

@@ -271,6 +271,7 @@ impl<'ast> Run<'ast, '_> {
                 self.set_field(name.to_owned(), value);
             }
             Value::Array(elements) if key.text() == Some("length") => {
+                self.writable(object)?;
                 match value.number() {
                     Some(length) => {
                         let length = convert::length(length)
@@ -294,6 +295,7 @@ impl<'ast> Run<'ast, '_> {
                     .and_then(convert::length)
                     .filter(|&index| index < MAXIMUM_LENGTH)
                     .ok_or_else(|| unsupported("array index", key))?;
+                self.writable(object)?;
                 let mut elements = elements.borrow_mut();
                 if elements.len() <= index {
                     elements.resize(index + 1, Value::Undefined);
@@ -304,6 +306,7 @@ impl<'ast> Run<'ast, '_> {
                 let name = key
                     .property()
                     .ok_or_else(|| unsupported("object key", key))?;
+                self.writable(object)?;
                 let mut properties = properties.borrow_mut();
                 match properties
                     .iter_mut()
@@ -348,33 +351,14 @@ impl<'ast> Run<'ast, '_> {
 
     /// Decrypts a string record using the same logic as the register file's `read` method.
     fn decrypted(&mut self, record: Value<'ast>) -> Evaluation<'ast, Value<'ast>> {
-        let Value::Array(elements) = &record else {
+        if !matches!(record, Value::Array(_)) {
             return Ok(record);
-        };
-        let field = |index: usize| elements.borrow().get(index).and_then(Value::number);
-        let key = match (field(1), field(2), field(3)) {
-            (Some(pc), Some(length), Some(key)) => Some((pc as u32, length as u32, key as u32)),
-            _ => None,
-        };
-        if let Some(key) = key
-            && let Some(text) = self.session.decrypted.borrow().get(&key)
-        {
-            return Ok(text.clone());
         }
         let decoder = self
             .session
             .record_decoder
-            .as_ref()
             .ok_or_else(|| Stop::unsupported("an encrypted string with no decoder"))?;
-        let decoder = self.lookup(decoder)?;
-        let text = self.apply(decoder, Value::Undefined, vec![record])?;
-        if let (Some(key), Value::String(_)) = (key, &text) {
-            self.session
-                .decrypted
-                .borrow_mut()
-                .insert(key, text.clone());
-        }
-        Ok(text)
+        self.script(decoder, None, Value::Undefined, vec![record])
     }
 
     /// A member of the register file (see [`Member`]).

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

@@ -216,17 +216,7 @@ impl<'ast> Run<'ast, '_> {
                 let Value::Array(elements) = &this else {
                     return self.apply(Value::symbolic(global()), this, arguments);
                 };
-                // Preserve [pc, key, cells, depth] frames for disassembly even when the
-                // constructor-created stack is concrete. Other pushes need no symbolic effect.
-                for value in &arguments {
-                    if let Value::Array(frame) = value
-                        && frame.borrow().len() == 4
-                        && let Term::Array(frame) = value.expr()
-                        && crate::vm::catch_frame(&frame).is_some()
-                    {
-                        self.temp(Term::Array(frame));
-                    }
-                }
+                self.writable(&this)?;
                 let mut elements = elements.borrow_mut();
                 elements.extend(arguments);
                 Ok(Value::Number(elements.len() as f64))
@@ -238,6 +228,7 @@ impl<'ast> Run<'ast, '_> {
                 let Value::Array(elements) = &this else {
                     return self.apply(Value::symbolic(global()), this, arguments);
                 };
+                self.writable(&this)?;
                 let popped = elements.borrow_mut().pop();
                 match popped {
                     Some(value) => Ok(value),
@@ -377,11 +368,13 @@ impl<'ast> Run<'ast, '_> {
                     },
                     Builtin::Add => {
                         if contains(&members.borrow(), &key) == Some(false) {
+                            self.writable(&this)?;
                             members.borrow_mut().push(key);
                         }
                         Ok(this.clone())
                     }
                     _ => {
+                        self.writable(&this)?;
                         let mut members = members.borrow_mut();
                         let before = members.len();
                         members.retain(|member| {
@@ -414,6 +407,7 @@ impl<'ast> Run<'ast, '_> {
                     Builtin::MapHas => Ok(Value::Bool(position.is_some())),
                     Builtin::MapSet => {
                         let value = argument(1);
+                        self.writable(&this)?;
                         let mut entries = entries.borrow_mut();
                         match position {
                             Some(position) => entries[position].1 = value,
@@ -423,6 +417,7 @@ impl<'ast> Run<'ast, '_> {
                     }
                     _ => {
                         if let Some(position) = position {
+                            self.writable(&this)?;
                             entries.borrow_mut().remove(position);
                         }
                         Ok(Value::Bool(position.is_some()))
@@ -608,48 +603,6 @@ mod tests {
         assert!(call(Builtin::Floor, &[]).is_nan());
     }
 
-    #[test]
-    fn concrete_stack_pushes_expose_exception_frames_to_disassembly() {
-        let session = Session::empty();
-        let mut run = Run::method(&session);
-        let stack = Value::array(vec![]);
-        let frame = Value::array(vec![
-            Value::Number(42.0),
-            Value::Number(7.0),
-            Value::Cells,
-            Value::Number(0.0),
-        ]);
-        let expected = frame.expr();
-        assert_eq!(
-            number(run.builtin(Builtin::Push, stack.clone(), vec![frame])),
-            1.0
-        );
-        assert_eq!(
-            run.effects,
-            vec![crate::vm::Effect::Let(0, expected.clone())]
-        );
-        assert_eq!(stack.expr(), Term::Array(vec![expected]));
-        for (length, value) in [
-            (2.0, Value::Number(9.0)),
-            (3.0, Value::array(vec![Value::Number(42.0)])),
-            (
-                4.0,
-                Value::array(vec![
-                    Value::Number(42.0),
-                    Value::Number(256.0),
-                    Value::Cells,
-                    Value::Number(0.0),
-                ]),
-            ),
-        ] {
-            assert_eq!(
-                number(run.builtin(Builtin::Push, stack.clone(), vec![value])),
-                length
-            );
-            assert_eq!(run.effects.len(), 1);
-        }
-    }
-
     /// Checks `SameValueZero` membership: the set contains 1, "1", NaN, and 0 after duplicate
     /// removal.
     #[test]

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

@@ -1,11 +1,13 @@
 //! Calls and constructions of script functions, arrows, builtins, and bound functions.
 
+use std::ptr;
+
 use swc_core::atoms::{Atom, atom};
 use swc_core::ecma::ast::{ArrowExpr, Decl, Function, Pat, Stmt};
 
 use super::access::Key;
-use super::plan;
-use super::run::{Evaluation, Frame, Run, Stop};
+use super::run::{Evaluation, Frame, RecordKey, RecordPart, Run, Stop};
+use super::{intrinsic, plan};
 use crate::vm::HashMap;
 use crate::vm::output::Term;
 use crate::vm::value::{Callable, Env, Scope, Value};
@@ -112,15 +114,24 @@ impl<'ast> Run<'ast, '_> {
                 function,
                 scope,
             } if arguments.iter().any(Value::is_symbolic) => {
-                let call = Term::Call {
+                // The call records the arguments as they were before the attempt. Only
+                // containers can change during it, so calls without them are kept (`Err`) and
+                // recorded only when the attempt fails.
+                let call = |arguments: &[Value<'ast>]| Term::Call {
                     callee: Box::new(Term::Global(name.to_string())),
                     this: None,
                     arguments: arguments.iter().map(Value::expr).collect(),
                 };
+                let recorded = if arguments.iter().all(Value::is_immutable) {
+                    Err(arguments.clone())
+                } else {
+                    Ok(call(&arguments))
+                };
                 let checkpoint = self.checkpoint();
                 match self.script(function, scope.as_ref(), this, arguments) {
                     Err(stop) if matches!(*stop, Stop::Unsupported(_)) => {
                         self.restore(checkpoint);
+                        let call = recorded.unwrap_or_else(|kept| call(&kept));
                         Ok(self.temp(call))
                     }
                     outcome => {
@@ -191,20 +202,59 @@ impl<'ast> Run<'ast, '_> {
         }
     }
 
-    /// Calls a function through its slot plan if it has one and is not a closure, or else
-    /// through its scoped plan.
-    fn script(
+    /// Calls a script function: natively if it has an intrinsic that accepts the arguments,
+    /// from the program's cache if it decrypts a string record decrypted before, or else
+    /// interpreted.
+    pub(super) fn script(
+        &mut self,
+        function: &'ast Function,
+        scope: Option<&Scope<'ast>>,
+        this: Value<'ast>,
+        arguments: Vec<Value<'ast>>,
+    ) -> Evaluation<'ast, Value<'ast>> {
+        if let Some(intrinsic) = self.session.intrinsics.get(&intrinsic::address(function)) {
+            // Intrinsics may write to their arguments.
+            for argument in &arguments {
+                self.writable(argument)?;
+            }
+            if let Some(value) = intrinsic.call(&arguments) {
+                return Ok(value);
+            }
+        }
+        // Handlers decrypt strings both by reading registers and by calling the decoder.
+        if self
+            .session
+            .record_decoder
+            .is_some_and(|decoder| ptr::eq(decoder, function))
+            && let Some(decrypted) = self.decrypted
+            && let [record] = &arguments[..]
+            && let Some(key) = record_key(record)
+        {
+            if let Some(text) = decrypted.borrow().get(&key) {
+                return Ok(text.clone());
+            }
+            let text = self.interpret(function, scope, this, arguments)?;
+            // A run that thawed a shared object may have computed the text differently.
+            if matches!(text, Value::String(_)) && !self.thawed {
+                decrypted.borrow_mut().insert(key, text.clone());
+            }
+            return Ok(text);
+        }
+        self.interpret(function, scope, this, arguments)
+    }
+
+    /// Runs a function through its slot plan if it has one, or else through its scoped plan.
+    fn interpret(
         &mut self,
         function: &'ast Function,
         scope: Option<&Scope<'ast>>,
         this: Value<'ast>,
         arguments: Vec<Value<'ast>>,
     ) -> Evaluation<'ast, Value<'ast>> {
-        if scope.is_none()
-            && self.setup.is_none()
+        if self.setup.is_none()
             && let Some(plan) = self.session.compiled.slots(function)
         {
-            return self.call_plan(&plan, this, arguments);
+            return self.call_plan(&plan, scope, this, arguments);
         }
         let body = function
             .body
@@ -252,6 +302,33 @@ impl<'ast> Run<'ast, '_> {
     }
 }
 
+/// Identifies a string record: the program, then numbers and arrays of numbers. A program's
+/// records with the same contents decrypt to the same string.
+fn record_key(record: &Value<'_>) -> Option<RecordKey> {
+    let Value::Array(elements) = record else {
+        return None;
+    };
+    let elements = elements.borrow();
+    let (Value::Program, rest) = elements.split_first()? else {
+        return None;
+    };
+    let bits = |value: &Value<'_>| match value {
+        Value::Number(number) => Some(number.to_bits()),
+        _ => None,
+    };
+    rest.iter()
+        .map(|element| match element {
+            Value::Array(numbers) => numbers
+                .borrow()
+                .iter()
+                .map(bits)
+                .collect::<Option<_>>()
+                .map(RecordPart::Numbers),
+            element => bits(element).map(RecordPart::Number),
+        })
+        .collect()
+}
+
 /// Binds call arguments to parameters and reserves `room` additional local slots.
 fn parameters<'ast, 'pattern>(
     patterns: impl Iterator<Item = &'pattern Pat>,