@tishlang/tish-lsp 2.16.13 → 2.36.0

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/fixtures/process_capture.tish

@@ -0,0 +1,16 @@
+// Issue #475: process.execCapture / execFileCapture return { code, stdout, stderr }.
+import { execFileCapture, execCapture } from "tish:process"
+
+let ok = execFileCapture("echo", ["hi"])
+console.log("ok=" + ok.code + "," + ok.stdout.trim() + "," + (ok.stderr === ""))
+
+let bad = execFileCapture("false", [])
+console.log("bad=" + bad.code)
+
+let miss = execFileCapture("/no/such/prog/xyz", [])
+console.log("miss=" + miss.code + "," + (miss.stderr !== ""))
+
+let shell = execCapture("echo a; echo b 1>&2")
+console.log("shell=" + shell.code + "," + shell.stdout.trim() + "," + shell.stderr.trim())
+
+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/process_capture.rs

@@ -0,0 +1,40 @@
+//! Issue #475: `process.execCapture` / `execFileCapture` return `{ code, stdout, stderr }` identically
+//! on every backend (interpreter, bytecode VM, native AOT).
+
+use std::path::PathBuf;
+use std::process::Command;
+
+fn run_on(backend: &str) -> String {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join("process_capture.tish");
+    let out = Command::new(&tish)
+        .args([
+            "run",
+            "--backend",
+            backend,
+            "--feature",
+            "process",
+            path.to_str().unwrap(),
+        ])
+        .output()
+        .expect("spawn tish run");
+    assert!(
+        out.status.success(),
+        "tish run --backend {backend} process_capture.tish failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    String::from_utf8_lossy(&out.stdout).into_owned()
+}
+
+const EXPECTED: &str = "ok=0,hi,true\nbad=1\nmiss=-1,true\nshell=0,a,b\ndone\n";
+
+#[test]
+#[cfg(unix)]
+fn exec_capture_on_every_backend() {
+    for backend in ["vm", "interp", "native"] {
+        assert_eq!(run_on(backend), EXPECTED, "exec-capture mismatch on {backend}");
+    }
+}

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

@@ -157,13 +157,15 @@ pub enum ExportDeclaration {
     /// export default expr
     Default(Expr),
     /// Re-export from another module (#305):
-    ///   `export { foo, bar as inc } from "./m"`  -> specifiers, all=false
-    ///   `export * from "./m"`                    -> specifiers=[], all=true
+    ///   `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: Arc<str>,
+        from: Option<Arc<str>>,
         span: Span,
     },
 }
@@ -173,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 {
@@ -231,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,
@@ -431,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,
@@ -653,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]