@tishlang/tish 1.7.0 → 1.8.0

package/crates/tish/src/repl_completion.rs

@@ -2,8 +2,8 @@
 //! Grey preview hint below the line (like Node) and Tab for full list.
 
 use std::borrow::Cow;
-use std::cell::RefCell;
-use std::rc::Rc;
+
+use tishlang_core::VmRef;
 
 use rustyline::completion::{Completer, Pair};
 use rustyline::highlight::Highlighter;
@@ -29,7 +29,7 @@ const ANSI_RESET: &str = "\x1b[0m";
 
 /// Tab completer that evaluates the expression before the last `.` and suggests property/method names.
 pub struct ReplCompleter {
-    pub vm: Rc<RefCell<Vm>>,
+    pub vm: VmRef<Vm>,
     pub no_optimize: bool,
 }
 

package/crates/tish/tests/cargo_example_compile.rs

@@ -39,7 +39,7 @@ fn resolve_and_merge_cargo_example_fixture() {
         panic!("expected import, got {:?}", first);
     };
     assert_eq!(from.as_ref(), "cargo:demo_shim");
-    merge_modules(modules).unwrap();
+    let _ = merge_modules(modules).unwrap();
 }
 
 #[test]

package/crates/tish/tests/integration_test.rs

@@ -66,12 +66,20 @@ fn file_content_hash(path: &Path) -> u64 {
 ///
 /// Cache is keyed by backend (native, cranelift, js, wasi) so e.g. cranelift and wasi
 /// compiles of the same file do not overwrite each other: .../cranelift/<stem>_<hash> vs .../wasi/<stem>_<hash>.wasm.
+///
+/// The artifact **basename** must be unique per `(stem, hash, backend)`: nested `tish build`
+/// uses it as the Cargo binary name under the workspace `target/release/`. If native and
+/// cranelift both used `strict_equality_<hash>`, parallel `cargo nextest` could run those
+/// tests concurrently and corrupt the same `target/release/...` output (Linux: ETXTBSY when
+/// executing a binary still being written).
 fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
     let stem = path.file_stem().unwrap().to_string_lossy();
     let hash = file_content_hash(path);
     let hash8 = &format!("{:016x}", hash)[..8];
     let cache_base = integration_compile_cache_dir().join(backend);
     let _ = std::fs::create_dir_all(&cache_base);
+    // Include `backend` in the leaf name so nested cargo bin names never collide across backends.
+    let leaf = format!("{}__{}__{}", stem, backend, hash8);
 
     let (artifact_path, compile_args): (PathBuf, Vec<OsString>) = match backend {
         "native" => {
@@ -80,7 +88,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             } else {
                 ""
             };
-            let cached = cache_base.join(format!("{}_{}{}", stem, hash8, ext));
+            let cached = cache_base.join(format!("{}{}", leaf, ext));
             let args = vec![
                 OsString::from("build"),
                 OsString::from(path),
@@ -95,7 +103,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             } else {
                 ""
             };
-            let cached = cache_base.join(format!("{}_{}{}", stem, hash8, ext));
+            let cached = cache_base.join(format!("{}{}", leaf, ext));
             let args = vec![
                 OsString::from("build"),
                 OsString::from(path),
@@ -107,7 +115,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             (cached, args)
         }
         "js" => {
-            let cached = cache_base.join(format!("{}_{}.js", stem, hash8));
+            let cached = cache_base.join(format!("{}.js", leaf));
             let args = vec![
                 OsString::from("build"),
                 OsString::from(path),
@@ -119,7 +127,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             (cached, args)
         }
         "wasi" => {
-            let out_base = cache_base.join(format!("{}_{}", stem, hash8));
+            let out_base = cache_base.join(&leaf);
             let artifact = out_base.with_extension("wasm");
             let args = vec![
                 OsString::from("build"),
@@ -397,7 +405,7 @@ fn test_async_await_run() {
     }
 }
 
-/// Run Promise and setTimeout module tests (require http feature).
+/// Run Promise and setTimeout module tests (`promise` needs `http`; `settimeout` needs `timers`, which `http` enables).
 /// Ignored: tishlang_eval::run() does not run the event loop.
 #[test]
 #[cfg(feature = "http")]
@@ -455,7 +463,9 @@ fn test_vm_date_now() {
     // Library path
     let modules = tishlang_compile::resolve_project(&path, path.parent()).expect("resolve");
     tishlang_compile::detect_cycles(&modules).expect("cycles");
-    let program = tishlang_compile::merge_modules(modules).expect("merge");
+    let program = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
     let chunk = tishlang_bytecode::compile(&program).expect("compile");
     let result = tishlang_vm::run(&chunk);
     assert!(
@@ -499,7 +509,9 @@ fn test_vm_index_assign_via_resolve() {
         .join("array_sort_minimal.tish");
     let modules = tishlang_compile::resolve_project(&path, path.parent()).expect("resolve");
     tishlang_compile::detect_cycles(&modules).expect("cycles");
-    let program = tishlang_compile::merge_modules(modules).expect("merge");
+    let program = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
     let chunk = tishlang_bytecode::compile(&program).expect("compile");
     let result = tishlang_vm::run(&chunk);
     assert!(

package/crates/tish/tests/shortcircuit.rs

@@ -53,7 +53,7 @@ fn test_and_shortcircuit_via_resolve_project() {
     let path = path.canonicalize().expect("path");
     let project_root = path.parent().unwrap();
     let modules = resolve_project(&path, Some(project_root)).expect("resolve");
-    let program = merge_modules(modules).expect("merge");
+    let program = merge_modules(modules).expect("merge").program;
     let program = tishlang_opt::optimize(&program); // Mirror CLI
     let chunk = compile(&program).expect("compile");
     let result = tishlang_vm::run(&chunk);

package/crates/tish_ast/src/ast.rs

@@ -30,6 +30,7 @@ pub enum TypeAnnotation {
 #[derive(Debug, Clone, PartialEq)]
 pub struct TypedParam {
     pub name: Arc<str>,
+    pub name_span: Span,
     pub type_ann: Option<TypeAnnotation>,
     pub default: Option<Expr>,
 }
@@ -64,11 +65,11 @@ impl FunParam {
                 for el in elements {
                     if let Some(el) = el {
                         match el {
-                            DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                            DestructElement::Ident(n, _) => out.push(Arc::clone(n)),
                             DestructElement::Pattern(p) => {
                                 Self::collect_pattern_binding_names(p, out);
                             }
-                            DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                            DestructElement::Rest(n, _) => out.push(Arc::clone(n)),
                         }
                     }
                 }
@@ -76,11 +77,11 @@ impl FunParam {
             DestructPattern::Object(props) => {
                 for prop in props {
                     match &prop.value {
-                        DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                        DestructElement::Ident(n, _) => out.push(Arc::clone(n)),
                         DestructElement::Pattern(p) => {
                             Self::collect_pattern_binding_names(p, out);
                         }
-                        DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                        DestructElement::Rest(n, _) => out.push(Arc::clone(n)),
                     }
                 }
             }
@@ -101,11 +102,11 @@ pub enum DestructPattern {
 #[derive(Debug, Clone, PartialEq)]
 pub enum DestructElement {
     /// Simple binding: a
-    Ident(Arc<str>),
+    Ident(Arc<str>, Span),
     /// Nested pattern: [a, b] or { x, y }
     Pattern(Box<DestructPattern>),
     /// Rest element: ...rest
-    Rest(Arc<str>),
+    Rest(Arc<str>, Span),
 }
 
 /// Property in object destructuring pattern
@@ -123,12 +124,20 @@ pub enum ImportSpecifier {
     /// Named: { foo } or { foo as bar }
     Named {
         name: Arc<str>,
+        name_span: Span,
         alias: Option<Arc<str>>,
+        alias_span: Option<Span>,
     },
     /// Namespace: * as M
-    Namespace(Arc<str>),
+    Namespace {
+        name: Arc<str>,
+        name_span: Span,
+    },
     /// Default: import X from "..."
-    Default(Arc<str>),
+    Default {
+        name: Arc<str>,
+        name_span: Span,
+    },
 }
 
 /// Export declaration: named (const/let/fn) or default
@@ -153,6 +162,7 @@ pub enum Statement {
     },
     VarDecl {
         name: Arc<str>,
+        name_span: Span,
         mutable: bool, // true for `let`, false for `const`
         type_ann: Option<TypeAnnotation>,
         init: Option<Expr>,
@@ -189,6 +199,7 @@ pub enum Statement {
     },
     ForOf {
         name: Arc<str>,
+        name_span: Span,
         iterable: Expr,
         body: Box<Statement>,
         span: Span,
@@ -206,6 +217,7 @@ pub enum Statement {
     FunDecl {
         async_: bool,
         name: Arc<str>,
+        name_span: Span,
         params: Vec<FunParam>,
         rest_param: Option<TypedParam>,
         return_type: Option<TypeAnnotation>,
@@ -230,6 +242,7 @@ pub enum Statement {
     Try {
         body: Box<Statement>,
         catch_param: Option<Arc<str>>,
+        catch_param_span: Option<Span>,
         catch_body: Option<Box<Statement>>,
         finally_body: Option<Box<Statement>>,
         span: Span,
@@ -243,6 +256,31 @@ pub enum Statement {
         declaration: Box<ExportDeclaration>,
         span: Span,
     },
+    /// `type Name = Type` (erased at runtime; for checker / declaration files).
+    TypeAlias {
+        name: Arc<str>,
+        name_span: Span,
+        ty: TypeAnnotation,
+        span: Span,
+    },
+    /// `declare let name: T` or `declare const name: T`
+    DeclareVar {
+        name: Arc<str>,
+        name_span: Span,
+        type_ann: Option<TypeAnnotation>,
+        const_: bool,
+        span: Span,
+    },
+    /// `declare [async] function name(...): R` (no body).
+    DeclareFun {
+        async_: bool,
+        name: Arc<str>,
+        name_span: Span,
+        params: Vec<FunParam>,
+        rest_param: Option<TypedParam>,
+        return_type: Option<TypeAnnotation>,
+        span: Span,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -550,6 +588,39 @@ pub enum UnaryOp {
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum MemberProp {
-    Name(Arc<str>),
+    /// Property name in `obj.prop` / `obj?.prop` (span covers **prop** only).
+    Name {
+        name: Arc<str>,
+        span: Span,
+    },
     Expr(Box<Expr>), // for computed property
 }
+
+impl Statement {
+    /// Source span covering this statement (including nested bodies where applicable).
+    pub fn span(&self) -> Span {
+        match self {
+            Statement::Block { span, .. }
+            | Statement::VarDecl { span, .. }
+            | Statement::VarDeclDestructure { span, .. }
+            | Statement::ExprStmt { span, .. }
+            | Statement::If { span, .. }
+            | Statement::While { span, .. }
+            | Statement::For { span, .. }
+            | Statement::ForOf { span, .. }
+            | Statement::Return { span, .. }
+            | Statement::Break { span, .. }
+            | Statement::Continue { span, .. }
+            | Statement::FunDecl { span, .. }
+            | Statement::Switch { span, .. }
+            | Statement::DoWhile { span, .. }
+            | Statement::Throw { span, .. }
+            | Statement::Try { span, .. }
+            |             Statement::Import { span, .. }
+            | Statement::Export { span, .. }
+            | Statement::TypeAlias { span, .. }
+            | Statement::DeclareVar { span, .. }
+            | Statement::DeclareFun { span, .. } => *span,
+        }
+    }
+}

package/crates/tish_build_utils/Cargo.toml

@@ -5,3 +5,7 @@ edition = "2021"
 description = "Shared build utilities for Tish (workspace discovery, path resolution)"
 license-file = { workspace = true }
 repository = { workspace = true }
+
+[dependencies]
+# Bundled `protoc` for nested `cargo build` (Lance / prost-build) when none is on PATH.
+protoc-bin-vendored = "3"

package/crates/tish_build_utils/src/lib.rs

@@ -137,6 +137,39 @@ fn tish_root_from_project_cargo_files(mut start: PathBuf) -> Option<PathBuf> {
 /// Returns the directory containing the workspace Cargo.toml (with [workspace]).
 /// Used when building native binaries, WASM, or locating runtime crates.
 pub fn find_workspace_root() -> Result<PathBuf, String> {
+    // Strategy 0: explicit checkout (e.g. tish-hub `npm run dev` / native build from a JS-only tree)
+    if let Ok(root) = std::env::var("TISHLANG_WORKSPACE") {
+        let trimmed = root.trim();
+        if !trimmed.is_empty() {
+            let p = PathBuf::from(trimmed);
+            if p.is_dir() && is_tish_workspace_root(&p) {
+                return p.canonicalize().map_err(|e| {
+                    format!(
+                        "TISHLANG_WORKSPACE is set but not a usable directory: {}",
+                        e
+                    )
+                });
+            }
+            // Non-empty but invalid: fall through (sibling `tish/` discovery may still apply).
+        }
+    }
+
+    // Strategy 0b: monorepo layout `…/<parent>/tish-hub` (cwd) next to `…/<parent>/tish` (language repo).
+    // Works without `TISHLANG_WORKSPACE` so older `tish` binaries still find the compiler tree.
+    if let Ok(mut dir) = std::env::current_dir() {
+        for _ in 0..24 {
+            let candidate = dir.join("tish");
+            if is_tish_workspace_root(&candidate) {
+                return candidate.canonicalize().map_err(|e| {
+                    format!("Cannot canonicalize Tish workspace {}: {}", candidate.display(), e)
+                });
+            }
+            if !dir.pop() {
+                break;
+            }
+        }
+    }
+
     // Strategy 1: CARGO_MANIFEST_DIR (works during cargo build/run from workspace)
     if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
         let path = PathBuf::from(&manifest_dir);
@@ -301,18 +334,70 @@ pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String>
     Ok(build_dir)
 }
 
+/// `PROTOC` for prost-build in transitive crates (e.g. lance-encoding) during nested `cargo build`.
+/// Respects an existing `PROTOC`, then `protoc` on `PATH`, then `protoc-bin-vendored`.
+fn protoc_for_nested_cargo() -> Option<PathBuf> {
+    // Empty or non-file PROTOC must not short-circuit: prost-build treats "" like a missing binary.
+    if let Some(v) = std::env::var_os("PROTOC") {
+        if !v.is_empty() {
+            let p = PathBuf::from(&v);
+            if p.is_file() {
+                return None;
+            }
+        }
+    }
+    // Prefer vendored protoc over PATH: a broken or non-executable `protoc` on PATH still passes `is_file()`.
+    if let Ok(p) = protoc_bin_vendored::protoc_bin_path() {
+        return Some(p);
+    }
+    let ext = if cfg!(windows) { ".exe" } else { "" };
+    let name = format!("protoc{}", ext);
+    if let Some(paths) = std::env::var_os("PATH") {
+        for dir in std::env::split_paths(&paths) {
+            let candidate = dir.join(&name);
+            if candidate.is_file() {
+                return Some(candidate);
+            }
+        }
+    }
+    None
+}
+
 /// Run cargo build in the given directory.
 /// If target_dir is Some, use that for --target-dir (e.g. workspace target for caching).
 pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<(), String> {
     let target_dir = target_dir
         .map(|p| p.to_path_buf())
         .unwrap_or_else(|| build_dir.join("target"));
-    let output = Command::new("cargo")
-        .args(["build", "--release", "--target-dir"])
+    // Default to target-cpu=native so the emitted binary uses every SIMD / ISA
+    // extension the build host supports. Callers can override by pre-setting
+    // RUSTFLAGS in the environment.
+    let existing_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
+    let merged_rustflags = if existing_rustflags.is_empty() {
+        "-C target-cpu=native".to_string()
+    } else if existing_rustflags.contains("target-cpu") {
+        existing_rustflags
+    } else {
+        format!("{} -C target-cpu=native", existing_rustflags)
+    };
+    // Nested `cargo build` (e.g. `tish build --native-backend rust`) inherits the parent
+    // environment. CI often sets `RUSTC_WRAPPER=sccache`; wrapping this inner compile too can
+    // cause flaky or failed builds (LTO / temp-crate paths). Use plain rustc here; the main
+    // workspace build still benefits from the wrapper.
+    let mut cmd = Command::new("cargo");
+    cmd.args(["build", "--release", "--target-dir"])
         .arg(&target_dir)
         .current_dir(build_dir)
         .env_remove("CARGO_TARGET_DIR")
+        .env_remove("RUSTC_WRAPPER")
+        .env_remove("RUSTC_WORKSPACE_WRAPPER")
+        .env_remove("CARGO_BUILD_RUSTC_WRAPPER")
         .env("CARGO_TERM_PROGRESS", "always")
+        .env("RUSTFLAGS", &merged_rustflags);
+    if let Some(protoc) = protoc_for_nested_cargo() {
+        cmd.env("PROTOC", protoc);
+    }
+    let output = cmd
         .output()
         .map_err(|e| format!("Failed to run cargo: {}", e))?;
 
@@ -327,6 +412,24 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
     Ok(())
 }
 
+#[cfg(test)]
+mod protoc_tests {
+    use super::*;
+
+    #[test]
+    fn protoc_for_nested_cargo_without_env_uses_vendored_or_path() {
+        let _lock = std::sync::Mutex::new(());
+        let _guard = _lock.lock().unwrap();
+        std::env::remove_var("PROTOC");
+        let p = protoc_for_nested_cargo().expect("expected vendored or PATH protoc");
+        assert!(
+            p.exists(),
+            "resolved protoc should exist: {}",
+            p.display()
+        );
+    }
+}
+
 /// Find the built binary in target/release.
 pub fn find_release_binary(binary_dir: &Path, bin_name: &str) -> Result<PathBuf, String> {
     let binary_no_ext = binary_dir.join(bin_name);

package/crates/tish_builtins/Cargo.toml

@@ -8,9 +8,13 @@ description = "Shared builtin implementations for Tish (array, string, object, m
 license-file = { workspace = true }
 repository = { workspace = true }
 [dependencies]
-rand = "0.10.0"
+rand = "0.10.1"
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 
 [features]
 default = []
 regex = ["tishlang_core/regex"]
+# Propagate the `send-values` feature from `tishlang_core` so that closures
+# handed to us via `NativeFn` pick up the `Send + Sync` bound automatically
+# when multi-threaded `Value`s are enabled upstream.
+send-values = ["tishlang_core/send-values"]

package/crates/tish_builtins/src/array.rs

@@ -1,13 +1,14 @@
 //! Array builtin methods.
 
 use crate::helpers::normalize_index;
+use tishlang_core::VmRef;
 use std::cell::RefCell;
 use std::rc::Rc;
 use tishlang_core::Value;
 
 /// Create a new array Value from a Vec of Values.
 pub fn from_vec(v: Vec<Value>) -> Value {
-    Value::Array(Rc::new(RefCell::new(v)))
+    Value::Array(VmRef::new(v))
 }
 
 /// Get the length of an array.
@@ -110,7 +111,7 @@ pub fn join(arr: &Value, sep: &Value) -> Value {
 pub fn reverse(arr: &Value) -> Value {
     if let Value::Array(arr) = arr {
         arr.borrow_mut().reverse();
-        Value::Array(Rc::clone(arr))
+        Value::Array(arr.clone())
     } else {
         Value::Null
     }
@@ -122,7 +123,7 @@ pub fn shuffle(arr: &Value) -> Value {
         let mut v = arr.borrow().clone();
         use rand::seq::SliceRandom;
         v.shuffle(&mut rand::rng());
-        Value::Array(Rc::new(RefCell::new(v)))
+        Value::Array(VmRef::new(v))
     } else {
         Value::Null
     }
@@ -141,7 +142,7 @@ pub fn splice(arr: &Value, start: &Value, delete_count: Option<&Value>, items: &
         let removed: Vec<Value> = arr_mut
             .splice(start_idx..start_idx + actual_delete, items.iter().cloned())
             .collect();
-        Value::Array(Rc::new(RefCell::new(removed)))
+        Value::Array(VmRef::new(removed))
     } else {
         Value::Null
     }
@@ -158,7 +159,7 @@ pub fn slice(arr: &Value, start: &Value, end: &Value) -> Value {
         } else {
             vec![]
         };
-        Value::Array(Rc::new(RefCell::new(sliced)))
+        Value::Array(VmRef::new(sliced))
     } else {
         Value::Null
     }
@@ -174,7 +175,7 @@ pub fn concat(arr: &Value, args: &[Value]) -> Value {
                 result.push(v.clone());
             }
         }
-        Value::Array(Rc::new(RefCell::new(result)))
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -200,7 +201,7 @@ pub fn flat(arr: &Value, depth: &Value) -> Value {
         };
         let mut result = Vec::new();
         flatten(&arr.borrow(), d, &mut result);
-        Value::Array(Rc::new(RefCell::new(result)))
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -217,7 +218,7 @@ pub fn map(arr: &Value, callback: &Value) -> Value {
             .enumerate()
             .map(|(i, v)| cb(&[v.clone(), Value::Number(i as f64)]))
             .collect();
-        Value::Array(Rc::new(RefCell::new(result)))
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -238,7 +239,7 @@ pub fn filter(arr: &Value, callback: &Value) -> Value {
                 }
             })
             .collect();
-        Value::Array(Rc::new(RefCell::new(result)))
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -340,7 +341,7 @@ pub fn flat_map(arr: &Value, callback: &Value) -> Value {
                 result.push(mapped);
             }
         }
-        Value::Array(Rc::new(RefCell::new(result)))
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -352,7 +353,7 @@ where
 {
     if let Value::Array(arr) = arr {
         arr.borrow_mut().sort_by(cmp);
-        Value::Array(Rc::clone(arr))
+        Value::Array(arr.clone())
     } else {
         Value::Null
     }
@@ -387,7 +388,7 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
             .map(|i| std::mem::replace(&mut elements[i], Value::Null))
             .collect();
         drop(arr_mut);
-        Value::Array(Rc::clone(arr))
+        Value::Array(arr.clone())
     } else {
         Value::Null
     }