@tishlang/tish-lsp 2.43.8 → 3.0.0

package/crates/tish_compile/src/resolve.rs

@@ -22,6 +22,11 @@ pub struct ResolvedNativeModule {
     pub export_fn: String,
     /// When false, omit `path = …` in the generated Cargo.toml (crate comes from `tish.rustDependencies` only).
     pub use_path_dependency: bool,
+    /// The crate's own SOURCE directory (where its `Cargo.toml`/`src` live), when known — distinct from
+    /// `crate_path` (the importing project root). Used to find a `tish.d.tish` the crate ships (typed
+    /// externs). For a `cargo:` dep it's the resolved `rustDependencies` path; for a `tish.module`
+    /// package it's the package dir; `None` for registry deps with no local path.
+    pub source_dir: Option<PathBuf>,
 }
 
 /// How codegen links a native import to Rust (`generateNativeWrapper` for `tish:*`; `cargo:*` always generated).
@@ -39,6 +44,18 @@ pub enum NativeModuleInit {
     },
 }
 
+impl NativeModuleInit {
+    /// The Rust crate name whose functions back this module — the path for a direct typed call
+    /// (`<crate_name>::name_typed(..)`). Both variants carry it (Legacy directly, Generated as the
+    /// shim crate the generated namespace forwards to).
+    pub fn crate_name(&self) -> &str {
+        match self {
+            NativeModuleInit::Legacy { crate_name, .. } => crate_name,
+            NativeModuleInit::Generated { shim_crate, .. } => shim_crate,
+        }
+    }
+}
+
 /// Extra native build inputs produced alongside Rust source (Cargo merge + optional wrapper).
 #[derive(Debug, Clone)]
 pub struct NativeBuildArtifacts {
@@ -383,6 +400,17 @@ fn resolve_cargo_native_module(
     let crate_path = project_root
         .canonicalize()
         .unwrap_or_else(|_| project_root.to_path_buf());
+    // The crate's own source dir, from a `rustDependencies` `path` (so we can find its `tish.d.tish`).
+    let source_dir = rust_deps
+        .get(&dep_key)
+        .and_then(|v| v.as_object())
+        .and_then(|o| o.get("path"))
+        .and_then(|p| p.as_str())
+        .map(|raw| {
+            let p = Path::new(raw);
+            let resolved = if p.is_absolute() { p.to_path_buf() } else { project_root.join(p) };
+            resolved.canonicalize().unwrap_or(resolved)
+        });
     Ok(ResolvedNativeModule {
         spec: spec.to_string(),
         package_name: dep_key.clone(),
@@ -390,6 +418,7 @@ fn resolve_cargo_native_module(
         crate_path,
         export_fn,
         use_path_dependency: false,
+        source_dir,
     })
 }
 
@@ -442,9 +471,11 @@ fn resolve_native_module(spec: &str, project_root: &Path) -> Result<ResolvedNati
         spec: spec.to_string(),
         package_name: raw_crate.clone(),
         crate_name: raw_crate.replace('-', "_"),
-        crate_path,
+        crate_path: crate_path.clone(),
         export_fn,
         use_path_dependency: true,
+        // A tish.module package IS its own source dir — that's where any `tish.d.tish` lives.
+        source_dir: Some(crate_path),
     })
 }
 
@@ -1126,11 +1157,14 @@ pub fn resolve_bare_spec(spec: &str, from_dir: &Path, _project_root: &Path) -> O
 /// directory (`from_dir`) to an absolute path that must exist — a missing file is a compile-time
 /// error, not a device panic — and the spec becomes `prefix:/abs/path` (the codegen feeds that
 /// absolute path to the scheme's include macro; agb's `resolve_path` takes absolute paths as-is, so
-/// no asset-copy step is needed). A non-`resolve_file` scheme passes through unchanged.
+/// no asset-copy step is needed). A trailing `@N` on the path (e.g. `font:face.ttf@7`) is stripped
+/// before canonicalize and reattached on the canonical spec so `{size}` is available at emit. A
+/// bare `font:path` (no `@N`) defaults to [`crate::schemes::FONT_DEFAULT_SIZE`]. A non-`resolve_file`
+/// scheme passes through unchanged.
 fn resolve_scheme_spec(spec: &str, from_dir: &Path) -> Result<String, String> {
-    let (prefix, resolve_file) = crate::schemes::with_active(|reg| {
+    let (scheme_name, prefix, resolve_file) = crate::schemes::with_active(|reg| {
         reg.matches(spec)
-            .map(|s| (s.prefix(), s.resolve_file))
+            .map(|s| (s.name.clone(), s.prefix(), s.resolve_file))
     })
     .ok_or_else(|| format!("import '{}' is not a registered scheme", spec))?;
     let rest = spec.strip_prefix(&prefix).unwrap_or(spec);
@@ -1144,7 +1178,8 @@ fn resolve_scheme_spec(spec: &str, from_dir: &Path) -> Result<String, String> {
             prefix
         ));
     }
-    let path = Path::new(rest);
+    let (file_rest, size_opt) = crate::schemes::split_path_size(rest);
+    let path = Path::new(file_rest);
     let joined = if path.is_absolute() {
         path.to_path_buf()
     } else {
@@ -1155,12 +1190,23 @@ fn resolve_scheme_spec(spec: &str, from_dir: &Path) -> Result<String, String> {
             "{} import '{}': cannot find '{}' (resolved from {}): {}",
             prefix.trim_end_matches(':'),
             spec,
-            rest,
+            file_rest,
             from_dir.display(),
             e
         )
     })?;
-    Ok(format!("{}{}", prefix, abs.to_string_lossy()))
+    let mut out = format!("{}{}", prefix, abs.to_string_lossy());
+    // `font:` always carries an explicit size in the canonical spec (explicit @N, or default 16).
+    if scheme_name == "font" {
+        let size = size_opt.unwrap_or(crate::schemes::FONT_DEFAULT_SIZE);
+        out.push('@');
+        out.push_str(&size.to_string());
+    } else if let Some(size) = size_opt {
+        // Other schemes may use `@N` + `{size}` later; preserve when present.
+        out.push('@');
+        out.push_str(&size.to_string());
+    }
+    Ok(out)
 }
 
 /// Resolve an import specifier (e.g. "./foo.tish", "../lib/utils", "lattish") to an absolute path.

package/crates/tish_compile/src/schemes.rs

@@ -13,7 +13,8 @@
 //! * `resolve_file` — resolve the rest as a project-relative file and validate it exists.
 //! * `targets` — per emit-target ("gba", …) code templates: the `use`s + body of a generated
 //!   `mod`, an accessor, and a registration call. Templates substitute `{path}` (the resolved
-//!   absolute path, as a Rust string literal) and `{mod}` (the generated module's identifier).
+//!   absolute path, as a Rust string literal), `{mod}` (the generated module's identifier),
+//!   `{charset}` (used non-ASCII chars), and optionally `{size}` (from a trailing `@N` on the path).
 //!
 //! Only *file-baking* schemes are expressible this way today — the family `asset:` belongs to
 //! (resolve a file → emit a macro + a registration + bind an i32 handle). Schemes needing
@@ -235,14 +236,38 @@ pub fn is_scheme_import(spec: &str) -> bool {
     with_active(|r| r.matches(spec).is_some())
 }
 
-/// Substitute `{path}` (the file as a Rust string literal), `{mod}` (the generated module ident), and
-/// `{charset}` (the program's used non-ASCII characters as a Rust string literal — for schemes that
-/// bake only the glyphs a program actually uses, e.g. `font<N>:`) in a template.
+/// Default bake size when `font:path` omits `@N` (most common native grid: monogram/alagard/m3x6).
+pub const FONT_DEFAULT_SIZE: u32 = 16;
+
+/// Split a scheme path rest into `(file_path, size)` when it ends with `@` + digits
+/// (`face.ttf@7` → `("face.ttf", Some(7))`). Non-digit suffixes after `@` are left intact
+/// (`foo@2x.png` is not a size).
+pub fn split_path_size(rest: &str) -> (&str, Option<u32>) {
+    let Some((path, size_str)) = rest.rsplit_once('@') else {
+        return (rest, None);
+    };
+    if path.is_empty() || size_str.is_empty() || !size_str.bytes().all(|b| b.is_ascii_digit()) {
+        return (rest, None);
+    }
+    match size_str.parse::<u32>() {
+        Ok(n) if n > 0 => (path, Some(n)),
+        _ => (rest, None),
+    }
+}
+
+/// Substitute `{path}` (the file as a Rust string literal), `{mod}` (the generated module ident),
+/// `{charset}` (used non-ASCII chars as a Rust string literal), and `{size}` (plain integer from a
+/// trailing `@N` on the path, e.g. `font:face.ttf@7`) in a template. `{path}` never includes `@N`.
 pub fn render_template(template: &str, abspath: &str, module_ident: &str, charset: &str) -> String {
+    let (path, size) = split_path_size(abspath);
+    let size_str = size
+        .map(|n| n.to_string())
+        .unwrap_or_else(|| FONT_DEFAULT_SIZE.to_string());
     template
-        .replace("{path}", &format!("{:?}", abspath))
+        .replace("{path}", &format!("{:?}", path))
         .replace("{mod}", module_ident)
         .replace("{charset}", &format!("{:?}", charset))
+        .replace("{size}", &size_str)
 }
 
 #[cfg(test)]
@@ -275,4 +300,34 @@ mod tests {
         // The same def under a valid name parses.
         assert!(parse_scheme_def("sheet", &def).is_some());
     }
+
+    #[test]
+    fn split_path_size_parses_trailing_at_digits() {
+        assert_eq!(split_path_size("face.ttf@7"), ("face.ttf", Some(7)));
+        assert_eq!(split_path_size("/abs/face.ttf@16"), ("/abs/face.ttf", Some(16)));
+        assert_eq!(split_path_size("face.ttf"), ("face.ttf", None));
+        // Not a size — non-digit suffix after @.
+        assert_eq!(split_path_size("foo@2x.png"), ("foo@2x.png", None));
+        assert_eq!(split_path_size("@7"), ("@7", None));
+        assert_eq!(split_path_size("face.ttf@0"), ("face.ttf@0", None));
+    }
+
+    #[test]
+    fn render_template_substitutes_size_and_strips_at_from_path() {
+        let out = render_template(
+            "pack!({path}, {size}, {charset}); //{mod}",
+            "/abs/face.ttf@7",
+            "__scheme_font_0",
+            "你好",
+        );
+        assert!(out.contains("pack!(\"/abs/face.ttf\", 7, \"你好\")"), "got: {out}");
+        assert!(out.contains("//__scheme_font_0"));
+        assert!(!out.contains("face.ttf@7"));
+    }
+
+    #[test]
+    fn render_template_defaults_size_when_missing() {
+        let out = render_template("x({size})", "/abs/face.ttf", "m", "");
+        assert_eq!(out, format!("x({})", FONT_DEFAULT_SIZE));
+    }
 }

package/crates/tish_compile/src/types.rs

@@ -255,6 +255,17 @@ impl RustType {
         !matches!(self, RustType::Value)
     }
 
+    /// Whether the generated Rust type is `Copy` — the native numeric scalars, `Fixed`, and `Unit`.
+    /// A `Copy` field can be read out of a borrowed place (`arr[i].field`, `(*cell.borrow()).field`)
+    /// by value; a non-`Copy` one (`Value`/`String`/an aggregate) must be `.clone()`d there or it
+    /// moves out of the borrow — a use-after-move / cannot-move-out-of-index error (E0382 / E0507).
+    pub fn is_copy(&self) -> bool {
+        matches!(
+            self,
+            RustType::F64 | RustType::I32 | RustType::Bool | RustType::Fixed | RustType::Unit
+        ) || self.is_narrow_int()
+    }
+
     /// Check if this type is numeric (f64).
     pub fn is_numeric(&self) -> bool {
         matches!(self, RustType::F64)
@@ -533,11 +544,19 @@ impl RustType {
                 // e.g. an assignment-as-expression `{ let _v = obj; lhs = <coerce _v>; _v }` reuses
                 // `_v` for its value (tishlang/tish#486). `&(expr)` evaluates the source once and
                 // (for a temporary) lifetime-extends it to this block, so it's still single-eval.
+                //
+                // FAST PATH (GBA/portable): if the source is a BY-REFERENCE boxed struct of exactly this
+                // type (`Value::Struct`, e.g. from a `Value::from_struct` return), `downcast_struct`
+                // clones it out directly — no per-field `get_prop`. Off-portable there is no struct
+                // variant, so `downcast_struct` is a `None` constant the optimiser removes, leaving the
+                // rebuild path byte-identical to before.
+                let struct_ident = named_struct_ident(name);
                 format!(
-                    "{{ let _src = &({}); {} {{ {} }} }}",
-                    value_expr,
-                    named_struct_ident(name),
-                    field_assigns
+                    "{{ let _src = &({}); match _src.downcast_struct::<{}>() {{ \
+                        Some(_s) => _s, \
+                        None => {} {{ {} }} \
+                    }} }}",
+                    value_expr, struct_ident, struct_ident, field_assigns
                 )
             }
             RustType::ShapeUnion { .. } => {
@@ -602,34 +621,22 @@ impl RustType {
                     native_expr, inner_to_value
                 )
             }
-            RustType::Named { fields, .. } => {
-                // Build the boxed Value with an ORDERED PropMap via `object_from_pairs` (no
-                // intermediate `AHashMap`), so key order == field-declaration order == JS
-                // insertion order. The old `ObjectMap::default()` (`AHashMap`) + insert path
-                // scrambled key order NON-DETERMINISTICALLY per run (ahash seed) — a shipped
-                // `JSON.stringify` / `Object.keys` / `for..in` divergence from node whenever a
-                // native struct crosses back into untyped Tish. This boundary is paid only on
-                // that crossing (JSON.stringify, calling a Value::Function, etc.); direct
-                // Rust-to-Rust paths between two Named values stay as plain struct moves.
-                let pairs = fields
-                    .iter()
-                    .map(|(k, ty)| {
-                        let access = format!("{}.{}", native_expr, field_ident(k));
-                        // A `Value`-typed field (e.g. from a generic struct `Box<T>`) accessed
-                        // behind `&self` must be cloned — it isn't `Copy` and `to_value_expr(Value)`
-                        // is identity. Native field types clone/copy inside their own `to_value_expr`.
-                        let v_expr = if matches!(ty, RustType::Value) {
-                            format!("{}.clone()", access)
-                        } else {
-                            ty.to_value_expr(&access)
-                        };
-                        format!("(::std::sync::Arc::from({:?}), {})", k.as_ref(), v_expr)
-                    })
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                // `object_from_pairs::<N>` builds the `PropMap` in one ordered pass (N = field
-                // count, a codegen-time constant) — no AHashMap, so key order is preserved.
-                format!("Value::object_from_pairs([{}])", pairs)
+            RustType::Named { .. } => {
+                // Box the struct BY SHARED REFERENCE via `Value::from_struct_ref(&(..))`. Portable/GBA
+                // keeps it as a cheap `Value::Struct` (one `Rc` — the struct must be OWNED there, so it
+                // clones internally). Every other native backend serialises the borrow directly through
+                // `TishStruct::tish_to_object` (the ordered `object_from_pairs` boundary — see
+                // [`named_struct_to_object_expr`]) with NO whole-struct clone, byte-identical to the
+                // historical behaviour that read fields straight off the place (#565: the previous
+                // `from_struct((..).clone())` cloned the entire struct just to serialise it off-GBA).
+                // Property access on a boxed struct dispatches through the generated `impl TishStruct`
+                // (small match, no hash); materialisation is reached only on JSON.stringify / display /
+                // `Object.keys`-family / `for..in` / `in` / `Object.assign` / `{...s}` spread. `&(..)`
+                // borrows the place codegen already emits here (a value or a deref like `(*gs.borrow())`).
+                format!(
+                    "tishlang_runtime::Value::from_struct_ref(&({}))",
+                    native_expr
+                )
             }
             RustType::ShapeUnion { name, variants } => {
                 // union → boxed Value::Object: one match arm per variant, delegating to that
@@ -673,6 +680,31 @@ pub fn named_struct_ident(tish_name: &str) -> String {
     format!("TishStruct_{}", tish_name)
 }
 
+/// Build the `Value::object_from_pairs([...])` that materialises a Named struct at `native_expr` into
+/// an ORDERED boxed object (field-declaration = JS insertion order — deterministic, unlike an AHashMap
+/// insert). This was the body of `to_value_expr`'s `Named` arm; it now backs the generated
+/// `TishStruct::tish_to_object` (the JSON / display / `Object.keys`-family / `for..in` / `in` /
+/// `Object.assign` / `{...s}` spread materialisation, and the non-portable
+/// `Value::from_struct` fallback), while the live boxing path emits the cheap by-ref `Value::from_struct`.
+pub fn named_struct_to_object_expr(fields: &[(Arc<str>, RustType)], native_expr: &str) -> String {
+    let pairs = fields
+        .iter()
+        .map(|(k, ty)| {
+            let access = format!("{}.{}", native_expr, field_ident(k));
+            // A `Value`-typed field must be cloned (not `Copy`, and `to_value_expr(Value)` is identity);
+            // native field types clone/copy inside their own `to_value_expr`.
+            let v_expr = if matches!(ty, RustType::Value) {
+                format!("{}.clone()", access)
+            } else {
+                ty.to_value_expr(&access)
+            };
+            format!("(::std::sync::Arc::from({:?}), {})", k.as_ref(), v_expr)
+        })
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("Value::object_from_pairs([{}])", pairs)
+}
+
 /// #179 Stage B: map a shape-union alias to the generated Rust enum identifier.
 pub fn shape_union_enum_ident(tish_name: &str) -> String {
     format!("TishUnion_{}", tish_name)

package/crates/tish_compile/tests/regr_556_param_name_collision.rs

@@ -0,0 +1,40 @@
+//! tishlang/tish#556 — a top-level MUTABLE var captured by a closure becomes a `VmRef` cell; if its
+//! name matches an imported/other function's PARAMETER, a reference to the parameter inside that
+//! function must resolve to the parameter, NOT a `vm_read` of the outer cell (which emits
+//! `vm_read(&param)` — a `&Value` where a `&VmRef` is wanted, so the generated Rust won't compile).
+//! The bug bit the GBA backend; guard both emit modes.
+use std::collections::HashSet;
+use std::path::PathBuf;
+use tishlang_compile::{compile_project_full_emit, NativeEmitMode};
+
+fn compile(rel: &str, mode: NativeEmitMode) -> String {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    let caps: HashSet<String> = HashSet::new();
+    compile_project_full_emit(&path, path.parent(), &[], true, mode, Some(&caps))
+        .unwrap()
+        .0
+}
+
+#[test]
+fn param_shadows_outer_cell_not_read_via_vm_read() {
+    let rel = "crates/tish_compile/tests/regression/name_collision_main.tish";
+    for mode in [NativeEmitMode::DesktopBin, NativeEmitMode::Gba] {
+        let rust = compile(rel, mode);
+        // The bug: inside `loadScene`, calling the `scene` PARAMETER (`scene(1)`) compiled the callee
+        // as `vm_read(&scene)` — a read of the outer `VmRef` cell, i.e. `&Value` where a `&VmRef` is
+        // wanted (won't compile). The param must be used directly instead. (A plain `vm_read(&scene)`
+        // still legitimately appears where `bump` mutates the real outer cell, so we target this
+        // exact param-as-callee shape.)
+        assert!(
+            !rust.contains("_callee = (tishlang_runtime::vm_read(&scene))"),
+            "#556 ({mode:?}): `loadScene`'s `scene` parameter must shadow the outer cell — a call to \
+             it must not read `vm_read(&scene)`\n{rust}"
+        );
+        // The outer cell itself is still legitimately a real `VmRef` where `bump` mutates it.
+        assert!(
+            rust.contains("scene.borrow_mut()"),
+            "#556 ({mode:?}): expected the outer captured `scene` to remain a real `VmRef` cell\n{rust}"
+        );
+    }
+}

package/crates/tish_compile/tests/regr_558_struct_array_write.rs

@@ -0,0 +1,65 @@
+//! tishlang/tish#558 — a typed `Vec<struct>` element field write (`arr[i].field = v`) must lower to
+//! a NATIVE store into the Vec element, not a `set_prop` on a throwaway `Value::object_from_pairs`
+//! copy of the element (which silently discards the write). Regressed the module-level array and the
+//! local array; both are covered here.
+use std::collections::HashSet;
+use std::path::PathBuf;
+use tishlang_compile::{compile_project_full, compile_project_full_emit, NativeEmitMode};
+
+fn compile(rel: &str) -> String {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    compile_project_full(&path, path.parent(), &[], true).unwrap().0
+}
+
+fn compile_gba(rel: &str) -> String {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    let caps: HashSet<String> = HashSet::new();
+    compile_project_full_emit(&path, path.parent(), &[], true, NativeEmitMode::Gba, Some(&caps))
+        .unwrap()
+        .0
+}
+
+#[test]
+fn gba_struct_write_is_a_fully_native_i32_store() {
+    // On the GBA target a `: i32` struct field is a native `i32`, so the write is a single-word store
+    // into the Vec element — the whole point of typed struct arrays for hot AI loops. Guard that the
+    // perf win is maximal there: no `Value`, no `set_prop`, no per-write allocation.
+    let rust = compile_gba("crates/tish_compile/tests/regression/struct_array_write.tish");
+    assert!(
+        rust.contains("pub x: i32"),
+        "expected the `: i32` field to be a native i32 on the GBA target\n{rust}"
+    );
+    assert!(
+        rust.contains("arr[(0_f64) as usize].x = (200_f64) as i32"),
+        "#558: expected a fully-native i32 element store on GBA\n{rust}"
+    );
+    assert!(
+        !rust.contains("set_prop(&(Value::object_from_pairs"),
+        "#558: the GBA struct write must not box + set_prop on a throwaway copy\n{rust}"
+    );
+}
+
+#[test]
+fn struct_array_write_is_a_native_store_not_a_discarded_copy() {
+    let rust = compile("crates/tish_compile/tests/regression/struct_array_write.tish");
+
+    // The write must NOT build a throwaway object and set_prop on it — that mutates a copy and
+    // discards the store. This exact shape is what the bug emitted.
+    assert!(
+        !rust.contains("set_prop(&(Value::object_from_pairs"),
+        "#558: `arr[i].field = v` must not set_prop on a throwaway object_from_pairs copy\n{rust}"
+    );
+
+    // It must instead be a direct field store into the Vec element (module-level `arr` here).
+    assert!(
+        rust.contains("arr[(0_f64) as usize].x ="),
+        "#558: expected a native `arr[(0_f64) as usize].x = …` store into the Vec element\n{rust}"
+    );
+    // …and the local array `es` inside the function.
+    assert!(
+        rust.contains("es[(0_f64) as usize].x ="),
+        "#558: expected a native `es[(0_f64) as usize].x = …` store into the local Vec element\n{rust}"
+    );
+}

package/crates/tish_compile/tests/regr_558b_struct_field_read.rs

@@ -0,0 +1,21 @@
+//! tishlang/tish#558 residual — a struct-field read from a Vec element in a value/return position must
+//! clone a non-Copy field instead of moving it out of the borrowed element (E0507).
+use std::path::PathBuf;
+use tishlang_compile::compile_project_full;
+
+fn compile(rel: &str) -> String {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    compile_project_full(&path, path.parent(), &[], true).unwrap().0
+}
+
+#[test]
+fn struct_field_read_from_vec_element_clones_non_copy() {
+    let rust = compile("crates/tish_compile/tests/regression/struct_field_return_read.tish");
+    // Off-GBA the `: i32` field is a boxed `Value` (non-Copy); the read must clone it out of the
+    // borrowed `es[0]`, not move it.
+    assert!(
+        rust.contains("es[(0_f64) as usize]).x.clone()"),
+        "#558 residual: `es[0].x` read must clone the non-Copy field out of the borrowed element\n{rust}"
+    );
+}

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