@tishlang/tish 2.10.1 → 2.16.13

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/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "2.10.1"
+version = "2.16.13"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/cli_help.rs

@@ -563,6 +563,14 @@ pub(crate) struct BuildArgs {
     /// For `--target js`: `bundle` (default) merges all modules into one file; `esm` emits one `.js` per `.tish` module with real `import`/`export` (so `-o` is a directory) for Vite/Rollup tree-shaking.
     #[arg(long, default_value = "bundle", value_name = "FORMAT", help_heading = "Options")]
     pub format: String,
+    /// For `--target js --format esm`: package the JSX runtime (`h`/`Fragment`) is auto-imported from when a module uses JSX without importing them (default `lattish`).
+    #[arg(
+        long = "jsx-import-source",
+        default_value = "lattish",
+        value_name = "PKG",
+        help_heading = "Options"
+    )]
+    pub jsx_import_source: String,
     /// 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>,
@@ -594,6 +602,14 @@ pub(crate) struct CompileModuleArgs {
     /// Disable AST optimizations (forced on when a source map is emitted).
     #[arg(long, help_heading = "Options")]
     pub no_optimize: bool,
+    /// Package the JSX runtime (`h`/`Fragment`) is auto-imported from when a module uses JSX without importing them (default `lattish`).
+    #[arg(
+        long = "jsx-import-source",
+        default_value = "lattish",
+        value_name = "PKG",
+        help_heading = "Options"
+    )]
+    pub jsx_import_source: String,
     /// Entry `.tish` file to compile (only this file is read; dependencies are left to the bundler).
     #[arg(required = true, value_name = "FILE", help_heading = "Arguments")]
     pub file: String,

package/crates/tish/src/main.rs

@@ -137,6 +137,7 @@ fn main() {
                 a.ios_triple.as_deref(),
                 &a.crate_type,
                 &a.format,
+                &a.jsx_import_source,
             )
         }
         Some(Commands::CompileModule(a)) => compile_module(&a),
@@ -544,6 +545,7 @@ fn compile_to_js(
     optimize: bool,
     source_map: bool,
     format: &str,
+    jsx_import_source: &str,
 ) -> Result<(), String> {
     if format != "bundle" && format != "esm" {
         return Err(format!(
@@ -574,7 +576,14 @@ fn compile_to_js(
         }
     });
     if format == "esm" {
-        return compile_to_js_esm(input_path, output_path, optimize, source_map, project_root);
+        return compile_to_js_esm(
+            input_path,
+            output_path,
+            optimize,
+            source_map,
+            project_root,
+            jsx_import_source,
+        );
     }
     let out_path = Path::new(output_path);
     let out_path = if out_path.extension().is_none()
@@ -656,6 +665,7 @@ fn compile_to_js_esm(
     optimize: bool,
     source_map: bool,
     project_root: Option<&Path>,
+    jsx_import_source: &str,
 ) -> Result<(), String> {
     if source_map {
         return Err(
@@ -671,8 +681,9 @@ fn compile_to_js_esm(
                 .into(),
         );
     }
-    let modules = tishlang_compile_js::compile_project_esm(input_path, project_root, optimize)
-        .map_err(|e| format!("{}", e))?;
+    let modules =
+        tishlang_compile_js::compile_project_esm(input_path, project_root, optimize, jsx_import_source)
+            .map_err(|e| format!("{}", e))?;
     let out_dir = Path::new(output_path);
     fs::create_dir_all(out_dir)
         .map_err(|e| format!("Cannot create output directory {}: {}", out_dir.display(), e))?;
@@ -753,6 +764,7 @@ fn compile_module(args: &CompileModuleArgs) -> Result<(), String> {
         optimize,
         import_rewrite,
         want_map,
+        &args.jsx_import_source,
     )
     .map_err(|e| format!("{}", e))?;
 
@@ -781,6 +793,7 @@ fn build_file(
     ios_triple: Option<&str>,
     crate_type: &str,
     format: &str,
+    jsx_import_source: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path = Path::new(input_path)
@@ -790,7 +803,14 @@ fn build_file(
     let is_js = input_path.extension().map(|e| e == "js") == Some(true);
 
     if target == "js" {
-        return compile_to_js(&input_path, output_path, optimize, source_map, format);
+        return compile_to_js(
+            &input_path,
+            output_path,
+            optimize,
+            source_map,
+            format,
+            jsx_import_source,
+        );
     }
 
     // `wasm-gpu` (#277): same pipeline as `wasm` but builds the `--features gpu` WebGPU runtime and

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
@@ -846,6 +916,75 @@ fn test_compile_module_no_source_map_prints_raw_js() {
     );
 }
 
+/// #291: `compile-module` auto-imports the JSX runtime (`h` / `Fragment`) when a module uses JSX
+/// but doesn't import them itself, so per-module ESM output doesn't throw `ReferenceError` at load.
+/// `--jsx-import-source` overrides the runtime package.
+#[test]
+fn test_compile_module_jsx_auto_imports_runtime() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let widget = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("vite_hmr")
+        .join("widget.tish");
+    if !widget.exists() {
+        return;
+    }
+    // Default runtime source (`lattish`), Vite-dev so the specifier stays bare.
+    let out = Command::new(&bin)
+        .args(["compile-module"])
+        .arg(&widget)
+        .args([
+            "--target",
+            "js",
+            "--format",
+            "esm",
+            "--vite-dev",
+            "--no-source-map",
+        ])
+        .current_dir(workspace_root())
+        .output()
+        .expect("run compile-module");
+    assert!(
+        out.status.success(),
+        "compile-module failed: stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("import { h, Fragment } from \"lattish\";"),
+        "JSX module with a fragment auto-imports both h and Fragment:\n{stdout}"
+    );
+
+    // Custom runtime source via --jsx-import-source.
+    let out2 = Command::new(&bin)
+        .args(["compile-module"])
+        .arg(&widget)
+        .args([
+            "--target",
+            "js",
+            "--format",
+            "esm",
+            "--vite-dev",
+            "--no-source-map",
+            "--jsx-import-source",
+            "@tishlang/lattish",
+        ])
+        .current_dir(workspace_root())
+        .output()
+        .expect("run compile-module");
+    assert!(out2.status.success());
+    let stdout2 = String::from_utf8_lossy(&out2.stdout);
+    assert!(
+        stdout2.contains("from \"@tishlang/lattish\";"),
+        "--jsx-import-source overrides the runtime package:\n{stdout2}"
+    );
+}
+
 /// Ignored: tishlang_eval::run() does not run the event loop.
 #[test]
 #[cfg(feature = "http")]
@@ -1307,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_ast/src/ast.rs

@@ -156,6 +156,16 @@ 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
+    ///   `export * from "./m"`                    -> specifiers=[], all=true
+    /// Specifiers reuse `ImportSpecifier::Named` (`{ a as b }`).
+    ReExport {
+        specifiers: Vec<ImportSpecifier>,
+        all: bool,
+        from: Arc<str>,
+        span: Span,
+    },
 }
 
 #[derive(Debug, Clone)]