@tishlang/tish-format 2.12.0 → 2.35.0

package/Cargo.toml

@@ -34,6 +34,9 @@ members = [
     "crates/tish_resolve",
     "crates/tishlang_cargo_bindgen",
 ]
+# Generated native-build projects (`tish build`) land under `target/` when TMPDIR points there;
+# never enroll anything beneath `target/` as a workspace member.
+exclude = ["target"]
 resolver = "2"
 
 [workspace.package]

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

@@ -176,7 +176,12 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                     span: span_util::oxc_span_to_tish(ctx.1, &*arrow.body),
                 }))
             };
-            Ok(Expr::ArrowFunction { params, body, span })
+            Ok(Expr::ArrowFunction {
+                async_: arrow.r#async,
+                params,
+                body,
+                span,
+            })
         }
         OxcExpr::AwaitExpression(a) => Ok(Expr::Await {
             operand: Box::new(convert_expr(&a.argument, ctx)?),
@@ -229,7 +234,12 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                     }))
                 }
             };
-            Ok(Expr::ArrowFunction { params, body, span })
+            Ok(Expr::ArrowFunction {
+                async_: f.r#async,
+                params,
+                body,
+                span,
+            })
         }
         _ => Err(ConvertError::new(ConvertErrorKind::Unsupported {
             what: format!("expression: {:?}", std::mem::discriminant(expr)),

package/crates/tish/tests/fixtures/fs_parity_callbacks.tish

@@ -0,0 +1,22 @@
+// Issue #122: Node callback form on the VM — `fs.writeFile(path, data, (err) => …)` and
+// `fs.readFile(path, (err, data) => …)`, with (err, data) semantics and a non-null err on a
+// missing file. Operates under $FS_TMP.
+import { writeFile, readFile, stat, unlink } from "node:fs"
+import { process } from "tish:process"
+
+let d = process.env.FS_TMP
+writeFile(d + "/cb.txt", "callback data", (err) => {
+  console.log("write-err-null=" + String(err === null))
+  readFile(d + "/cb.txt", (err2, data) => {
+    console.log("read=" + data)
+    stat(d + "/cb.txt", (err3, st) => {
+      console.log("size=" + String(st.size) + ",file=" + String(st.isFile()))
+      unlink(d + "/cb.txt", (err4) => {
+        console.log("unlink-err-null=" + String(err4 === null))
+      })
+    })
+  })
+})
+readFile(d + "/missing.txt", (err, data) => {
+  console.log("missing-err-set=" + String(!(err === null)) + ",data-null=" + String(data === null))
+})

package/crates/tish/tests/fixtures/fs_parity_promises.tish

@@ -0,0 +1,21 @@
+// Issue #122: the async `node:fs/promises` surface — await on the same methods, and `access`
+// rejects on a missing path. Operates under $FS_TMP.
+import { writeFile, readFile, stat, mkdir, readdir, rm, access } from "node:fs/promises"
+import { process } from "tish:process"
+
+async fn main() {
+  let d = process.env.FS_TMP
+  await writeFile(d + "/p.txt", "async hello")
+  console.log("read=" + (await readFile(d + "/p.txt")))
+  let st = await stat(d + "/p.txt")
+  console.log("size=" + String(st.size))
+  await mkdir(d + "/pd")
+  await writeFile(d + "/pd/x", "x")
+  console.log("dir=" + (await readdir(d + "/pd")).join(","))
+  let rejected = false
+  try { await access(d + "/missing") } catch (e) { rejected = true }
+  console.log("access-missing-rejected=" + String(rejected))
+  await rm(d + "/pd", { recursive: true })
+  console.log("done")
+}
+main()

package/crates/tish/tests/fixtures/fs_parity_sync.tish

@@ -0,0 +1,20 @@
+// Issue #122: Node-compatible fs sync surface via `node:fs`. Operates under $FS_TMP.
+import { writeFileSync, readFileSync, existsSync, statSync, mkdirSync, readdirSync, renameSync, rmSync, appendFileSync, copyFileSync, constants } from "node:fs"
+import { process } from "tish:process"
+
+let d = process.env.FS_TMP
+writeFileSync(d + "/a.txt", "hi")
+appendFileSync(d + "/a.txt", "!")
+console.log("read=" + readFileSync(d + "/a.txt"))
+console.log("exists=" + String(existsSync(d + "/a.txt")) + "," + String(existsSync(d + "/no")))
+let st = statSync(d + "/a.txt")
+console.log("size=" + String(st.size) + ",file=" + String(st.isFile()) + ",dir=" + String(st.isDirectory()))
+mkdirSync(d + "/sub")
+copyFileSync(d + "/a.txt", d + "/sub/x.txt")
+console.log("dir=" + readdirSync(d + "/sub").join(","))
+renameSync(d + "/a.txt", d + "/b.txt")
+console.log("renamed=" + String(existsSync(d + "/a.txt")) + "," + String(existsSync(d + "/b.txt")))
+rmSync(d + "/sub", { recursive: true })
+console.log("rm=" + String(existsSync(d + "/sub")))
+console.log("const=" + String(constants.R_OK))
+console.log("done")

package/crates/tish/tests/fs_parity.rs

@@ -0,0 +1,103 @@
+//! Issue #122: Node `fs` parity on the bytecode VM (`tish run` default backend) — the sync
+//! surface via `node:fs` and the async `node:fs/promises` surface (await + rejection).
+
+use std::path::PathBuf;
+use std::process::Command;
+
+fn run_on(backend: &str, fixture: &str, tmp: &str) -> String {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join(fixture);
+    let out = Command::new(&tish)
+        .args([
+            "run",
+            "--backend",
+            backend,
+            "--feature",
+            "fs,process",
+            path.to_str().unwrap(),
+        ])
+        .env("FS_TMP", tmp)
+        .output()
+        .expect("spawn tish run");
+    assert!(
+        out.status.success(),
+        "tish run --backend {backend} {fixture} failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    String::from_utf8_lossy(&out.stdout).into_owned()
+}
+
+fn tmp_dir(tag: &str) -> String {
+    let nanos = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let d = std::env::temp_dir().join(format!("tish_fs_parity_{tag}_{nanos:x}"));
+    std::fs::create_dir_all(&d).unwrap();
+    d.to_str().unwrap().to_string()
+}
+
+const SYNC_EXPECTED: &str = "read=hi!\n\
+     exists=true,false\n\
+     size=3,file=true,dir=false\n\
+     dir=x.txt\n\
+     renamed=false,true\n\
+     rm=false\n\
+     const=4\n\
+     done\n";
+
+const PROMISES_EXPECTED: &str = "read=async hello\n\
+     size=11\n\
+     dir=x\n\
+     access-missing-rejected=true\n\
+     done\n";
+
+#[test]
+fn node_fs_sync_surface_on_every_backend() {
+    for backend in ["vm", "interp"] {
+        let tmp = tmp_dir(&format!("sync_{backend}"));
+        assert_eq!(
+            run_on(backend, "fs_parity_sync.tish", &tmp),
+            SYNC_EXPECTED,
+            "sync surface mismatch on {backend}"
+        );
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+}
+
+#[test]
+fn node_fs_callback_form_on_every_backend() {
+    // Node callback form `readFile(path, (err, data) => …)` on every backend (#122): native's
+    // multi-arg-closure-to-native lowering was fixed upstream, and the interpreter runs the callback
+    // at the eval level (call_func's Native arm) instead of the self-less core bridge.
+    let expected = "write-err-null=true\n\
+         read=callback data\n\
+         size=13,file=true\n\
+         unlink-err-null=true\n\
+         missing-err-set=true,data-null=true\n";
+    for backend in ["vm", "interp", "native"] {
+        let tmp = tmp_dir(&format!("cb_{backend}"));
+        assert_eq!(
+            run_on(backend, "fs_parity_callbacks.tish", &tmp),
+            expected,
+            "callback form mismatch on {backend}"
+        );
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+}
+
+#[test]
+fn node_fs_promises_surface_on_every_backend() {
+    for backend in ["vm", "interp"] {
+        let tmp = tmp_dir(&format!("prom_{backend}"));
+        assert_eq!(
+            run_on(backend, "fs_parity_promises.tish", &tmp),
+            PROMISES_EXPECTED,
+            "promises surface mismatch on {backend}"
+        );
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+}

package/crates/tish/tests/integration_test.rs

@@ -52,6 +52,28 @@ fn integration_compile_cache_dir() -> PathBuf {
     target_dir().join("integration_compile_cache")
 }
 
+/// Remove cache entries under `dir` whose name starts with `prefix` but is not part of the current
+/// generation `keep_leaf` (the current artifact may have an extension appended, e.g. `<leaf>.wasm`,
+/// so we keep anything that *starts with* `keep_leaf`). Best-effort: caps the per-fixture compile
+/// cache so a `tish` rebuild doesn't leave the previous generation behind forever. Parallel-safe —
+/// see the call site in `compile_cached`.
+fn prune_stale_cache_generations(dir: &Path, prefix: &str, keep_leaf: &str) {
+    if let Ok(rd) = std::fs::read_dir(dir) {
+        for ent in rd.flatten() {
+            let name = ent.file_name();
+            let name = name.to_string_lossy();
+            if name.starts_with(prefix) && !name.starts_with(keep_leaf) {
+                let p = ent.path();
+                if p.is_dir() {
+                    let _ = std::fs::remove_dir_all(&p);
+                } else {
+                    let _ = std::fs::remove_file(&p);
+                }
+            }
+        }
+    }
+}
+
 /// Match `tish build` with no `--feature`: link every capability compiled into this `tish` binary.
 fn native_build_features_for_integration_test() -> Vec<String> {
     let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
@@ -170,6 +192,14 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
     // Include `backend` in the leaf name so nested cargo bin names never collide across backends.
     let leaf = format!("{}__{}__{}", stem, backend, hash8);
 
+    // Cap the cache: `hash8` mixes in the `tish` binary's mtime, so every recompile of `tish`
+    // orphans the previous generation of THIS (stem, backend). Drop those stale siblings now, so the
+    // cache holds ~one generation per fixture instead of growing without bound across rebuilds
+    // (it reached 14 GB in one session and exhausted the disk). Safe under parallel `nextest`: every
+    // live process for this (stem, backend) computes the SAME `hash8`, so only genuinely-stale
+    // generations (a different hash) are removed, never an artifact a concurrent run is using.
+    prune_stale_cache_generations(&cache_base, &format!("{}__{}__", stem, backend), &leaf);
+
     let (artifact_path, compile_args): (PathBuf, Vec<OsString>) = match backend {
         "native" => {
             let ext = if cfg!(target_os = "windows") {
@@ -588,6 +618,46 @@ fn test_import_alias() {
     }
 }
 
+/// #305: re-export — `export { foo, bar as inc } from "./dep"` and `export * from "./dep"` in a
+/// middle module, consumed by a named import and a namespace import in the entry. Identical across
+/// the interpreter and the VM (native/cranelift/js verified via the bundle path).
+#[test]
+fn test_reexport() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let path = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("reexport.tish");
+    if !path.exists() {
+        return;
+    }
+    let expected = "42\n42\n1.0\n42\n";
+    for backend_args in [vec!["run"], vec!["run", "--backend", "vm"]] {
+        let mut args = backend_args.clone();
+        args.push(path.to_string_lossy().to_string().leak());
+        let out = Command::new(&bin)
+            .args(&args)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish binary");
+        assert!(
+            out.status.success(),
+            "reexport.tish ({:?}) failed: stderr={}",
+            backend_args,
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "reexport output mismatch on backend {:?}",
+            backend_args
+        );
+    }
+}
+
 /// Combined validation: async/await + Promise + setTimeout + multiple HTTP requests.
 /// #97: a module's non-exported top-level bindings stay private — a same-named binding in
 /// another module must not overwrite them (runtime), and the `--target js` bundle must not
@@ -1376,6 +1446,16 @@ fn test_mvp_programs_native() {
     let combined = combined_mvp_native_inputs_hash(&paths);
     let cache_dir = mvp_native_batch_cache_dir(combined);
     let _ = std::fs::create_dir_all(&cache_dir);
+    // Cap the native batch cache: a new combined hash (a codegen / inference / source change) orphans
+    // the previous `native_many/<hash>` directory, each of which holds a full nested Cargo `target/`
+    // (~GBs). Drop the stale siblings, keeping only the current generation. Only `test_mvp_programs_
+    // native` builds here, so there is no cross-process race.
+    if let (Some(parent), Some(keep)) = (
+        cache_dir.parent(),
+        cache_dir.file_name().map(|n| n.to_string_lossy().into_owned()),
+    ) {
+        prune_stale_cache_generations(parent, "", &keep);
+    }
 
     let ext = if cfg!(target_os = "windows") {
         ".exe"

package/crates/tish/tests/shortcircuit.rs

@@ -9,7 +9,7 @@ use tishlang_vm;
 
 #[test]
 fn test_and_shortcircuit_emits_jump() {
-    let source = "let x = null; let y = x != null && x.foo;";
+    let source = "let x = null; let y = x !== null && x.foo;";
     let program = parse(source).expect("parse");
     let chunk = compile_unoptimized(&program).expect("compile");
     let code = &chunk.code;
@@ -22,7 +22,7 @@ fn test_and_shortcircuit_emits_jump() {
 
 #[test]
 fn test_and_shortcircuit_runs_unoptimized() {
-    let source = "let x = null; let y = x != null && x.foo;";
+    let source = "let x = null; let y = x !== null && x.foo;";
     let program = parse(source).expect("parse");
     let chunk = compile_unoptimized(&program).expect("compile");
     let result = tishlang_vm::run(&chunk);
@@ -35,7 +35,7 @@ fn test_and_shortcircuit_runs_unoptimized() {
 
 #[test]
 fn test_and_shortcircuit_runs_optimized() {
-    let source = "let x = null; let y = x != null && x.foo;";
+    let source = "let x = null; let y = x !== null && x.foo;";
     let program = parse(source).expect("parse");
     let program = tishlang_opt::optimize(&program);
     let chunk = tishlang_bytecode::compile(&program).expect("compile");

package/crates/tish_ast/src/ast.rs

@@ -156,6 +156,18 @@ pub enum ExportDeclaration {
     Named(Box<Statement>),
     /// export default expr
     Default(Expr),
+    /// Re-export from another module (#305):
+    ///   `export { foo, bar as inc } from "./m"`  -> specifiers, all=false, from=Some
+    ///   `export * from "./m"`                    -> specifiers=[], all=true, from=Some
+    ///   `export { a, b as c }`                   -> specifiers, all=false, from=None (#415 —
+    ///                                               a LOCAL named export of already-declared bindings)
+    /// Specifiers reuse `ImportSpecifier::Named` (`{ a as b }`).
+    ReExport {
+        specifiers: Vec<ImportSpecifier>,
+        all: bool,
+        from: Option<Arc<str>>,
+        span: Span,
+    },
 }
 
 #[derive(Debug, Clone)]
@@ -163,6 +175,64 @@ pub struct Program {
     pub statements: Vec<Statement>,
 }
 
+/// #469: adopt a Go/Rust/Swift-style `main` entry point.
+///
+/// tish runs top-level statements (JS module semantics), so `fn main() { … }` on its own defines a
+/// function that is never called — a footgun for devs coming from compiled languages (the native
+/// server case: `fn main() { serve(...) }` silently exits). This appends a synthetic `main()`
+/// invocation to the ENTRY program's top-level statements so a defined `main` actually runs: top-level
+/// statements still execute first (module init), then `main`.
+///
+/// Deliberately conservative to avoid a double-invocation: it fires ONLY when a top-level `main`
+/// function is declared AND the program does not already invoke `main()` itself at top level (the
+/// JS-habit `fn main(){…}; main()` shape). This must be applied to the entry module only (not imported
+/// modules) and identically for every backend — call it from `merge_modules` so interp/vm/native/js
+/// stay consistent by construction.
+///
+/// The synthetic call is a plain `main()` (never `await main()`), even for `async fn main`: a blocking
+/// server main never returns anyway, and the interpreter cannot `await` a user async function's result
+/// (a separate pre-existing gap), so an unwrapped call is the one form that behaves identically on
+/// every backend.
+///
+/// Note: this is a tish-specific divergence from JS/node (node does not auto-call `main`); test it via
+/// interp==vm==native cross-checks, and pair any `.tish` fixture with a `.js` that calls `main()`
+/// explicitly so the node reference matches.
+pub fn append_main_entry(statements: &mut Vec<Statement>) {
+    // A top-level `fn main` / `async fn main` declaration.
+    let has_main = statements.iter().any(|s| {
+        matches!(s, Statement::FunDecl { name, .. } if &**name == "main")
+    });
+    if !has_main {
+        return;
+    }
+    // Already invoked at top level? Then the user is driving it — don't double-call.
+    fn is_main_call(expr: &Expr) -> bool {
+        match expr {
+            Expr::Call { callee, .. } => {
+                matches!(callee.as_ref(), Expr::Ident { name, .. } if &**name == "main")
+            }
+            Expr::Await { operand, .. } => is_main_call(operand),
+            _ => false,
+        }
+    }
+    let already_called = statements
+        .iter()
+        .any(|s| matches!(s, Statement::ExprStmt { expr, .. } if is_main_call(expr)));
+    if already_called {
+        return;
+    }
+    let span = Span::default();
+    let call = Expr::Call {
+        callee: Box::new(Expr::Ident {
+            name: Arc::from("main"),
+            span,
+        }),
+        args: Vec::new(),
+        span,
+    };
+    statements.push(Statement::ExprStmt { expr: call, span });
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum Statement {
     Block {
@@ -221,6 +291,16 @@ pub enum Statement {
         body: Box<Statement>,
         span: Span,
     },
+    /// `for (let k in object)` — iterates the object's own enumerable keys (JS `for-in` semantics).
+    /// Distinct from `ForOf` (which iterates values). Kept as a first-class node so every backend
+    /// enumerates keys consistently and `tish fmt` round-trips `for-in`.
+    ForIn {
+        name: Arc<str>,
+        name_span: Span,
+        object: Expr,
+        body: Box<Statement>,
+        span: Span,
+    },
     Return {
         value: Option<Expr>,
         span: Span,
@@ -421,6 +501,9 @@ pub enum Expr {
     },
     /// Arrow function: (params) => body
     ArrowFunction {
+        /// `true` for `async () => …` (#428) — the body runs in async context (`await` allowed) and
+        /// the JS target emits an `async` prefix. Non-async arrows have `async_: false`.
+        async_: bool,
         params: Vec<FunParam>,
         body: ArrowBody,
         span: Span,
@@ -643,6 +726,7 @@ impl Statement {
             | Statement::While { span, .. }
             | Statement::For { span, .. }
             | Statement::ForOf { span, .. }
+            | Statement::ForIn { span, .. }
             | Statement::Return { span, .. }
             | Statement::Break { span, .. }
             | Statement::Continue { span, .. }

package/crates/tish_builtins/Cargo.toml

@@ -11,6 +11,7 @@ repository = { workspace = true }
 ahash = "0.8.11"
 indexmap = "2"
 rand = "0.10.1"
+unicode-normalization = "0.1.25"
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 
 [features]