@tishlang/tish-format 2.43.8 → 3.0.0

package/crates/tish_compile/tests/regr_558d_native_vec_mutators.rs

@@ -0,0 +1,156 @@
+//! tishlang/tish#558 — in-place native `Vec` mutators (`pop`/`shift`/`unshift`/`reverse`/`sort`) must
+//! mutate the REAL Vec, both for a plain local and for a closure-captured (refcell-wrapped) one. The
+//! boxed `array_*` fallback operates on a THROWAWAY boxed copy of the Vec (cloning + `from_struct`-boxing
+//! every element into a `Value::Array`), so the mutation is silently discarded (O(n), and an E0282 on
+//! the boxing closure for a `Vec<struct>`). These assert the native forms are emitted — plain (`a.pop()`,
+//! `a.remove(0)`, `a.insert(0, …)`, `a.reverse()`, `a.sort_by(…)`) and captured (`(*a.borrow_mut())…`) —
+//! and that the throwaway-boxing fallback does NOT appear.
+//!
+//! End-to-end runtime parity (interp/vm == native) is exercised by the fixtures under tests/core via
+//! `test_mvp_programs_native`; these codegen-string checks pin the lowering itself.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+fn emit(body: &str, name: &str) -> String {
+    let src = format!("interface E {{ x: number; y: number }}\n{}", body);
+    let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join(name);
+    std::fs::write(&path, src).unwrap();
+    compile_project_full(&path, path.parent(), &[], true).unwrap().0
+}
+
+// A plain local `a` mutated at top level (not captured) — native, not wrapped.
+const PLAIN: &str = "\
+let a: E[] = []
+a.push({ x: 1, y: 2 })
+a.push({ x: 3, y: 4 })
+let p = a.pop()
+let s = a.shift()
+a.unshift({ x: 9, y: 9 })
+a.reverse()
+a.sort((u, v) => u.x - v.x)
+console.log(a.length)
+";
+
+#[test]
+fn plain_native_vec_mutators_are_native() {
+    let r = emit(PLAIN, "plain_mut.tish");
+    assert!(r.contains("a.pop()"), "pop must be native `a.pop()`\n{r}");
+    assert!(r.contains("a.remove(0)"), "shift must be native `a.remove(0)`\n{r}");
+    assert!(r.contains("a.insert(0,"), "unshift must be native `a.insert(0, …)`\n{r}");
+    assert!(r.contains("a.reverse()"), "reverse must be native `a.reverse()`\n{r}");
+    assert!(r.contains("a.sort_by("), "sort must be native `a.sort_by(…)`\n{r}");
+    // None of the mutators may fall to the throwaway whole-Vec boxing fallback.
+    for boxed in ["array_pop(&Value::Array(VmRef::new", "array_shift", "array_unshift", "array_reverse"] {
+        assert!(!r.contains(boxed), "mutator must not box the whole Vec (`{boxed}`)\n{r}");
+    }
+}
+
+// `a` is captured AND mutated inside a closure → refcell-wrapped. Each mutator must go through the cell.
+fn wrapped(mutator: &str, name: &str) -> String {
+    emit(
+        &format!(
+            "let a: E[] = []\na.push({{ x: 1, y: 2 }})\na.push({{ x: 3, y: 4 }})\nfunction f() {{ {mutator} }}\nf()\nconsole.log(a.length)\n"
+        ),
+        name,
+    )
+}
+
+#[test]
+fn wrapped_pop_is_native_through_cell() {
+    let r = wrapped("a.pop()", "w_pop.tish");
+    assert!(r.contains(".borrow_mut()).pop()"), "wrapped pop must be `(*a.borrow_mut()).pop()`\n{r}");
+    assert!(!r.contains("array_pop(&Value::Array(VmRef::new"), "wrapped pop must not box the whole Vec\n{r}");
+}
+
+#[test]
+fn wrapped_shift_is_native_through_cell() {
+    let r = wrapped("a.shift()", "w_shift.tish");
+    assert!(r.contains(".borrow_mut()).remove(0)"), "wrapped shift must be `(*a.borrow_mut()).remove(0)`\n{r}");
+}
+
+#[test]
+fn wrapped_unshift_is_native_through_cell() {
+    let r = wrapped("a.unshift({ x: 9, y: 9 })", "w_unshift.tish");
+    assert!(r.contains(".borrow_mut()).insert(0,"), "wrapped unshift must be `(*a.borrow_mut()).insert(0, …)`\n{r}");
+}
+
+#[test]
+fn wrapped_reverse_is_native_through_cell() {
+    let r = wrapped("a.reverse()", "w_reverse.tish");
+    assert!(r.contains(".borrow_mut()).reverse()"), "wrapped reverse must be `(*a.borrow_mut()).reverse()`\n{r}");
+}
+
+#[test]
+fn wrapped_sort_is_native_through_cell() {
+    let r = wrapped("a.sort((u, v) => u.x - v.x)", "w_sort.tish");
+    assert!(
+        r.contains(".borrow_mut()).sort_by(") || r.contains(".borrow_mut() = "),
+        "wrapped sort must mutate through the cell (`(*a.borrow_mut()).sort_by` or a write-back)\n{r}"
+    );
+}
+
+// ── splice / fill / copyWithin (native emitters, plain + captured) ──
+
+const SFC_PLAIN: &str = "\
+let a: E[] = []
+a.push({ x: 1, y: 2 })
+a.push({ x: 3, y: 4 })
+let removed = a.splice(0, 1, { x: 9, y: 9 })
+a.fill({ x: 0, y: 0 }, 0, 1)
+a.copyWithin(0, 1)
+console.log(a.length + \"\" + removed.length)
+";
+
+#[test]
+fn plain_splice_fill_copywithin_are_native() {
+    let r = emit(SFC_PLAIN, "sfc_plain.tish");
+    assert!(r.contains(".splice(__start"), "splice must be native `Vec::splice`\n{r}");
+    assert!(r.contains("__v.clone()"), "fill must write elements natively\n{r}");
+    assert!(r.contains(".to_vec()"), "copyWithin must copy via a native temp\n{r}");
+    for boxed in ["array_splice", "array_fill", "array_copy_within", "copy_within as"] {
+        assert!(!r.contains(boxed), "must not fall to the boxed `{boxed}` on a throwaway copy\n{r}");
+    }
+}
+
+#[test]
+fn wrapped_splice_is_native_through_guard() {
+    // `a` captured + spliced in a closure → wrapped; splice uses a `borrow_mut` guard.
+    let r = wrapped("a.splice(0, 1)", "w_splice.tish");
+    assert!(
+        r.contains(".borrow_mut()") && r.contains("__g.splice("),
+        "wrapped splice must run on a `borrow_mut` guard (`__g.splice(..)`)\n{r}"
+    );
+    assert!(!r.contains("array_splice"), "wrapped splice must not box the whole Vec\n{r}");
+}
+
+// ── captured (wrapped) array READS must NOT box the whole Vec (tish#558 read side) ──
+
+#[test]
+fn wrapped_element_field_read_is_native_not_whole_array_box() {
+    // `arr` captured + mutated in a closure → wrapped; reading `arr[0].x` must index the borrowed
+    // Vec directly, NOT clone+box the entire Vec into a `Value::Array` just to read one field.
+    let src = "let arr: E[] = []\narr.push({ x: 1, y: 2 })\nfunction f() { arr[0].x = 9; return arr[0].x }\nconsole.log(f())\n";
+    let path = std::path::PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("w_read.tish");
+    std::fs::write(&path, format!("interface E {{ x: number; y: number }}\n{src}")).unwrap();
+    let r = compile_project_full(&path, path.parent(), &[], true).unwrap().0;
+    assert!(
+        r.contains("let __bg = arr.borrow();") && r.contains("(*__bg)["),
+        "wrapped `arr[i].field` read must index the borrowed Vec natively via a scoped guard (#567)\n{r}"
+    );
+    assert!(
+        !r.contains("iter().cloned().map(|v| tishlang_runtime::Value::from_struct"),
+        "wrapped read must NOT clone+box the whole Vec into a Value::Array (O(n)/read)\n{r}"
+    );
+}
+
+#[test]
+fn push_returns_new_length_not_null() {
+    // `push` returns the new length (JS / tish interp), a plain `.len()` read — not `Value::Null`.
+    let r = emit("let a: E[] = []\nlet n = a.push({ x: 1, y: 2 })\nconsole.log(n)\n", "push_ret.tish");
+    assert!(
+        r.contains(".len() as f64"),
+        "push must return the new length (`.len() as f64`), not Null\n{r}"
+    );
+}

package/crates/tish_compile/tests/regr_562_wrapped_struct_array_push.rs

@@ -0,0 +1,50 @@
+//! tishlang/tish#562 — `.push()` (and `.length`) on a captured (refcell-wrapped) typed struct array
+//! must lower to NATIVE ops, not box the whole `Vec` into a `Value::Array` via an UNTYPED `map(|v| …)`
+//! closure. The boxed path both wasted O(n) per op AND failed to compile with `error[E0282]: type
+//! annotations needed` (the untyped closure param, since the skipped native push never pinned the Vec's
+//! element type). Reproduced on the GBA emit path (the `i32` struct field is native only there).
+
+use std::path::PathBuf;
+
+use tishlang_compile::{compile_project_full_emit, NativeEmitMode};
+
+fn gba_emit(src: &str, name: &str) -> String {
+    let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join(name);
+    std::fs::write(&path, src).unwrap();
+    compile_project_full_emit(&path, path.parent(), &[], true, NativeEmitMode::Gba, None)
+        .unwrap()
+        .0
+}
+
+// The #562 repro shape: a typed struct array with an i32 field, captured + pushed in a closure (which
+// is what refcell-wraps it, matching the issue's `(*enemyStates.borrow())` generated code).
+const SRC: &str = "\
+type EnemyState = { timer: i32 }
+let enemyStates: EnemyState[] = []
+function update() { enemyStates.push({ timer: 0 }) }
+update()
+console.log(enemyStates.length)
+";
+
+#[test]
+fn wrapped_struct_push_and_length_do_not_box_the_whole_vec() {
+    let rust = gba_emit(SRC, "regr562.tish");
+    // No whole-Vec boxing (the E0282-prone untyped `map(|v| …)` closure) for either push or length.
+    assert!(
+        !rust.contains("iter().cloned().map(|v|"),
+        "#562: wrapped struct push/length must NOT box the whole Vec via an untyped `map(|v| …)`\n{rust}"
+    );
+    assert!(
+        !rust.contains("array_push(&Value::Array(VmRef::new"),
+        "#562: push must not fall to the boxed `array_push` on a throwaway Value::Array copy\n{rust}"
+    );
+    // Native push through the shared cell, and a native `len()` for `.length`.
+    assert!(
+        rust.contains(".borrow_mut()).push("),
+        "#562: push must be native `(*enemyStates.borrow_mut()).push(..)`\n{rust}"
+    );
+    assert!(
+        rust.contains("enemyStates.borrow(); __bg.len()"),
+        "#562: `.length` must be a native scoped `{{ let __bg = enemyStates.borrow(); __bg.len() }}` (#567), not a whole-Vec box\n{rust}"
+    );
+}

package/crates/tish_compile/tests/regr_fixed_native_coercions.rs

@@ -0,0 +1,69 @@
+//! GBA `fixed` native coercions (the "gba perf" numeric lowering). These paths lift a native
+//! integer/f64 into `tishlang_runtime::Fixed` (agb `Num<i32,8>`, raw = value << 8) WITHOUT a boxed
+//! `Value` round-trip, so `fixed` arithmetic stays native:
+//!   * `let v: fixed = <int/float literal>`          — literal → Fixed
+//!   * `let d: fixed = t * speed` (t is a runtime i32) — runtime integer LIFTED to Fixed before `Fixed * Fixed`
+//!   * `nx = <int literal>` (reassign a fixed local)  — RHS lifted to Fixed (the E0308 reassignment fix)
+//!
+//! All three are GBA-only (`fixed`/`i32` are native scalars only under `--target gba`). Off-GBA the
+//! `fixed` annotation falls back to a boxed `Value`, so none of the native `Fixed` code appears —
+//! asserted below so a leak into the desktop build (where `tishlang_runtime::Fixed` does not exist)
+//! would fail the test rather than the downstream Rust compile.
+
+use std::path::PathBuf;
+
+use tishlang_compile::{compile_project_full, compile_project_full_emit, NativeEmitMode};
+
+const SRC: &str = "\
+let speed: fixed = 2
+let t: i32 = 5
+let d: fixed = t * speed
+let nx: fixed = 0
+nx = 3
+console.log(d)
+console.log(nx)
+";
+
+fn write_src() -> PathBuf {
+    let dir = PathBuf::from(env!("CARGO_TARGET_TMPDIR"));
+    let path = dir.join("fixed_native_coercions.tish");
+    std::fs::write(&path, SRC).unwrap();
+    path
+}
+
+#[test]
+fn gba_lifts_int_and_float_into_native_fixed() {
+    let path = write_src();
+    let rust = compile_project_full_emit(&path, path.parent(), &[], true, NativeEmitMode::Gba, None)
+        .unwrap()
+        .0;
+
+    // `let speed: fixed = 2` — the int literal lifts to Fixed (× 256 via from_raw), not a boxed number.
+    assert!(
+        rust.contains("let mut speed: tishlang_runtime::Fixed = tishlang_runtime::Fixed::from_raw("),
+        "`let speed: fixed = 2` must lower to a native Fixed::from_raw literal.\n{rust}"
+    );
+    // `t * speed` (runtime i32 × fixed) — the integer operand `t` is LIFTED to Fixed (raw = value * 256)
+    // so the whole op stays `Fixed * Fixed`, instead of dropping `t` to f64 and boxing to `ops::*`.
+    assert!(
+        rust.contains("as i32) * 256) * speed"),
+        "`t * speed` must lift the runtime integer `t` to Fixed and stay native Fixed*Fixed.\n{rust}"
+    );
+    // `nx = 3` — reassigning a fixed local lifts the RHS to Fixed (the E0308 reassignment fix), not f64.
+    assert!(
+        rust.contains("nx = tishlang_runtime::Fixed::from_raw("),
+        "reassigning a `fixed` local must lift the RHS to Fixed (not leave it f64).\n{rust}"
+    );
+}
+
+#[test]
+fn off_gba_fixed_stays_boxed_no_native_fixed_type() {
+    let path = write_src();
+    // Default (desktop) emit: `fixed` has no host type, so every one of the above must stay boxed —
+    // NO `tishlang_runtime::Fixed` anywhere (it would not compile off-GBA).
+    let rust = compile_project_full(&path, path.parent(), &[], true).unwrap().0;
+    assert!(
+        !rust.contains("tishlang_runtime::Fixed"),
+        "`fixed` (incl. the `t * speed` lift and `nx =` reassign) must stay boxed off-GBA.\n{rust}"
+    );
+}

package/crates/tish_compile/tests/regr_gba_struct_reflection.rs

@@ -0,0 +1,106 @@
+//! GBA static-type-aware struct reflection. On `--target gba`, `Object.keys/values/entries(s)` and
+//! object spread `{ ...s }` over a statically-known struct (`RustType::Named`) lower to NATIVE reads of
+//! the `TishStruct_*` Rust struct — the struct is never boxed to a `Value::Struct` and no intermediate
+//! hashmap `Value::Object` is built. Only the RESULT (an array / the spread object) is a `Value`.
+//!
+//! DESKTOP is deliberately untouched: reflection there keeps the boxed path (a struct materialises to a
+//! real `Value::Object`, already correct), and struct spread boxes exactly as before — so the hot
+//! `object_spread` bench keeps its clone-shape path. Asserted below so a future change that leaks the
+//! GBA native lowering onto desktop (bench regression) fails here.
+
+use std::path::PathBuf;
+
+use tishlang_compile::{compile_project_full, compile_project_full_emit, NativeEmitMode};
+
+fn emit(src: &str, name: &str, gba: bool) -> String {
+    let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join(name);
+    std::fs::write(&path, src).unwrap();
+    if gba {
+        compile_project_full_emit(&path, path.parent(), &[], true, NativeEmitMode::Gba, None)
+            .unwrap()
+            .0
+    } else {
+        compile_project_full(&path, path.parent(), &[], true).unwrap().0
+    }
+}
+
+const KEYS_SRC: &str = "\
+interface P { x: number; y: number }
+let p: P = { x: 1, y: 2 }
+console.log(Object.keys(p).join(\",\"))
+";
+
+#[test]
+fn gba_object_keys_on_struct_is_native_field_names() {
+    let rust = emit(KEYS_SRC, "gba_keys.tish", true);
+    // Field names emitted as a native array literal — no boxed `tish_object_keys` call on the struct.
+    assert!(
+        rust.contains("Value::String(\"x\".into()), Value::String(\"y\".into())"),
+        "GBA `Object.keys(struct)` must emit the field names natively (no struct box / hashmap).\n{rust}"
+    );
+}
+
+#[test]
+fn desktop_object_keys_stays_boxed_untouched() {
+    let rust = emit(KEYS_SRC, "desk_keys.tish", false);
+    assert!(
+        !rust.contains("Value::String(\"x\".into()), Value::String(\"y\".into())"),
+        "desktop reflection must stay on the boxed path (GBA-gated native lowering leaked to desktop).\n{rust}"
+    );
+}
+
+const SPREAD_SRC: &str = "\
+interface P { x: number; y: number }
+let base: P = { x: 1, y: 2 }
+let merged = { ...base, z: 3 }
+console.log(JSON.stringify(merged))
+";
+
+#[test]
+fn gba_struct_spread_inserts_fields_natively() {
+    let rust = emit(SPREAD_SRC, "gba_spread.tish", true);
+    // Native per-field inserts from a borrowed struct — not the boxed `object_spread_props` helper
+    // (that stays the fallback for a struct hidden behind a `Value`) and not a hashmap materialisation.
+    assert!(
+        rust.contains("let _s = &(") && rust.contains("_obj.insert("),
+        "GBA `{{ ...struct }}` must insert the struct's fields natively.\n{rust}"
+    );
+}
+
+#[test]
+fn desktop_struct_spread_stays_boxed_untouched() {
+    let rust = emit(SPREAD_SRC, "desk_spread.tish", false);
+    // Desktop must keep the inline `if let Value::Object` clone-shape path — the native `let _s = &(`
+    // insert form must NOT appear (that would mean the GBA lowering leaked onto the object_spread bench).
+    assert!(
+        !rust.contains("let _s = &("),
+        "desktop struct spread must stay boxed/inline (bench-safe); native inserts leaked.\n{rust}"
+    );
+}
+
+const IN_SRC: &str = "\
+interface P { x: number; y: number }
+let p: P = { x: 1, y: 2 }
+console.log(\"x\" in p)
+console.log(\"z\" in p)
+";
+
+#[test]
+fn gba_in_on_struct_folds_to_native_bool() {
+    let rust = emit(IN_SRC, "gba_in.tish", true);
+    // A string-literal key `in` a known struct folds to a compile-time bool — no boxed `tish_in_operator`
+    // on the struct, no `Value::Struct` box.
+    assert!(
+        rust.contains("Value::Bool(true)") && rust.contains("Value::Bool(false)"),
+        "GBA `\"x\" in struct` must fold to a compile-time bool.\n{rust}"
+    );
+}
+
+#[test]
+fn desktop_in_on_struct_stays_boxed_untouched() {
+    let rust = emit(IN_SRC, "desk_in.tish", false);
+    assert!(
+        rust.contains("tish_in_operator"),
+        "desktop `in` must stay on the boxed runtime operator (GBA native lowering leaked).\n{rust}"
+    );
+}

package/crates/tish_compile/tests/regression/name_collision_lib.tish

@@ -0,0 +1,6 @@
+// An exported helper whose PARAMETER name (`scene`) collides with a top-level mutable var in the
+// importer. The reference to the parameter inside the body must resolve to the parameter, not the
+// importer's VmRef cell of the same name (tishlang/tish#556).
+export function loadScene(scene) {
+  return scene(1)
+}

package/crates/tish_compile/tests/regression/name_collision_main.tish

@@ -0,0 +1,13 @@
+import { loadScene } from './name_collision_lib'
+
+// A top-level var named `scene`, CAPTURED + mutated by a closure ⇒ it becomes a shared `VmRef` cell.
+// This is the shape the real game hit: mutable module state whose name matches an imported helper's
+// parameter (tishlang/tish#556).
+let scene = 0
+function bump() { scene = scene + 1 }
+bump()
+
+function build(n) { return n + 100 }
+
+console.log(loadScene(build))   // expect 101 — the param `scene` inside loadScene, not the cell
+console.log(scene)              // expect 1

package/crates/tish_compile/tests/regression/struct_array_write.tish

@@ -0,0 +1,22 @@
+// tishlang/tish#558 — typed `Vec<struct>` element field writes must be NATIVE stores into the Vec,
+// not a `set_prop` on a throwaway `Value::object_from_pairs([field.clone()...])` copy (which discards
+// the write). Covers a module-level typed struct array and a local one; both read the field back so a
+// discarded write is observable.
+
+type P = { x: i32, y: i32 }
+
+// (1) module-level typed struct array
+let arr: P[] = []
+arr.push({ x: 10, y: 0 })
+arr[0].x = 200
+
+// (2) local typed struct array inside a function
+function localWrite() {
+  let es: P[] = []
+  es.push({ x: 1, y: 2 })
+  es[0].x = 99
+  console.log(es[0].x)  // 99 if the write took effect, 1 if discarded
+}
+
+console.log(arr[0].x)   // 200 if the write took effect, 10 if discarded
+localWrite()

package/crates/tish_compile/tests/regression/struct_field_return_read.tish

@@ -0,0 +1,10 @@
+// tishlang/tish#558 residual — reading a struct field from a Vec element in a value/return position
+// must CLONE a non-Copy field, not move it out of the borrowed element (E0507). (A Copy field like an
+// on-GBA `i32` reads by value fine; off-GBA a `: i32` field is a boxed `Value`, which is non-Copy.)
+type P = { x: i32 }
+function firstX(): i32 {
+  let es: P[] = []
+  es.push({ x: 7 })
+  return es[0].x
+}
+console.log(firstX())

package/crates/tish_core/src/console_style.rs

@@ -90,6 +90,10 @@ fn format_value_styled_inner(value: &Value, colors: bool, quote_strings: bool) -
         }
         Value::Bool(b) => format!("{BOOLEAN}{b}{RESET}"),
         Value::Null => format!("{NULL}null{RESET}"),
+        #[cfg(feature = "portable")]
+        Value::Struct(s) => {
+            format_value_styled_inner(&s.borrow().tish_to_object(), colors, quote_strings)
+        }
         Value::Array(arr) => {
             let inner: Vec<String> = arr
                 .borrow()

package/crates/tish_core/src/json.rs

@@ -239,6 +239,14 @@ fn json_stringify_into_guarded(buf: &mut String, value: &Value, ancestors: &mut
         }
         #[cfg(feature = "regex")]
         Value::RegExp(_) => buf.push_str("null"),
+        // A boxed typed struct serialises like the object it is: materialise once and recurse. (This is
+        // the generic path; codegen also has a direct `__tish_json_TishStruct_*` fast path that never
+        // boxes to a struct-Value in the first place, used when the static type is known.)
+        #[cfg(feature = "portable")]
+        Value::Struct(s) => {
+            let obj = s.borrow().tish_to_object();
+            json_stringify_into_guarded(buf, &obj, ancestors);
+        }
     }
 }