@tishlang/tish 1.13.2 → 2.0.1

package/Cargo.toml

@@ -21,6 +21,8 @@ members = [
     "crates/tish_compiler_wasm",
     "crates/tish_vm",
     "crates/tish_llvm",
+    "crates/tish_ffi",
+    "examples/ffi/mathext",
 
     "crates/tish_native",
     "crates/tish_wasm",

package/crates/js_to_tish/src/transform/expr.rs

@@ -477,6 +477,7 @@ fn convert_bin_op(op: &oxc::ast::ast::BinaryOperator) -> Result<BinOp, ConvertEr
         oxc::ast::ast::BinaryOperator::BitwiseXOR => BinOp::BitXor,
         oxc::ast::ast::BinaryOperator::ShiftLeft => BinOp::Shl,
         oxc::ast::ast::BinaryOperator::ShiftRight => BinOp::Shr,
+        oxc::ast::ast::BinaryOperator::ShiftRightZeroFill => BinOp::UShr,
         _ => {
             return Err(ConvertError::new(ConvertErrorKind::Unsupported {
                 what: format!("binary operator: {op:?}"),

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.13.2"
+version = "2.0.1"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }
@@ -16,10 +16,15 @@ path = "src/main.rs"
 # (see workspace `justfile`). `tish run --feature …` / `tish build --feature …` gate what runs
 # or what gets linked into a *native output* binary — they are not the primary way to ship a
 # “full” vs “empty” CLI.
-default = ["full"]
+default = ["full", "fast-alloc"]
 # Alias: same dependency edges as `default` (kept for `--features full` in CI and docs).
 # Includes `pg` so `tish run` can resolve `import … from '@tishlang/pg'` (`cargo:tish_pg`) on the bytecode VM.
-full = ["http", "fs", "process", "regex", "ws", "timers", "pg"]
+full = ["http", "fs", "process", "regex", "ws", "timers", "tty", "pg"]
+# Fast allocator (mimalloc) as the process `#[global_allocator]`. tish's object/array/string workloads
+# are allocation-bound (a sampling profile of object-heavy code spends ~14%+ in system malloc/free);
+# mimalloc is markedly faster for the many-small-allocations pattern — the same reason JSC ships bmalloc.
+# Semantically transparent (just a faster malloc); `--no-default-features` drops it for the system allocator.
+fast-alloc = ["dep:mimalloc"]
 # Opt-out: build without Postgres (`cargo build -p tishlang --no-default-features --features http,...`).
 pg = ["dep:tishlang_pg"]
 # Individual capability flags
@@ -29,6 +34,7 @@ fs      = ["tishlang_eval/fs",      "tishlang_runtime/fs",      "tishlang_compil
 process = ["tishlang_eval/process", "tishlang_runtime/process", "tishlang_compile/process", "tishlang_vm/process"]
 regex   = ["tishlang_eval/regex",   "tishlang_runtime/regex",   "tishlang_compile/regex",   "tishlang_vm/regex"]
 ws      = ["tishlang_eval/ws",      "tishlang_runtime/ws",      "tishlang_compile/ws",      "tishlang_vm/ws"]
+tty     = ["tishlang_eval/tty",     "tishlang_runtime/tty",     "tishlang_compile/tty",     "tishlang_vm/tty"]
 # GPU compute — Apple Silicon only
 [dependencies]
 rustyline = { version = "17", features = ["with-file-history"] }
@@ -41,6 +47,7 @@ tishlang_compile_js = { path = "../tish_compile_js", version = ">=0.1" }
 tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 tishlang_vm = { path = "../tish_vm", version = ">=0.1" }
+tishlang_ffi = { path = "../tish_ffi", version = ">=0.1" }
 tishlang_native = { path = "../tish_native", version = ">=0.1" }
 tishlang_llvm = { path = "../tish_llvm", version = ">=0.1" }
 tishlang_wasm = { path = "../tish_wasm", version = ">=0.1" }
@@ -49,6 +56,7 @@ tishlang_core = { path = "../tish_core", version = ">=0.1" }
 tishlang_js_to_tish = { path = "../js_to_tish", version = ">=0.1" }
 clap = { version = "4.6.0", features = ["derive", "color"] }
 tishlang_pg = { path = "../tish_pg", version = ">=0.1", optional = true }
+mimalloc = { version = "0.1", optional = true }
 
 [dev-dependencies]
 rayon = "1.11"

package/crates/tish/build.rs

@@ -0,0 +1,21 @@
+//! Export the `tish_value_*` C-ABI accessors (from `tishlang_ffi`) in the `tish` binary's dynamic
+//! symbol table, so a `dlopen`'d native extension (`ffi:`) can resolve them at load time. This is
+//! the **decoupled** FFI model: the extension declares the accessors `extern "C"` and does NOT link
+//! `tish_core`, so there is a single value representation and no host/extension layout matching.
+//! Without this flag the host's accessor symbols aren't visible to the loaded library.
+
+fn main() {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    match target_os.as_str() {
+        // macOS/iOS: export all global symbols (so the two-level-namespace binary exposes them).
+        "macos" | "ios" => {
+            println!("cargo:rustc-link-arg-bins=-Wl,-export_dynamic");
+        }
+        // Windows PE export tables work differently; the host-export FFI model isn't wired there yet.
+        "windows" => {}
+        // Linux/BSD: -rdynamic puts all symbols in the dynamic table.
+        _ => {
+            println!("cargo:rustc-link-arg-bins=-rdynamic");
+        }
+    }
+}

package/crates/tish/src/cli_help.rs

@@ -72,8 +72,7 @@ fn write_tish_banner_frame(out: &mut impl Write, reveal_t: f32, color_frame: usi
         let visible = ((len as f32) * reveal_t).round() as usize;
         let visible = visible.min(len);
 
-        for col in 0..len {
-            let ch = chars[col];
+        for (col, &ch) in chars.iter().enumerate() {
             if col >= visible || ch == ' ' {
                 let _ = write!(out, " ");
             } else {
@@ -321,6 +320,8 @@ pub fn cli_after_help() -> String {
 {oh}Environment variables:{r}
   {t}TISH_NO_OPTIMIZE=1{r}
           Disable AST and bytecode optimizations for run/build
+  {t}TISH_IGNORE_INDENT=1{r}
+          Ignore indentation syntax: parse blocks by braces only (debug nested-block transpilation)
 
 See {t}tish run --help{r} and {t}tish build --help{r} for backend and feature options."
     )
@@ -348,8 +349,10 @@ fn capabilities_section(oh: &str, t: &str, r: &str) -> String {
           RegExp
   {t}ws{r}
           WebSocket client / server
+  {t}tty{r}
+          Interactive terminal: raw mode, key/resize events, size, alt screen (`import from \"tish:tty\"`)
   {t}full{r}
-          All of the above (http, timers, fs, process, regex, ws)
+          All of the above (http, timers, fs, process, regex, ws, tty)
 
 Omit --feature to allow every capability compiled into this `tish` binary; pass flags to restrict what scripts may use. The CLI is normally built with all of them (Cargo default on `tishlang`)."
     )
@@ -429,8 +432,10 @@ pub fn build_after_help() -> String {
           RegExp
   {t}ws{r}
           WebSocket client / server
+  {t}tty{r}
+          Interactive terminal: raw mode, key/resize events, size, alt screen (`import from \"tish:tty\"`)
   {t}full{r}
-          All of the above (http, timers, fs, process, regex, ws)
+          All of the above (http, timers, fs, process, regex, ws, tty)
 
 For `--target native`, these choose what is linked into the **output** executable (omit = same set as this `tish` binary was built with). Minimal native outputs still use a full `tish` CLI unless you built it with `cargo build -p tishlang --no-default-features`."
     )
@@ -543,6 +548,9 @@ pub(crate) struct BuildArgs {
     /// For `--target js` project builds: emit `OUTPUT.js.map` and `//# sourceMappingURL=…` so JS/TS tools can jump to original `.tish` (implies `--no-optimize` for that build).
     #[arg(long, help_heading = "Options")]
     pub source_map: bool,
+    /// Run the gradual type checker: `warn` prints `line:col` type diagnostics; `error` also fails the build on them. (Equivalent to setting `TISH_CHECK`.)
+    #[arg(long, value_name = "MODE", help_heading = "Options")]
+    pub check: Option<String>,
     /// Entry `.tish` file (or `.js` where supported).
     #[arg(required = true, value_name = "FILE", help_heading = "Arguments")]
     pub file: String,
@@ -561,5 +569,8 @@ pub(crate) enum Commands {
     DumpAst {
         #[arg(required = true, value_name = "FILE", help_heading = "Arguments")]
         file: String,
+        /// Ignore indentation syntax: parse blocks by braces only (same as TISH_IGNORE_INDENT=1).
+        #[arg(long, help_heading = "Options")]
+        ignore_indent: bool,
     },
 }

package/crates/tish/src/main.rs

@@ -1,5 +1,14 @@
 //! Tish CLI - run, REPL, build to native or other targets.
 
+// Fast allocator for the whole process. tish's object/array/string workloads are allocation-bound
+// (sampling profiles spend a large fraction in system malloc/free + Arc drops); mimalloc is much
+// faster for the many-small-allocations pattern — the technique JSC uses with bmalloc. Transparent:
+// it only changes WHICH malloc backs every allocation, never program behaviour. `fast-alloc` is in
+// `default`; `--no-default-features` falls back to the system allocator.
+#[cfg(feature = "fast-alloc")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 mod cargo_native_registry;
 mod cli_help;
 mod repl_completion;
@@ -21,7 +30,7 @@ fn normalize_capability_flags(features: &[String]) -> HashSet<String> {
     for s in features {
         for part in s.split(',').map(str::trim).filter(|p| !p.is_empty()) {
             if part == "full" {
-                for name in ["http", "timers", "fs", "process", "regex", "ws"] {
+                for name in ["http", "timers", "fs", "process", "regex", "ws", "tty"] {
                     out.insert(name.to_string());
                 }
             } else {
@@ -63,7 +72,7 @@ fn argv_with_implicit_run(mut argv: Vec<String>) -> Vec<String> {
     if argv.len() >= 2 {
         let first = argv[1].as_str();
         const SUBCOMMANDS: &[&str] = &["run", "repl", "build", "dump-ast"];
-        let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.iter().any(|&s| s == first);
+        let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.contains(&first);
         if looks_like_file {
             argv.insert(1, "run".to_string());
         }
@@ -103,18 +112,28 @@ fn main() {
             a.no_optimize || no_opt_env,
         ),
         Some(Commands::Repl(a)) => run_repl(&a.backend, a.no_optimize || no_opt_env, &a.features),
-        Some(Commands::Build(a)) => build_file(
-            &a.file,
-            &a.output,
-            &a.target,
-            &a.native_backend,
-            &a.features,
-            a.no_optimize || no_opt_env,
-            a.source_map,
-            a.ios_triple.as_deref(),
-            &a.crate_type,
-        ),
-        Some(Commands::DumpAst { file }) => dump_ast(&file),
+        Some(Commands::Build(a)) => {
+            // `--check warn|error` drives the gradual type checker via the same channel as the
+            // `TISH_CHECK` env var that `tishlang_compile::run_type_check` reads.
+            if let Some(mode) = &a.check {
+                std::env::set_var("TISH_CHECK", mode);
+            }
+            build_file(
+                &a.file,
+                &a.output,
+                &a.target,
+                &a.native_backend,
+                &a.features,
+                a.no_optimize || no_opt_env,
+                a.source_map,
+                a.ios_triple.as_deref(),
+                &a.crate_type,
+            )
+        }
+        Some(Commands::DumpAst {
+            file,
+            ignore_indent,
+        }) => dump_ast(&file, ignore_indent),
         None => {
             if io::stdin().is_terminal() {
                 run_repl("vm", no_opt_env, &[])
@@ -169,7 +188,7 @@ fn run_stdin_source(
     } else {
         tishlang_opt::optimize(&prog)
     };
-    run_program(&program, backend, no_optimize, features)
+    run_program(&program, &cwd, backend, no_optimize, features, None)
 }
 
 fn run_file(
@@ -214,16 +233,55 @@ fn run_file(
         }
     };
 
-    run_program(&program, backend, no_optimize, features)
+    let ffi_base = Path::new(path)
+        .parent()
+        .map(|p| p.to_path_buf())
+        .unwrap_or_else(|| std::path::PathBuf::from("."));
+    run_program(&program, &ffi_base, backend, no_optimize, features, Some(path))
+}
+
+/// Load every `ffi:<path>` cdylib the program imports, resolving each path relative to `base_dir`
+/// (the importing file's directory). Returns `(spec, exports)` pairs the backends register as
+/// native modules so `import { f } from "ffi:./lib.dylib"` resolves to the extension's exports.
+fn load_ffi_modules(
+    program: &tishlang_ast::Program,
+    base_dir: &Path,
+) -> Result<Vec<(String, tishlang_core::ObjectMap)>, String> {
+    let mut out = Vec::new();
+    for spec in tishlang_compile::ffi_native_specs(program) {
+        let rel = spec.strip_prefix("ffi:").unwrap_or(spec.as_str());
+        let lib_path = base_dir.join(rel);
+        let path_str = lib_path
+            .to_str()
+            .ok_or_else(|| format!("ffi: non-UTF-8 path: {}", lib_path.display()))?;
+        let exports = tishlang_ffi::load_module(path_str)?;
+        out.push((spec, exports));
+    }
+    Ok(out)
 }
 
 fn run_program(
     program: &tishlang_ast::Program,
+    base_dir: &Path,
     backend: &str,
     no_optimize: bool,
     features: &[String],
+    source_name: Option<&str>,
 ) -> Result<(), String> {
+    // FFI: load each `ffi:<path>` cdylib (resolved relative to the importing file) into a
+    // name→export map the backends register as a native module. Built once, shared across backends.
+    let ffi_modules = load_ffi_modules(program, base_dir)?;
+
     if backend == "interp" {
+        if !ffi_modules.is_empty() {
+            // The interpreter runs on `EvalValue`, but the FFI shim is built over core `Value`;
+            // bridging the two is a follow-up. `ffi:` works on the default VM backend today.
+            return Err(
+                "ffi: native extensions currently require the default (VM) backend; \
+                 run without `--backend interp`"
+                    .to_string(),
+            );
+        }
         let mut eval = tishlang_eval::Evaluator::new();
         let value = eval.eval_program(program)?;
         #[cfg(feature = "timers")]
@@ -242,14 +300,22 @@ fn run_program(
         return Ok(());
     }
 
+    let source_arc: Option<std::sync::Arc<str>> = source_name.map(std::sync::Arc::from);
     let chunk = if no_optimize {
-        tishlang_bytecode::compile_unoptimized(program).map_err(|e| e.to_string())?
+        // `--no-optimize` keeps the simpler path; line info is most useful with optimization on.
+        let mut c = tishlang_bytecode::compile_unoptimized(program).map_err(|e| e.to_string())?;
+        c.source = source_arc.clone();
+        c
     } else {
-        tishlang_bytecode::compile(program).map_err(|e| e.to_string())?
+        tishlang_bytecode::compile_with_source(program, source_arc.clone())
+            .map_err(|e| e.to_string())?
     };
     let caps = vm_capabilities_for_cli_run(features);
     let mut vm = tishlang_vm::Vm::with_capabilities(caps);
     cargo_native_registry::register_bytecode_native_modules(&mut vm);
+    for (spec, exports) in ffi_modules {
+        vm.register_native_module(spec, exports);
+    }
     let value = vm.run_with_options(&chunk, false)?;
     if !matches!(value, tishlang_core::Value::Null) {
         println!(
@@ -561,7 +627,7 @@ fn compile_to_js(
     Ok(())
 }
 
-#[allow(clippy::vec_init_then_push)]
+#[allow(clippy::vec_init_then_push, clippy::too_many_arguments)] // build_file maps CLI build flags 1:1
 fn build_file(
     input_path: &str,
     output_path: &str,
@@ -773,9 +839,15 @@ mod cli_tests {
     }
 }
 
-fn dump_ast(path: &str) -> Result<(), String> {
+fn dump_ast(path: &str, ignore_indent: bool) -> Result<(), String> {
     let source = fs::read_to_string(path).map_err(|e| format!("Cannot read {}: {}", path, e))?;
-    let program = tishlang_parser::parse(&source)?;
+    // The `--ignore-indent` flag ORs with the `TISH_IGNORE_INDENT` env var, mirroring how
+    // `--no-optimize` combines with `TISH_NO_OPTIMIZE`.
+    let ignore_indent = ignore_indent || tishlang_parser::LexerOptions::from_env().ignore_indent;
+    let program = tishlang_parser::parse_with_options(
+        &source,
+        tishlang_parser::LexerOptions { ignore_indent },
+    )?;
     println!("{:#?}", program);
     Ok(())
 }

package/crates/tish/src/repl_completion.rs

@@ -13,7 +13,6 @@ use rustyline::Context;
 use rustyline::Helper;
 
 use tishlang_bytecode::{compile_for_repl, compile_for_repl_unoptimized};
-use tishlang_parser;
 use tishlang_vm::Vm;
 
 /// Tish keywords for bare-word completion (Python-style).

package/crates/tish/tests/error_source_location.rs

@@ -0,0 +1,36 @@
+//! Issue #74: a runtime error from the bytecode VM carries its source location (`file:line`)
+//! instead of a bare message, so embedders/users can find where it came from.
+
+use std::path::PathBuf;
+use std::process::Command;
+
+#[test]
+fn runtime_error_reports_source_file_and_line() {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join("runtime_error_location.tish");
+    assert!(fixture.is_file(), "missing fixture {}", fixture.display());
+
+    // `obj.field.deep` reads `.field` of `null` on line 4 of the fixture.
+    let out = Command::new(&tish)
+        .args(["run", "--backend", "vm", fixture.to_str().unwrap()])
+        .output()
+        .expect("spawn tish run");
+    assert!(!out.status.success(), "expected a runtime error");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+
+    assert!(
+        stderr.contains(":4"),
+        "error should report the source line (4):\n{stderr}"
+    );
+    assert!(
+        stderr.contains("runtime_error_location.tish"),
+        "error should report the source file:\n{stderr}"
+    );
+    assert!(
+        stderr.contains("Cannot read property 'field' of null"),
+        "error should keep the original message:\n{stderr}"
+    );
+}

package/crates/tish/tests/fixtures/runtime_error_location.tish

@@ -0,0 +1,5 @@
+let a = 1
+let b = 2
+let obj = null
+let x = obj.field.deep
+console.log(x)

package/crates/tish/tests/fixtures/trycatch_runtime_errors.tish

@@ -0,0 +1,15 @@
+// try/catch catches runtime errors (null property/method access, "not a function")
+// AND throws that cross function-call frames, with the thrown value preserved (issue #60).
+try { let x = null; x.foo() } catch (e) { console.log("A caught") }
+function f() { throw new Error("boom") }
+try { f() } catch (e) { console.log("B caught:", e.message) }
+function g() { let y = null; y.baz() }
+try { g() } catch (e) { console.log("C caught") }
+console.log("D done")
+try { try { throw "inner" } catch (e) { throw "rethrown" } } catch (e) { console.log("E caught:", e) }
+try { console.log("F ok") } catch (e) { console.log("F should not happen") }
+let total = 0
+function risky(n) { if (n > 3) { throw n }; return n }
+let i = 0
+while (i < 6) { try { total = total + risky(i) } catch (e) { total = total + 100 }; i = i + 1 }
+console.log("G total:", total)

package/crates/tish/tests/fixtures/tty_capability.tish

@@ -0,0 +1,9 @@
+// tish:tty capability (issue #101). Asserts the module loads and degrades gracefully when
+// stdout/stdin is not a terminal (CI), so the output is deterministic without a real TTY.
+import { isTTY, size, setRawMode, enterAltScreen, leaveAltScreen, read, readLine } from 'tish:tty'
+console.log("isTTY:", typeof isTTY())
+console.log("size:", size() ? "object" : "null")
+console.log("setRawMode:", typeof setRawMode)
+console.log("read:", typeof read)
+console.log("readLine:", typeof readLine)
+console.log("alt:", typeof enterAltScreen, typeof leaveAltScreen)