@tishlang/tish-format 1.0.13 → 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_wasm/src/lib.rs

@@ -379,10 +379,14 @@ fn main() {
         message: format!("Cannot write main.rs: {}", e),
     })?;
 
-    // Build - use explicit target-dir so we know where the artifact is
+    // Build into a SHARED target dir (one per host), not per-program. The wasi runtime + embedded
+    // VM then compile ONCE and are reused by every wasi build; only each program's tiny main is
+    // rebuilt. Without this each program left its own multi-GB `target/` and a full-suite sweep
+    // would fill the disk (same issue fixed for cranelift; see full-backend-parity-plan.md A3).
+    // cargo's target lock serializes concurrent builds safely.
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
     let bin_name = format!("tish_wasi_{}", stem);
-    let target_dir = build_dir.join("target");
+    let target_dir = std::env::temp_dir().join("tishlang_wasi_target");
     let build_status = Command::new(&cargo)
         .current_dir(&build_dir)
         .env("CARGO_TARGET_DIR", &target_dir)

package/crates/tish_wasm_runtime/src/gpu.rs

@@ -10,7 +10,7 @@
 //!   command API is synchronous, so this covers it)
 //! - `js_new(ctorNameOrHandle, argsArray)`
 //! - `js_typeof(handle)` — debugging
-//! - `f32a(arr)` / `u16a(arr)` / `u8a(arr)` — tish `number[]` → real typed array
+//! - `f32a(arr)` / `u16a(arr)` / `u8a(arr)` / `u32a(arr)` — tish `number[]` → real typed array
 //! - `request_animation_frame(cb)` — drive a render loop
 //!
 //! GPU/JS objects (device, queue, context, buffers, pipelines, textures,
@@ -284,6 +284,21 @@ fn ffi_u8a() -> Value {
     })
 }
 
+fn ffi_u32a() -> Value {
+    Value::native(|args: &[Value]| {
+        let arr = match args.first() {
+            Some(Value::Array(a)) => a.clone(),
+            _ => return Value::Null,
+        };
+        let b = arr.borrow();
+        let ta = js_sys::Uint32Array::new_with_length(b.len() as u32);
+        for (i, v) in b.iter().enumerate() {
+            ta.set_index(i as u32, v.as_number().unwrap_or(0.0) as u32);
+        }
+        wrap(ta.into())
+    })
+}
+
 // ---------------------------------------------------------------------------
 // requestAnimationFrame render loop
 // ---------------------------------------------------------------------------
@@ -362,6 +377,7 @@ fn install_ffi(vm: &mut Vm) {
     vm.set_global("f32a".into(), ffi_f32a());
     vm.set_global("u16a".into(), ffi_u16a());
     vm.set_global("u8a".into(), ffi_u8a());
+    vm.set_global("u32a".into(), ffi_u32a());
     vm.set_global("request_animation_frame".into(), ffi_request_animation_frame());
 }
 

package/crates/tishlang_cargo_bindgen/src/classify.rs

@@ -39,9 +39,7 @@ fn classify_tish_abi(item: &ItemFn) -> Option<SignatureClass> {
     if value_args != 1 || sig.inputs.len() != 1 {
         return None;
     }
-    let Some(ret_ty) = return_type_inner(&sig.output) else {
-        return None;
-    };
+    let ret_ty = return_type_inner(&sig.output)?;
     if !is_value_type(ret_ty) {
         return None;
     }

package/crates/tishlang_cargo_bindgen/src/lib.rs

@@ -121,7 +121,7 @@ fn generate_from_resolved(
 impl BindgenConfig {
     /// Write using [`generate_from_registry_dependency`].
     pub fn write_files(&self) -> io::Result<()> {
-        generate_from_registry_dependency(self).map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+        generate_from_registry_dependency(self).map_err(io::Error::other)
     }
 }
 
@@ -199,7 +199,7 @@ fn render_generated_lib(
                 name = rust_fn
             ),
             SignatureClass::SerializeRefToResultString => format!(
-                "pub fn {name}(args: &[Value]) -> Value {{\n    let Some(v) = args.first() else {{ return Value::Null }};\n    match _tish_upstream::{name}(&tish_to_json(v)) {{\n        Ok(s) => Value::String(Arc::from(s)),\n        Err(_) => Value::Null,\n    }}\n}}\n\n",
+                "pub fn {name}(args: &[Value]) -> Value {{\n    let Some(v) = args.first() else {{ return Value::Null }};\n    match _tish_upstream::{name}(&tish_to_json(v)) {{\n        Ok(s) => Value::String(arcstr::ArcStr::from(s)),\n        Err(_) => Value::Null,\n    }}\n}}\n\n",
                 name = rust_fn
             ),
             SignatureClass::DeserializeStrToResult => format!(

package/crates/tishlang_cargo_bindgen/src/metadata.rs

@@ -79,7 +79,7 @@ edition = "2021"
         && !pkg
             .targets
             .iter()
-            .any(|t| t.kind.iter().any(|k| *k == TargetKind::Lib))
+            .any(|t| t.kind.contains(&TargetKind::Lib))
     {
         return Err(format!(
             "package `{}` has no src/ or lib target at {}",

package/justfile

@@ -258,6 +258,14 @@ perf-suite *ARGS:
 perf-suite-gen:
     ./scripts/generate_perf_ci_main.sh
 
+# HTTP throughput: tish vs Node, single vs multi-worker, plaintext + json (needs oha + jq)
+perf-http *ARGS:
+    ./scripts/run_http_perf.sh {{ARGS}}
+
+# Perf gauntlet: compute benchmarks vs Node, incl. known-fail targets to evolve past (needs node)
+perf-gauntlet *ARGS:
+    ./scripts/run_perf_gauntlet.sh {{ARGS}}
+
 # Show binary sizes for different builds
 sizes:
     @echo "Building secure binary..."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "1.0.13",
+  "version": "2.0.1",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {
@@ -34,4 +34,4 @@
     "format",
     "formatter"
   ]
-}
+}

package/README.md

@@ -1,138 +0,0 @@
-<picture>
-  <img alt="Tishlang" src="https://tishlang.com/banner.png">
-</picture>
-
-# Tish
-
-<p>
-  <a href="https://npmjs.com/package/@tishlang/tish?activeTab=readme"><img src="https://img.shields.io/npm/v/@tishlang/tish?style=flat-square&colorA=1C1C1C&colorB=B688FF" alt="npm version" /></a>
-  <a href="https://npmcharts.com/compare/@tishlang/tish"><img src="https://img.shields.io/npm/dm/@tishlang/tish.svg?style=flat-square&colorA=1C1C1C&colorB=B688FF" alt="downloads" /></a>
-  <a href="https://nodejs.org/en/about/previous-releases"><img src="https://img.shields.io/node/v/@tishlang/tish.svg?style=flat-square&colorA=1C1C1C&colorB=B688FF" alt="node version"></a>
-  <a href="https://crates.io/crates/tishlang"><img src="https://img.shields.io/crates/v/tishlang?style=flat-square&colorA=1C1C1C&colorB=B688FF" alt="crate version" /></a>
-  <a href="https://github.com/tishlang/tish/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-PIF-blue.svg?style=flat-square&colorA=1C1C1C&colorB=B688FF" alt="license" /></a>
-
-</p>
-
-Tish is a TypeScript- and JavaScript-compatible language implemented in Rust. It is aimed at teams who want a familiar surface syntax, predictable semantics, and the option to ship either interpreted scripts or runtime free **native binaries**.
-
-The same source can run on a tree-walking interpreter, a bytecode VM, or compiled targets (native, WASM/WASI, and others). Network, filesystem, and process APIs are **feature-gated** so defaults stay safe. For the full syntax and semantics, see the canonical spec in-repo; for tutorials and reference, see [tishlang.com/docs](https://tishlang.com/docs).
-
-## 🔥 Features
-
-- **JS-like surface** — `let` / `const`, `fn`, arrows, template literals, async/await, modules, and a large slice of familiar builtins (`console`, `Math`, `JSON`, arrays, strings, objects).
-- **Two ways to run** — interpret for fast iteration (`tish run`, REPL); compile to native or WASM for distribution and performance (`tish build`).
-- **Memory-safe implementation** — Rust-hosted runtime and compiler pipeline; no GC in the host language for the toolchain itself.
-- **Secure by default** — I/O and platform APIs (`http`, `fs`, `process`, etc.) are opt-in via features.
-- **No `undefined`** — `null` only where JS would use undefined; strict equality (`===` / `!==`) without loose coercion.
-- **Optional types** — TypeScript-style annotations are parsed for tooling and future checking; see the language reference for status.
-
-Full specification: [docs/LANGUAGE.md](docs/LANGUAGE.md). Implementation status, gaps, and JS compatibility: [docs/plan-gap-analysis.md](docs/plan-gap-analysis.md).
-
-## 📚 Documentation
-
-User-facing guides and reference:
-
-| Section | Description |
-|---------|-------------|
-| [Getting started](https://tishlang.com/docs/getting-started/installation/) | Install Tish, build your first app |
-| [First app](https://tishlang.com/docs/getting-started/first-app/) | Run and build workflows, targets |
-| [Editor & IDE](https://tishlang.com/docs/getting-started/editor/) | VS Code, LSP, tasks, Neovim |
-| [Language server](https://tishlang.com/docs/reference/language-server/) | `tish-lsp` capabilities |
-| [Formatting](https://tishlang.com/docs/reference/formatting/) | `tish-fmt` |
-| [Linting](https://tishlang.com/docs/reference/linting/) | `tish-lint` |
-| [Interactive REPL](https://tishlang.com/docs/getting-started/repl/) | Multi-line input, completion, history |
-| [Language overview](https://tishlang.com/docs/language/overview/) | Syntax, keywords, semantics |
-| [Tish vs JavaScript](https://tishlang.com/docs/language/vs-javascript/) | Differences and additions from JS |
-| [Builtins](https://tishlang.com/docs/builtins/overview/) | Console, Math, JSON, Array, String, Object |
-| [Features (APIs)](https://tishlang.com/docs/features/http/) | `http`, `fs`, `process`, `regex` — feature-gated |
-| [Native backend](https://tishlang.com/docs/reference/native-backend/) | Rust, Cranelift, LLVM compilation |
-| [WASM targets](https://tishlang.com/docs/reference/wasm-targets/) | Web and WASI |
-| [Deploy](https://tishlang.com/docs/deploy/overview/) | Platform and hosting |
-
-### In-repo docs
-
-Contributor- and spec-oriented material in [docs/](docs/):
-
-| File | Purpose |
-|------|---------|
-| [LANGUAGE.md](docs/LANGUAGE.md) | Canonical language reference (syntax, semantics, builtins) |
-| [ecma-alignment.md](docs/ecma-alignment.md) | ECMA-262 / test262 mapping |
-| [plan-gap-analysis.md](docs/plan-gap-analysis.md) | Implementation audit, MVP checklist |
-| [architecture-next-steps.md](docs/architecture-next-steps.md) | Crate layout, design decisions |
-| [builtins-gap-analysis.md](docs/builtins-gap-analysis.md) | Builtins across Rust vs bytecode VM (Cranelift/WASI) |
-
-## 🛠️ Toolchain
-
-| Tool | Purpose |
-|------|---------|
-| **`tish`** | CLI — `run`, `repl`, `build`, `dump-ast` |
-| **`tish-fmt`** | Formatter |
-| **`tish-lint`** | Linter (`--format sarif` for code scanning) |
-| **`tish-lsp`** | Language server; uses `tish_fmt` / `tish_lint` as libraries |
-| **`tish-security/`** (sibling repo) | Rules & CI examples — clone next to `tish/` as `../tish-security` ([OpenGrep](https://github.com/opengrep/opengrep), ast-grep, Comby, Codacy scaffold, fixtures) |
-| **`tree-sitter-tish/`** | Tree-sitter grammar (editors, ast-grep, future OpenGrep integration) |
-| **VS Code extension** | [tish-vscode](https://github.com/tishlang/tish-vscode) — grammar, snippets, LSP client, tasks |
-
-Related docs on [tishlang.com](https://tishlang.com/docs): [Editor & IDE](https://tishlang.com/docs/getting-started/editor/), [Language server](https://tishlang.com/docs/reference/language-server/), [Formatting](https://tishlang.com/docs/reference/formatting/), [Linting](https://tishlang.com/docs/reference/linting/).
-
-## 📦 Installation
-
-Install globally:
-
-```sh
-brew tap tishlang/tish https://github.com/tishlang/tish
-brew install tish
-```
-
-Or locally with npm:
-
-```sh
-npm install @tishlang/tish
-```
-
-More options: [Installation](https://tishlang.com/docs/getting-started/installation/).
-
-## ⚡ Quick start
-
-```sh
-npx @tishlang/create-tish-app my-app
-cd my-app
-npx @tishlang/tish run src/main.tish
-```
-
-## ▶️ Run and build
-
-```tish
-// hello.tish
-fn greeting(name) = `Hello, ${name}!`
-console.log(greeting("World"))
-```
-
-```bash
-tish run hello.tish
-# Hello, World!
-
-tish build hello.tish -o hello
-./hello
-# Hello, World!
-```
-
-Native binaries are standalone (no Tish or Rust runtime required on the machine that runs them). Backends, flags, and WASM are covered in [First app](https://tishlang.com/docs/getting-started/first-app/), [Native backend](https://tishlang.com/docs/reference/native-backend/), and [WASM targets](https://tishlang.com/docs/reference/wasm-targets/).
-
-## 🤝 Contribution
-
-Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for building, testing, and code style. Tish is licensed under the [Pay It Forward License (PIF)](https://payitforwardlicense.com/).
-
-## 💪 Performance
-
-JavaScript equivalents live in `tests/core/*.js`. Compare Tish with Node.js or Bun:
-
-```bash
-./scripts/run_performance_manual.sh
-```
-
-Details: [docs/perf.md](docs/perf.md).
-
-## 📝 License
-
-Tish is licensed under the [Pay It Forward License (PIF)](https://payitforwardlicense.com/). See [LICENSE](LICENSE).