@tishlang/tish 2.8.0 → 2.9.0

package/crates/tish_compile_js/Cargo.toml

@@ -16,3 +16,6 @@ tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_ui = { path = "../tish_ui", version = ">=0.1", default-features = false, features = ["compiler"] }
+
+[dev-dependencies]
+tempfile = "3"

package/crates/tish_compile_js/src/codegen.rs

@@ -4,16 +4,32 @@ use std::path::{Path, PathBuf};
 
 use sourcemap::SourceMapBuilder;
 use tishlang_ast::{
-    ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr,
-    FunParam, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, UnaryOp,
+    ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
+    ExportDeclaration, Expr, FunParam, ImportSpecifier, Literal, LogicalAssignOp, MemberProp,
+    ObjectProp, Program, Statement, UnaryOp,
 };
 
 use crate::error::CompileError;
 
+/// JS output mode. `Bundle` flattens every module into one file (imports/exports are resolved away
+/// by `merge_modules`). `Esm` emits one file per module with real ES `import`/`export` statements so
+/// a bundler (Vite/Rollup) can tree-shake and code-split. See issue #177's sibling, #282.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum EmitMode {
+    Bundle,
+    Esm,
+}
+
 struct Codegen {
     output: String,
     indent: usize,
     in_async: bool,
+    emit_mode: EmitMode,
+    /// ESM only: the absolute path of the module being emitted (the importer), used to rewrite
+    /// relative/bare import specifiers to sibling `.js` output paths.
+    module_path: PathBuf,
+    /// ESM only: the project root, so import targets can be located relative to the output tree.
+    project_root: PathBuf,
 }
 
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
@@ -31,6 +47,20 @@ impl Codegen {
             output: String::new(),
             indent: 0,
             in_async: false,
+            emit_mode: EmitMode::Bundle,
+            module_path: PathBuf::new(),
+            project_root: PathBuf::new(),
+        }
+    }
+
+    fn new_esm(module_path: PathBuf, project_root: PathBuf) -> Self {
+        Self {
+            output: String::new(),
+            indent: 0,
+            in_async: false,
+            emit_mode: EmitMode::Esm,
+            module_path,
+            project_root,
         }
     }
 
@@ -398,9 +428,18 @@ impl Codegen {
                 }
                 self.writeln("}");
             }
-            Statement::Import { .. } | Statement::Export { .. } => {
-                // Resolved away by merge_modules
-            }
+            Statement::Import {
+                specifiers, from, ..
+            } => match self.emit_mode {
+                // Bundle: resolved away by merge_modules (the dep bindings are already inlined).
+                EmitMode::Bundle => {}
+                EmitMode::Esm => self.emit_esm_import(specifiers, from.as_ref())?,
+            },
+            Statement::Export { declaration, .. } => match self.emit_mode {
+                // Bundle: merge_modules unwrapped exports into plain top-level declarations.
+                EmitMode::Bundle => {}
+                EmitMode::Esm => self.emit_esm_export(declaration)?,
+            },
             Statement::TypeAlias { .. }
             | Statement::DeclareVar { .. }
             | Statement::DeclareFun { .. } => {}
@@ -859,6 +898,172 @@ impl Codegen {
             CallArg::Spread(e) => Ok(format!("...{}", self.emit_expr(e)?)),
         }
     }
+
+    /// Emit a real ES `import` statement (ESM mode), rewriting the `.tish` specifier to its sibling
+    /// `.js` output path. Named and namespace specifiers can't share one statement, so a module that
+    /// imports both is split across two lines.
+    fn emit_esm_import(
+        &mut self,
+        specifiers: &[ImportSpecifier],
+        from: &str,
+    ) -> Result<(), CompileError> {
+        let spec = rewrite_import_to_js(from, &self.module_path, &self.project_root)?;
+        let mut named: Vec<String> = Vec::new();
+        let mut default_local: Option<String> = None;
+        let mut namespace_local: Option<String> = None;
+        for s in specifiers {
+            match s {
+                ImportSpecifier::Named { name, alias, .. } => match alias {
+                    Some(a) => named.push(format!(
+                        "{} as {}",
+                        Self::escape_ident(name.as_ref()),
+                        Self::escape_ident(a.as_ref())
+                    )),
+                    None => named.push(Self::escape_ident(name.as_ref())),
+                },
+                ImportSpecifier::Default { name, .. } => {
+                    default_local = Some(Self::escape_ident(name.as_ref()))
+                }
+                ImportSpecifier::Namespace { name, .. } => {
+                    namespace_local = Some(Self::escape_ident(name.as_ref()))
+                }
+            }
+        }
+        if let Some(ns) = namespace_local {
+            match &default_local {
+                Some(def) => self.writeln(&format!("import {}, * as {} from \"{}\";", def, ns, spec)),
+                None => self.writeln(&format!("import * as {} from \"{}\";", ns, spec)),
+            }
+            if !named.is_empty() {
+                self.writeln(&format!("import {{ {} }} from \"{}\";", named.join(", "), spec));
+            }
+        } else if !named.is_empty() {
+            match &default_local {
+                Some(def) => self.writeln(&format!(
+                    "import {}, {{ {} }} from \"{}\";",
+                    def,
+                    named.join(", "),
+                    spec
+                )),
+                None => self.writeln(&format!("import {{ {} }} from \"{}\";", named.join(", "), spec)),
+            }
+        } else if let Some(def) = &default_local {
+            self.writeln(&format!("import {} from \"{}\";", def, spec));
+        } else {
+            self.writeln(&format!("import \"{}\";", spec));
+        }
+        Ok(())
+    }
+
+    /// Emit a real ES `export` (ESM mode). Named exports prefix the inner declaration with the
+    /// `export` keyword; default exports become `export default <expr>;`.
+    fn emit_esm_export(&mut self, declaration: &ExportDeclaration) -> Result<(), CompileError> {
+        match declaration {
+            ExportDeclaration::Named(inner) => {
+                // Emit the inner declaration, then splice the `export ` keyword in front of it. The
+                // declaration's first line is `<indent><keyword> …`, so the keyword goes right after
+                // the leading indent.
+                let start = self.output.len();
+                self.emit_statement(inner)?;
+                let insert_at = start + self.indent_str().len();
+                if insert_at <= self.output.len() {
+                    self.output.insert_str(insert_at, "export ");
+                }
+            }
+            ExportDeclaration::Default(e) => {
+                let v = self.emit_expr(e)?;
+                self.writeln(&format!("export default {};", v));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Rewrite a Tish import specifier to the ESM `.js` specifier that the emitted module tree uses.
+/// Relative specifiers keep their shape (the output tree mirrors the source tree) with `.tish`
+/// swapped to `.js`. Bare specifiers are resolved to a `.tish` file and re-expressed as a relative
+/// path from the importer's output location. Native imports (`tish:*`, `cargo:*`, …) are rejected.
+fn rewrite_import_to_js(
+    spec: &str,
+    importer_abs: &Path,
+    project_root: &Path,
+) -> Result<String, CompileError> {
+    if tishlang_compile::is_native_import(spec) {
+        return Err(CompileError {
+            message: format!(
+                "Native module import '{}' is not supported with --target js --format esm (native modules require --target native).",
+                spec
+            ),
+        });
+    }
+    if spec.starts_with("./") || spec.starts_with("../") {
+        return Ok(spec_ext_to_js(spec));
+    }
+    // Bare specifier (e.g. a package): resolve to its `.tish` file and express it relative to the
+    // importer's output `.js`, so the emitted module tree stays self-contained.
+    let from_dir = importer_abs.parent().unwrap_or_else(|| Path::new("."));
+    let dep = tishlang_compile::resolve_bare_spec(spec, from_dir, project_root).ok_or_else(|| {
+        CompileError {
+            message: format!(
+                "Cannot resolve package import '{}' for --format esm. Only relative imports and packages resolvable to a .tish entry are supported; use --format bundle otherwise.",
+                spec
+            ),
+        }
+    })?;
+    // The emitted module tree mirrors the real source tree under a common base (see
+    // `compile_project_esm`), so the relative path between two *absolute* canonical paths is the
+    // same as the relative path between their emitted `.js` files. This holds whether the dependency
+    // lives under the entry's project root, in a sibling package, or in `node_modules` (#282), so no
+    // "outside the project root" rejection is needed.
+    let dep_canon = dep.canonicalize().unwrap_or(dep);
+    let importer_canon = importer_abs
+        .canonicalize()
+        .unwrap_or_else(|_| importer_abs.to_path_buf());
+    let importer_dir = importer_canon.parent().unwrap_or_else(|| Path::new("/"));
+    Ok(spec_ext_to_js(&relative_specifier(importer_dir, &dep_canon)))
+}
+
+/// Swap a relative import specifier's `.tish` extension for `.js` (or append `.js` when extensionless).
+/// Already-`.js`/`.mjs` specifiers pass through unchanged.
+fn spec_ext_to_js(spec: &str) -> String {
+    if let Some(base) = spec.strip_suffix(".tish") {
+        format!("{}.js", base)
+    } else if spec.ends_with(".js") || spec.ends_with(".mjs") {
+        spec.to_string()
+    } else {
+        format!("{}.js", spec)
+    }
+}
+
+/// Build a `./`-prefixed relative module specifier from `from_dir` to `to_file`, compared
+/// component-wise, using `/` separators as ESM requires. Both paths must be expressed the same way
+/// (both absolute canonical, or both relative to the same base) so the shared prefix lines up.
+fn relative_specifier(from_dir: &Path, to_file: &Path) -> String {
+    let from: Vec<String> = from_dir
+        .components()
+        .map(|c| c.as_os_str().to_string_lossy().into_owned())
+        .collect();
+    let to: Vec<String> = to_file
+        .components()
+        .map(|c| c.as_os_str().to_string_lossy().into_owned())
+        .collect();
+    let mut i = 0;
+    while i < from.len() && i < to.len() && from[i] == to[i] {
+        i += 1;
+    }
+    let mut parts: Vec<String> = Vec::new();
+    for _ in i..from.len() {
+        parts.push("..".to_string());
+    }
+    for c in &to[i..] {
+        parts.push(c.clone());
+    }
+    let joined = parts.join("/");
+    if joined.starts_with("..") {
+        joined
+    } else {
+        format!("./{}", joined)
+    }
 }
 
 /// Compile a single program (no imports) to JavaScript. JSX lowers to `h` / `Fragment` (Lattish).
@@ -987,3 +1192,103 @@ pub fn compile_project_with_jsx(
     };
     Ok(compile_project_js_inner(entry_path, project_root, optimize, false, &out_name)?.js)
 }
+
+/// One emitted ES module: where it goes (relative to the output directory, mirroring the source
+/// tree) and its JavaScript. See [`compile_project_esm`].
+#[derive(Debug, Clone)]
+pub struct EmittedJsModule {
+    pub relative_path: PathBuf,
+    pub js: String,
+}
+
+/// Compile a project to **ES modules** — one `.js` file per `.tish` module, with real `import` /
+/// `export` statements (issue #282). Unlike [`compile_project_with_jsx`], modules are NOT merged, so
+/// each keeps its own scope (no exported-name collisions) and a bundler can tree-shake the graph.
+/// Output paths mirror the source tree relative to the deepest directory common to every module in
+/// the graph (so sibling-package / `node_modules` deps are included), with `.tish` swapped to `.js`.
+pub fn compile_project_esm(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    optimize: bool,
+) -> Result<Vec<EmittedJsModule>, CompileError> {
+    let modules = tishlang_compile::resolve_project(entry_path, project_root)
+        .map_err(|e| CompileError { message: e })?;
+    tishlang_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
+    // Resolution root: where bare-specifier / `node_modules` lookups are anchored. Unchanged
+    // semantics — only used for `resolve_bare_spec`, which itself walks upward from each importer.
+    let res_root = project_root
+        .map(Path::to_path_buf)
+        .or_else(|| entry_path.parent().map(Path::to_path_buf))
+        .unwrap_or_else(|| PathBuf::from("."));
+    let res_root_canon = res_root.canonicalize().unwrap_or(res_root);
+
+    // Output layout base: the deepest directory that is an ancestor of *every* module in the graph.
+    // The output tree mirrors the real filesystem beneath this base, so a dependency in a sibling
+    // package or `node_modules` (#282 follow-up) gets a stable home in the output instead of being
+    // rejected for living "outside the project root". For a self-contained project this is just the
+    // project root, so existing layouts are unchanged.
+    let mod_canons: Vec<PathBuf> = modules
+        .iter()
+        .map(|m| m.path.canonicalize().unwrap_or_else(|_| m.path.clone()))
+        .collect();
+    let layout_base = common_ancestor_dir(&mod_canons);
+
+    let mut out = Vec::with_capacity(modules.len());
+    for (module, mod_canon) in modules.iter().zip(mod_canons.iter()) {
+        let rel = mod_canon
+            .strip_prefix(&layout_base)
+            .map(Path::to_path_buf)
+            .unwrap_or_else(|_| {
+                // `layout_base` is a common ancestor of every module, so this is unreachable; fall
+                // back to the bare file name rather than panicking if a path is unexpectedly absolute.
+                PathBuf::from(mod_canon.file_name().unwrap_or(mod_canon.as_os_str()))
+            });
+        let rel_js = rel.with_extension("js");
+        let program = if optimize {
+            tishlang_opt::optimize(&module.program)
+        } else {
+            module.program.clone()
+        };
+        let mut gen = Codegen::new_esm(mod_canon.clone(), res_root_canon.clone());
+        gen.emit_program(&program, None, None)?;
+        out.push(EmittedJsModule {
+            relative_path: rel_js,
+            js: gen.output,
+        });
+    }
+    Ok(out)
+}
+
+/// Deepest directory that is an ancestor of every given file path, compared component-wise. Used as
+/// the base of the `--format esm` output tree so modules outside the entry's project root (sibling
+/// packages, `node_modules`) still map to a stable, collision-free location. For a single file this
+/// is its parent directory; for files that share only the filesystem root it is `/`.
+fn common_ancestor_dir(files: &[PathBuf]) -> PathBuf {
+    let parent_components = |p: &Path| -> Vec<std::ffi::OsString> {
+        p.parent()
+            .unwrap_or_else(|| Path::new("/"))
+            .components()
+            .map(|c| c.as_os_str().to_os_string())
+            .collect()
+    };
+    let mut common: Vec<std::ffi::OsString> = match files.first() {
+        Some(f) => parent_components(f),
+        None => return PathBuf::from("/"),
+    };
+    for f in &files[1..] {
+        let comps = parent_components(f);
+        let mut i = 0;
+        while i < common.len() && i < comps.len() && common[i] == comps[i] {
+            i += 1;
+        }
+        common.truncate(i);
+    }
+    if common.is_empty() {
+        return PathBuf::from("/");
+    }
+    let mut base = PathBuf::new();
+    for c in &common {
+        base.push(c);
+    }
+    base
+}

package/crates/tish_compile_js/src/lib.rs

@@ -8,7 +8,8 @@ mod error;
 mod tests_jsx;
 
 pub use codegen::{
-    compile_project_with_jsx, compile_project_with_jsx_and_source_map, compile_with_jsx, JsBundle,
+    compile_project_esm, compile_project_with_jsx, compile_project_with_jsx_and_source_map,
+    compile_with_jsx, EmittedJsModule, JsBundle,
 };
 pub use error::CompileError;
 

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -4,7 +4,7 @@ mod tests {
 
     use tishlang_parser::parse;
 
-    use crate::{compile_project_with_jsx, compile_with_jsx};
+    use crate::{compile_project_esm, compile_project_with_jsx, compile_with_jsx, EmittedJsModule};
 
     #[test]
     fn lattish_jsx_emits_h_with_children_array() {
@@ -455,4 +455,188 @@ fn factory() {
         let neg = crate::compile(&parse("console.log(-1 / 0)\n").unwrap(), true).unwrap();
         assert!(neg.contains("-Infinity"), "-1/0 must emit -Infinity:\n{neg}");
     }
+
+    // ── #282: ESM module output (one file per module, real import/export) ──────────────────────
+
+    /// Write a set of `(relative_path, source)` modules into a fresh temp dir and compile the entry
+    /// in ESM mode. Returns the emitted modules keyed for easy lookup by their output relative path.
+    fn build_esm(entry: &str, modules: &[(&str, &str)]) -> Vec<EmittedJsModule> {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        for (rel, src) in modules {
+            let p = dir.join(rel);
+            if let Some(parent) = p.parent() {
+                std::fs::create_dir_all(parent).unwrap();
+            }
+            let mut f = std::fs::File::create(&p).unwrap();
+            f.write_all(src.as_bytes()).unwrap();
+            f.sync_all().unwrap();
+        }
+        compile_project_esm(&dir.join(entry), Some(dir), false).expect("compile_project_esm failed")
+    }
+
+    fn module_js<'a>(mods: &'a [EmittedJsModule], rel: &str) -> &'a str {
+        mods.iter()
+            .find(|m| m.relative_path.to_string_lossy() == rel)
+            .map(|m| m.js.as_str())
+            .unwrap_or_else(|| panic!("module {rel} not emitted; got {:?}", mods.iter().map(|m| m.relative_path.display().to_string()).collect::<Vec<_>>()))
+    }
+
+    #[test]
+    fn esm_emits_named_and_default_exports() {
+        let mods = build_esm(
+            "main.tish",
+            &[(
+                "main.tish",
+                "export const VERSION = \"1.0\"\nexport fn greet(n) { return \"hi \" + n }\nexport default greet\n",
+            )],
+        );
+        let js = module_js(&mods, "main.js");
+        assert!(js.contains("export const VERSION = \"1.0\";"), "named const export:\n{js}");
+        assert!(js.contains("export function greet "), "named fn export:\n{js}");
+        assert!(js.contains("export default greet;"), "default export:\n{js}");
+    }
+
+    #[test]
+    fn esm_rewrites_import_specifier_to_js_with_alias() {
+        let mods = build_esm(
+            "main.tish",
+            &[
+                ("dep.tish", "export const ssrH = 42\nexport fn greet(n) { return n }\n"),
+                (
+                    "main.tish",
+                    "import { ssrH as h, greet } from \"./dep.tish\"\nimport * as M from \"./dep.tish\"\nconsole.log(h)\nconsole.log(greet(M.ssrH))\n",
+                ),
+            ],
+        );
+        let js = module_js(&mods, "main.js");
+        assert!(
+            js.contains("import { ssrH as h, greet } from \"./dep.js\";"),
+            "named import with alias, .tish->.js:\n{js}"
+        );
+        assert!(js.contains("import * as M from \"./dep.js\";"), "namespace import:\n{js}");
+    }
+
+    #[test]
+    fn esm_one_file_per_module_preserves_tree() {
+        let mods = build_esm(
+            "main.tish",
+            &[
+                ("lib/util.tish", "export fn id(x) { return x }\n"),
+                ("main.tish", "import { id } from \"./lib/util.tish\"\nconsole.log(id(1))\n"),
+            ],
+        );
+        // Nested module keeps its relative path; importer points at the nested `.js`.
+        let _ = module_js(&mods, "lib/util.js");
+        let main = module_js(&mods, "main.js");
+        assert!(
+            main.contains("from \"./lib/util.js\";"),
+            "nested relative import preserved:\n{main}"
+        );
+    }
+
+    #[test]
+    fn esm_module_outside_project_root_is_emitted() {
+        // #282 follow-up: a dependency in a *sibling* package (outside the entry's project root)
+        // must still be emitted — the output tree is rooted at the directory common to all modules.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let base = tmp.path();
+        std::fs::create_dir_all(base.join("app/src")).unwrap();
+        std::fs::create_dir_all(base.join("lib")).unwrap();
+        std::fs::write(base.join("lib/util.tish"), "export fn id(x) { return x }\n").unwrap();
+        std::fs::write(
+            base.join("app/src/main.tish"),
+            "import { id } from \"../../lib/util.tish\"\nconsole.log(id(1))\n",
+        )
+        .unwrap();
+        // Project root is the entry's package (`app`); `lib/util.tish` lives outside it.
+        let mods = compile_project_esm(
+            &base.join("app/src/main.tish"),
+            Some(&base.join("app")),
+            false,
+        )
+        .expect("compile_project_esm failed for sibling dep");
+        let rels: Vec<String> = mods
+            .iter()
+            .map(|m| m.relative_path.to_string_lossy().replace('\\', "/"))
+            .collect();
+        let main_js = mods
+            .iter()
+            .find(|m| m.relative_path.to_string_lossy().replace('\\', "/").ends_with("app/src/main.js"))
+            .map(|m| m.js.clone());
+        assert!(
+            rels.iter().any(|r| r.ends_with("lib/util.js")),
+            "sibling dep emitted under common base: {:?}",
+            rels
+        );
+        assert!(
+            rels.iter().any(|r| r.ends_with("app/src/main.js")),
+            "entry emitted under its own subtree: {:?}",
+            rels
+        );
+        let main_js = main_js.expect("entry module present");
+        assert!(
+            main_js.contains("from \"../../lib/util.js\";"),
+            "relative import to sibling rewritten to .js:\n{main_js}"
+        );
+    }
+
+    #[test]
+    fn esm_bare_node_modules_dep_is_emitted() {
+        // #282 follow-up: a bare specifier resolved from `node_modules` (like `lattish`) is emitted
+        // into the output tree and the importer points at it with a relative `.js` specifier.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let base = tmp.path();
+        std::fs::create_dir_all(base.join("src")).unwrap();
+        std::fs::create_dir_all(base.join("node_modules/pkg")).unwrap();
+        std::fs::write(
+            base.join("node_modules/pkg/package.json"),
+            "{\"name\":\"pkg\",\"main\":\"index.tish\"}\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("node_modules/pkg/index.tish"),
+            "export fn ping() { return \"pong\" }\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/main.tish"),
+            "import { ping } from \"pkg\"\nconsole.log(ping())\n",
+        )
+        .unwrap();
+        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false)
+            .expect("compile_project_esm failed for node_modules dep");
+        let rels: Vec<String> = mods
+            .iter()
+            .map(|m| m.relative_path.to_string_lossy().replace('\\', "/"))
+            .collect();
+        let main_js = mods
+            .iter()
+            .find(|m| m.relative_path.to_string_lossy().replace('\\', "/").ends_with("src/main.js"))
+            .map(|m| m.js.clone());
+        assert!(
+            rels.iter().any(|r| r.ends_with("node_modules/pkg/index.js")),
+            "node_modules dep emitted: {:?}",
+            rels
+        );
+        let main_js = main_js.expect("entry module present");
+        assert!(
+            main_js.contains("from \"../node_modules/pkg/index.js\";"),
+            "bare specifier rewritten to relative .js path:\n{main_js}"
+        );
+    }
+
+    #[test]
+    fn esm_rejects_native_imports() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "import { readFile } from \"fs\"\nconsole.log(1)\n").unwrap();
+        let err = compile_project_esm(&p, Some(dir), false).unwrap_err();
+        assert!(
+            err.message.contains("Native module import") && err.message.contains("esm"),
+            "expected a native-import rejection for ESM, got: {}",
+            err.message
+        );
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {