@tishlang/tish-lsp 2.39.0 → 3.0.0

package/crates/tish_compile/tests/regr_558c_wrapped_struct_array.rs

@@ -0,0 +1,64 @@
+//! tishlang/tish#558 — a captured (refcell-wrapped) native struct `Vec` must mutate NATIVELY, not fall
+//! to the boxed path. When a struct array is closure-captured-and-mutated it is wrapped in a `VmRef`;
+//! the native fast paths used to bail on that (`!refcell_wrapped_vars`), so `arr[i].field = v` and
+//! `arr.push(x)` fell to the generic boxed path, which cloned+`from_struct`-boxed the WHOLE Vec into a
+//! throwaway `Value::Array` and ran `set_prop`/`array_push` on the discarded copy — O(n) per op, the
+//! write lost, and (for a `Vec<struct>`) an E0282 on the boxing closure since the skipped native op
+//! never pinned the element type. These assert the native `borrow_mut` forms are emitted instead.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+fn 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(&path, path.parent(), &[], true).unwrap().0
+}
+
+// `arr` is captured AND mutated (field-assign) by `update`, so it is refcell-wrapped.
+const WRAPPED_ASSIGN: &str = "\
+interface E { x: number; y: number }
+let arr: E[] = []
+arr.push({ x: 0, y: 0 })
+function update() { arr[0].x = 200 }
+update()
+console.log(arr[0].x)
+";
+
+#[test]
+fn wrapped_struct_element_field_assign_is_a_native_store() {
+    let rust = emit(WRAPPED_ASSIGN, "wrapped_assign.tish");
+    // Native element field store through the shared cell — not a `set_prop` on a boxed copy.
+    assert!(
+        rust.contains("borrow_mut())[_i]") || rust.contains(".borrow_mut())[") ,
+        "#558: wrapped `arr[i].field = v` must store natively through `(*arr.borrow_mut())[i]`.\n{rust}"
+    );
+    assert!(
+        !rust.contains("set_prop(&(tishlang_runtime::get_index(&Value::Array(VmRef::new"),
+        "#558: wrapped struct assign must NOT box the whole Vec and set_prop a throwaway copy.\n{rust}"
+    );
+}
+
+// `a` is captured AND mutated (push) by `f`, so it is refcell-wrapped.
+const WRAPPED_PUSH: &str = "\
+interface E { x: number; y: number }
+let a: E[] = []
+function f() { a.push({ x: 1, y: 2 }) }
+f()
+console.log(a[0].x)
+";
+
+#[test]
+fn wrapped_struct_push_is_a_native_push() {
+    let rust = emit(WRAPPED_PUSH, "wrapped_push.tish");
+    // Native push through the shared cell — not a boxed `array_push` on a whole-Vec copy.
+    assert!(
+        rust.contains("borrow_mut()).push("),
+        "#558: wrapped `a.push(struct)` must push natively through `(*a.borrow_mut()).push(..)`.\n{rust}"
+    );
+    assert!(
+        !rust.contains("array_push(&Value::Array(VmRef::new"),
+        "#558: wrapped struct push must NOT box the whole Vec into a throwaway array_push.\n{rust}"
+    );
+}

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_numerics_gated.rs

@@ -0,0 +1,58 @@
+//! Regression: `fixed` and the narrow integer widths (`i8/u8/i16/u16/u32`) are the GBA typed-scalar
+//! vocabulary and must lower to native scalars ONLY for `--target gba`. On the default native build
+//! they must fall back to boxed `Value` — otherwise `fixed` references `tishlang_runtime::Fixed`,
+//! which does not exist off-GBA (a hard compile error), and narrow widths truncate on store,
+//! diverging from the interpreter and breaking the typed == boxed == interpreter guarantee.
+use std::path::PathBuf;
+use tishlang_compile::{compile_project_full, compile_project_full_emit, NativeEmitMode};
+
+fn fixture(rel: &str) -> PathBuf {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    manifest.join("../..").join(rel).canonicalize().unwrap()
+}
+
+fn compile(rel: &str) -> String {
+    let path = fixture(rel);
+    // compile_project_full uses the default DesktopBin emit mode (i.e. NOT --target gba).
+    compile_project_full(&path, path.parent(), &[], true).unwrap().0
+}
+
+#[test]
+fn narrow_int_and_fixed_do_not_lower_to_native_off_gba() {
+    let rust = compile("tests/regression/gba_numerics_gated.tish");
+    // `fixed` must not emit the GBA-only native type (absent off-GBA → would not compile).
+    assert!(
+        !rust.contains("tishlang_runtime::Fixed"),
+        "`: fixed` must fall back to boxed Value on a non-GBA build (found the native Fixed type):\n{}",
+        rust
+    );
+    // The narrow-width fields must not become native storage types (which would truncate).
+    assert!(
+        !rust.contains(": u8") && !rust.contains(": i16") && !rust.contains("as u8"),
+        "narrow-int annotations must stay boxed Value off-GBA (found native narrow storage):\n{}",
+        rust
+    );
+}
+
+#[test]
+fn gba_numeric_profile_does_not_leak_to_a_later_desktop_compile() {
+    // The numeric profile is a thread-local. A GBA compile turns it on; a subsequent non-GBA
+    // compile on the SAME thread (as happens in an LSP / a `cargo test` worker) must NOT inherit it
+    // — otherwise `: fixed`/narrow/`i32` would lower natively off-GBA and diverge. This orders both
+    // compiles on one thread and checks the desktop one is clean.
+    let path = fixture("tests/regression/gba_numerics_gated.tish");
+    let gba = compile_project_full_emit(&path, path.parent(), &[], true, NativeEmitMode::Gba, None)
+        .unwrap()
+        .0;
+    assert!(
+        gba.contains("tishlang_runtime::Fixed"),
+        "sanity: GBA mode DOES lower `: fixed` to the native Fixed type"
+    );
+    // Same thread, right after the GBA compile: a default (DesktopBin) compile must reset the profile.
+    let desktop = compile_project_full(&path, path.parent(), &[], true).unwrap().0;
+    assert!(
+        !desktop.contains("tishlang_runtime::Fixed"),
+        "a desktop compile after a GBA compile leaked the GBA numeric profile (found native Fixed):\n{}",
+        desktop
+    );
+}

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_compiler_wasm/Cargo.toml

@@ -16,6 +16,7 @@ wasm-bindgen = "0.2"
 
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_compile_js = { path = "../tish_compile_js", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -76,7 +76,8 @@ fn parent_dir(path: &str) -> &str {
     }
 }
 
-/// Resolve import spec to a key for the files map. Tries .tish extension if missing.
+/// Resolve import spec to a key for the files map.
+/// Uses the same platform/surface cascade as `tish resolve-id` / disk resolve (`TISH_PLATFORM` / `TISH_SURFACE`).
 fn resolve_import_to_key(
     spec: &str,
     from_dir: &str,
@@ -86,14 +87,29 @@ fn resolve_import_to_key(
     if files.contains_key(&normalized) {
         return Ok(normalized);
     }
-    if !normalized.ends_with(".tish") && !normalized.contains('.') {
-        let with_ext = format!("{}.tish", normalized);
-        if files.contains_key(&with_ext) {
-            return Ok(with_ext);
+
+    let stem = if normalized.ends_with(".tish") {
+        &normalized[..normalized.len() - 5]
+    } else if !normalized.contains('.') {
+        normalized.as_str()
+    } else {
+        return Err(format!(
+            "Cannot resolve import '{}' from {}: file not in virtual file map",
+            spec, from_dir
+        ));
+    };
+
+    // Match CLI: honor env when set (playground can set TISH_PLATFORM / TISH_SURFACE).
+    let _ = tishlang_compile::apply_resolve_env(None, None);
+    let ctx = tishlang_compile::resolve_context();
+    for key in tishlang_compile::platform_virtual_keys(stem, ctx) {
+        if files.contains_key(&key) {
+            return Ok(key);
         }
     }
+
     Err(format!(
-        "Cannot resolve import '{}' from {}: file not in virtual file map",
+        "Cannot resolve import '{}' from {}: file not in virtual file map (platform cascade)",
         spec, from_dir
     ))
 }
@@ -584,4 +600,38 @@ mod tests {
             "import of re-exported `plus` should bind to dep's `add`"
         );
     }
+
+    #[test]
+    fn resolve_virtual_honors_platform_cascade() {
+        use tishlang_compile::{set_resolve_context, Platform, ResolveContext, Surface};
+        set_resolve_context(ResolveContext {
+            platform: Platform::Macos,
+            surface: Surface::Native,
+        });
+        let mut files = HashMap::new();
+        files.insert(
+            "Button.tish".to_string(),
+            "export fn Button() {}".to_string(),
+        );
+        files.insert(
+            "Button.macos.tish".to_string(),
+            "export fn Button() {}".to_string(),
+        );
+        files.insert(
+            "main.tish".to_string(),
+            "import { Button } from \"./Button\"\nButton()".to_string(),
+        );
+        let modules = resolve_virtual("main.tish", &files).unwrap();
+        // macos/native → the .macos variant wins; the base is never loaded.
+        assert!(
+            modules.iter().any(|m| m.path == "Button.macos.tish"),
+            "platform cascade should resolve Button.macos.tish"
+        );
+        assert!(
+            !modules.iter().any(|m| m.path == "Button.tish"),
+            "base Button.tish must not resolve when the macos variant exists"
+        );
+        // Reset the process-wide context so it doesn't leak into sibling tests.
+        set_resolve_context(ResolveContext::default());
+    }
 }