@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish_vm/tests/concurrent_shared_state.rs

@@ -0,0 +1,140 @@
+//! Regression: concurrent HTTP handlers that mutate shared module-level state must not deadlock.
+//!
+//! ## What this guards
+//!
+//! Under `send-values` (forced on by the `http` feature), `serve(port, handler)` runs the handler
+//! closure — a `NativeFn` (`Arc<dyn Callable>`, `Send + Sync`) — **directly on each accept thread**
+//! (`tish_runtime::http::worker_loop_direct`). So N concurrent requests execute the SAME handler in
+//! parallel, all sharing the captured module scope through `Arc<Mutex>` (`VmRef`). A handler that
+//! mutates a module-level `let` (a request counter / cache / rate-limiter) therefore has many threads
+//! reading and writing the same scope cell at once.
+//!
+//! This test drives that exact path without a network: it pulls the handler `Value::Function` out of
+//! a freshly-run program and invokes it from many OS threads while they all read-modify-write a shared
+//! module-level `let`. It exists to catch a regression where the VM's variable-write path holds a
+//! scope guard across a re-acquisition of the same lock (which would deadlock concurrent writers and
+//! hang `serve`). The watchdog turns such a hang into a fast, explicit test failure instead of a
+//! stuck CI job.
+//!
+//! Note on coverage: macOS `SO_REUSEPORT` funnels HTTP accepts to a single worker thread, so a
+//! network-level test can't actually run two handlers concurrently on macOS. Calling the handler
+//! closure directly does — and OS thread scheduling + mutex semantics are platform-independent, so
+//! this reproduces the Linux multi-worker dispatch contention the bug was reported against.
+#![cfg(feature = "send-values")]
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tishlang_bytecode::compile;
+use tishlang_core::{NativeFn, Value};
+use tishlang_vm::Vm;
+
+// `Value::Function` holds a `NativeFn` (= `Arc<dyn Callable>`, `Callable: Send + Sync` under
+// send-values); invoke a handler via the trait-object method `.call(args)`.
+type Handler = NativeFn;
+
+/// Compile + run `src`, then pull a function it stored in a global back out.
+fn export(vm: &Vm, name: &str) -> Handler {
+    match vm.get_global(name).unwrap_or_else(|| panic!("global `{name}` not found")) {
+        Value::Function(f) => f,
+        other => panic!("global `{name}` is not a function: {other:?}"),
+    }
+}
+
+fn read_num(obj: &Value, field: &str) -> f64 {
+    match obj {
+        Value::Object(o) => match o.borrow().strings.get(field) {
+            Some(Value::Number(n)) => *n,
+            other => panic!("stats.{field} is not a number: {other:?}"),
+        },
+        other => panic!("stats is not an object: {other:?}"),
+    }
+}
+
+#[test]
+fn concurrent_handlers_mutating_shared_module_state_do_not_deadlock() {
+    // `handler`/`stats` are bare top-level assignments (undeclared names) -> stored in globals, so
+    // the test can pull them out. Both functions close over the same module-level `let`s, exactly as
+    // a real `serve` handler closes over module state. `served` is monotonic (only incremented), so
+    // it gives a deterministic plausibility bound even though the read-modify-write is racy.
+    let src = r#"
+let active = 0
+let maxActive = 0
+let served = 0
+fn handleRequest(req) {
+    active = active + 1
+    served = served + 1
+    if (active > maxActive) { maxActive = active }
+    let i = 0
+    while (i < 2000) { i = i + 1 }   // brief CPU hold so handlers overlap
+    active = active - 1
+    return { status: 200, body: "ok" }
+}
+fn getStats() {
+    return { active: active, maxActive: maxActive, served: served }
+}
+handler = handleRequest
+stats = getStats
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    let mut vm = Vm::new();
+    vm.run(&chunk).expect("run top-level");
+    let handler = export(&vm, "handler");
+    let stats = export(&vm, "stats");
+
+    const THREADS: usize = 12;
+    const ITERS: usize = 100;
+    let total = THREADS * ITERS;
+
+    let done = Arc::new(AtomicUsize::new(0));
+    let start = Instant::now();
+    let mut handles = Vec::with_capacity(THREADS);
+    for t in 0..THREADS {
+        let h = handler.clone();
+        let done = Arc::clone(&done);
+        handles.push(std::thread::spawn(move || {
+            for i in 0..ITERS {
+                let resp = h.call(&[Value::Number((t * ITERS + i) as f64)]);
+                assert!(matches!(resp, Value::Object(_)), "handler must return a response object");
+                done.fetch_add(1, Ordering::Relaxed);
+            }
+        }));
+    }
+
+    // Watchdog: if concurrent writers deadlocked on the scope mutex, `done` stops advancing.
+    // Fail fast (and loudly) rather than hang the test runner.
+    let mut last = 0usize;
+    let mut last_change = Instant::now();
+    while done.load(Ordering::Relaxed) < total {
+        let cur = done.load(Ordering::Relaxed);
+        if cur != last {
+            last = cur;
+            last_change = Instant::now();
+        }
+        assert!(
+            last_change.elapsed() < Duration::from_secs(15),
+            "DEADLOCK regression: concurrent handlers stalled at {cur}/{total} (no progress for 15s)"
+        );
+        std::thread::sleep(Duration::from_millis(20));
+    }
+    for h in handles {
+        h.join().expect("a handler thread panicked");
+    }
+
+    // All calls returned without hanging. Read the shared counters back.
+    let s = stats.call(&[]);
+    let served = read_num(&s, "served");
+    let max_active = read_num(&s, "maxActive");
+    let active = read_num(&s, "active");
+    eprintln!(
+        "completed {total} concurrent calls / {THREADS} threads in {:?}; served={served}, maxActive={max_active}, active(final)={active}",
+        start.elapsed()
+    );
+
+    // `served` is monotonic, so it is deterministically in (0, total] regardless of lost updates.
+    assert!(served > 0.0 && served <= total as f64, "served={served} out of plausible range (0, {total}]");
+    // `maxActive` >= 2 proves at least two handlers were genuinely in-flight simultaneously, i.e. we
+    // actually exercised concurrent shared-state mutation (not an accidentally-serialized run).
+    assert!(max_active >= 2.0, "handlers never overlapped (maxActive={max_active}); test did not exercise concurrency");
+}

package/crates/tish_vm/tests/fixtures/or_string_cmd.tish

@@ -0,0 +1,2 @@
+let cmd = "a"
+if (cmd === "a" || cmd === "b") { console.log("hit") } else { console.log("miss") }

package/crates/tish_vm/tests/lexical_scope_declare.rs

@@ -0,0 +1,34 @@
+//! `DeclareVar` + block scopes: function `let` shadows script-level names (bytecode VM).
+
+use tishlang_bytecode::compile;
+use tishlang_vm::run;
+
+#[test]
+fn declare_var_shadows_script_let_inside_fn() {
+    let src = r#"
+let x = 1
+fn f() {
+  let x = 2
+  return x
+}
+let r = f()
+console.log("script", x, "fn", r)
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    run(&chunk).expect("run");
+}
+
+#[test]
+fn block_let_restores_outer_binding() {
+    let src = r#"
+let x = 1
+{
+  let x = 2
+}
+console.log(x)
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    run(&chunk).expect("run");
+}

package/crates/tish_vm/tests/peephole_jump_chain_logical_or.rs

@@ -0,0 +1,150 @@
+//! Regression: bytecode peephole `chain_jumps` must not follow `JumpIfFalse` as if it were an
+//! unconditional `Jump`. Doing so broke `===` + `||` when nested as the condition of an outer `if`
+//! (default VM differed from `--backend interp` / `--no-optimize`).
+//!
+//! CLI parity for the same source is covered in `crates/tish/tests/run_optimize_stdout_parity.rs`.
+
+use std::path::PathBuf;
+
+use tishlang_bytecode::{
+    compile, compile_for_repl, compile_for_repl_unoptimized, compile_unoptimized,
+};
+use tishlang_core::Value;
+
+fn run_chunk(chunk: &tishlang_bytecode::Chunk) -> Value {
+    tishlang_vm::run(chunk).expect("vm run")
+}
+
+/// `tish run` ends with trailing `null` when the last statement is not a REPL-style expr; use
+/// `compile_for_repl` so the VM return value reflects the `||` result (catches peephole/AST bugs).
+#[test]
+fn string_strict_eq_logical_or_repl_last_expr_is_true() {
+    let src = "let cmd = \"a\"\ncmd === \"a\" || cmd === \"b\"";
+    let opt = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&opt).expect("compile repl"));
+    let v_unopt = run_chunk(&compile_for_repl_unoptimized(&opt).expect("compile repl unopt"));
+    assert!(
+        v_peep.strict_eq(&v_unopt),
+        "peephole vs unopt repl: peep={v_peep:?} unopt={v_unopt:?}"
+    );
+    assert!(
+        matches!(&v_peep, Value::Bool(true)),
+        "expected true for cmd===a||cmd===b with cmd=a, got {v_peep:?}"
+    );
+}
+
+/// `?:` uses different codegen than `if`; both must agree with unoptimized bytecode.
+#[test]
+fn string_strict_eq_logical_or_inside_ternary_repl_last_expr() {
+    // Statement boundary: without `;` or `;`-like ASI, the parser can tie the `(` line to `let`.
+    let src = "let cmd = \"a\"\n;(cmd === \"a\" || cmd === \"b\") ? 1 : 0";
+    let opt = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&opt).expect("compile repl"));
+    let v_unopt = run_chunk(&compile_for_repl_unoptimized(&opt).expect("compile repl unopt"));
+    assert!(
+        v_peep.strict_eq(&v_unopt),
+        "peep={v_peep:?} unopt={v_unopt:?}"
+    );
+    assert!(
+        matches!(&v_peep, Value::Number(n) if *n == 1.0),
+        "expected 1, got {v_peep:?}"
+    );
+}
+
+#[test]
+fn logical_or_strict_eq_peephole_matches_unoptimized() {
+    let src = "let a = 1\nlet b = 2\na === 1 || b === 2";
+    let program = tishlang_parser::parse(src).expect("parse");
+    let program = tishlang_opt::optimize(&program);
+
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("compile unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "peephole changed semantics: peep={v_peep:?} raw={v_raw:?}"
+    );
+
+    let v_peep_repl = run_chunk(&compile_for_repl(&program).expect("compile repl"));
+    let v_raw_repl =
+        run_chunk(&compile_for_repl_unoptimized(&program).expect("compile repl unopt"));
+    assert!(
+        v_peep_repl.strict_eq(&v_raw_repl),
+        "repl: peep={v_peep_repl:?} raw={v_raw_repl:?}"
+    );
+}
+
+#[test]
+fn logical_or_inside_if_condition_peephole_matches_unoptimized() {
+    let src = "let a = 1\nlet b = 2\nif (a === 1 || b === 2) { 1 } else { 0 }";
+    let program = tishlang_parser::parse(src).expect("parse");
+    let program = tishlang_opt::optimize(&program);
+
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("compile unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "if + || : peep={v_peep:?} raw={v_raw:?}"
+    );
+}
+
+#[test]
+fn string_strict_eq_logical_or_ast_opt_matches_unoptimized_bytecode() {
+    let src = "let cmd = \"a\"\nif (cmd === \"a\" || cmd === \"b\") { 1 } else { 0 }";
+    let raw = tishlang_parser::parse(src).expect("parse");
+    let opt = tishlang_opt::optimize(&raw);
+    let v_raw = run_chunk(&compile_unoptimized(&raw).expect("raw"));
+    let v_opt = run_chunk(&compile_unoptimized(&opt).expect("opt"));
+    assert!(
+        v_raw.strict_eq(&v_opt),
+        "AST optimizer changed semantics: raw={v_raw:?} opt={v_opt:?}"
+    );
+}
+
+#[test]
+fn string_strict_eq_logical_or_peephole_matches_unoptimized() {
+    let src = "let cmd = \"a\"\nif (cmd === \"a\" || cmd === \"b\") { 1 } else { 0 }";
+    let program = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "peephole + strings: peep={v_peep:?} raw={v_raw:?}"
+    );
+}
+
+/// `tish run path/to/file.tish` uses merge_modules; ensure that matches plain parse for the fixture.
+#[test]
+fn merged_module_program_bytecode_matches_parse_for_string_or_fixture() {
+    let fixture =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/or_string_cmd.tish");
+    let src = std::fs::read_to_string(&fixture).expect("read fixture");
+    let modules = tishlang_compile::resolve_project(&fixture, Some(fixture.parent().unwrap()))
+        .expect("resolve");
+    let merged = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
+    let flat = tishlang_parser::parse(&src).expect("parse");
+    let m_opt = tishlang_opt::optimize(&merged);
+    let f_opt = tishlang_opt::optimize(&flat);
+    let c_m = compile(&m_opt).expect("compile merged");
+    let c_f = compile(&f_opt).expect("compile flat");
+    assert_eq!(
+        c_m.code, c_f.code,
+        "merge_modules vs parse produced different bytecode"
+    );
+}
+
+/// `if (cmd === "a" || cmd === "b")` must match unoptimized VM semantics (Nop padding from other
+/// peepholes must not confuse `chain_jumps`).
+#[test]
+fn string_eq_or_in_if_stmt_matches_unoptimized_repl() {
+    let src = "let cmd = \"a\"\nlet ok = false\nif (cmd === \"a\" || cmd === \"b\") { ok = true } else { ok = false }\nok";
+    let program = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&program).expect("compile repl"));
+    let v_raw = run_chunk(&compile_for_repl_unoptimized(&program).expect("compile repl unopt"));
+    assert!(v_peep.strict_eq(&v_raw), "peep={v_peep:?} raw={v_raw:?}");
+    assert!(
+        matches!(&v_peep, Value::Bool(true)),
+        "expected ok=true, got {v_peep:?}"
+    );
+}

package/crates/tish_wasm/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tishlang_wasm"
+version = "0.1.0"
+edition = "2021"
+description = "WebAssembly backend for Tish - compiles to real .wasm"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+[dependencies]
+tishlang_build_utils = { path = "../tish_build_utils", version = ">=0.1" }
+tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
+tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
+tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
+base64 = "0.22"