@tishlang/tish-lint 2.12.0 → 2.35.0

package/crates/tish_compile/src/lib.rs

@@ -10,6 +10,25 @@ mod types;
 
 pub use check::{check_program, TypeDiagnostic};
 
+/// The native typed-codegen optimizations — numeric param inference, struct/aggregate inference,
+/// native (monomorphic) free fns, native-vec params, recursive-struct arena lowering, fused/native
+/// higher-order fns, and native `number[]` params — are **ON BY DEFAULT**. There are no per-pass
+/// flags anymore: that per-flag gating caused repeated "did I set all of them?" drift between the
+/// gauntlet, manual builds, and CI. The single escape hatch `TISH_NATIVE_OPT=0` turns the whole
+/// stack off — used only by the gauntlet's boxed A/B baseline and to bisect a suspected miscompile.
+pub(crate) fn native_opts_enabled() -> bool {
+    std::env::var("TISH_NATIVE_OPT").map(|v| v != "0").unwrap_or(true)
+}
+
+/// #381 — the native recursion guard: rotation copies for self/mutually-recursive typed fns plus a
+/// depth guard at boxed user-fn closure entry, so unbounded recursion raises a catchable
+/// `RangeError` instead of overflowing the stack (an uncatchable process abort). **Default ON**;
+/// `TISH_NATIVE_RECUR_GUARD=0` turns it off — mirrors the VM JIT tier's `TISH_JIT_RECUR_GUARD`
+/// (for bisection and code-size-sensitive builds; unbounded recursion then aborts again, as before).
+pub(crate) fn native_recur_guard_enabled() -> bool {
+    std::env::var("TISH_NATIVE_RECUR_GUARD").map(|v| v != "0").unwrap_or(true)
+}
+
 /// How generated Rust is linked (desktop binary vs embedded iOS staticlib).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum NativeEmitMode {
@@ -88,8 +107,10 @@ fn count(): number {
 
     #[test]
     fn loop_var_decl_clone_outer_var() {
-        // With inference, outerVar = 42 gets inferred as f64. f64 is Copy, so no clone is
-        // needed — direct assignment is correct. The test verifies compilation succeeds.
+        // outerVar = 42 is inferred as f64. Per #313, a top-level numeric used ONLY at top level
+        // (never inside a function/closure body) is a native `run()`-local `let mut _: f64`, NOT a
+        // `thread_local Cell<f64>` — the Cell is reserved for globals a function reads across calls
+        // (e.g. fasta's `seed`). The read `let x = outerVar` loads it as a Copy f64.
         let src = r#"
 let outerVar = 42
 for (let i = 0; i < 5; i = i + 1) {
@@ -98,10 +119,14 @@ for (let i = 0; i < 5; i = i + 1) {
 "#;
         let program = parse(src).unwrap();
         let rust = compile(&program).unwrap();
-        // outerVar and x are f64 (inferred) — Copy assignment, no .clone() needed.
+        // outerVar is a native f64 local (no TLS Cell, since no function references it); x reads it.
         assert!(
             rust.contains("let mut outerVar: f64"),
-            "expected outerVar: f64"
+            "expected outerVar as a native f64 local (#313)"
+        );
+        assert!(
+            !rust.contains("G_OUTERVAR"),
+            "outerVar must NOT be a thread_local Cell global — it is top-level-only (#313)"
         );
         assert!(rust.contains("let mut x: f64"), "expected x: f64");
     }

package/crates/tish_compile/src/resolve.rs

@@ -49,17 +49,23 @@ pub struct NativeBuildArtifacts {
     pub native_init: std::collections::HashMap<String, NativeModuleInit>,
 }
 
-/// Node-compatible aliases for built-in modules (fs -> tish:fs, etc.).
+/// Node-compatible aliases for built-in modules (fs -> tish:fs, etc.). The `node:` prefix
+/// (e.g. `node:fs`, `node:fs/promises`) is stripped before lookup.
 const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("fs", "tish:fs"),
+    ("fs/promises", "tish:fs/promises"),
     ("http", "tish:http"),
     ("timers", "tish:timers"),
     ("process", "tish:process"),
     ("ws", "tish:ws"),
+    ("tty", "tish:tty"),
 ];
 
-/// Normalize built-in spec to canonical form. E.g. "fs" -> "tish:fs".
+/// Normalize built-in spec to canonical form. Handles the Node `node:` prefix
+/// (`node:fs` -> `tish:fs`, `node:fs/promises` -> `tish:fs/promises`) and bare aliases.
 pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
+    // Strip a leading `node:` so `node:fs` resolves the same as `fs`.
+    let spec = spec.strip_prefix("node:").unwrap_or(spec);
     if spec.starts_with("tish:") {
         return Some(spec.to_string());
     }
@@ -71,10 +77,20 @@ pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
 
 /// Built-in modules that come from tishlang_runtime, not from package.json.
 pub fn is_builtin_native_spec(spec: &str) -> bool {
+    let spec = spec.strip_prefix("node:").unwrap_or(spec);
     matches!(
         spec,
-        "tish:fs" | "tish:http" | "tish:timers" | "tish:process" | "tish:ws" | "tish:tty"
-    ) || matches!(spec, "fs" | "http" | "timers" | "process" | "ws" | "tty")
+        "tish:fs"
+            | "tish:fs/promises"
+            | "tish:http"
+            | "tish:timers"
+            | "tish:process"
+            | "tish:ws"
+            | "tish:tty"
+    ) || matches!(
+        spec,
+        "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty"
+    )
 }
 
 /// Resolve all native imports in a merged program via package.json lookup.
@@ -238,9 +254,12 @@ pub fn program_uses_document(program: &Program) -> bool {
                     || update.as_ref().is_some_and(expr_uses_document)
                     || stmt_uses_document(body)
             }
-            Statement::ForOf { iterable, body, .. } => {
-                expr_uses_document(iterable) || stmt_uses_document(body)
-            }
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => expr_uses_document(iterable) || stmt_uses_document(body),
             Statement::Switch {
                 expr,
                 cases,
@@ -854,7 +873,7 @@ pub fn resolve_project_from_stdin(
     let from_dir = stdin_path.parent().unwrap_or_else(|| Path::new("."));
 
     for stmt in &program.statements {
-        if let Statement::Import { from, .. } = stmt {
+        if let Some(from) = stmt_module_dep(stmt) {
             if is_native_import(from.as_ref()) {
                 continue;
             }
@@ -883,6 +902,21 @@ pub fn resolve_project_from_stdin(
         .collect())
 }
 
+/// #305 — the module path a statement depends on: an `import ... from "p"` or a re-export
+/// `export ... from "p"`. Used by dependency discovery + cycle detection so a module reached ONLY
+/// through a re-export is still loaded. None for non-module statements.
+fn stmt_module_dep(stmt: &Statement) -> Option<&std::sync::Arc<str>> {
+    match stmt {
+        Statement::Import { from, .. } => Some(from),
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            // A local named export (`export { a }`, from=None) has no module dependency.
+            ExportDeclaration::ReExport { from, .. } => from.as_ref(),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
 fn load_module_recursive(
     module_path: &Path,
     project_root: &Path,
@@ -907,7 +941,7 @@ fn load_module_recursive(
     // Collect imports and load dependencies first (skip native imports)
     let dir = canonical.parent().unwrap_or(Path::new("."));
     for stmt in &program.statements {
-        if let Statement::Import { from, .. } = stmt {
+        if let Some(from) = stmt_module_dep(stmt) {
             if is_native_import(from.as_ref()) {
                 continue; // Native imports don't load files
             }
@@ -937,10 +971,15 @@ fn load_module_recursive(
 ///
 /// Scoped npm packages (`@scope/pkg`) are merged as Tish source unless imported via `tish:…`.
 pub fn is_native_import(spec: &str) -> bool {
+    // A leading `node:` (node:fs, node:fs/promises) resolves the same as the bare form.
+    let spec = spec.strip_prefix("node:").unwrap_or(spec);
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
         || spec.starts_with("ffi:")
-        || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
+        || matches!(
+            spec,
+            "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty"
+        )
 }
 
 /// True for `ffi:…` specs (portable C-ABI cdylib extensions, loadable on every backend). The
@@ -1113,7 +1152,7 @@ fn has_cycle_from(
     visiting: &mut HashSet<usize>,
 ) -> Result<bool, String> {
     for stmt in &program.statements {
-        if let Statement::Import { from, .. } = stmt {
+        if let Some(from) = stmt_module_dep(stmt) {
             if is_native_import(from.as_ref()) {
                 continue;
             }
@@ -1146,6 +1185,11 @@ fn has_cycle_from(
 pub struct MergedProgram {
     pub program: Program,
     pub statement_sources: Vec<PathBuf>,
+    /// #295: the ENTRY module's exported `(local_name, exported_name)` pairs, excluding `default`
+    /// (handled separately as `export default`). Merge unwraps exports into plain top-level
+    /// declarations, so `--target js --format bundle` re-emits these as a trailing `export { … }` to
+    /// produce a valid ES module. Sorted by local name for deterministic output.
+    pub entry_exports: Vec<(String, String)>,
 }
 
 fn merge_push(
@@ -1374,7 +1418,11 @@ fn shadow_params(
 }
 
 /// Scope-aware statement rewriter for [`isolate_private_top_level_bindings`].
-fn rewrite_stmt_scope(
+/// Scope-aware statement rewriter: rename declared bindings and their free references
+/// according to `active` (name → new Arc). Exposed `pub(crate)` so the #179 factory inliner
+/// (infer.rs) can reuse this exhaustive, resolution-tested renamer for alpha-renaming a
+/// spliced factory body instead of hand-rolling a completeness-sensitive walker.
+pub(crate) fn rewrite_stmt_scope(
     stmt: &mut Statement,
     active: &mut HashMap<String, Arc<str>>,
     top_level: bool,
@@ -1447,6 +1495,12 @@ fn rewrite_stmt_scope(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            object: iterable,
+            body,
+            ..
         } => {
             rewrite_expr_scope(iterable, active);
             let mut child = active.clone();
@@ -1522,6 +1576,9 @@ fn rewrite_stmt_scope(
             // body can still reference module-private names that were renamed.
             ExportDeclaration::Named(inner) => rewrite_stmt_scope(inner, active, top_level),
             ExportDeclaration::Default(e) => rewrite_expr_scope(e, active),
+            // #305: a re-export has no inner statement/expr to scope-rewrite; names are resolved by
+            // the export-table merge against the dep's (already-rewritten) bindings.
+            ExportDeclaration::ReExport { .. } => {}
         },
         Statement::Import { .. }
         | Statement::TypeAlias { .. }
@@ -1533,7 +1590,8 @@ fn rewrite_stmt_scope(
 /// Scope-aware expression rewriter: rename every free reference to a name in `active`.
 /// Expressions never declare module-level bindings, so `active` is read-only here; arrow
 /// functions clone it for their own (shadowed) parameter scope.
-fn rewrite_expr_scope(expr: &mut Expr, active: &HashMap<String, Arc<str>>) {
+/// `pub(crate)` so the #179 factory inliner can rename a spliced return expression.
+pub(crate) fn rewrite_expr_scope(expr: &mut Expr, active: &HashMap<String, Arc<str>>) {
     let rename = |name: &mut Arc<str>| {
         if let Some(renamed) = active.get(name.as_ref()) {
             *name = Arc::clone(renamed);
@@ -1674,6 +1732,14 @@ fn rewrite_expr_scope(expr: &mut Expr, active: &HashMap<String, Arc<str>>) {
 /// Import statements are rewritten as bindings from already-emitted dep exports.
 /// Export statements are unwrapped (the inner declaration is emitted).
 pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram, String> {
+    // #469: give the ENTRY module a Go/Rust/Swift-style `main` entry point. The entry is the last
+    // module (post-order dependency load order), and this runs BEFORE private-binding isolation so the
+    // synthetic `main()` call is renamed in lockstep with the `main` declaration if isolation renames
+    // it. Every backend consumes the merged program, so this keeps interp/vm/native/js consistent.
+    if let Some(entry) = modules.last_mut() {
+        tishlang_ast::append_main_entry(&mut entry.program.statements);
+    }
+
     // #97: isolate module-private top-level bindings before they are flattened together.
     isolate_private_top_level_bindings(&mut modules);
 
@@ -1701,6 +1767,57 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                         let default_name = format!("__default_{}", idx);
                         module_exports[idx].insert("default".to_string(), default_name);
                     }
+                    // #305: re-export — map each re-exported name to the DEP's binding (the dep is
+                    // earlier in load order, so its export table is already built). `export *` copies
+                    // every dep export (without overriding an explicit one); `export { a as b }` maps
+                    // b -> dep's binding for a. Downstream imports then resolve straight to the dep.
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        all,
+                        from: Some(from),
+                        ..
+                    } => {
+                        let dir = module.path.parent().unwrap_or_else(|| Path::new("."));
+                        let dep = resolve_import_path(from.as_ref(), dir, Path::new("."))
+                            .ok()
+                            .map(|p| p.canonicalize().unwrap_or(p))
+                            .and_then(|p| path_to_idx.get(&p).copied())
+                            .map(|dep_idx| module_exports[dep_idx].clone());
+                        if let Some(dep) = dep {
+                            if *all {
+                                for (k, v) in &dep {
+                                    module_exports[idx]
+                                        .entry(k.clone())
+                                        .or_insert_with(|| v.clone());
+                                }
+                            }
+                            for spec in specifiers {
+                                if let ImportSpecifier::Named { name, alias, .. } = spec {
+                                    if let Some(binding) = dep.get(name.as_ref()) {
+                                        let export_name =
+                                            alias.as_deref().unwrap_or(name.as_ref()).to_string();
+                                        module_exports[idx].insert(export_name, binding.clone());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // #415 local named export (`export { a, b as c }`, no `from`): each specifier
+                    // exports an already-declared LOCAL top-level binding, mapping export-name -> that
+                    // binding. (`isolate_private_top_level_bindings` keeps exported names un-renamed.)
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        from: None,
+                        ..
+                    } => {
+                        for spec in specifiers {
+                            if let ImportSpecifier::Named { name, alias, .. } = spec {
+                                let export_name =
+                                    alias.as_deref().unwrap_or(name.as_ref()).to_string();
+                                module_exports[idx].insert(export_name, name.to_string());
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -1885,6 +2002,10 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                             src_path.clone(),
                         );
                     }
+                    // #305: re-export emits no code — `module_exports` already maps the re-exported
+                    // names to the dep's bindings (in scope in the flattened bundle), so downstream
+                    // imports resolve directly. Nothing to push here.
+                    ExportDeclaration::ReExport { .. } => {}
                 },
                 _ => merge_push(
                     &mut statements,
@@ -1895,9 +2016,26 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
             }
         }
     }
+    // #295: capture the ENTRY module's exports (the entry is last — deps are emitted first). Merge
+    // already built `module_exports[idx]` as exported_name -> local_binding; re-express as
+    // (local, exported) for the JS bundle emitter, excluding `default` (emitted as `export default`).
+    let entry_exports: Vec<(String, String)> = modules
+        .len()
+        .checked_sub(1)
+        .map(|last| {
+            let mut v: Vec<(String, String)> = module_exports[last]
+                .iter()
+                .filter(|(exported, _)| exported.as_str() != "default")
+                .map(|(exported, local)| (local.clone(), exported.clone()))
+                .collect();
+            v.sort();
+            v
+        })
+        .unwrap_or_default();
     Ok(MergedProgram {
         program: Program { statements },
         statement_sources,
+        entry_exports,
     })
 }