@tishlang/tish-lsp 3.10.9 → 3.11.0

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_lsp/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_lsp"
-version = "3.10.9"
+version = "3.11.0"
 edition = "2021"
 description = "Language Server Protocol implementation for Tish"
 license-file = { workspace = true }

package/crates/tish_native/src/build.rs

@@ -287,7 +287,9 @@ edition = "2021"
         .parent()
         .and_then(|p| p.parent())
         .map(|ws| ws.join("target"));
-    let target_dir = workspace_target.filter(|p| p.exists());
+    let target_dir = workspace_target
+        .filter(|p| p.exists())
+        .or_else(shared_native_target_dir);
     let cross = build_config.cargo_target.as_deref();
     let release_sub = if let Some(triple) = cross {
         format!("{triple}/release")
@@ -456,7 +458,10 @@ fn runtime_dep_toml(runtime_path: &str, features_str: &str) -> String {
     if let Some(v) = released_compiler_version() {
         format!("tishlang_runtime = {{ version = {:?}{} }}", v, features_str)
     } else {
-        format!("tishlang_runtime = {{ path = {:?}{} }}", runtime_path, features_str)
+        format!(
+            "tishlang_runtime = {{ path = {:?}{} }}",
+            runtime_path, features_str
+        )
     }
 }
 
@@ -693,8 +698,7 @@ tishlang_runtime = {{ path = {runtime:?}{version}{features} }}
         fs::write(src_dir.join("generated_native.rs"), gen)
             .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
     }
-    fs::write(src_dir.join("lib.rs"), lib_rs)
-        .map_err(|e| format!("Cannot write lib.rs: {}", e))?;
+    fs::write(src_dir.join("lib.rs"), lib_rs).map_err(|e| format!("Cannot write lib.rs: {}", e))?;
 
     println!("Emitted Rust library crate: {}", output_path.display());
     Ok(())
@@ -739,8 +743,7 @@ fn build_gba_rom(
     // the source of truth. The generated ROM crate must depend on the SAME agb: a skew would pull in
     // two agb crates and mismatch types at the sprite-registration boundary. Falls back to a known
     // pin only if the line can't be read (never blocks the build on a parse miss).
-    let agb_version =
-        read_facade_agb_version(&facade_path).unwrap_or_else(|| "0.25.0".to_string());
+    let agb_version = read_facade_agb_version(&facade_path).unwrap_or_else(|| "0.25.0".to_string());
 
     let out_stem = output_path
         .file_stem()
@@ -816,11 +819,13 @@ agb = "{agb_version}"
     // Only the channel is inherited. `components` stays `rust-src` because that is what build-std
     // needs — copying a project's `clippy`/`rustfmt` entries in would fail the ROM build whenever
     // the pinned toolchain lacks a component the ROM never uses.
-    let channel =
-        find_project_toolchain_channel(&base).unwrap_or_else(|| "nightly".to_string());
+    let channel = find_project_toolchain_channel(&base).unwrap_or_else(|| "nightly".to_string());
     fs::write(
         build_dir.join("rust-toolchain.toml"),
-        format!("[toolchain]\nchannel = \"{}\"\ncomponents = [\"rust-src\"]\n", channel),
+        format!(
+            "[toolchain]\nchannel = \"{}\"\ncomponents = [\"rust-src\"]\n",
+            channel
+        ),
     )
     .map_err(|e| format!("Cannot write rust-toolchain.toml: {}", e))?;
 
@@ -971,6 +976,30 @@ fn find_project_toolchain_channel(start: &Path) -> Option<String> {
     None
 }
 
+/// `TISH_NATIVE_TARGET_DIR` — opt-in shared cargo target dir for native (desktop) builds.
+///
+/// Native builds compile the generated crate under a per-process temp dir that is deleted on
+/// success (`cleanup_build_dir`), so nothing survives between two `tish build --target native`
+/// invocations and CI recompiles every dependency each run. Inside the tish workspace the
+/// workspace `target/` is shared automatically; a released compiler has no workspace, and this
+/// env var is the equivalent for it: point it at a directory that persists (a CI cache) and
+/// cargo reuses the dependency artifacts across builds. Deliberately NOT the ambient
+/// `CARGO_TARGET_DIR` — see the GBA path for why that is scrubbed (`TISH_GBA_TARGET_DIR` is the
+/// same opt-in for ROM builds). The directory is created if missing.
+fn shared_native_target_dir() -> Option<PathBuf> {
+    let dir = std::env::var_os("TISH_NATIVE_TARGET_DIR")
+        .map(PathBuf::from)
+        .filter(|p| !p.as_os_str().is_empty())?;
+    if let Err(e) = fs::create_dir_all(&dir) {
+        eprintln!(
+            "warning: TISH_NATIVE_TARGET_DIR={} is not usable ({e}); building in the temp dir",
+            dir.display()
+        );
+        return None;
+    }
+    Some(dir)
+}
+
 /// Remove a finished build's per-PID source directory (#384). Called only on SUCCESS, after the
 /// binary is copied out — the dir is then disposable (it holds only the generated crate source;
 /// compiled artifacts live in the shared workspace `target/`). Left in place on any earlier error so a
@@ -1126,7 +1155,9 @@ edition = "2021"
         .parent()
         .and_then(|p| p.parent())
         .map(|ws| ws.join("target"));
-    let target_dir = workspace_target.filter(|p| p.exists());
+    let target_dir = workspace_target
+        .filter(|p| p.exists())
+        .or_else(shared_native_target_dir);
     let binary_dir = target_dir
         .as_ref()
         .map(|t| t.join("release"))
@@ -1188,14 +1219,41 @@ mod tests {
         let _ = fs::remove_dir_all(&base);
     }
 
+    /// `TISH_NATIVE_TARGET_DIR`: unset/empty → None (temp-dir build); set → that dir, created.
+    #[test]
+    fn shared_native_target_dir_follows_env() {
+        use super::shared_native_target_dir;
+        use std::fs;
+        use std::path::PathBuf;
+        // Only this test touches TISH_NATIVE_TARGET_DIR; the lock keeps it single-threaded anyway.
+        use std::sync::Mutex;
+        static ENV_LOCK: Mutex<()> = Mutex::new(());
+        let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        std::env::remove_var("TISH_NATIVE_TARGET_DIR");
+        assert!(shared_native_target_dir().is_none());
+        std::env::set_var("TISH_NATIVE_TARGET_DIR", "");
+        assert!(shared_native_target_dir().is_none());
+        // Scratch under the workspace target/ (never /tmp), unique per case.
+        let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("../../target/tmp_shared_target_test")
+            .join(format!("t_{}", std::process::id()));
+        let _ = fs::remove_dir_all(&dir);
+        std::env::set_var("TISH_NATIVE_TARGET_DIR", &dir);
+        let got = shared_native_target_dir().expect("set → Some");
+        assert_eq!(got, dir);
+        assert!(dir.is_dir(), "the shared target dir is created on demand");
+        std::env::remove_var("TISH_NATIVE_TARGET_DIR");
+        let _ = fs::remove_dir_all(dir.parent().unwrap());
+    }
+
     /// #384: `cleanup_build_dir` removes a finished build's dir by default, and preserves it under
     /// `TISH_KEEP_BUILD_DIR=1`.
     #[test]
     fn cleanup_build_dir_removes_by_default_and_keeps_on_flag() {
         use std::path::PathBuf;
         // Scratch under the workspace target/ (never /tmp), unique per case.
-        let base: PathBuf = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("../../target/tmp_cleanup_test");
+        let base: PathBuf =
+            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/tmp_cleanup_test");
         let removed = base.join("to_remove");
         let kept = base.join("to_keep");
         for d in [&removed, &kept] {
@@ -1209,7 +1267,10 @@ mod tests {
 
         std::env::set_var("TISH_KEEP_BUILD_DIR", "1");
         super::cleanup_build_dir(&kept);
-        assert!(kept.exists(), "TISH_KEEP_BUILD_DIR=1 should preserve the build dir");
+        assert!(
+            kept.exists(),
+            "TISH_KEEP_BUILD_DIR=1 should preserve the build dir"
+        );
         std::env::remove_var("TISH_KEEP_BUILD_DIR");
 
         let _ = std::fs::remove_dir_all(&base);