@tishlang/tish 2.12.0 → 2.16.13

package/crates/tish_compile/tests/perf_codegen_178.rs

@@ -0,0 +1,114 @@
+//! #178 Bun-style fusion targets — AST shape checks + codegen assertions when fusion lands.
+
+use std::fs;
+use std::path::PathBuf;
+
+use tishlang_ast::{BinOp, Expr, Statement};
+use tishlang_compile::compile_project_full;
+use tishlang_opt::optimize;
+use tishlang_parser::parse;
+
+fn enable_typed_flags() {
+}
+
+fn compile_fixture_typed(rel: &str) -> String {
+    enable_typed_flags();
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    rust
+}
+
+fn stmt_slice_unwrapped(body: &Statement) -> Vec<&Statement> {
+    let mut cur = body;
+    loop {
+        match cur {
+            Statement::Block { statements, .. } | Statement::Multi { statements, .. } => {
+                if statements.len() == 1 {
+                    cur = &statements[0];
+                } else {
+                    return statements.iter().collect();
+                }
+            }
+            other => return vec![other],
+        }
+    }
+}
+
+fn find_flip_for_body(s: &Statement) -> Option<&Statement> {
+    match s {
+        Statement::For { cond, body, .. } => {
+            if let Some(cond) = cond.as_ref() {
+                if let Expr::Binary {
+                    op: BinOp::Lt,
+                    right,
+                    ..
+                } = cond
+                {
+                    if matches!(right.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "k2") {
+                        return Some(body);
+                    }
+                }
+            }
+            None
+        }
+        Statement::Block { statements, .. } | Statement::Multi { statements, .. } => {
+            for st in statements {
+                if let Some(b) = find_flip_for_body(st) {
+                    return Some(b);
+                }
+            }
+            None
+        }
+        Statement::While { body, .. } => find_flip_for_body(body),
+        Statement::If { then_branch, .. } => find_flip_for_body(then_branch),
+        _ => None,
+    }
+}
+
+#[test]
+fn fannkuch_flip_for_body_is_three_index_assigns() {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest
+        .join("../../tests/perf/fannkuch.tish")
+        .canonicalize()
+        .unwrap();
+    let program = optimize(&parse(&fs::read_to_string(&path).unwrap()).unwrap());
+    let body = program
+        .statements
+        .iter()
+        .find_map(|s| {
+            if let Statement::FunDecl { name, body, .. } = s {
+                if name.as_ref() == "fannkuch" {
+                    return find_flip_for_body(body);
+                }
+            }
+            None
+        })
+        .expect("flip for body");
+    let stmts = stmt_slice_unwrapped(body);
+    assert_eq!(stmts.len(), 3);
+    for st in &stmts[1..] {
+        let Statement::ExprStmt { expr, .. } = st else {
+            panic!("expected expr stmt");
+        };
+        assert!(matches!(expr, Expr::IndexAssign { .. }));
+    }
+}
+
+#[test]
+fn fannkuch_nv_uses_usize_sub_index_in_flip() {
+    let rust = compile_fixture_typed("tests/perf/fannkuch.tish");
+    if rust.contains("fn fannkuch_nv(") {
+        let nv = rust.split("fn fannkuch_nv(").nth(1).unwrap();
+        let nv = nv.split("fn run()").next().unwrap_or(nv);
+        assert!(
+            nv.contains("let ku =") && nv.contains("for _usize_flip_"),
+            "flip loop should fuse to ku half-loop with usize swaps"
+        );
+        assert!(
+            !nv.contains("let mut k2:") && !nv.contains("let mut temp:"),
+            "fused flip loop should not emit k2/temp temps"
+        );
+    }
+}

package/crates/tish_compile/tests/perf_codegen_178_rec.rs

@@ -0,0 +1,124 @@
+//! #178 — recursive-struct native lowering.
+//!
+//! A developer-shaped recursive binary tree (arbitrary identifiers, NOT the fixture names
+//! bottomUpTree/itemCheck/binaryTrees) must lower to a native arena: an `i32`-indexed struct,
+//! native `build`/`check` free fns threading `&mut Vec<Node>` / `&Vec<Node>`, and a top-level
+//! routed call — with NO `object_from_pairs` / `get_prop` / `value_call` on the hot path. This is
+//! the real, name-independent fix that makes the boxed `binary_trees` path fast under any names.
+//! See docs/recursive-struct-native.md.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+fn enable_flags() {
+}
+
+const SRC: &str = r#"
+function buildNode(d) {
+  if (d > 0) { return { left: buildNode(d - 1), right: buildNode(d - 1) } }
+  return { left: null, right: null }
+}
+function sumNode(node) {
+  if (node.left === null) { return 1 }
+  return 1 + sumNode(node.left) + sumNode(node.right)
+}
+let t0 = Date.now()
+let check = sumNode(buildNode(10))
+console.log("GAUNTLET rec " + (Date.now() - t0) + " " + check)
+"#;
+
+#[test]
+fn recursive_tree_lowers_to_native_arena() {
+    enable_flags();
+    let dir = PathBuf::from(env!("CARGO_TARGET_TMPDIR"));
+    let path = dir.join("rec_tree_dev_178.tish");
+    std::fs::write(&path, SRC).unwrap();
+
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+
+    // The synthesized arena node struct (i32 child indices, not Option<Box> / not boxed Value).
+    assert!(
+        rust.contains("struct TishStruct_TishRecNode"),
+        "expected a synthesized recursive node struct"
+    );
+    // Native builder + consumer free fns over the arena.
+    assert!(
+        rust.contains("fn buildNode_rec(") && rust.contains("__rec_arena: &mut Vec<"),
+        "expected a native arena builder fn"
+    );
+    assert!(
+        rust.contains("fn sumNode_rec(__rec_idx: i32, __rec_arena: &Vec<"),
+        "expected a native arena consumer fn"
+    );
+    // Top-level call routed through the arena, not the boxed closure.
+    assert!(
+        rust.contains("let __rec_root = buildNode_rec("),
+        "expected the top-level builder call to be routed to the native arena fn"
+    );
+    assert!(
+        rust.contains("sumNode_rec(__rec_root, &__rec_arena)"),
+        "expected the consumer to be invoked on the arena root index"
+    );
+    // No per-node boxed allocation on the recursive build path.
+    assert!(
+        rust.contains("__rec_arena.push(TishStruct_TishRecNode"),
+        "expected nodes to be bump-allocated into the arena Vec"
+    );
+}
+
+// The FULL binary_trees shape (with a loop-bearing orchestrator) — developer identifiers.
+const SRC_ORCH: &str = r#"
+function makeTree(d) {
+  if (d > 0) { return { left: makeTree(d - 1), right: makeTree(d - 1) } }
+  return { left: null, right: null }
+}
+function countTree(node) {
+  if (node.left === null) { return 1 }
+  return 1 + countTree(node.left) + countTree(node.right)
+}
+function run(maxDepth) {
+  let minDepth = 4
+  let total = countTree(makeTree(maxDepth + 1))
+  let longLived = makeTree(maxDepth)
+  let depth = minDepth
+  while (depth <= maxDepth) {
+    let iterations = 1 << (maxDepth - depth + minDepth)
+    let sum = 0
+    for (let i = 0; i < iterations; i++) { sum = sum + countTree(makeTree(depth)) }
+    total = total + sum
+    depth = depth + 2
+  }
+  total = total + countTree(longLived)
+  return total
+}
+let t0 = Date.now()
+let check = run(8)
+console.log("GAUNTLET t " + (Date.now() - t0) + " " + check)
+"#;
+
+#[test]
+fn recursive_tree_orchestrator_lowers_to_native_arena() {
+    enable_flags();
+    let dir = PathBuf::from(env!("CARGO_TARGET_TMPDIR"));
+    let path = dir.join("rec_orch_dev_178.tish");
+    std::fs::write(&path, SRC_ORCH).unwrap();
+
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+
+    // The orchestrator becomes a native fn threading the arena and returning f64.
+    assert!(
+        rust.contains("fn run_rec(") && rust.contains("__rec_arena: &mut Vec<"),
+        "expected the orchestrator to lower to a native arena fn"
+    );
+    // It calls builders/consumers natively (no value_call on the hot path).
+    assert!(
+        rust.contains("makeTree_rec(") && rust.contains("countTree_rec("),
+        "expected the orchestrator to call builder/consumer fns natively"
+    );
+    // Top-level call routed through a fresh arena.
+    assert!(
+        rust.contains("let mut __rec_arena") && rust.contains("run_rec("),
+        "expected the top-level orchestrator call to set up and thread the arena"
+    );
+}

package/crates/tish_compile/tests/perf_codegen_181.rs

@@ -0,0 +1,36 @@
+//! #181 — direct Map method dispatch for `new Map()` locals.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+fn enable_typed_flags() {
+}
+
+#[test]
+fn k_nucleotide_uses_direct_map_has_get_set() {
+    enable_typed_flags();
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest
+        .join("../../tests/perf/k_nucleotide.tish")
+        .canonicalize()
+        .unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    assert!(
+        rust.contains("tish_map_has("),
+        "expected direct map_has dispatch:\n{}",
+        rust.lines()
+            .filter(|l| l.contains("map_has") || l.contains("map_set"))
+            .take(6)
+            .collect::<Vec<_>>()
+            .join("\n")
+    );
+    assert!(
+        rust.contains("tish_map_get(") && rust.contains("tish_map_set("),
+        "expected direct map_get/set dispatch"
+    );
+    assert!(
+        !rust.contains("get_prop(&(m).clone(), \"has\")"),
+        "should not use bound-method has on map local m"
+    );
+}

package/crates/tish_compile/tests/perf_codegen_320.rs

@@ -0,0 +1,211 @@
+//! #320 — honest native-array lowering for fn-call-built numeric arrays.
+//!
+//! Two sound, name-independent inference fixes:
+//!   fix1: a 0-param numeric fn (`nextBase`, mutates a numeric global, returns number) is eligible
+//!         for native `-> f64` promotion (`collect_native_fns` no longer requires ≥1 param).
+//!   fix2: a fn PROVEN to always return a number lets `infer_expr_type(f(...))` be `number`, so
+//!         `seq.push(nextBase())` keeps `seq` a native `Vec<f64>` instead of a boxed `Value[]`.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+/// The general typed-native inference flags.
+fn enable_typed_flags() {
+}
+
+/// Write `src` under the workspace `target/` (scratch lives there, per repo convention) and compile.
+fn compile_src(stem: &str, src: &str) -> String {
+    let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/perf_codegen_320");
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join(format!("{stem}.tish"));
+    std::fs::write(&path, src).unwrap();
+    let path = path.canonicalize().unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    rust
+}
+
+const NON_ESCAPING: &str = r#"
+let seed = 7
+function nextBase() {
+  seed = (seed * 3877 + 29573) % 139968
+  if (seed < 34992) { return 0 }
+  if (seed < 69984) { return 1 }
+  if (seed < 104976) { return 2 }
+  return 3
+}
+let seq = []
+for (let i = 0; i < 100; i++) { seq.push(nextBase()) }
+let sum = 0
+for (let i = 0; i < seq.length; i++) { sum = sum + seq[i] }
+console.log("R " + sum)
+"#;
+
+#[test]
+fn zero_param_numeric_fn_goes_native() {
+    enable_typed_flags();
+    let rust = compile_src("zero_param", NON_ESCAPING);
+    // fix1: the 0-param fn is promoted to a native `-> f64` form.
+    assert!(
+        rust.contains("fn nextBase_native() -> f64"),
+        "0-param numeric fn should get a native f64 form (fix1)"
+    );
+}
+
+#[test]
+fn numeric_returning_fn_keeps_pushed_array_native() {
+    enable_typed_flags();
+    let rust = compile_src("native_push", NON_ESCAPING);
+    // fix2: `seq.push(nextBase())` keeps `seq` a native `Vec<f64>` (the pushed value infers numeric).
+    assert!(
+        rust.contains("let mut seq: Vec<f64>"),
+        "seq built by push(numericFn()) should be a native Vec<f64> (fix2)"
+    );
+    // And the push routes straight to the native fn (no boxed Value array push).
+    assert!(
+        rust.contains("seq.push(nextBase_native())"),
+        "push should call the native fn into the native Vec (fix1+fix2)"
+    );
+}
+
+/// A fn that can fall through to an implicit `undefined` (no trailing unconditional return) must NOT
+/// be treated as number-returning — else `a.push(maybe())` could put `undefined` in a `Vec<f64>`.
+#[test]
+fn fallthrough_fn_is_not_number_returning() {
+    enable_typed_flags();
+    let src = r#"
+let g = 0
+function maybe() {
+  g = g + 1
+  if (g < 10) { return 1 }
+}
+let a = []
+for (let i = 0; i < 100; i++) { a.push(maybe()) }
+let sum = 0
+for (let i = 0; i < a.length; i++) { sum = sum + 1 }
+console.log("R " + sum)
+"#;
+    let rust = compile_src("fallthrough", src);
+    // Unsound to type `a` as Vec<f64> here — it must stay a boxed array.
+    assert!(
+        !rust.contains("let mut a: Vec<f64>"),
+        "fall-through fn must not make the pushed array native (soundness)"
+    );
+}
+
+/// #320 part 2: a read-only `number[]` param of a normal (boxed-body, boxed-return) fn is unboxed
+/// once into an owned native `Vec<f64>`, so the body indexes it natively. This is the
+/// cross-fn-boundary lever — `kNucleotide(seq, k)` indexes `seq` but builds & returns a boxed Map,
+/// so it is NOT a native-vec fn.
+fn enable_arr_param() {}
+
+const ARR_PARAM: &str = r#"
+let seed = 7
+function nextBase() {
+  seed = (seed * 3877 + 29573) % 139968
+  if (seed < 34992) { return 0 }
+  if (seed < 69984) { return 1 }
+  if (seed < 104976) { return 2 }
+  return 3
+}
+function count(seq, k) {
+  let m = new Map()
+  let n = seq.length - k + 1
+  for (let i = 0; i < n; i++) {
+    let key = 0
+    for (let j = 0; j < k; j++) { key = key * 4 + seq[i + j] }
+    if (m.has(key)) { m.set(key, m.get(key) + 1) } else { m.set(key, 1) }
+  }
+  return m
+}
+let seq = []
+for (let i = 0; i < 100; i++) { seq.push(nextBase()) }
+let m = count(seq, 4)
+let sum = 0
+for (let v of m.values()) { sum = sum + v }
+console.log("R " + sum)
+"#;
+
+#[test]
+fn readonly_arr_param_unboxed_to_native_vec() {
+    enable_arr_param();
+    let rust = compile_src("arr_param", ARR_PARAM);
+    // The `seq` param is unboxed once into an owned native Vec<f64> at the closure entry (a packed
+    // NumberArray clones its backing; a boxed Array is mapped element-wise).
+    assert!(
+        rust.contains("let mut seq: Vec<f64> = match args.get(")
+            && rust.contains("Some(Value::NumberArray(a)) => a.borrow().clone()"),
+        "read-only number[] param should be unboxed to a native Vec<f64>"
+    );
+    // And the hot inner loop indexes it natively (f64 mul + native vec read), no boxed get_index.
+    assert!(
+        rust.contains("key * 4_f64") && rust.contains("seq.get("),
+        "inner loop should be native f64 arithmetic over a native Vec read"
+    );
+    assert!(
+        !rust.contains("tishlang_runtime::get_index(&seq")
+            && !rust.contains("get_index(&(seq)"),
+        "seq must not be read via the boxed runtime get_index inside the fn"
+    );
+}
+
+#[test]
+fn mutating_arr_param_stays_boxed() {
+    enable_arr_param();
+    // `a` is index-ASSIGNED → an owned native copy would silently drop the write, so the param must
+    // stay boxed (classify_vec_param reports is_mut, and the detection requires read-only).
+    let src = r#"
+function bump(a) { a[0] = a[0] + 1; return a.length }
+let arr = []
+for (let i = 0; i < 10; i++) { arr.push(i) }
+let r = bump(arr)
+console.log("R " + r)
+"#;
+    let rust = compile_src("mut_arr_param", src);
+    assert!(
+        !rust.contains("let mut a: Vec<f64>"),
+        "a mutated array param must stay boxed (soundness — owned copy would lose writes)"
+    );
+}
+
+#[test]
+fn escaping_arr_param_stays_boxed() {
+    enable_arr_param();
+    // `seq.push` MUTATES the param via a method (not index-assign): an owned copy would lose the
+    // caller-visible push. `scan_param_use` flags this as an escape → the param stays boxed.
+    let src = r#"
+function build(seq) {
+  let m = new Map()
+  for (let i = 0; i < seq.length; i++) { m.set(i, seq[i]) }
+  seq.push(99)
+  return m
+}
+let arr = []
+for (let i = 0; i < 10; i++) { arr.push(i) }
+let m = build(arr)
+console.log("R " + arr.length)
+"#;
+    let rust = compile_src("escape_arr_param", src);
+    assert!(
+        !rust.contains("let mut seq: Vec<f64>"),
+        "an escaping (pushed) array param must stay boxed (soundness)"
+    );
+}
+
+#[test]
+fn non_number_array_arg_keeps_callee_boxed() {
+    enable_arr_param();
+    // `joinup` reads its param read-only, but the ONLY caller passes a NON-number[] array. Unboxing
+    // to Vec<f64> would turn "x" into NaN (vs JS string concat) — so the call-site check keeps the
+    // callee fully boxed.
+    let src = r#"
+function joinup(seq) { let r = ""; for (let i = 0; i < seq.length; i++) { r = r + seq[i] } return r }
+let arr = [1, "x", 3]
+console.log(joinup(arr))
+"#;
+    let rust = compile_src("nonnum_arr_arg", src);
+    assert!(
+        !rust.contains("let mut seq: Vec<f64>"),
+        "a read-only fn whose caller passes a non-number[] array must stay boxed (call-site soundness)"
+    );
+}

package/crates/tish_compile/tests/perf_codegen_module_const_forof.rs

@@ -0,0 +1,40 @@
+//! Hoisted module-level f64 array literals (`const G_XS`) must compile when used in for-of / join.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+#[test]
+fn typed_array_forof_compiles() {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest
+        .join("../../tests/core/typed_array_forof.tish")
+        .canonicalize()
+        .unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    assert!(rust.contains("const G_XS:"), "expected hoisted xs array");
+    assert!(
+        !rust.contains("normalize_for_of((xs)"),
+        "for-of should use native index loop over G_XS, not boxed xs reference"
+    );
+    assert!(
+        rust.contains("for _fof_i0 in 0..G_XS.len()"),
+        "expected native for-of over hoisted G_XS"
+    );
+}
+
+#[test]
+fn template_literals_hoisted_nums_compiles() {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest
+        .join("../../tests/core/template_literals.tish")
+        .canonicalize()
+        .unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    assert!(rust.contains("const G_NUMS:"));
+    assert!(
+        rust.contains("array_join(&Value::NumberArray(VmRef::new(G_NUMS"),
+        "nums.join should box hoisted G_NUMS, not reference missing local nums"
+    );
+    assert!(!rust.contains("&nums,"));
+}

package/crates/tish_compile_js/src/codegen.rs

@@ -1036,6 +1036,39 @@ impl Codegen {
                 let v = self.emit_expr(e)?;
                 self.writeln(&format!("export default {};", v));
             }
+            // #305: re-export in ESM mode — emit the native `export { … } from` / `export * from`,
+            // rewriting the `.tish` specifier to the emitted `.js` module path.
+            ExportDeclaration::ReExport {
+                specifiers,
+                all,
+                from,
+                ..
+            } => {
+                let spec = rewrite_import_to_js(
+                    from.as_ref(),
+                    &self.module_path,
+                    &self.project_root,
+                    self.import_rewrite,
+                )?;
+                if *all {
+                    self.writeln(&format!("export * from {:?};", spec));
+                } else {
+                    let mut parts: Vec<String> = Vec::new();
+                    for s in specifiers {
+                        if let ImportSpecifier::Named { name, alias, .. } = s {
+                            match alias {
+                                Some(a) => parts.push(format!(
+                                    "{} as {}",
+                                    Self::escape_ident(name.as_ref()),
+                                    Self::escape_ident(a.as_ref())
+                                )),
+                                None => parts.push(Self::escape_ident(name.as_ref()).to_string()),
+                            }
+                        }
+                    }
+                    self.writeln(&format!("export {{ {} }} from {:?};", parts.join(", "), spec));
+                }
+            }
         }
         Ok(())
     }