@tishlang/tish-lint 3.6.0 → 3.7.0

package/crates/tish_bytecode/src/compiler.rs

@@ -1521,6 +1521,27 @@ impl<'a> Compiler<'a> {
         Ok(())
     }
 
+    /// Compile a function/arrow body **without** the outermost block's `EnterBlock`/`ExitBlock`.
+    ///
+    /// A function body's top-level block is the frame's own scope: its bindings live in the
+    /// frame-local map that is created fresh per call and dropped when the call returns, so there
+    /// is nothing for `ExitBlock` to restore or hide. Emitting it is not merely wasted work — it is
+    /// actively wrong. `ExitBlock` REMOVES the block's names from that map, and closures capture
+    /// the map **by reference**, so any closure that outlived the call lost its captures
+    /// ("Undefined variable"). An explicit `return` masked the bug by jumping over the teardown.
+    /// See tests/core/parity_block_scope_capture.tish (#247).
+    fn compile_fn_body(&mut self, body: &Statement) -> Result<(), CompileError> {
+        if let Statement::Block { statements, .. } = body {
+            self.enter_block_scope();
+            for stmt in statements {
+                self.compile_statement(stmt)?;
+            }
+            self.exit_block_scope();
+            return Ok(());
+        }
+        self.compile_statement(body)
+    }
+
     fn compile_statement(&mut self, stmt: &Statement) -> Result<(), CompileError> {
         self.mark_line(stmt.span());
         match stmt {
@@ -1999,7 +2020,7 @@ impl<'a> Compiler<'a> {
                 if let Some(map) = simple_slots {
                     inner_comp.slot_ctx = Some(map);
                     inner_comp.emit_param_defaults_prologue(params)?;
-                    inner_comp.compile_statement(body)?;
+                    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
@@ -2011,7 +2032,7 @@ impl<'a> Compiler<'a> {
                         inner_comp.declare_slot(p);
                     }
                     inner_comp.emit_param_defaults_prologue(params)?;
-                    inner_comp.compile_statement(body)?;
+                    inner_comp.compile_fn_body(body)?;
                     general_frame_slots = Some(inner_comp.next_slot);
                 } else {
                     inner_comp.scope = vec![param_names
@@ -2021,7 +2042,7 @@ impl<'a> Compiler<'a> {
                     inner_comp
                         .emit_param_destructure_prologue(&param_names[..formal_len], &slots)?;
                     inner_comp.emit_param_defaults_prologue(params)?;
-                    inner_comp.compile_statement(body)?;
+                    inner_comp.compile_fn_body(body)?;
                 }
                 inner_comp.emit(Opcode::LoadConst);
                 let idx = inner_comp.constant_idx(Constant::Null);
@@ -2769,7 +2790,7 @@ impl<'a> Compiler<'a> {
                         inner_comp.emit(Opcode::Return);
                     }
                     ArrowBody::Block(s) => {
-                        inner_comp.compile_statement(s)?;
+                        inner_comp.compile_fn_body(s)?;
                         let idx = inner_comp.constant_idx(Constant::Null);
                         inner_comp.emit(Opcode::LoadConst);
                         inner_comp.chunk.write_u16(idx);

package/crates/tish_compile/src/resolve.rs

@@ -81,13 +81,22 @@ const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("encoding", "tish:encoding"),
     ("crypto", "tish:crypto"),
     ("zip", "tish:zip"),
+    ("test", "tish:test"),
+    ("assert", "tish:assert"),
+    ("assert/strict", "tish:assert"),
 ];
 
 /// Normalize built-in spec to canonical form. Handles the Node `node:` prefix
-/// (`node:fs` -> `tish:fs`, `node:fs/promises` -> `tish:fs/promises`) and bare aliases.
+/// (`node:fs` -> `tish:fs`, `node:fs/promises` -> `tish:fs/promises`,
+/// `node:test` -> `tish:test`, `node:assert` / `node:assert/strict` -> `tish:assert`)
+/// and bare aliases.
 pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
     // Strip a leading `node:` so `node:fs` resolves the same as `fs`.
     let spec = spec.strip_prefix("node:").unwrap_or(spec);
+    // `node:assert/strict` (and bare `assert/strict`) → `tish:assert`.
+    if spec == "assert/strict" {
+        return Some("tish:assert".to_string());
+    }
     if spec.starts_with("tish:") {
         return Some(spec.to_string());
     }
@@ -97,7 +106,7 @@ pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
         .map(|(_, canonical)| (*canonical).to_string())
 }
 
-/// Built-in modules that come from tishlang_runtime, not from package.json.
+/// Built-in modules that come from tishlang_runtime / tishlang_test, not from package.json.
 pub fn is_builtin_native_spec(spec: &str) -> bool {
     let spec = spec.strip_prefix("node:").unwrap_or(spec);
     matches!(
@@ -114,10 +123,12 @@ pub fn is_builtin_native_spec(spec: &str) -> bool {
             | "tish:encoding"
             | "tish:crypto"
             | "tish:zip"
+            | "tish:test"
+            | "tish:assert"
     ) || matches!(
         spec,
         "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty" | "pty" | "net"
-            | "encoding" | "crypto" | "zip"
+            | "encoding" | "crypto" | "zip" | "test" | "assert" | "assert/strict"
     )
 }
 
@@ -1031,7 +1042,7 @@ fn load_module_recursive(
 /// resolution for `import … from "@scope/pkg"` is interop, and the native-vs-merged axis is the one
 /// piece tish adds on top, keyed off the native markers rather than mere presence of `tish.module`.
 pub fn is_native_import(spec: &str) -> bool {
-    // A leading `node:` (node:fs, node:fs/promises) resolves the same as the bare form.
+    // A leading `node:` (node:fs, node:fs/promises, node:assert/strict) resolves like the bare form.
     let spec = spec.strip_prefix("node:").unwrap_or(spec);
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
@@ -1039,7 +1050,7 @@ pub fn is_native_import(spec: &str) -> bool {
         || matches!(
             spec,
             "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty" | "net" | "encoding"
-                | "crypto" | "zip"
+                | "crypto" | "zip" | "test" | "assert" | "assert/strict"
         )
 }
 
@@ -2110,13 +2121,35 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                                         from.as_ref()
                                     ));
                                 }
-                                ImportSpecifier::Default { name, .. } => {
-                                    return Err(format!(
-                                        "Default import '{}' not supported for native module '{}'. Use named import, e.g. import {{ egui }} from '{}'",
-                                        name.as_ref(),
-                                        from.as_ref(),
-                                        from.as_ref()
-                                    ));
+                                ImportSpecifier::Default { name, name_span } => {
+                                    // Only `tish:assert` (and aliases) expose a callable default.
+                                    // Other natives still require named imports.
+                                    if canonical_spec != "tish:assert" {
+                                        return Err(format!(
+                                            "Default import '{}' not supported for native module '{}'. Use named import, e.g. import {{ egui }} from '{}'",
+                                            name.as_ref(),
+                                            from.as_ref(),
+                                            from.as_ref()
+                                        ));
+                                    }
+                                    let init = Expr::NativeModuleLoad {
+                                        spec: Arc::from(canonical_spec.clone()),
+                                        export_name: Arc::from("default"),
+                                        span: *span,
+                                    };
+                                    merge_push(
+                                        &mut statements,
+                                        &mut statement_sources,
+                                        Statement::VarDecl {
+                                            name: name.clone(),
+                                            name_span: *name_span,
+                                            mutable: false,
+                                            type_ann: None,
+                                            init: Some(init),
+                                            span: *span,
+                                        },
+                                        src_path.clone(),
+                                    );
                                 }
                             }
                         }

package/crates/tish_core/src/lib.rs

@@ -109,17 +109,17 @@ pub fn process_argv() -> Vec<String> {
     }
 }
 
-/// #303 — a thrown JS value parked while it unwinds across a boundary that can't carry a `Result`.
-///
-/// The native value-fn ABI is `Fn(&[Value]) -> Value`, and `Callable::call` likewise returns a bare
-/// `Value`, so a `throw` crossing such a boundary can't ride a `Result`. It is parked here and picked
-/// up at the next checkpoint: native codegen checks it after each call; the VM checks it after each
-/// `Callable::call`; and the shared array builtins (`forEach`/`map`/`sort`/…) check it between
-/// elements so they stop iterating promptly instead of running the callback for the rest of the
-/// array. The slot lives in `tishlang_core` (rather than `tishlang_runtime`) so `tishlang_builtins`
-/// can poll it without a `builtins -> runtime` dependency cycle; `tishlang_runtime` and `tishlang_vm`
-/// share this one slot. First-throw-wins; drained exactly once by [`take_pending_throw`] at the frame
-/// that converts it back into a `Result`.
+// #303 — a thrown JS value parked while it unwinds across a boundary that can't carry a `Result`.
+//
+// The native value-fn ABI is `Fn(&[Value]) -> Value`, and `Callable::call` likewise returns a bare
+// `Value`, so a `throw` crossing such a boundary can't ride a `Result`. It is parked here and picked
+// up at the next checkpoint: native codegen checks it after each call; the VM checks it after each
+// `Callable::call`; and the shared array builtins (`forEach`/`map`/`sort`/…) check it between
+// elements so they stop iterating promptly instead of running the callback for the rest of the
+// array. The slot lives in `tishlang_core` (rather than `tishlang_runtime`) so `tishlang_builtins`
+// can poll it without a `builtins -> runtime` dependency cycle; `tishlang_runtime` and `tishlang_vm`
+// share this one slot. First-throw-wins; drained exactly once by [`take_pending_throw`] at the frame
+// that converts it back into a `Result`.
 #[cfg(not(feature = "portable"))]
 thread_local! {
     static PENDING_THROW: core::cell::RefCell<Option<Value>> = const { core::cell::RefCell::new(None) };
@@ -151,6 +151,98 @@ pub fn take_pending_throw() -> Option<Value> {
     PENDING_THROW.with(|c| c.borrow_mut().take())
 }
 
+// ---------------------------------------------------------------------------
+// Cooperative execution deadline (`tish test --timeout`).
+//
+// Without this a runaway loop is uninterruptible: the runner can only notice a blown
+// deadline *after* the body returns, which never happens. Backends poll
+// [`execution_deadline_exceeded`] on loop back-edges and abort with a catchable error.
+//
+// Disarmed is the default and costs one relaxed load — `tish run` never arms it. Armed,
+// the clock is read once every `DEADLINE_POLL_MASK + 1` back-edges so a hot loop is not
+// paying a `now()` per iteration.
+// ---------------------------------------------------------------------------
+
+#[cfg(not(feature = "portable"))]
+mod deadline {
+    use core::sync::atomic::{AtomicU64, Ordering};
+    use std::sync::LazyLock;
+    use std::time::Instant;
+
+    /// Nanoseconds since [`START`] at which execution must stop. 0 = disarmed.
+    static DEADLINE_NS: AtomicU64 = AtomicU64::new(0);
+    static START: LazyLock<Instant> = LazyLock::new(Instant::now);
+
+    const DEADLINE_POLL_MASK: u32 = 0x3FF;
+
+    thread_local! {
+        static POLL_TICK: core::cell::Cell<u32> = const { core::cell::Cell::new(0) };
+        static TRIPPED: core::cell::Cell<bool> = const { core::cell::Cell::new(false) };
+    }
+
+    /// Arm the deadline `millis` from now, or disarm with `None`. Clears any previous trip.
+    pub fn set_execution_deadline(millis: Option<u64>) {
+        TRIPPED.with(|t| t.set(false));
+        POLL_TICK.with(|t| t.set(0));
+        match millis {
+            Some(ms) => {
+                let at = START.elapsed().as_nanos() as u64 + ms.saturating_mul(1_000_000);
+                // 0 means "disarmed"; nudge an exact-zero deadline to 1ns.
+                DEADLINE_NS.store(at.max(1), Ordering::Relaxed);
+            }
+            None => DEADLINE_NS.store(0, Ordering::Relaxed),
+        }
+    }
+
+    /// Has the armed deadline passed? Cheap and false when disarmed.
+    #[inline]
+    pub fn execution_deadline_exceeded() -> bool {
+        let at = DEADLINE_NS.load(Ordering::Relaxed);
+        if at == 0 {
+            return false;
+        }
+        if TRIPPED.with(|t| t.get()) {
+            return true;
+        }
+        let tick = POLL_TICK.with(|t| {
+            let n = t.get().wrapping_add(1);
+            t.set(n);
+            n
+        });
+        if tick & DEADLINE_POLL_MASK != 0 {
+            return false;
+        }
+        if START.elapsed().as_nanos() as u64 >= at {
+            TRIPPED.with(|t| t.set(true));
+            return true;
+        }
+        false
+    }
+
+    /// Did this thread abort because the deadline tripped?
+    pub fn execution_deadline_tripped() -> bool {
+        TRIPPED.with(|t| t.get())
+    }
+}
+
+// Portable / single-core builds (GBA and friends) have no wall clock to poll.
+#[cfg(feature = "portable")]
+mod deadline {
+    pub fn set_execution_deadline(_millis: Option<u64>) {}
+    #[inline]
+    pub fn execution_deadline_exceeded() -> bool {
+        false
+    }
+    pub fn execution_deadline_tripped() -> bool {
+        false
+    }
+}
+
+pub use deadline::{execution_deadline_exceeded, execution_deadline_tripped, set_execution_deadline};
+
+/// Message backends raise when [`execution_deadline_exceeded`] trips.
+pub const DEADLINE_ERROR: &str = "Test exceeded its timeout and was aborted";
+
 // Current user-function call depth for the bytecode VM. The VM's recursive path builds a fresh
 // `Vm` per call (so no shared struct field can accumulate) and its `Callable::call` signature is
 // fixed — a thread-local is the VM's equivalent of the interpreter's shared `Rc<Cell>` counter.

package/crates/tish_eval/src/eval.rs

@@ -639,6 +639,7 @@ impl Evaluator {
             }
             Statement::While { cond, body, .. } => {
                 loop {
+                    deadline_check()?;
                     if !self.eval_expr(cond)?.is_truthy() {
                         break;
                     }
@@ -778,6 +779,10 @@ impl Evaluator {
                 };
                 let mut ret = Ok(Value::Null);
                 loop {
+                    if let Err(e) = deadline_check() {
+                        ret = Err(e);
+                        break;
+                    }
                     self.scope = Rc::clone(&loop_env);
                     let cond_ok = match cond.as_ref() {
                         Some(c) => match self.eval_expr(c) {
@@ -909,6 +914,7 @@ impl Evaluator {
             }
             Statement::DoWhile { body, cond, .. } => {
                 loop {
+                    deadline_check()?;
                     match self.eval_statement(body) {
                         Ok(_) => {}
                         Err(EvalError::Break) => break,
@@ -5389,6 +5395,16 @@ impl Evaluator {
     }
 }
 
+/// Cooperative timeout poll for loop back-edges (`tish test --timeout`). Disarmed on every
+/// other path, where it costs one relaxed atomic load.
+#[inline]
+fn deadline_check() -> Result<(), EvalError> {
+    if tishlang_core::execution_deadline_exceeded() {
+        return Err(EvalError::Error(tishlang_core::DEADLINE_ERROR.to_string()));
+    }
+    Ok(())
+}
+
 #[derive(Debug)]
 enum EvalError {
     Return(Value),

package/crates/tish_eval/src/value_convert.rs

@@ -187,6 +187,16 @@ pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
         }
         Value::Symbol(s) => Ok(CoreValue::Symbol(Arc::clone(s))),
         Value::Opaque(o) => Ok(CoreValue::Opaque(Arc::clone(o))),
+        // A core function that came IN through `core_to_eval` round-trips back out unchanged.
+        Value::CoreFn(f) => Ok(CoreValue::Function(f.clone())),
+        // Interpreter closures carry an AST body plus a scope that only the `Evaluator` can
+        // resolve, and they do not outlive it. Say so instead of printing a discriminant.
+        Value::Function { .. } | Value::Native(_) => Err(
+            "Cannot pass an interpreter function to a native module: interpreter closures are \
+             bound to the evaluator and cannot be invoked from native code. Use the default \
+             (VM) backend."
+                .to_string(),
+        ),
         _ => Err(format!(
             "Cannot pass {:?} to native function (unsupported type)",
             std::mem::discriminant(v)

package/crates/tish_lint/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_lint"
-version = "3.6.0"
+version = "3.7.0"
 edition = "2021"
 description = "AST-based linter for Tish"
 license-file = { workspace = true }

package/crates/tish_test/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "tishlang_test"
+version = "0.0.0-dev"
+edition = "2021"
+description = "Native tish test runner, expect, and Node-compatible assert"
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[features]
+default = ["fs", "regex", "promise"]
+# Fan features into runtime + optional eval/vm so send-values / regex stay consistent.
+fs = ["tishlang_runtime/fs", "tishlang_eval/fs", "tishlang_vm/fs"]
+regex = [
+    "tishlang_core/regex",
+    "tishlang_runtime/regex",
+    "tishlang_eval/regex",
+    "tishlang_vm/regex",
+]
+promise = ["tishlang_runtime/promise", "tishlang_vm/promise"]
+# Full runner needs compile + VM to load files
+runner = [
+    "dep:tishlang_compile",
+    "dep:tishlang_opt",
+    "dep:tishlang_bytecode",
+    "dep:tishlang_vm",
+    "dep:tishlang_ast",
+    "dep:tishlang_eval",
+]
+watch = ["dep:notify"]
+
+[dependencies]
+tishlang_core = { path = "../tish_core", version = ">=0.1" }
+tishlang_builtins = { path = "../tish_builtins", version = ">=0.1" }
+tishlang_runtime = { path = "../tish_runtime", version = ">=0.1" }
+tishlang_ast = { path = "../tish_ast", version = ">=0.1", optional = true }
+tishlang_compile = { path = "../tish_compile", version = ">=0.1", optional = true }
+tishlang_opt = { path = "../tish_opt", version = ">=0.1", optional = true }
+tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1", optional = true }
+tishlang_vm = { path = "../tish_vm", version = ">=0.1", optional = true }
+tishlang_eval = { path = "../tish_eval", version = ">=0.1", optional = true }
+serde_json = "1"
+walkdir = "2"
+regex = "1"
+notify = { version = "7", optional = true }
+
+[dev-dependencies]
+tempfile = "3"