@tishlang/tish-lsp 2.12.0 → 2.35.0

package/crates/tish_compile/tests/perf_codegen_175.rs

@@ -0,0 +1,190 @@
+//! Generated-Rust assertions for #175 — native plain-array free fns.
+//!
+//! A top-level fn over `number[]`/`boolean[]` params (used only by index/length, no escape) whose
+//! call sites pass pairwise-distinct array idents is de-virtualized to `fn name_nv(<f64..>,
+//! <&/&mut Vec<T>..>) -> f64 | ()`; calls route there passing arrays by reference. A fn that calls a
+//! boxed (non-native) closure, or whose array args can't be proven distinct/native, falls back to the
+//! boxed closure (no `_nv`). Cross-backend soundness is covered by `tests/core/native_vec_params`.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+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 compile_fixture_embedded_lib(rel: &str) -> String {
+    compile_fixture_embedded_lib_with_features(rel, &[])
+}
+
+fn compile_fixture_embedded_lib_with_features(rel: &str, features: &[String]) -> String {
+    enable_typed_flags();
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    let (rust, _, _, _) = tishlang_compile::compile_project_full_emit(
+        &path,
+        path.parent(),
+        features,
+        true,
+        tishlang_compile::NativeEmitMode::EmbeddedLib,
+        None,
+    )
+    .unwrap();
+    rust
+}
+
+#[test]
+fn native_vec_params_emit_ref_signatures_and_route() {
+    let rust = compile_fixture_typed("tests/core/native_vec_params.tish");
+    // Recursive `&mut boolean[]` fn.
+    assert!(
+        rust.contains("fn mark_nv(mut n: f64, mut row: f64, a: &mut Vec<bool>, b: &mut Vec<bool>)"),
+        "mark lowers to a native free fn over &mut Vec<bool> params:\n{}",
+        rust.lines().filter(|l| l.contains("mark_nv")).take(4).collect::<Vec<_>>().join("\n")
+    );
+    // Recursion reborrows the ref params through.
+    assert!(
+        rust.contains("mark_nv(n, (row + 1_f64), &mut *a, &mut *b)"),
+        "recursive call reborrows the &mut params:\n{}",
+        rust.lines().filter(|l| l.contains("mark_nv(")).take(4).collect::<Vec<_>>().join("\n")
+    );
+    // Read-only `&Vec<f64>` + write `&mut Vec<f64>`.
+    assert!(
+        rust.contains("fn scaleInto_nv(mut n: f64, src: &Vec<f64>, dst: &mut Vec<f64>)"),
+        "scaleInto distinguishes read (&) vs written (&mut) array params:\n{}",
+        rust.lines().filter(|l| l.contains("scaleInto_nv")).take(4).collect::<Vec<_>>().join("\n")
+    );
+    // Top-level call sites address-of native `Vec` locals.
+    assert!(
+        rust.contains("mark_nv(5_f64, 0_f64, &mut a, &mut b)"),
+        "the entry call passes the local Vecs by &mut:\n{}",
+        rust.lines().filter(|l| l.contains("mark_nv(5")).take(2).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("scaleInto_nv(6_f64, &src, &mut dst)"),
+        "scaleInto call passes & / &mut:\n{}",
+        rust.lines().filter(|l| l.contains("scaleInto_nv(6")).take(2).collect::<Vec<_>>().join("\n")
+    );
+    // The local arrays became native Vecs (the escape into the native-vec fn is not a boxing escape).
+    assert!(
+        rust.contains("let mut a: Vec<bool>") && rust.contains("let mut src: Vec<f64>"),
+        "caller arrays are unboxed native Vecs"
+    );
+}
+
+#[test]
+fn queens_place_devirtualizes_to_native_vec_fn() {
+    let rust = compile_fixture_typed("tests/perf/queens.tish");
+    assert!(
+        rust.contains("fn place_nv(mut n: f64, mut row: f64, cols: &mut Vec<bool>, diag1: &mut Vec<bool>, diag2: &mut Vec<bool>) -> f64"),
+        "queens' place lowers to a native free fn over three &mut Vec<bool> params:\n{}",
+        rust.lines().filter(|l| l.contains("place_nv")).take(3).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("place_nv(5_f64, 0_f64") || rust.contains("place_nv(match") || rust.contains("place_nv("),
+        "the place call routes to place_nv"
+    );
+}
+
+#[test]
+fn spectral_norm_devirtualizes_with_inlined_evala() {
+    // `multiplyAv`/`multiplyAtv` (over `&Vec<f64>` + `&mut Vec<f64>`) call `evalA`, a numeric leaf fn.
+    // `evalA` inlines at the native-f64 call site (no dispatch, no boxed reference), so the native-vec
+    // group de-virtualizes. The boxed `evalA` closure is left intact for any non-f64 callers.
+    let rust = compile_fixture_typed("tests/perf/spectral_norm.tish");
+    assert!(
+        rust.contains("fn multiplyAv_nv(") && (rust.contains("v: &Vec<f64>") || rust.contains("av: &mut Vec<f64>")),
+        "multiplyAv lowers to a native-vec fn:\n{}",
+        rust.lines().filter(|l| l.contains("multiplyAv_nv")).take(3).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("fn multiplyAtAv_nv("),
+        "multiplyAtAv should forward to native-vec callees:\n{}",
+        rust.lines().filter(|l| l.contains("multiplyAtAv_nv")).take(3).collect::<Vec<_>>().join("\n")
+    );
+    // evalA is inlined: the native-vec body has the substituted body (a `_inl…` temp) and does NOT
+    // call evalA (no `value_call`/`evalA(` inside multiplyAv_nv).
+    let mav = rust
+        .lines()
+        .skip_while(|l| !l.contains("fn multiplyAv_nv("))
+        .take_while(|l| !l.trim_start().starts_with("fn ") || l.contains("multiplyAv_nv"))
+        .collect::<Vec<_>>()
+        .join("\n");
+    assert!(
+        mav.contains("_inl") && !mav.contains("value_call"),
+        "evalA must be inlined into multiplyAv_nv (substituted temps, no value_call):\n{}",
+        mav
+    );
+    if rust.contains("fn spectralNorm_nv(") {
+        let sn = rust.split("fn spectralNorm_nv(").nth(1).unwrap();
+        let sn = sn.split("fn run()").next().unwrap_or(sn);
+        assert!(
+            sn.contains("let mut u: Vec<f64>"),
+            "spectralNorm_nv should keep u/v/w as native Vec<f64> locals"
+        );
+        assert!(
+            sn.contains("multiplyAtAv_nv(") && !sn.contains("multiplyAtAv_native("),
+            "spectralNorm_nv should call multiplyAtAv_nv, not the boxed native shim"
+        );
+    }
+}
+
+#[test]
+fn spectral_norm_embedded_lib_devirtualizes_to_native_vec_fns() {
+    // EmbeddedLib mode fully de-virtualizes the `multiply*` group to native-vec (`_nv`) fns over
+    // `Vec<f64>` params (#350-352 native struct-array codegen). Once the whole group de-virtualizes,
+    // the old boxed `*_native` shims this test used to assert are correctly no longer emitted —
+    // matching the typed-mode `spectral_norm_devirtualizes_with_inlined_evala` check above (which
+    // asserts `multiplyAtAv` routes to `_nv`, not the boxed `_native` shim). Cross-backend soundness
+    // of the de-virtualized code is covered by the gauntlet + `tests/core/native_vec_params`.
+    let rust = compile_fixture_embedded_lib("tests/perf/spectral_norm.tish");
+    assert!(
+        rust.contains("fn multiplyAv_nv(")
+            && rust.contains("fn multiplyAtv_nv(")
+            && rust.contains("fn multiplyAtAv_nv("),
+        "multiply* should de-virtualize to native-vec fns:\n{}",
+        rust.lines().filter(|l| l.contains("_nv(")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("v: &Vec<f64>") && rust.contains("av: &mut Vec<f64>"),
+        "native-vec fns take Vec<f64> params by &/&mut ref"
+    );
+    assert!(
+        !rust.contains("fn multiplyAv_native(")
+            && !rust.contains("fn multiplyAtv_native(")
+            && !rust.contains("fn multiplyAtAv_native("),
+        "the boxed `*_native` shims must be elided once the group fully de-virtualizes:\n{}",
+        rust.lines().filter(|l| l.contains("_native(")).take(6).collect::<Vec<_>>().join("\n")
+    );
+}
+
+#[test]
+fn spectral_norm_embedded_lib_with_runtime_features_devirtualizes() {
+    // The same de-virtualization holds with the runtime features enabled — they swap the embedded
+    // runtime in, but don't change the native-vec lowering of the user fns (still no boxed shims).
+    let features: Vec<String> = [
+        "http", "timers", "fs", "process", "regex", "ws", "tty",
+    ]
+    .into_iter()
+    .map(String::from)
+    .collect();
+    let rust =
+        compile_fixture_embedded_lib_with_features("tests/perf/spectral_norm.tish", &features);
+    assert!(
+        rust.contains("fn multiplyAv_nv(") && rust.contains("fn multiplyAtAv_nv("),
+        "runtime-feature build still de-virtualizes multiply* to native-vec fns:\n{}",
+        rust.lines().filter(|l| l.contains("_nv(")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        !rust.contains("fn multiplyAv_native(") && !rust.contains("fn multiplyAtAv_native("),
+        "no boxed `*_native` shims under runtime features either"
+    );
+}

package/crates/tish_compile/tests/perf_codegen_176.rs

@@ -0,0 +1,60 @@
+//! Generated-Rust assertions for #176 — native numeric globals (`thread_local Cell<f64>`).
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+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
+}
+
+#[test]
+fn fasta_seed_lowers_to_thread_local_and_genrandom_native() {
+    let rust = compile_fixture_typed("tests/perf/fasta.tish");
+    assert!(
+        rust.contains("thread_local!"),
+        "fasta emits thread_local globals:\n{}",
+        rust.lines().filter(|l| l.contains("thread_local") || l.contains("G_SEED")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("static G_SEED: std::cell::Cell<f64>"),
+        "seed lowers to G_SEED Cell:\n{}",
+        rust.lines().filter(|l| l.contains("G_SEED")).take(4).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("fn genRandom_native("),
+        "genRandom becomes M5-eligible after native global seed:\n{}",
+        rust.lines().filter(|l| l.contains("genRandom")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("G_SEED.with(|c| c.set("),
+        "genRandom_native mutates G_SEED:\n{}",
+        rust.lines().filter(|l| l.contains("G_SEED.with")).take(6).collect::<Vec<_>>().join("\n")
+    );
+}
+
+#[test]
+fn native_numeric_global_fixture_interleaved_state() {
+    let rust = compile_fixture_typed("tests/core/native_numeric_global.tish");
+    assert!(
+        rust.contains("static G_COUNTER: std::cell::Cell<f64>"),
+        "counter global lowers:\n{}",
+        rust.lines().filter(|l| l.contains("G_COUNTER")).take(4).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("G_COUNTER.with(|c| c.get())") && rust.contains("G_COUNTER.with(|c| c.set("),
+        "boxed + native paths share G_COUNTER:\n{}",
+        rust.lines()
+            .filter(|l| l.contains("G_COUNTER::with"))
+            .take(8)
+            .collect::<Vec<_>>()
+            .join("\n")
+    );
+}

package/crates/tish_compile/tests/perf_codegen_177.rs

@@ -0,0 +1,167 @@
+//! Generated-Rust assertions for #177 follow-on — Vec<f64> returns, mandel native, fasta cum path.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+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
+}
+
+#[test]
+fn fasta_lowers_cumulative_and_native_arrays() {
+    let rust = compile_fixture_typed("tests/perf/fasta.tish");
+    assert!(rust.contains("fn cumulative_nv("), "cumulative_nv missing");
+    assert!(
+        rust.contains("const G_CODES") || rust.contains("let mut codes: Vec<f64>"),
+        "codes not lowered to module const or native vec"
+    );
+    assert!(
+        rust.contains("const G_PROBS_CUM"),
+        "precomputed cumulative array missing"
+    );
+    if rust.contains("fn fastaRandom_native(") {
+        assert!(
+            rust.contains("fastaRandom_native("),
+            "fastaRandom_native declared but not called"
+        );
+        assert!(
+            rust.contains("G_CODES["),
+            "fastaRandom_native should index G_CODES directly"
+        );
+        assert!(
+            rust.contains("_lcg_seed"),
+            "fastaRandom_native should hoist LCG seed to a local"
+        );
+        assert!(
+            rust.contains("_lcg_seed: i64") && rust.contains("3877i64"),
+            "fastaRandom_native should use integer LCG arithmetic"
+        );
+    }
+}
+
+#[test]
+fn mandelbrot_lowers_mandel_native() {
+    let rust = compile_fixture_typed("tests/perf/mandelbrot.tish");
+    // Prefer top-level `mandel_native` when M5-eligible; the hot loop is already native f64
+    // inside the closure even when this is absent.
+    if rust.contains("fn mandel_native(") {
+        assert!(
+            rust.contains("mandel_native("),
+            "mandel_native declared but not called"
+        );
+        assert!(
+            rust.contains("for _usize_iter") && rust.contains("0..100"),
+            "mandel_native should use usize bounded escape loop for maxIter=100"
+        );
+        assert!(
+            rust.contains("_stayed_") && rust.contains("if _stayed_"),
+            "mandel_native should fuse iter===maxIter into stayed flag"
+        );
+        assert!(
+            rust.contains("count += 1_f64"),
+            "mandel_native should increment count with +="
+        );
+        if let Some(native) = rust.split("fn mandel_native(").nth(1) {
+            let native = native.split("fn run()").next().unwrap_or(native);
+            assert!(
+                !native.contains("iter = (iter + 1_f64)"),
+                "mandel_native should skip iter increment in usize escape loop"
+            );
+            assert!(
+                native.contains("0.0025_f64") && !native.contains("let mut py:"),
+                "mandel_native should fuse py/h and px/w into reciprocal coord init"
+            );
+            assert!(
+                !native.contains("let mut xt:"),
+                "mandel_native should fuse x2/y2/xy iteration temps"
+            );
+            assert!(
+                native.contains("let x2 =") && native.contains("let xy ="),
+                "mandel_native should emit fused iteration temps"
+            );
+        }
+    }
+}
+
+#[test]
+fn fannkuch_nv_uses_direct_flip_indexing() {
+    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_"),
+            "fannkuch_nv flip loop should fuse to ku half-loop"
+        );
+        assert!(
+            !nv.contains("let mut k2:") && !nv.contains("let mut temp:"),
+            "fannkuch_nv fused flip should not emit k2/temp"
+        );
+        assert!(
+            !nv.contains("perm.get(((k - i))"),
+            "fannkuch_nv should not use perm.get for k-i sub-index"
+        );
+        assert!(
+            nv.contains("copy_within(1..((r as usize) + 1), 0)")
+                || nv.contains("copy_within(1..((r) as usize + 1), 0)")
+                || nv.contains("copy_within(1..(_ru + 1), 0)"),
+            "fannkuch_nv rotation should shift perm1 via copy_within"
+        );
+        assert!(
+            nv.contains("perm1[(r) as usize] = perm0")
+                || nv.contains("perm1[r as usize] = perm0")
+                || nv.contains("perm1[(r as usize)] = perm0")
+                || nv.contains("perm1[(r) as usize] = (perm0) as i32"),
+            "fannkuch_nv rotation should assign perm1[r] without resize"
+        );
+        assert!(
+            nv.contains("count[(r) as usize] = (count[(r) as usize] - 1)")
+                || nv.contains("count[r as usize] = (count[r as usize] - 1)")
+                || nv.contains("count[(r) as usize] = (count[(r) as usize] - 1i32)")
+                || nv.contains("count[r as usize] = (count[r as usize] - 1i32)")
+                || nv.contains("count[(r) as usize] = (count[(r) as usize] - 1_f64)"),
+            "fannkuch_nv should decrement count[r] via direct indexing"
+        );
+        assert!(
+            nv.contains("perm = std::iter::repeat(0i32).take(10)")
+                || nv.contains("perm = std::iter::repeat(0_f64).take(10)")
+                || nv.contains("perm.extend(std::iter::repeat(0i32).take(10))"),
+            "fannkuch_nv should bulk-init perm array"
+        );
+        assert!(
+            nv.contains("perm1 = (0..10).collect()")
+                || nv.contains("perm1 = (0..10).map(|j| j as f64).collect()"),
+            "fannkuch_nv should iota-init perm1"
+        );
+        assert!(
+            nv.contains(".copy_from_slice(&perm1)"),
+            "fannkuch_nv should copy perm1 into perm via copy_from_slice"
+        );
+        assert!(
+            nv.contains("while r != 1_f64") && nv.contains("count[ri - 1] = r"),
+            "fannkuch_nv should fill count via while r!=1 loop (not bulk 1..n init)"
+        );
+        assert!(
+            !nv.contains("_usize_shift_"),
+            "fannkuch_nv rotation should use copy_within, not per-element shift loop"
+        );
+        assert!(
+            (nv.contains("if ((permCount as i64) & 1) == 0")
+                || (nv.contains("to_int_unchecked") && nv.contains("& 1"))),
+            "fannkuch_nv checksum parity should use fast int parity"
+        );
+        assert!(
+            nv.contains("count[ri - 1] = r as i32")
+                || nv.contains("count[ri - 1] = r"),
+            "fannkuch_nv count[r-1] init should use direct indexing in while loop"
+        );
+    }
+}

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"
+    );
+}