@tishlang/tish 2.8.0 → 2.9.0

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "2.8.0"
+version = "2.9.0"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }
@@ -64,3 +64,4 @@ mimalloc = { version = "0.1", optional = true }
 
 [dev-dependencies]
 rayon = "1.11"
+tempfile = "3"

package/crates/tish/src/cli_help.rs

@@ -560,6 +560,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,
+    /// 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,
     /// 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>,

package/crates/tish/src/main.rs

@@ -136,6 +136,7 @@ fn main() {
                 a.source_map,
                 a.ios_triple.as_deref(),
                 &a.crate_type,
+                &a.format,
             )
         }
         Some(Commands::DumpAst {
@@ -541,7 +542,14 @@ fn compile_to_js(
     output_path: &str,
     optimize: bool,
     source_map: bool,
+    format: &str,
 ) -> Result<(), String> {
+    if format != "bundle" && format != "esm" {
+        return Err(format!(
+            "Unknown --format '{}' for --target js. Use 'bundle' (single merged file) or 'esm' (one file per module).",
+            format
+        ));
+    }
     if source_map && optimize {
         return Err(
             "tish build --target js --source-map requires --no-optimize (mappings follow unmerged statement order)."
@@ -564,6 +572,9 @@ fn compile_to_js(
             Some(p)
         }
     });
+    if format == "esm" {
+        return compile_to_js_esm(input_path, output_path, optimize, source_map, project_root);
+    }
     let out_path = Path::new(output_path);
     let out_path = if out_path.extension().is_none()
         || out_path.extension() == Some(std::ffi::OsStr::new(""))
@@ -635,6 +646,63 @@ fn compile_to_js(
     Ok(())
 }
 
+/// `--target js --format esm`: emit one `.js` per `.tish` module under the output directory,
+/// preserving the source tree layout, with real ES `import`/`export` so a bundler (Vite/Rollup)
+/// can tree-shake and code-split. `-o` is treated as a directory.
+fn compile_to_js_esm(
+    input_path: &Path,
+    output_path: &str,
+    optimize: bool,
+    source_map: bool,
+    project_root: Option<&Path>,
+) -> Result<(), String> {
+    if source_map {
+        return Err(
+            "tish build --target js --format esm does not yet support --source-map; use --format bundle for source maps."
+                .into(),
+        );
+    }
+    if input_path.extension().map(|e| e == "jsx") == Some(true)
+        || input_path.extension().map(|e| e == "js") == Some(true)
+    {
+        return Err(
+            "tish build --target js --format esm is only supported for .tish entry files; use --format bundle for .jsx / .js inputs."
+                .into(),
+        );
+    }
+    let modules = tishlang_compile_js::compile_project_esm(input_path, project_root, optimize)
+        .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))?;
+    for module in &modules {
+        let out = out_dir.join(&module.relative_path);
+        if let Some(parent) = out.parent() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("Cannot create output directory {}: {}", parent.display(), e))?;
+        }
+        fs::write(&out, &module.js)
+            .map_err(|e| format!("Cannot write {}: {}", out.display(), e))?;
+    }
+    println!("Built {} module(s) to {}", modules.len(), out_dir.display());
+    // The entry may sit in a subtree (the output is rooted at the directory common to every module,
+    // which can be an ancestor of the entry when deps live in sibling packages / node_modules), so
+    // point the user at the actual entry `.js` they should hand to a bundler.
+    let entry_js = input_path
+        .canonicalize()
+        .unwrap_or_else(|_| input_path.to_path_buf())
+        .with_extension("js");
+    if let Some(entry_rel) = modules
+        .iter()
+        .filter(|m| entry_js.ends_with(&m.relative_path))
+        .max_by_key(|m| m.relative_path.components().count())
+        .map(|m| m.relative_path.clone())
+    {
+        println!("Entry: {}", out_dir.join(entry_rel).display());
+    }
+    Ok(())
+}
+
 #[allow(clippy::vec_init_then_push, clippy::too_many_arguments)] // build_file maps CLI build flags 1:1
 fn build_file(
     input_path: &str,
@@ -646,6 +714,7 @@ fn build_file(
     source_map: bool,
     ios_triple: Option<&str>,
     crate_type: &str,
+    format: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path = Path::new(input_path)
@@ -655,7 +724,7 @@ 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);
+        return compile_to_js(&input_path, output_path, optimize, source_map, format);
     }
 
     // `wasm-gpu` (#277): same pipeline as `wasm` but builds the `--features gpu` WebGPU runtime and

package/crates/tish/tests/integration_test.rs

@@ -673,6 +673,71 @@ fn test_module_private_binding_isolation() {
     }
 }
 
+/// #282: `--target js --format esm` emits one ES module per `.tish` file with real
+/// `import`/`export`, so two modules exporting the same name (`export fn activate`) keep separate
+/// scopes instead of colliding. The merge-based pipeline (interp/VM/native and `--format bundle`)
+/// still flattens both into one scope — a separately-tracked collision — so this test pins the ESM
+/// JS target, which is the path that isolates them. Builds the module tree and runs it under Node.
+#[test]
+fn test_js_esm_export_collision() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let main = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("export_collision")
+        .join("main.tish");
+    if !main.exists() {
+        return;
+    }
+    let expected = "ab\n";
+
+    // JS ESM target: build the module tree, then load + run the entry under Node.
+    let node_available = Command::new("node")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if node_available {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let out_dir = tmp.path().join("esm_out");
+        let build = Command::new(&bin)
+            .args(["build"])
+            .arg(&main)
+            .args(["-o"])
+            .arg(&out_dir)
+            .args(["--target", "js", "--format", "esm"])
+            .current_dir(workspace_root())
+            .output()
+            .expect("build esm");
+        assert!(
+            build.status.success(),
+            "esm build failed: stderr={}",
+            String::from_utf8_lossy(&build.stderr)
+        );
+        let entry = out_dir.join("main.js");
+        assert!(entry.exists(), "esm entry {} not emitted", entry.display());
+        let out = Command::new("node")
+            .arg(&entry)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run node");
+        assert!(
+            out.status.success(),
+            "esm JS run failed (collision not isolated?): stderr={}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "esm export_collision mismatch on JS ESM target"
+        );
+    }
+}
+
 /// Ignored: tishlang_eval::run() does not run the event loop.
 #[test]
 #[cfg(feature = "http")]