@tishlang/tish 2.10.1 → 2.16.13

package/crates/tish_compile/tests/perf_codegen_173_part3.rs

@@ -0,0 +1,61 @@
+//! Generated-Rust assertions for #173 part 3 — in-bounds index elision.
+//!
+//! When a native `Vec` is filled to a fixed length and an index is proven `< len` (an enclosing
+//! `i < len` guard) and `>= 0`, the store drops its OOB-growth `resize` branch and the read drops its
+//! `.get().unwrap_or(..)` branch — a direct `a[i]` like V8/Bun emit after range-proving a loop. Any
+//! array that can't be proven (escapes, is reassigned, or the index isn't a guarded counter) keeps
+//! the OOB-safe lowering. Soundness across backends is covered by the `tests/core` parity corpus.
+
+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 nsieve_inbounds_store_and_read_elide_their_guards() {
+    // `isPrime` is filled to length `n` and only indexed; the read `isPrime[i]` (guard `i < n`) and
+    // the strided store `isPrime[k] = false` (guard `k < n`, `k` non-negative, stored before its own
+    // `k = k + i` reassignment) are both provably in-bounds.
+    let rust = compile_fixture_typed("tests/perf/nsieve.tish");
+    // Read: direct index, NOT `.get(..).copied().unwrap_or(false)`.
+    assert!(
+        rust.contains("isPrime[(i) as usize]"),
+        "in-bounds read should be a direct index:\n{}",
+        rust.lines().filter(|l| l.contains("isPrime")).take(8).collect::<Vec<_>>().join("\n")
+    );
+    // Store: direct index, NO `resize` grow branch. The strided `isPrime[k] = false` is a discarded
+    // statement, so it lowers to the bare side-effect form (no `{ …; Value::Null }` value wrapper);
+    // the point is it is a direct indexed store, not a resize-grow.
+    assert!(
+        rust.contains("isPrime[(k) as usize] = false;"),
+        "in-bounds store should be a direct indexed store (no resize-grow branch):\n{}",
+        rust.lines().filter(|l| l.contains("isPrime")).take(8).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        !rust.contains("isPrime.resize") && !rust.contains("isPrime.get("),
+        "the proven-fixed-length isPrime must have no resize/get fallbacks left:\n{}",
+        rust.lines().filter(|l| l.contains("isPrime")).take(8).collect::<Vec<_>>().join("\n")
+    );
+}
+
+#[test]
+fn escaping_array_keeps_oob_safe_lowering() {
+    // `a` is passed to a function, so it could be mutated/shrunk out of line — the fixed-length fact
+    // must NOT apply and the store must keep its OOB-growth `resize` branch.
+    let rust = compile_fixture_typed("tests/core/inbounds_index.tish");
+    assert!(
+        rust.contains("resize"),
+        "an escaping array must retain the OOB-safe resize store:\n{}",
+        rust.lines().filter(|l| l.contains("resize") || l.contains("esc")).take(8).collect::<Vec<_>>().join("\n")
+    );
+}

package/crates/tish_compile/tests/perf_codegen_174.rs

@@ -0,0 +1,160 @@
+//! Generated-Rust assertions for the #174 Int32/U32 range-lattice round-trip erasure.
+//!
+//! #174 erases redundant `tishlang_runtime::to_int32` / `to_uint32` calls in the typed bitwise/shift
+//! emitter when an operand is PROVABLY a finite integer — either an integer literal (a compile-time
+//! constant) or a value the integer-range lattice bounds within `(-2^53, 2^53)`. The guarded
+//! `to_int32` (NaN/±Infinity → 0) is retained for every unproven leaf, so the lowering is purely
+//! additive and behaviour-identical (the gauntlet's `typed == boxed == node` checksum is the gate).
+//!
+//! These run in their own test binary so any env flags set here never leak into other tests.
+
+use tishlang_compile::compile;
+use tishlang_parser::parse;
+
+fn enable_typed_flags() {
+}
+
+/// FNV-style hash loop: the canonical bitwise hot loop. The accumulator `h` lives in an i32 register
+/// (existing lowering); #174 additionally folds the constant mask / shift counts and keeps the
+/// `(h * C) >>> 0` f64-rounding excursion intact.
+const FNV: &str = r#"
+let h = 2166136261
+for (let i = 0; i < 100; i++) {
+  h = h ^ (i & 255)
+  h = (h * 16777619) >>> 0
+  h = ((h << 13) | (h >>> 19)) >>> 0
+}
+let check = h >>> 0
+console.log(check)
+"#;
+
+#[test]
+fn issue_174_constant_mask_and_shift_counts_fold() {
+    // `i & 255`, `h << 13`, `h >>> 19`, `… >>> 0`: every integer-literal operand is a compile-time
+    // ToInt32 constant, so it must emit as a bare `i32` literal — NOT a runtime `to_int32(255_f64)`.
+    let rust = compile(&parse(FNV).unwrap()).unwrap();
+    assert!(
+        rust.contains("255i32"),
+        "the `& 255` mask must fold to an i32 constant:\n{}",
+        rust.lines().filter(|l| l.contains("255")).take(4).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("13i32") && rust.contains("19i32"),
+        "shift counts 13 / 19 must fold to i32 constants"
+    );
+    // No runtime ToInt32/ToUint32 call on an integer LITERAL remains.
+    assert!(
+        !rust.contains("to_int32(255") && !rust.contains("to_uint32(13")
+            && !rust.contains("to_uint32(19") && !rust.contains("to_uint32(0"),
+        "integer-literal operands must not round-trip through a runtime to_int32/to_uint32 call:\n{}",
+        rust.lines().filter(|l| l.contains("to_uint32(") || l.contains("to_int32(")).take(8).collect::<Vec<_>>().join("\n")
+    );
+}
+
+#[test]
+fn issue_174_fnv_accumulator_still_i32_register_no_regression() {
+    // The i32-register accumulator lowering (and its `(h * C)` f64-rounding excursion) is preserved:
+    // `h` is an i32 register, there is no per-op `to_int32(h)` round-trip, and the multiply excursion
+    // lowers to an unchecked f64 truncation. (Mirror of `fnv_accumulator_lowers_to_i32_register`.)
+    let rust = compile(&parse(FNV).unwrap()).unwrap();
+    assert!(
+        rust.contains("let mut h: i32 = (2166136261u32) as i32;"),
+        "h must stay an i32 register seeded via u32 reinterpretation"
+    );
+    assert!(
+        !rust.contains("to_int32(h)"),
+        "no per-op to_int32(h) round-trip on the i32 accumulator"
+    );
+    assert!(
+        rust.contains(".to_int_unchecked::<i64>()") && rust.contains("16777619"),
+        "the `h * 16777619` excursion stays an f64 multiply with an unchecked truncation"
+    );
+}
+
+#[test]
+fn issue_174_range_proven_counter_drops_is_finite_guard() {
+    // A loop counter masked into a bitwise op is range-proven integral, so its ToInt32 must not
+    // round-trip through the guarded `to_int32(i)` call. The guard-free lowering is the saturating
+    // `(i) as i64 as i32` cast — #380 (PR #387) replaced the original `to_int_unchecked::<i64>()`
+    // here because `int_valued_locals` proves integrality but not magnitude, making the unchecked
+    // truncation UB on an overflowing accumulator; the saturating cast is defined for all f64 at
+    // the same hot-path cost (fnv_hash/fannkuch/mandelbrot measured at baseline in #387).
+    let src = r#"
+let acc = 0
+for (let i = 0; i < 64; i = i + 1) {
+  acc = acc ^ (i & 15)
+}
+console.log(acc >>> 0)
+"#;
+    let rust = compile(&parse(src).unwrap()).unwrap();
+    assert!(
+        rust.contains("as i64 as i32"),
+        "a range-proven counter `i` in `i & 15` must lower to the guard-free saturating cast:\n{}",
+        rust.lines().filter(|l| l.contains("acc") || l.contains("to_int")).take(8).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        !rust.contains("to_int32(i)"),
+        "a range-proven counter must not round-trip through the guarded to_int32 call:\n{}",
+        rust.lines().filter(|l| l.contains("to_int32(")).take(8).collect::<Vec<_>>().join("\n")
+    );
+    // Nothing in this program is the bounded `(h * C) >>> 0` excursion shape, so the UB-prone
+    // unchecked truncation must not appear at all (#380).
+    assert!(
+        !rust.contains("to_int_unchecked"),
+        "no unchecked truncation may appear for an unbounded-magnitude program"
+    );
+}
+
+#[test]
+fn fnv_value_fn_uses_usize_for_loop() {
+    let src = r#"
+function fnv1a(n) {
+  let h = 2166136261
+  for (let i = 0; i < n; i++) {
+    h = h ^ (i & 255)
+    h = (h * 16777619) >>> 0
+    h = ((h << 13) | (h >>> 19)) >>> 0
+  }
+  return h >>> 0
+}
+let check = fnv1a(100)
+console.log(check)
+"#;
+    enable_typed_flags();
+    let rust = compile(&parse(src).unwrap()).unwrap();
+    assert!(
+        rust.contains("for _usize_i_0 in 0..(n as usize)"),
+        "fnv1a hot loop should lower to a usize `for` over param n:\n{}",
+        rust.lines().filter(|l| l.contains("usize") || l.contains("fnv1a")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        rust.contains("let mut h: i32 = (2166136261u32) as i32;"),
+        "accumulator h must stay on the i32 register path"
+    );
+}
+
+#[test]
+fn issue_174_unproven_leaf_keeps_guarded_to_int32() {
+    // SOUNDNESS: an f64 value that is NOT provably a finite integer (here a fractional accumulator —
+    // the range lattice drops it because `n = n + 0.5` is not integer-preserving) must KEEP the
+    // guarded `tishlang_runtime::to_int32`, never the unchecked truncation (a non-integer/NaN/±Inf
+    // input must map through the JS ToInt32 path, not a raw `to_int_unchecked`).
+    let src = r#"
+let n = 0.0
+for (let i = 0; i < 10; i = i + 1) { n = n + 0.5 }
+let m = n & 7
+console.log(m >>> 0)
+"#;
+    let rust = compile(&parse(src).unwrap()).unwrap();
+    // `n` is a top-level numeric used only at top level, so per #313 it is a native `let mut n: f64`
+    // local (not a `thread_local Cell` — no function references it). The soundness invariant is
+    // unchanged: the unproven fractional value must STILL pass through the guarded `to_int32` (not an
+    // unchecked truncation) before the `& 7` mask.
+    assert!(
+        rust.contains("tishlang_runtime::to_int32(n) & 7i32"),
+        "an unproven f64 leaf must keep the guarded to_int32 before the mask:\n{}",
+        rust.lines().filter(|l| l.contains("& ") || l.contains("to_int")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    // The literal `7` still folds; only the unproven `n` keeps the guard.
+    assert!(rust.contains("7i32"), "the literal mask `7` still folds to a constant");
+}

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