@tishlang/tish-format 3.10.9 → 3.10.11

package/crates/tish/src/cargo_native_registry.rs

@@ -15,6 +15,10 @@ pub(crate) fn register_bytecode_native_modules(vm: &mut tishlang_vm::Vm) {
     );
     om.insert(Arc::from("connect"), Value::native(tishlang_pg::connect));
     om.insert(Arc::from("prepare"), Value::native(tishlang_pg::prepare));
+    om.insert(
+        Arc::from("unprepare"),
+        Value::native(tishlang_pg::unprepare),
+    );
     om.insert(
         Arc::from("query_prepared"),
         Value::native(tishlang_pg::query_prepared),

package/crates/tish/tests/integration_test.rs

@@ -1068,6 +1068,9 @@ allSettled[1] rejected: boom
 allSettled[2] ok: 30
 race winner: A
 any passthrough: 42
+race pending-loser winner: fast
+loser still awaitable: late
+re-await: 7 7
 ";
     for backend_args in [vec!["run"], vec!["run", "--backend", "interp"]] {
         let mut args = backend_args.clone();

package/crates/tish_bytecode/src/compiler.rs

@@ -844,8 +844,11 @@ impl SlotScan {
 
 /// Capture-aware eligibility for general slot-based locals in a FUNCTION. Returns the captured-name set
 /// (names that must stay name-based) when eligible, else `None` (compile name-based). Eligible iff the
-/// flag is on, no rest param, all params simple, the body fully analysable, and no PARAM is captured
-/// (the VM binds params into slots 0..n, but a closure reads captures by name from `local_scope`).
+/// flag is on, no rest param, all params simple, and the body fully analysable. A CAPTURED param does
+/// NOT disqualify the chunk (#716 follow-up): the VM still binds the arg into its positional slot, and
+/// a copy-in prologue moves it into `local_scope` at entry — from then on the scope is that param's
+/// single source of truth (its name stays out of the slot map, so every body read/write compiles
+/// name-based to the very map closures capture — shared-cell mutation semantics preserved exactly).
 fn slot_analyze(
     params: &[FunParam],
     has_rest: bool,
@@ -863,13 +866,6 @@ fn slot_analyze(
     if !scan.stmt(body, false) {
         return None;
     }
-    for p in params {
-        if let FunParam::Simple(tp) = p {
-            if scan.captured.contains(&tp.name) {
-                return None;
-            }
-        }
-    }
     Some(scan.captured)
 }
 
@@ -1060,12 +1056,12 @@ impl<'a> Compiler<'a> {
             self.emit_u16(Opcode::ArgMissing, i as u16);
             let skip = self.emit_jump(Opcode::JumpIfFalse);
             self.compile_expr(default_expr)?;
-            let slot = self
-                .slot_ctx
-                .as_ref()
-                .and_then(|m| m.get(tp.name.as_ref()))
-                .copied();
-            match slot {
+            // #727: resolve through BOTH slot maps (`resolve_slot`), not `slot_ctx` alone. In
+            // GENERAL slot mode params live in `slot_scopes` (declared before this prologue) and
+            // every read of the param lowers to `LoadLocal <slot>` — a `DeclareVarPlain` here wrote
+            // the default into the name-based scope map no read resolves to, leaving the slot's
+            // missing-arg `Null` visible (`f(a, b = 5); f(1)` → `1 + null` → NaN).
+            match self.resolve_slot(tp.name.as_ref()) {
                 Some(slot) => self.emit_u16(Opcode::StoreLocal, slot),
                 None => {
                     let idx = self.name_idx(&tp.name);
@@ -2022,14 +2018,42 @@ impl<'a> Compiler<'a> {
                     inner_comp.emit_param_defaults_prologue(params)?;
                     inner_comp.compile_fn_body(body)?;
                 } else if let Some(cap) = captured {
-                    // Params (all uncaptured — gated) → slots 0..n (matching the VM's param binding);
-                    // uncaptured body `let`s get fresh slots via the scope-aware allocator; captured
-                    // locals stay name-based in `local_scope` (which closures capture).
+                    // Params → slots 0..n (matching the VM's positional arg binding); uncaptured
+                    // body `let`s get fresh slots via the scope-aware allocator; captured locals
+                    // stay name-based in `local_scope` (which closures capture).
+                    //
+                    // #716 follow-up: a CAPTURED param no longer disqualifies the chunk. It keeps
+                    // its slot NUMBER (the VM binds args positionally, so numbering must stay
+                    // 0..n) but is NOT slot-resolvable: its name never enters `slot_scopes`, so
+                    // every body read/write compiles name-based (`LoadVar`/`StoreVar`) against
+                    // `local_scope` — the very map closures capture — keeping the scope the
+                    // single source of truth (shared-cell mutation semantics preserved exactly;
+                    // a body reassignment is visible to the closure and vice versa). The COPY-IN
+                    // prologue below moves each captured arg slot → scope once at entry, BEFORE
+                    // the defaults prologue so an applied default (stored name-based for a
+                    // captured param) overwrites the copied-in missing-arg null, never the other
+                    // way around. This keeps the chunk in slot mode, so the #716 fix (#728) slot-
+                    // binds an uncaptured body-level fn NAME and the per-call frame-scope↔closure
+                    // cycle never forms for the `handleEvent(payload){ function fmt(){…payload…} }`
+                    // shape.
                     inner_comp.general_slots = true;
                     inner_comp.slot_captured = cap;
                     inner_comp.slot_scopes.push(HashMap::new());
+                    let mut captured_param_copy_ins: Vec<(u16, Arc<str>)> = Vec::new();
                     for p in &param_names {
-                        inner_comp.declare_slot(p);
+                        if inner_comp.slot_captured.contains(p.as_ref()) {
+                            // Reserve the positional slot without making it resolvable.
+                            let slot = inner_comp.next_slot;
+                            inner_comp.next_slot += 1;
+                            captured_param_copy_ins.push((slot, Arc::clone(p)));
+                        } else {
+                            inner_comp.declare_slot(p);
+                        }
+                    }
+                    for (slot, p) in &captured_param_copy_ins {
+                        inner_comp.emit_u16(Opcode::LoadLocal, *slot);
+                        let idx = inner_comp.name_idx(p);
+                        inner_comp.emit_u16(Opcode::DeclareVarPlain, idx);
                     }
                     inner_comp.emit_param_defaults_prologue(params)?;
                     inner_comp.compile_fn_body(body)?;

package/crates/tish_bytecode/tests/captured_param_slot_binding.rs

@@ -0,0 +1,131 @@
+//! #716 follow-up: a function whose PARAM is captured by a nested closure must still
+//! compile in general slot mode, with a captured-param COPY-IN PROLOGUE (`LoadLocal
+//! <param slot>` + `DeclareVarPlain <name>`) so the closure reads the param from
+//! `local_scope` while the chunk keeps frame slots for everything uncaptured —
+//! including the body-level helper NAME (#728), which is what breaks the per-call
+//! frame-scope↔closure cycle for the #716 repro shape.
+
+use tishlang_bytecode::{compile, Chunk, Opcode};
+
+/// Count occurrences of `target` in `chunk.code`, walking real instruction boundaries.
+fn count_opcode(chunk: &Chunk, target: Opcode) -> usize {
+    let code = &chunk.code;
+    let mut ip = 0usize;
+    let mut n = 0usize;
+    while ip < code.len() {
+        let op = Opcode::from_u8(code[ip]).expect("valid opcode");
+        if op == target {
+            n += 1;
+        }
+        ip += op.instruction_size(code, ip).expect("sized instruction");
+    }
+    n
+}
+
+fn compile_src(src: &str) -> Chunk {
+    let program = tishlang_parser::parse(src).expect("parse");
+    compile(&program).expect("compile")
+}
+
+/// These tests assert slot-mode emission; running the suite with `TISH_VM_SLOTS=0`
+/// deliberately exercises the legacy name-based path, where they do not apply.
+fn slots_disabled() -> bool {
+    std::env::var("TISH_VM_SLOTS")
+        .map(|v| v == "0")
+        .unwrap_or(false)
+}
+
+/// The #716 repro shape: the chunk must stay slot-based, copy the captured param in
+/// exactly once, and slot-bind the (uncaptured) helper name — zero `DeclareVar`.
+#[test]
+fn captured_param_chunk_stays_slot_based_with_copy_in() {
+    if slots_disabled() {
+        return;
+    }
+    let chunk = compile_src(
+        r#"
+function handleEvent(payload) {
+  function fmt(x) { return x + payload.tag }
+  return fmt("v")
+}
+console.log(handleEvent({ tag: "t" }))
+"#,
+    );
+    let outer = &chunk.nested[0];
+    assert!(
+        outer.slot_based,
+        "a captured-param chunk must no longer be disqualified from general slot mode"
+    );
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVarPlain),
+        1,
+        "exactly one copy-in store for the one captured param"
+    );
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVar),
+        0,
+        "the uncaptured helper name must be slot-bound (#728), not DeclareVar-bound — \
+         that is the cycle"
+    );
+    assert!(
+        count_opcode(outer, Opcode::StoreLocal) >= 1,
+        "the helper closure should be stored to a frame slot"
+    );
+}
+
+/// Mixed params: only the CAPTURED one is copied in; the uncaptured one stays
+/// slot-resolved (no name-based traffic for it).
+#[test]
+fn only_captured_params_are_copied_in() {
+    if slots_disabled() {
+        return;
+    }
+    let chunk = compile_src(
+        r#"
+function outer(p, q) {
+  function get() { return p }
+  let r = get() + q
+  return r
+}
+console.log(outer(1, 2))
+"#,
+    );
+    let outer = &chunk.nested[0];
+    assert!(outer.slot_based, "mixed-param chunk should be slot-based");
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVarPlain),
+        1,
+        "only the captured param `p` gets a copy-in store; `q` stays slotted"
+    );
+}
+
+/// A self-recursive helper capturing the param: the helper NAME is captured (its own
+/// body references it) and stays on the `DeclareVar` scope path, while the chunk itself
+/// remains slot-based with the param copy-in.
+#[test]
+fn self_recursive_helper_keeps_scope_path_beside_copy_in() {
+    if slots_disabled() {
+        return;
+    }
+    let chunk = compile_src(
+        r#"
+function outer(n) {
+  function fact(k) { if (k < 2) { return n } return k * fact(k - 1) }
+  return fact(4)
+}
+console.log(outer(1))
+"#,
+    );
+    let outer = &chunk.nested[0];
+    assert!(outer.slot_based, "chunk should stay slot-based");
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVarPlain),
+        1,
+        "the captured param `n` gets its copy-in"
+    );
+    assert_eq!(
+        count_opcode(outer, Opcode::DeclareVar),
+        1,
+        "the self-recursive helper name is captured and stays DeclareVar-bound"
+    );
+}

package/crates/tish_bytecode/tests/param_defaults_slot_binding.rs

@@ -0,0 +1,86 @@
+//! #727: WHERE the default-parameter prologue stores its value in general slot mode.
+//!
+//! In a general-slot-mode chunk every read of a param resolves to `LoadLocal <slot>`, so
+//! the applied default must be stored with `StoreLocal <slot>` — a `DeclareVarPlain`
+//! writes it into the name-based scope map where no read will ever find it (the slot
+//! keeps its missing-arg `Null`; `a + b` → NaN).
+
+use tishlang_bytecode::{compile, Chunk, Opcode};
+
+/// Count occurrences of `target` in `chunk.code`, walking real instruction boundaries.
+fn count_opcode(chunk: &Chunk, target: Opcode) -> usize {
+    let code = &chunk.code;
+    let mut ip = 0usize;
+    let mut n = 0usize;
+    while ip < code.len() {
+        let op = Opcode::from_u8(code[ip]).expect("valid opcode");
+        if op == target {
+            n += 1;
+        }
+        ip += op.instruction_size(code, ip).expect("sized instruction");
+    }
+    n
+}
+
+fn compile_src(src: &str) -> Chunk {
+    let program = tishlang_parser::parse(src).expect("parse");
+    compile(&program).expect("compile")
+}
+
+/// These tests assert slot-mode emission; running the suite with `TISH_VM_SLOTS=0`
+/// deliberately exercises the legacy name-based path, where they do not apply.
+fn slots_disabled() -> bool {
+    std::env::var("TISH_VM_SLOTS")
+        .map(|v| v == "0")
+        .unwrap_or(false)
+}
+
+#[test]
+fn general_slot_mode_default_stores_to_slot() {
+    if slots_disabled() {
+        return;
+    }
+    let chunk = compile_src(
+        r#"
+function f(a, b = 5) {
+  let c = a + b
+  return c
+}
+console.log(f(1))
+"#,
+    );
+    let f = &chunk.nested[0];
+    assert!(f.slot_based, "f should compile in general slot mode");
+    assert_eq!(
+        count_opcode(f, Opcode::DeclareVarPlain),
+        0,
+        "the applied default must not be declared into the name-based scope map — \
+         reads of the param resolve to its frame slot (#727)"
+    );
+    assert!(
+        count_opcode(f, Opcode::StoreLocal) >= 1,
+        "the applied default should be stored to the param's frame slot"
+    );
+}
+
+/// The slot-DISQUALIFIED shape (captured param → name-based chunk) must keep the
+/// `DeclareVarPlain` store: there is no slot, and closures read the param by name.
+#[test]
+fn name_based_chunk_default_still_declares_by_name() {
+    let chunk = compile_src(
+        r#"
+function g(a, b = 5) {
+  function h() { return b }
+  let c = a + h()
+  return c
+}
+console.log(g(1))
+"#,
+    );
+    let g = &chunk.nested[0];
+    assert_eq!(
+        count_opcode(g, Opcode::DeclareVarPlain),
+        1,
+        "captured-param chunk is name-based; its default must stay DeclareVarPlain-bound"
+    );
+}

package/crates/tish_core/src/value.rs

@@ -196,19 +196,46 @@ pub trait TishStruct {
 
 /// Trait for Promise-like values that can be awaited (block until settled).
 /// Implemented by the runtime for native compile; interpreter uses its own Promise.
-pub trait TishPromise: Send + Sync {
+///
+/// (`'static` is part of the contract: promises are shared as `Arc<dyn TishPromise>`
+/// inside `Value::Promise`, and settlement subscriptions outlive the subscribing frame.)
+pub trait TishPromise: Send + Sync + 'static {
     fn block_until_settled(&self) -> core::result::Result<Value, Value>;
     /// Try to settle WITHOUT blocking. Returns `Some(result)` if the promise was already
     /// settled before this call; returns `None` if it is still pending (a background thread
     /// / I/O task has not completed yet). Default: always pending — implementors of async
-    /// promises (fetch, spawn) leave this as `None`; `ImmediateSettledPromise` overrides it.
+    /// promises (fetch) leave this as `None`; settled/state-backed promises override it.
+    /// Must PEEK, not consume: a promise reporting `Some` here stays awaitable.
     ///
     /// Used by `race`/`any`/`allSettled` to handle already-settled promises in input-order
-    /// (deterministic, JS-compatible) before falling back to concurrent thread waiting for
-    /// genuinely-pending ones.
+    /// (deterministic, JS-compatible) before subscribing to genuinely-pending ones.
     fn try_settle(&self) -> Option<core::result::Result<Value, Value>> {
         None
     }
+
+    /// Register a callback to run exactly once when this promise settles (issue #702).
+    ///
+    /// `Promise.race` / `Promise.any` / `Promise.allSettled` use this to wait on N
+    /// promises concurrently WITHOUT parking one OS thread per pending input: an
+    /// implementor that can store the callback (state-cell or channel-backed promises)
+    /// invokes it from whichever thread settles the promise, so the combinator's own
+    /// channel `recv` is the only blocking wait. A subscription that loses a race is
+    /// simply dropped after (or instead of) firing — no cancellation path is needed.
+    ///
+    /// The default implementation is the legacy behavior — a detached waiter thread
+    /// blocking in [`Self::block_until_settled`] — so implementors that cannot register
+    /// callbacks keep working; they only miss the no-thread optimization until they
+    /// override this. Overrides MUST NOT block while the promise is pending.
+    #[cfg(feature = "send-values")]
+    fn subscribe(
+        self: Arc<Self>,
+        on_settled: Box<dyn FnOnce(core::result::Result<Value, Value>) + Send>,
+    ) {
+        std::thread::spawn(move || {
+            let r = self.block_until_settled();
+            on_settled(r);
+        });
+    }
 }
 
 /// JavaScript RegExp flags

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "3.10.9"
+version = "3.10.11"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/crates/tish_pg/src/lib.rs

@@ -10,6 +10,9 @@ use tishlang_runtime::VmRef;
 mod error;
 pub use error::{format_pg_error, format_tish_pg_error, Result, TishPgError};
 
+#[cfg(feature = "tish-bindings")]
+mod statement_registry;
+
 use deadpool_postgres::{Manager, Pool, Runtime};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Map, Value as JsonValue};
@@ -537,10 +540,15 @@ mod tish_sync {
     // worker threads each doing thousands of QPS, the prior `Mutex<Slab>`
     // serialised every query through one global lock; `RwLock` lets all
     // concurrent reads run lock-free against each other.
+    use crate::statement_registry::StatementRegistry;
     use std::sync::RwLock;
     static CLIENTS: Lazy<RwLock<Slab<PerWorkerClient>>> = Lazy::new(|| RwLock::new(Slab::new()));
-    static STATEMENTS: Lazy<RwLock<Slab<(usize, Statement)>>> =
-        Lazy::new(|| RwLock::new(Slab::new()));
+    // Statement lifecycle (see statement_registry.rs and tishlang/tish#712):
+    // entries are interned per (client, sql), validated against the owning
+    // client on every lookup, swept by `close`, and individually freed by
+    // `unprepare`.
+    static STATEMENTS: Lazy<RwLock<StatementRegistry<Statement>>> =
+        Lazy::new(|| RwLock::new(StatementRegistry::new()));
 
     /// Drive a future on our tokio runtime without panicking when called from
     /// inside another runtime's worker thread.
@@ -709,9 +717,13 @@ mod tish_sync {
         g.get(id as usize).cloned()
     }
 
-    fn get_statement(id: f64) -> Option<(usize, Statement)> {
+    /// Resolve a statement handle **for a specific client**. A handle whose
+    /// stored client id does not match is a miss: after `close()` recycles a
+    /// CLIENTS slab index, a stale statement handle must not be replayed
+    /// against whichever new connection reused that index.
+    fn get_statement(id: f64, client_id: f64) -> Option<Statement> {
         let g = STATEMENTS.read().unwrap();
-        g.get(id as usize).cloned()
+        g.get(id as usize, client_id as usize)
     }
 
     /// `prepare(client_handle, sql) -> statement_handle`.
@@ -726,10 +738,23 @@ mod tish_sync {
             return tish_err("prepare: unknown client handle");
         };
         let sql = sql.to_string();
+        // Idempotent per (client, sql): re-preparing identical SQL returns
+        // the interned handle without a server round-trip, so the statement
+        // table is bounded by distinct SQL text instead of prepare() calls.
+        {
+            let g = STATEMENTS.read().unwrap();
+            if let Some(id) = g.lookup(*client_id as usize, &sql) {
+                return TishValue::Number(id as f64);
+            }
+        }
         match block_on(client.prepare(&sql)) {
             Ok(stmt) => {
                 let mut g = STATEMENTS.write().unwrap();
-                let id = g.insert((*client_id as usize, stmt));
+                // insert() re-checks the intern map under the write lock: if
+                // a concurrent identical prepare won the race, its handle is
+                // reused and this fresh Statement drops (emitting the
+                // server-side DEALLOCATE).
+                let id = g.insert(*client_id as usize, &sql, stmt);
                 TishValue::Number(id as f64)
             }
             Err(e) => tish_err(format!("prepare: {}", crate::format_tish_pg_error(&e))),
@@ -752,7 +777,7 @@ mod tish_sync {
         let Some(client) = get_client(*client_id) else {
             return tish_err("queryPrepared: unknown client");
         };
-        let Some((_cid, stmt)) = get_statement(*stmt_id) else {
+        let Some(stmt) = get_statement(*stmt_id, *client_id) else {
             return tish_err("queryPrepared: unknown statement");
         };
         // Fast path: build `Value::Object` rows directly from `Row` so we
@@ -792,7 +817,7 @@ mod tish_sync {
                 let Some(TishValue::Number(stmt_id)) = pair_b.first() else {
                     return tish_err("queryAll: spec[0] must be a statement handle");
                 };
-                let Some((_cid, stmt)) = get_statement(*stmt_id) else {
+                let Some(stmt) = get_statement(*stmt_id, *client_id) else {
                     return tish_err("queryAll: unknown statement");
                 };
                 let params = match pair_b.get(1) {
@@ -821,8 +846,18 @@ mod tish_sync {
     }
 
     /// `close(client_handle) -> null`.
+    ///
+    /// Also sweeps the client's prepared statements. The sweep runs first,
+    /// while the connection is still alive, so each dropped `Statement`
+    /// emits its server-side `DEALLOCATE`; purging the intern entries keeps
+    /// a later client that reuses this slab index from inheriting stale
+    /// handles.
     pub fn close(args: &[TishValue]) -> TishValue {
         if let Some(TishValue::Number(id)) = args.first() {
+            {
+                let mut s = STATEMENTS.write().unwrap();
+                s.sweep_client(*id as usize);
+            }
             let mut g = CLIENTS.write().unwrap();
             if g.contains(*id as usize) {
                 g.remove(*id as usize);
@@ -831,6 +866,22 @@ mod tish_sync {
         TishValue::Null
     }
 
+    /// `unprepare(statement_handle) -> null`.
+    ///
+    /// Frees one prepared-statement entry. Dropping the `Statement` sends
+    /// the server-side `DEALLOCATE` (tokio-postgres emits a `Close` message
+    /// on drop) as long as the owning connection is still alive; if the
+    /// client was already closed the drop is inert and the server reclaimed
+    /// the statement on disconnect. Unknown handles are ignored, mirroring
+    /// `close`.
+    pub fn unprepare(args: &[TishValue]) -> TishValue {
+        if let Some(TishValue::Number(id)) = args.first() {
+            let mut g = STATEMENTS.write().unwrap();
+            g.remove(*id as usize);
+        }
+        TishValue::Null
+    }
+
     /// `migrate(client_handle, dir) -> { ok, applied: [name, …], error? }`.
     ///
     /// Reads `dir` for files matching `^\d+_.+\.sql$`, sorted lexically
@@ -940,7 +991,7 @@ mod tish_sync {
 // the Rust side (camelCase `queryAll` in .tish -> snake `query_all` here).
 #[cfg(feature = "tish-bindings")]
 pub use tish_sync::{
-    close, connect, migrate, per_worker_client, prepare, query_all, query_prepared,
+    close, connect, migrate, per_worker_client, prepare, query_all, query_prepared, unprepare,
 };
 
 #[cfg(test)]