@tishlang/tish-format 1.0.13 → 2.0.1

package/crates/tish_core/src/vmref.rs

@@ -110,16 +110,17 @@ mod imp {
 // --------------------------------------------------------------------------
 #[cfg(feature = "send-values")]
 mod imp {
-    use std::sync::{Arc, Mutex};
+    use parking_lot::Mutex;
+    use std::sync::Arc;
 
     #[derive(Default)]
     pub struct VmRef<T: ?Sized>(pub(super) Arc<Mutex<T>>);
 
     /// Read guard alias. On the multi-threaded path both readers and
     /// writers share a single `MutexGuard` (exclusive access).
-    pub type ReadGuard<'a, T> = std::sync::MutexGuard<'a, T>;
+    pub type ReadGuard<'a, T> = parking_lot::MutexGuard<'a, T>;
     /// Write guard alias.
-    pub type WriteGuard<'a, T> = std::sync::MutexGuard<'a, T>;
+    pub type WriteGuard<'a, T> = parking_lot::MutexGuard<'a, T>;
 
     impl<T> VmRef<T> {
         #[inline]
@@ -129,17 +130,21 @@ mod imp {
     }
 
     impl<T: ?Sized> VmRef<T> {
-        /// Acquire the inner mutex. Poisoning is swallowed — a Tish
-        /// handler panic already aborts the enclosing thread; there is
-        /// no invariant worth preserving past that point.
+        /// Acquire the inner mutex. `parking_lot::Mutex` is used (not
+        /// `std::sync::Mutex`): its uncontended lock is a single atomic with
+        /// no pthread syscall — a profile of object/array-heavy code showed
+        /// `pthread_mutex_lock/unlock` as a top cost under send-values, since
+        /// every property/element access locks. It also has no poisoning, so
+        /// there is no `Result` to swallow (a handler panic aborts the thread
+        /// regardless).
         #[inline]
         pub fn borrow(&self) -> ReadGuard<'_, T> {
-            self.0.lock().unwrap_or_else(|p| p.into_inner())
+            self.0.lock()
         }
 
         #[inline]
         pub fn borrow_mut(&self) -> WriteGuard<'_, T> {
-            self.0.lock().unwrap_or_else(|p| p.into_inner())
+            self.0.lock()
         }
 
         #[inline]

package/crates/tish_cranelift/src/link.rs

@@ -54,9 +54,15 @@ pub fn link_to_binary(
                 .join(", ")
         )
     };
+    // UNIQUE package name per program. With the shared target dir, a fixed package name
+    // (`tishlang_cranelift_out`) made cargo cross-contaminate builds — each program links its own
+    // per-program object via build.rs, so program B would reuse program A's cached build script and
+    // link A's (now-deleted) `.o`. A distinct package name keeps them separate while the heavy
+    // dependency (`tishlang_cranelift_runtime`, same path + features for all) still compiles once.
+    let pkg_name = format!("clout_{}", out_name);
     let cargo_toml_fixed = format!(
         r#"[package]
-name = "tishlang_cranelift_out"
+name = "{}"
 version = "0.1.0"
 edition = "2021"
 
@@ -67,7 +73,7 @@ path = "src/main.rs"
 [dependencies]
 tishlang_cranelift_runtime = {{ path = {:?}{} }}
 "#,
-        out_name, runtime_path, features_str
+        pkg_name, out_name, runtime_path, features_str
     );
 
     let main_rs = r#"
@@ -103,10 +109,17 @@ fn main() {{
         message: format!("Cannot write build.rs: {}", e),
     })?;
 
-    tishlang_build_utils::run_cargo_build(&build_dir, None, None)
+    // Build into a SHARED target dir (one per host), not the per-program `build_dir/target`.
+    // The heavy deps (cranelift_codegen + the embedded VM, ~several GB) then compile ONCE and
+    // are reused by every cranelift build; only each program's tiny main + object is rebuilt.
+    // Without this, every program left its own multi-GB `target/` behind and a full-suite sweep
+    // filled the disk (see docs/full-backend-parity-plan.md A3). Concurrent builds are serialized
+    // by `run_cargo_build`'s nested-cargo mutex and cargo's own target lock, so sharing is safe.
+    let shared_target = std::env::temp_dir().join("tishlang_cranelift_target");
+    tishlang_build_utils::run_cargo_build(&build_dir, Some(&shared_target), None)
         .map_err(|e| CraneliftError { message: e })?;
 
-    let binary_dir = build_dir.join("target").join("release");
+    let binary_dir = shared_target.join("release");
     let binary = tishlang_build_utils::find_release_binary(&binary_dir, out_name)
         .map_err(|e| CraneliftError { message: e })?;
     let target = tishlang_build_utils::resolve_output_path(output_path, out_name);

package/crates/tish_cranelift_runtime/Cargo.toml

@@ -14,6 +14,7 @@ http = ["tishlang_vm/http"]
 promise = ["tishlang_vm/promise"]
 timers = ["tishlang_vm/timers"]
 ws = ["tishlang_vm/ws"]
+tty = ["tishlang_vm/tty"]
 regex = ["tishlang_vm/regex"]
 
 [lib]

package/crates/tish_eval/Cargo.toml

@@ -26,13 +26,19 @@ http = [
 ]
 fs = []
 process = []
+tty = ["dep:tishlang_runtime", "tishlang_runtime/tty"]
 regex = ["dep:fancy-regex", "tishlang_core/regex"]
 tokio = ["dep:tokio"]
 ws = ["dep:tishlang_runtime", "tishlang_runtime/ws"]
 
 [dependencies]
 ahash = "0.8.12"
+indexmap = "2"
 rand = "0.10.1"
+# On-demand native stack growth for deep (non-tail) recursion in the tree-walker,
+# mirroring the bytecode VM. Plain dep (stacker is a no-op shim on wasm32, where
+# tish_vm already depends on it for the wasi backend).
+stacker = "0.1"
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_builtins = { path = "../tish_builtins", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }