@tishlang/tish-format 3.10.4 → 3.10.11

package/crates/tish_vm/src/lib.rs

@@ -4,6 +4,12 @@
 mod jit;
 mod vm;
 
+/// Test/diagnostic introspection of the process-global JIT cache sizes (#703). Hidden: not a stable
+/// public API — exists so regression tests and embedder diagnostics can observe that the caches grow
+/// with distinct program text, not with closure-instantiation volume.
+#[cfg(not(target_arch = "wasm32"))]
+#[doc(hidden)]
+pub use jit::jit_cache_lens;
 pub use vm::{all_compiled_capabilities, run, run_with_options, Vm, VmRunOptions};
 
 #[cfg(test)]

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
@@ -2610,7 +2611,9 @@ impl Vm {
                                 .get(*nested_idx)
                                 .ok_or_else(|| "Nested chunk index out of bounds".to_string())?;
                             // Numeric JIT fast path (native codegen, non-wasm): if this is a
-                            // straight-line numeric function, compile it once (cached per chunk)
+                            // straight-line numeric function, compile it once (cached by chunk
+                            // CONTENT, #703 — the `inner.clone()` below makes addresses
+                            // per-instance, so every instance of one source fn shares a compile)
                             // and call native code when all args are numbers; else fall back to
                             // the interpreter below. Purely additive — can't change behaviour.
                             #[cfg(not(target_arch = "wasm32"))]

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/fundecl_slot_no_frame_cycle.rs

@@ -0,0 +1,152 @@
+//! #716: a body-level `function NAME` used to be bound with `DeclareVar` into the very
+//! `local_scope` map its own closure had just captured (`Constant::Closure` →
+//! `VmClosure.enclosing`), minting a deterministic closure→scope→closure reference cycle
+//! per call. The runtime is refcount-only, so every such call frame — including everything
+//! reachable from its name-based locals — leaked (measured ~6.7 KB/call in the issue).
+//! In general slot mode an UNCAPTURED function name is now slot-bound instead, so the
+//! closure never enters the captured map and the frame drops normally 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 itself: N calls of a function with an uncaptured body-level named
+/// fn must not retain the N frames. The probe array is reachable from each frame's
+/// captured local `s`; before the fix `helper`'s `DeclareVar` completed the cycle and
+/// `VmRef::strong_count(&probe)` ended at `2 + N` — every frame stayed alive.
+#[test]
+fn uncaptured_body_fn_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 work() {
+  let s = probe
+  function helper() { return s.length }
+  return helper()
+}
+let i = 0
+let acc = 0
+while (i < 100) { acc = acc + work(); 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.
+    // Each leaked frame would hold one more (its `local_scope` binds `s` → probe).
+    assert_eq!(
+        VmRef::strong_count(&probe),
+        2,
+        "call frames retained the probe — the #716 frame-scope↔closure cycle is back"
+    );
+}
+
+/// Self-recursion keeps the scope path (its own name IS a capture) and still works.
+#[test]
+fn self_recursive_body_fn_still_works() {
+    run_src(
+        r#"
+function outer(n) {
+  function fact(k) { if (k < 2) { return 1 } return k * fact(k - 1) }
+  return fact(n)
+}
+if (outer(6) !== 720) { throw "self-recursion broken" }
+"#,
+    );
+}
+
+/// Mutual recursion: both names are captured by the sibling closure; both keep the scope path.
+#[test]
+fn mutually_recursive_body_fns_still_work() {
+    run_src(
+        r#"
+function outer(n) {
+  function isEven(k) { if (k === 0) { return true } return isOdd(k - 1) }
+  function isOdd(k) { if (k === 0) { return false } return isEven(k - 1) }
+  return isEven(n)
+}
+if (outer(10) !== true) { throw "mutual recursion broken (even)" }
+if (outer(7) !== false) { throw "mutual recursion broken (odd)" }
+"#,
+    );
+}
+
+/// tish binds body-level fn decls sequentially (no JS hoisting): a use BEFORE the
+/// declaration statement sees the outer binding, exactly as with `let`. The slot-bound
+/// variant must preserve that — the reference site compiles before the slot exists, so
+/// it stays a name-based load and resolves outward.
+#[test]
+fn body_fn_binding_is_sequential_not_hoisted() {
+    run_src(
+        r#"
+let f = "global"
+function outer() {
+  let before = f
+  function f() { return "local" }
+  return before + "|" + f()
+}
+if (outer() !== "global|local") { throw "sequential fn binding broken: " + outer() }
+"#,
+    );
+}
+
+/// An uncaptured body-level fn is callable, reassignable, passable as a value, and a
+/// block-scoped one stays confined to its block — identical to the name-based path.
+#[test]
+fn body_fn_value_semantics_unchanged() {
+    run_src(
+        r#"
+function outer() {
+  function f() { return 1 }
+  let a = f()
+  f = () => 2
+  let b = f()
+  function double(v) { return v * 2 }
+  let out = [1, 2, 3].map(double)
+  let got = 0
+  {
+    function inner() { return 39 }
+    got = inner()
+  }
+  return a + b + got + out[0] + out[1] + out[2]
+}
+if (outer() !== 54) { throw "body fn value semantics broken: " + outer() }
+"#,
+    );
+}
+
+/// A slot-bound fn that ESCAPES its frame (returned) still resolves its captures: the
+/// closure carries the captured `local_scope` chain; only the name binding moved to a slot.
+#[test]
+fn escaping_body_fn_keeps_captures() {
+    run_src(
+        r#"
+function makeGetter() {
+  let n = 7
+  function get() { return n }
+  return get
+}
+let g = makeGetter()
+if (g() !== 7) { throw "escaping body fn lost its capture" }
+"#,
+    );
+}

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.4",
+  "version": "3.10.11",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {