@tishlang/tish-format 3.10.9 → 3.10.11

package/crates/tish_runtime/src/promise_io.rs

@@ -15,20 +15,43 @@ pub struct StringResultPromise {
     pub(crate) rx: Mutex<Option<oneshot::Receiver<Result<String, String>>>>,
 }
 
+impl StringResultPromise {
+    fn convert(
+        r: Result<Result<String, String>, oneshot::error::RecvError>,
+    ) -> std::result::Result<Value, Value> {
+        match r {
+            Ok(Ok(s)) => Ok(Value::String(s.into())),
+            Ok(Err(e)) => Err(error_value(e)),
+            Err(_) => Err(Value::String("Promise dropped".into())),
+        }
+    }
+}
+
 impl TishPromise for StringResultPromise {
     fn block_until_settled(&self) -> std::result::Result<Value, Value> {
         let rx = self.rx.lock().unwrap().take();
         if let Some(rx) = rx {
-            let result = crate::http::block_on_http(rx);
-            match result {
-                Ok(Ok(s)) => Ok(Value::String(s.into())),
-                Ok(Err(e)) => Err(error_value(e)),
-                Err(_) => Err(Value::String("Promise dropped".into())),
-            }
+            Self::convert(crate::http::block_on_http(rx))
         } else {
             Err(Value::String("Promise already consumed".into()))
         }
     }
+
+    /// Await the oneshot on the shared subscriber runtime instead of parking a
+    /// blocking thread (plus a per-call tokio runtime) per raced input (issue #702).
+    fn subscribe(
+        self: Arc<Self>,
+        on_settled: Box<dyn FnOnce(std::result::Result<Value, Value>) + Send>,
+    ) {
+        match self.rx.lock().unwrap().take() {
+            Some(rx) => {
+                crate::http::subscriber_runtime().spawn(async move {
+                    on_settled(Self::convert(rx.await));
+                });
+            }
+            None => on_settled(Err(Value::String("Promise already consumed".into()))),
+        }
+    }
 }
 
 pub fn string_result_promise(rx: oneshot::Receiver<Result<String, String>>) -> Value {

package/crates/tish_vm/src/vm.rs

@@ -2350,10 +2350,11 @@ impl Vm {
         let names = &chunk.names;
 
         let mut ip = 0;
-        // Lazily allocated name-keyed scope. Slot-based chunks never WRITE it (params + body locals
-        // live in `slot_locals`; `StoreVar` checks-then-falls-through to globals; a slot-based chunk
-        // has no captured locals by construction), so on the hot slot-based call path we skip the
-        // `VmRef::new(Arc<Mutex<HashMap>>)` box entirely. Non-slot chunks need it eagerly for params.
+        // Lazily allocated name-keyed scope. A slot-based chunk with no captured names never writes
+        // it (params + body locals live in `slot_locals`), so the hot slot-based call path skips the
+        // `VmRef::new(Arc<Mutex<HashMap>>)` box entirely; captured locals (`DeclareVar`) and captured
+        // params (the #716 copy-in prologue's `DeclareVarPlain`) materialise it on first use.
+        // Non-slot chunks need it eagerly for params.
         // `ls_get_or_init!()` lazily creates it on the first write/capture; reads treat `None` as empty.
         let mut local_scope: Option<ScopeMap> = if chunk.slot_based {
             None

package/crates/tish_vm/tests/captured_param_slot_mode.rs

@@ -0,0 +1,210 @@
+//! #716 follow-up: functions whose PARAMS are captured by a nested closure were
+//! disqualified from general slot mode entirely (`slot_analyze` returned `None`), so the
+//! per-call frame-scope↔closure cycle from #716 persisted for them — the issue's exact
+//! repro (`handleEvent(payload)` with a body helper reading `payload`) still leaked after
+//! #728.
+//!
+//! The fix is a captured-param COPY-IN PROLOGUE: params land in slots 0..n as the VM's
+//! calling convention requires, and each captured param is copied into `local_scope` at
+//! entry (one `LoadLocal` + `DeclareVarPlain`). From then on the SCOPE is the single
+//! source of truth for that param — every body read/write compiles name-based
+//! (`LoadVar`/`StoreVar`), the very same map closures capture — so shared-cell mutation
+//! semantics are preserved exactly. The chunk stays in slot mode, and #728's slot-binding
+//! of the (uncaptured) helper NAME applies: no cycle, the frame drops on return.
+
+use std::sync::Arc;
+use tishlang_bytecode::compile;
+use tishlang_core::{Value, VmRef};
+use tishlang_vm::Vm;
+
+fn run_src(src: &str) {
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    tishlang_vm::run(&chunk).expect("run");
+}
+
+/// These tests pin slot-mode behavior; a suite run with `TISH_VM_SLOTS=0` deliberately
+/// exercises the legacy name-based path (which still has the #716 cycle).
+fn slots_disabled() -> bool {
+    std::env::var("TISH_VM_SLOTS")
+        .map(|v| v == "0")
+        .unwrap_or(false)
+}
+
+/// The leak regression — the #716 repro shape verbatim (helper captures the enclosing
+/// PARAM): N calls must not retain the N frames. The probe is the payload argument, so
+/// each leaked frame would hold one strong ref via its `local_scope` (`payload` →
+/// probe). Pre-fix the chunk is name-based and `fmt`'s `DeclareVar` completes the
+/// scope↔closure cycle: `VmRef::strong_count(&probe)` ends at `2 + N`.
+#[test]
+fn captured_param_frames_are_reclaimed() {
+    if slots_disabled() {
+        return;
+    }
+    let probe: VmRef<Vec<Value>> = VmRef::new(vec![Value::Number(1.0)]);
+    let mut vm = Vm::new();
+    vm.set_global(Arc::from("probe"), Value::Array(probe.clone()));
+    let src = r#"
+function handleEvent(payload) {
+  function fmt() { return payload.length }
+  return fmt()
+}
+let i = 0
+let acc = 0
+while (i < 100) { acc = acc + handleEvent(probe); i = i + 1 }
+if (acc !== 100) { throw "bad acc: " + acc }
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    vm.run(&chunk).expect("run");
+    // Exactly two live references: this test's `probe` clone + the VM globals entry.
+    assert_eq!(
+        VmRef::strong_count(&probe),
+        2,
+        "call frames retained the probe — the captured-param variant of the #716 \
+         frame-scope↔closure cycle is still leaking"
+    );
+}
+
+/// MUTATION SEMANTICS, direction 1: the body reassigns the param, then a closure reads
+/// it. The scope must be the single source of truth (a stale copy would return 1).
+#[test]
+fn closure_reads_param_after_body_reassigns() {
+    run_src(
+        r#"
+function outer(p) {
+  function get() { return p }
+  p = p + 1
+  let r = get()
+  return r
+}
+if (outer(1) !== 2) { throw "closure saw a stale param copy: " + outer(1) }
+"#,
+    );
+}
+
+/// MUTATION SEMANTICS, direction 2: a closure reassigns the param (via a call), then the
+/// body reads it. The body read must route to the shared scope (a slot read would see 1).
+#[test]
+fn body_reads_param_after_closure_reassigns() {
+    run_src(
+        r#"
+function outer(p) {
+  function bump() { p = p + 10 }
+  bump()
+  let r = p
+  return r
+}
+if (outer(1) !== 11) { throw "body saw a stale param slot: " + outer(1) }
+"#,
+    );
+}
+
+/// Both directions interleaved, plus a second UNCAPTURED param that must stay slotted.
+#[test]
+fn interleaved_mutation_and_mixed_params() {
+    run_src(
+        r#"
+function outer(p, q) {
+  function bump() { p = p + 1 }
+  p = p * 2
+  bump()
+  let r = p + q
+  return r
+}
+if (outer(3, 10) !== 17) { throw "interleaved captured-param mutation broken: " + outer(3, 10) }
+"#,
+    );
+}
+
+/// An ESCAPING closure keeps the captured param (including a body reassignment made
+/// before the escape) alive after the frame returns.
+#[test]
+fn escaping_closure_keeps_reassigned_param() {
+    run_src(
+        r#"
+function mk(p) {
+  function get() { return p }
+  p = p * 2
+  return get
+}
+let g = mk(4)
+if (g() !== 8) { throw "escaping closure lost the reassigned param: " + g() }
+"#,
+    );
+}
+
+/// A DEFAULT on a captured param: the copy-in must run before the defaults prologue so
+/// the applied default (stored name-based) is not clobbered by the missing-arg null.
+#[test]
+fn captured_param_default_applies() {
+    run_src(
+        r#"
+function withDefault(a, p = 5) {
+  function get() { return p }
+  let r = a + get()
+  return r
+}
+if (withDefault(1) !== 6) { throw "captured-param default lost: " + withDefault(1) }
+if (withDefault(1, 2) !== 3) { throw "captured-param supplied arg broken: " + withDefault(1, 2) }
+"#,
+    );
+}
+
+/// Recursion: every level gets a fresh frame scope; each closure sees its own level's
+/// param.
+#[test]
+fn recursion_with_captured_param() {
+    run_src(
+        r#"
+function recur(n) {
+  function dec() { return n - 1 }
+  if (n === 0) { return 0 }
+  let x = recur(dec())
+  return x + n
+}
+if (recur(3) !== 6) { throw "recursion with captured param broken: " + recur(3) }
+"#,
+    );
+}
+
+/// A MISSING captured param reads null — matching the interpreter (and slot mode's
+/// existing missing-arg behavior). The legacy name-based VM chunk left the name unbound
+/// ("Undefined variable"), a pre-existing interp divergence this shape no longer hits.
+#[test]
+fn missing_captured_param_is_null() {
+    if slots_disabled() {
+        return;
+    }
+    run_src(
+        r#"
+function m(a, b) {
+  function g() { return b === null }
+  let r = g()
+  return r
+}
+if (m(1) !== true) { throw "missing captured param not bound to null" }
+"#,
+    );
+}
+
+/// A block-scoped `let` shadowing the captured param: the shadow is undone at block
+/// exit and the param's (copied-in) binding is restored.
+#[test]
+fn block_shadow_of_captured_param_restores() {
+    run_src(
+        r#"
+function outer(p) {
+  function get() { return p }
+  let inner = 0
+  {
+    let p = 100
+    inner = p
+  }
+  let r = get() + inner
+  return r
+}
+if (outer(7) !== 107) { throw "block shadow of captured param broken: " + outer(7) }
+"#,
+    );
+}

package/crates/tish_vm/tests/captured_param_vm_slots_off.rs

@@ -0,0 +1,64 @@
+//! #716 follow-up parity guard: the captured-param mutation-semantics shapes must behave
+//! identically with `TISH_VM_SLOTS=0` (the legacy name-based path). This file holds
+//! exactly ONE test so the process-global env var cannot race a sibling test — cargo
+//! builds each file in `tests/` as its own binary/process.
+//!
+//! (The missing-arg shape is deliberately absent: the legacy name-based path leaves a
+//! missing param unbound — "Undefined variable" — a pre-existing divergence from the
+//! interpreter that slot mode does not share.)
+
+use tishlang_bytecode::compile;
+
+fn run_src(src: &str) {
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    tishlang_vm::run(&chunk).expect("run");
+}
+
+#[test]
+fn captured_param_semantics_identical_with_slots_off() {
+    std::env::set_var("TISH_VM_SLOTS", "0");
+    run_src(
+        r#"
+function outer(p) {
+  function get() { return p }
+  p = p + 1
+  let r = get()
+  return r
+}
+if (outer(1) !== 2) { throw "slots-off: closure saw stale param: " + outer(1) }
+
+function outer2(p) {
+  function bump() { p = p + 10 }
+  bump()
+  let r = p
+  return r
+}
+if (outer2(1) !== 11) { throw "slots-off: body saw stale param: " + outer2(1) }
+
+function mk(p) {
+  function get() { return p }
+  p = p * 2
+  return get
+}
+let g = mk(4)
+if (g() !== 8) { throw "slots-off: escaping closure lost reassigned param: " + g() }
+
+function withDefault(a, p = 5) {
+  function get() { return p }
+  let r = a + get()
+  return r
+}
+if (withDefault(1) !== 6) { throw "slots-off: captured-param default lost" }
+if (withDefault(1, 2) !== 3) { throw "slots-off: captured-param supplied arg broken" }
+
+function recur(n) {
+  function dec() { return n - 1 }
+  if (n === 0) { return 0 }
+  let x = recur(dec())
+  return x + n
+}
+if (recur(3) !== 6) { throw "slots-off: recursion with captured param broken" }
+"#,
+    );
+}

package/crates/tish_vm/tests/param_defaults_slot_mode.rs

@@ -0,0 +1,126 @@
+//! #727: VM general slot mode dropped simple-param DEFAULT values.
+//!
+//! `function f(a, b = 5) { let c = a + b; return c }` puts the chunk in GENERAL slot
+//! mode (`let c` breaks the param-only fast path; nothing is captured, so `slot_analyze`
+//! accepts). Params are slot-bound, and every READ of `b` resolves to `LoadLocal <slot>`
+//! — but `emit_param_defaults_prologue` consulted only `slot_ctx` (the simple param-only
+//! map, `None` here) and wrote the applied default via `DeclareVarPlain` into the
+//! name-based scope map. The default was invisible: `b` read the uninitialized slot's
+//! `Null`, so `f(1)` computed `1 + null` → NaN.
+//!
+//! These are behavior tests — they must hold identically with `TISH_VM_SLOTS=0` (the
+//! name-based legacy path, correct all along) and with slots on (default).
+
+use tishlang_bytecode::compile;
+
+fn run_src(src: &str) {
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    tishlang_vm::run(&chunk).expect("run");
+}
+
+/// The issue repro: a missing arg must get its default in general slot mode.
+#[test]
+fn general_slot_mode_missing_arg_gets_default() {
+    run_src(
+        r#"
+function f(a, b = 5) {
+  let c = a + b
+  return c
+}
+if (f(1) !== 6) { throw "default lost in general slot mode: f(1) = " + f(1) }
+"#,
+    );
+}
+
+/// A supplied arg must win over the default (and stay slot-read correct).
+#[test]
+fn general_slot_mode_supplied_arg_wins() {
+    run_src(
+        r#"
+function f(a, b = 5) {
+  let c = a + b
+  return c
+}
+if (f(1, 2) !== 3) { throw "supplied arg broken: f(1, 2) = " + f(1, 2) }
+"#,
+    );
+}
+
+/// A default referencing an EARLIER param evaluates against that param's slot and must
+/// land in this param's slot.
+#[test]
+fn general_slot_mode_default_references_earlier_param() {
+    run_src(
+        r#"
+function dep(a, b = a + 1) {
+  let c = a + b
+  return c
+}
+if (dep(3) !== 7) { throw "dependent default lost: dep(3) = " + dep(3) }
+if (dep(3, 10) !== 13) { throw "dependent default should not fire: dep(3, 10) = " + dep(3, 10) }
+"#,
+    );
+}
+
+/// A chain of dependent defaults: each later default sees the earlier ones' results.
+#[test]
+fn general_slot_mode_chained_dependent_defaults() {
+    run_src(
+        r#"
+function chain(a, b = a * 2, c = b + a) {
+  let out = [a, b, c]
+  return out
+}
+let r = chain(3)
+if (r[0] !== 3 || r[1] !== 6 || r[2] !== 9) { throw "chained defaults broken: " + r }
+let r2 = chain(3, 10)
+if (r2[1] !== 10 || r2[2] !== 13) { throw "chained defaults (partial) broken: " + r2 }
+"#,
+    );
+}
+
+/// A fn whose PARAM is captured is disqualified from slot mode entirely — the name-based
+/// `DeclareVarPlain` path was always correct and must stay so.
+#[test]
+fn slot_disqualified_captured_param_default_unchanged() {
+    run_src(
+        r#"
+function g(a, b = 5) {
+  function h() { return b }
+  let c = a + h()
+  return c
+}
+if (g(1) !== 6) { throw "name-based default broken: g(1) = " + g(1) }
+if (g(1, 2) !== 3) { throw "name-based supplied arg broken: g(1, 2) = " + g(1, 2) }
+"#,
+    );
+}
+
+/// The simple param-only fast path (`slot_ctx`) was always correct and must stay so.
+#[test]
+fn simple_param_only_fast_path_default_unchanged() {
+    run_src(
+        r#"
+function f(a, b = 5) { return a + b }
+if (f(1) !== 6) { throw "param-only default broken: f(1) = " + f(1) }
+if (f(1, 2) !== 3) { throw "param-only supplied arg broken: f(1, 2) = " + f(1, 2) }
+"#,
+    );
+}
+
+/// An explicit `null` is NOT a missing arg: the default must not apply (tish has no
+/// `undefined`; `ArgMissing(i)` is true iff `i >= argc`). Same in both slot modes.
+#[test]
+fn explicit_null_is_not_missing() {
+    run_src(
+        r#"
+function f(a, b = 5) {
+  let isNull = b === null
+  return isNull
+}
+if (f(1, null) !== true) { throw "explicit null was replaced by the default" }
+if (f(1) !== false) { throw "missing arg did not get the default" }
+"#,
+    );
+}

package/crates/tish_vm/tests/param_defaults_vm_slots_off.rs

@@ -0,0 +1,44 @@
+//! #727 parity guard: the same default-parameter shapes must behave identically with
+//! `TISH_VM_SLOTS=0` (the legacy name-based path). This file holds exactly ONE test so
+//! the process-global env var cannot race a sibling test — cargo builds each file in
+//! `tests/` as its own binary/process.
+
+use tishlang_bytecode::compile;
+
+fn run_src(src: &str) {
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    tishlang_vm::run(&chunk).expect("run");
+}
+
+#[test]
+fn param_defaults_behave_identically_with_slots_off() {
+    std::env::set_var("TISH_VM_SLOTS", "0");
+    run_src(
+        r#"
+function f(a, b = 5) {
+  let c = a + b
+  return c
+}
+if (f(1) !== 6) { throw "slots-off default broken: f(1) = " + f(1) }
+if (f(1, 2) !== 3) { throw "slots-off supplied arg broken: f(1, 2) = " + f(1, 2) }
+
+function dep(a, b = a + 1) {
+  let c = a + b
+  return c
+}
+if (dep(3) !== 7) { throw "slots-off dependent default broken: dep(3) = " + dep(3) }
+if (dep(3, 10) !== 13) { throw "slots-off dependent supplied broken" }
+
+function g(a, b = 5) {
+  function h() { return b }
+  let c = a + h()
+  return c
+}
+if (g(1) !== 6) { throw "slots-off captured-param default broken: g(1) = " + g(1) }
+
+function po(a, b = 5) { return a + b }
+if (po(1) !== 6) { throw "slots-off param-only default broken" }
+"#,
+    );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "3.10.9",
+  "version": "3.10.11",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {