@tishlang/tish-lint 3.2.2 → 3.3.3

package/crates/tish_lint/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_lint"
-version = "3.2.2"
+version = "3.3.3"
 edition = "2021"
 description = "AST-based linter for Tish"
 license-file = { workspace = true }

package/crates/tish_native/src/build.rs

@@ -1,7 +1,7 @@
 //! Build native binary via cargo (interim path until Cranelift backend is ready).
 
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use tishlang_compile::ResolvedNativeModule;
 
@@ -627,15 +627,34 @@ runner = ["mgba-qt", "-C", "logToStdout=1", "-C", "logLevel.gba.debug=127"]
     // with `-Tgba.ld` — cargo *joins* rustflags arrays across config files, so a
     // config-file approach would pass `-Tgba.ld` twice ("region already defined").
     // build-std still comes from the generated `[unstable]` config (not rustflags).
-    let status = Command::new("cargo")
+    //
+    // TISH_GBA_TARGET_DIR (opt-in, explicit — deliberately NOT the ambient
+    // CARGO_TARGET_DIR, which the desktop path scrubs for good reason): share ONE
+    // cargo target dir across every example's ROM build. Each example otherwise
+    // carries a full private dependency tree — measured at ~45 GB across the
+    // tish-gba fleet, and it filled the disk mid-build once. An inherited
+    // CARGO_TARGET_DIR meanwhile made cargo write where the ELF lookup below
+    // never looked ("GBA ELF not found" on a SUCCESSFUL compile), so that env is
+    // scrubbed here and only the explicit opt-in steers both paths together.
+    let shared_target = std::env::var_os("TISH_GBA_TARGET_DIR").map(PathBuf::from);
+    let target_root = shared_target
+        .clone()
+        .unwrap_or_else(|| build_dir.join("target"));
+    let mut cargo = Command::new("cargo");
+    cargo
         .arg("build")
         .arg("--release")
         .current_dir(&build_dir)
+        .env_remove("CARGO_TARGET_DIR")
         .env(
             "RUSTFLAGS",
             "-Clink-arg=-Tgba.ld -Ctarget-cpu=arm7tdmi -Cforce-frame-pointers=yes",
         )
-        .env("CARGO_TERM_COLOR", "always")
+        .env("CARGO_TERM_COLOR", "always");
+    if let Some(dir) = &shared_target {
+        cargo.env("CARGO_TARGET_DIR", dir);
+    }
+    let status = cargo
         .status()
         .map_err(|e| format!("Failed to run cargo for GBA build: {}", e))?;
     if !status.success() {
@@ -645,9 +664,8 @@ runner = ["mgba-qt", "-C", "logToStdout=1", "-C", "logLevel.gba.debug=127"]
         ));
     }
 
-    // ELF → .gba via agb-gbafix.
-    let elf = build_dir
-        .join("target")
+    // ELF → .gba via agb-gbafix. Resolved from the SAME root the build wrote to.
+    let elf = target_root
         .join("thumbv4t-none-eabi")
         .join("release")
         .join(&cargo_name);

package/crates/tish_runtime_gba/src/gba.rs

@@ -101,21 +101,41 @@ type BgAsset = (
     &'static agb::display::tile_data::TileData,
 );
 
-static ASSET_BGS: SingleCore<RefCell<Vec<BgAsset>>> = SingleCore::new(RefCell::new(Vec::new()));
+/// ⚠️ A FIXED TABLE, not a `Vec`, because every entry is `&'static` cartridge data and the registry
+/// never needed to own one.
+///
+/// As a `Vec` it did: registering N backgrounds ran N pushes with log2(N) reallocs, all during
+/// module init before the program body, and the freed buffers left the heap too fragmented for the
+/// one big contiguous block a GBA UI canvas wants. A game with a handful of backgrounds booted; a
+/// game with 162 died in the allocator with plenty of total heap free.
+///
+/// This costs `MAX_BGS * size_of::<Option<BgAsset>>()` of STATIC memory and allocates nothing.
+/// ⚠️ Not a `Vec` with `reserve` — that charges every small game for the largest one.
+const MAX_BGS: usize = 256;
+static ASSET_BGS: SingleCore<RefCell<[Option<BgAsset>; MAX_BGS]>> =
+    SingleCore::new(RefCell::new([None; MAX_BGS]));
+static ASSET_BGS_N: SingleCore<RefCell<usize>> = SingleCore::new(RefCell::new(0));
 
 /// Register a background (palettes + tile data), returning its i32 handle.
 pub fn __asset_register_bg(bg: BgAsset) -> i32 {
-    ASSET_BGS.with(|c| {
-        let mut v = c.borrow_mut();
-        let idx = v.len() as i32;
-        v.push(bg);
+    ASSET_BGS_N.with(|n| {
+        let mut n = n.borrow_mut();
+        if *n >= MAX_BGS {
+            return -1;
+        }
+        let idx = *n as i32;
+        ASSET_BGS.with(|c| c.borrow_mut()[*n] = Some(bg));
+        *n += 1;
         idx
     })
 }
 
 /// Look up a registered background by handle. `None` if out of range.
 pub fn asset_bg(handle: i32) -> Option<BgAsset> {
-    ASSET_BGS.with(|c| c.borrow().get(handle as usize).copied())
+    if handle < 0 || handle as usize >= MAX_BGS {
+        return None;
+    }
+    ASSET_BGS.with(|c| c.borrow()[handle as usize])
 }
 
 /// Registered fonts (`font<N>:` imports) — a compile-time-baked `Font`. All `font<N>:` schemes share

package/crates/tish_runtime_gba/src/lib.rs

@@ -283,6 +283,35 @@ pub fn str_index(s: &str, idx: &Value) -> Value {
     }
 }
 
+/// `&str` charCodeAt — the code unit at `idx`, NaN when out of range. Mirrors
+/// `tish_runtime::str_char_code_at`, and missing here for the same reason `str_index` was: codegen
+/// emits it whenever the receiver is statically a `&str`, so `"abc".charCodeAt(i)` was a hard E0425
+/// on the GBA target only while compiling everywhere else. Found by a ROM that hashes its own trace.
+#[inline]
+pub fn str_char_code_at(s: &str, idx: &Value) -> Value {
+    let i = match idx {
+        Value::Number(n) if *n >= 0.0 && n.fract() == 0.0 => *n as usize,
+        _ => return Value::Number(f64::NAN),
+    };
+    match s.chars().nth(i) {
+        Some(c) => Value::Number(c as u32 as f64),
+        None => Value::Number(f64::NAN),
+    }
+}
+
+/// `&str` charAt — the 1-character string at `idx`, `""` out of range. Same reason as above.
+#[inline]
+pub fn str_char_at(s: &str, idx: &Value) -> Value {
+    let i = match idx {
+        Value::Number(n) if *n >= 0.0 && n.fract() == 0.0 => *n as usize,
+        _ => return Value::String("".into()),
+    };
+    match s.chars().nth(i) {
+        Some(c) => Value::String(c.to_string().into()),
+        None => Value::String("".into()),
+    }
+}
+
 pub fn delete_property(obj: &Value, key: &Value) -> Value {
     match obj {
         Value::Object(m) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-lint",
-  "version": "3.2.2",
+  "version": "3.3.3",
   "description": "Tish code linter",
   "license": "PIF",
   "repository": {