@tishlang/tish-format 3.1.0 → 3.3.0

package/crates/tish_fmt/src/lib.rs

@@ -1706,6 +1706,12 @@ impl Scanner {
         self.chars.get(self.i + 1).copied()
     }
 
+    /// True when the char immediately before the cursor is `:`, i.e. the `//` about to
+    /// be scanned is the scheme separator of a URL (`http://`) rather than a comment.
+    fn prev_is_colon(&self) -> bool {
+        self.i > 0 && self.chars.get(self.i - 1) == Some(&':')
+    }
+
     /// Consume one char, tracking line/col like the lexer (col resets after `\n`).
     fn bump(&mut self) -> Option<char> {
         let c = *self.chars.get(self.i)?;
@@ -1765,7 +1771,23 @@ impl Scanner {
                     self.seen_nonws = true;
                     self.scan_template();
                 }
-                '/' if self.peek2() == Some('/') => self.scan_line_comment(),
+                // `://` is a URL scheme separator, never a comment. This scanner has no JSX
+                // awareness, so JSX TEXT — which, unlike a string or an attribute value, is bare
+                // source — used to have its URLs read as comments:
+                //
+                //   <div>Redirect URI: http://127.0.0.1/callback</div>
+                //
+                // scanned `//127.0.0.1/callback</div>` as a line comment, and the printer then
+                // re-emitted it after the element. Worse, the re-emitted text is a REAL comment, so
+                // every subsequent run found one more and the file grew without converging — and
+                // `--check` could never pass on such a file. See tishlang/tish#578.
+                //
+                // Guarding on the preceding `:` fixes the whole class (http://, file://, dune://)
+                // without teaching this scanner to parse JSX, which would mean distinguishing
+                // `<div>` from `a < b` and risks breaking comment scanning in ordinary code.
+                '/' if self.peek2() == Some('/') && !self.prev_is_colon() => {
+                    self.scan_line_comment()
+                }
                 '/' if self.peek2() == Some('*') => self.scan_block_comment(),
                 ' ' | '\t' | '\r' | '\n' => {
                     self.bump();
@@ -1884,6 +1906,37 @@ mod tests {
         let _ = tishlang_parser::parse(&out).unwrap();
     }
 
+    /// tishlang/tish#578 — a URL in JSX TEXT had its `//` scanned as a line comment, so the
+    /// printer re-emitted everything after it as a trailing comment. The re-emitted text was
+    /// itself a real comment, so each run appended another copy and the file never converged.
+    #[test]
+    fn url_in_jsx_text_is_not_a_comment() {
+        let src = "/** @jsxImportSource lattish */\n\nexport fn Demo() {\n  return <div>Redirect URI: http://127.0.0.1/callback for details</div>\n}\n";
+        let once = format_source(src).unwrap();
+        // Not `!contains("//127.0.0.1")` — that substring is part of the legitimate URL. The
+        // corruption signature is the text appearing TWICE: once in the JSX, once hoisted out.
+        assert_eq!(
+            once.matches("127.0.0.1").count(),
+            1,
+            "URL text was duplicated into a comment:\n{once}"
+        );
+        // Idempotence is the property that actually broke: formatting must reach a fixed point,
+        // otherwise `--check` can never pass no matter how many times the file is formatted.
+        let twice = format_source(&once).unwrap();
+        assert_eq!(once, twice, "formatting is not idempotent");
+        let thrice = format_source(&twice).unwrap();
+        assert_eq!(twice, thrice, "formatting is not idempotent");
+    }
+
+    /// The guard keys off the `:` immediately before `//`, so ordinary trailing comments —
+    /// including ones right after a colon-bearing construct — must still be recognised.
+    #[test]
+    fn ordinary_comments_still_scanned() {
+        let src = "fn f() {\n  let o = { a: 1 } // trailing\n  return o\n}\n";
+        let out = format_source(src).unwrap();
+        assert!(out.contains("// trailing"), "comment was dropped:\n{out}");
+    }
+
     /// Debug-render the parsed AST with all `Span { … }` contents removed, so two programs compare
     /// equal iff they are structurally identical (reformatting legitimately changes spans).
     fn structure(src: &str) -> String {

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;
 
@@ -149,6 +149,17 @@ pub fn build_via_cargo_with_config(
             project_root,
         );
     }
+    if build_config.artifact == NativeArtifact::RustLib {
+        return emit_rust_lib_crate(
+            rust_code,
+            native_modules,
+            output_path,
+            features,
+            extra_dependencies_toml,
+            generated_native_rs,
+            project_root,
+        );
+    }
 
     let out_stem = output_path
         .file_stem()
@@ -348,6 +359,122 @@ fn read_facade_agb_version(facade_path: &Path) -> Option<String> {
 /// Runs its own `cargo build` (NOT `run_cargo_build`) so the `.cargo/config.toml`
 /// rustflags (`-Tgba.ld`, `-Ctarget-cpu=arm7tdmi`) apply — `run_cargo_build` sets a
 /// `RUSTFLAGS` env that would shadow them.
+/// Read `version = "…"` from the `[package]` section of a crate's `Cargo.toml`.
+fn read_crate_version(crate_dir: &Path) -> Option<String> {
+    let toml = fs::read_to_string(crate_dir.join("Cargo.toml")).ok()?;
+    for line in toml.lines() {
+        let line = line.trim();
+        if let Some(rest) = line.strip_prefix("version") {
+            let rest = rest.trim_start();
+            if let Some(rest) = rest.strip_prefix('=') {
+                return Some(rest.trim().trim_matches('"').to_string());
+            }
+        }
+        // Only the first (package) table — stop before dependency versions.
+        if line.starts_with('[') && !line.starts_with("[package]") {
+            break;
+        }
+    }
+    None
+}
+
+/// `--target rust --emit lib`: write a Cargo **library source crate** to `output_path` and stop.
+///
+/// This is the one artifact that does not run cargo. The consumer decides what to build it for and
+/// how to depend on it, exactly as they would with any other crate — which is the point: it lets a
+/// Tish library be consumed from Rust the way `--target js` lets it be consumed from JS.
+///
+/// The `tishlang_runtime` dependency carries **both** `path` and `version`. Cargo prefers the path
+/// locally and falls back to the registry version when the crate is published, so the emitted crate
+/// is publishable without a post-processing step.
+fn emit_rust_lib_crate(
+    rust_code: &str,
+    native_modules: Vec<ResolvedNativeModule>,
+    output_path: &Path,
+    features: &[String],
+    extra_dependencies_toml: &str,
+    generated_native_rs: Option<&str>,
+    project_root: Option<&Path>,
+) -> Result<(), String> {
+    let crate_name = tishlang_build_utils::cargo_target_name(
+        output_path
+            .file_name()
+            .and_then(|s| s.to_str())
+            .unwrap_or("tish_lib"),
+    );
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
+    let runtime_version = read_crate_version(Path::new(&runtime_path))
+        .map(|v| format!(", version = {:?}", v))
+        .unwrap_or_default();
+
+    let runtime_features = runtime_features_for_cargo(features);
+    let runtime_refs: Vec<&str> = runtime_features.iter().map(String::as_str).collect();
+    let features_str = if runtime_refs.is_empty() {
+        String::new()
+    } else {
+        format!(", features = {:?}", runtime_refs)
+    };
+
+    let native_deps: String = native_modules
+        .iter()
+        .filter(|m| m.use_path_dependency)
+        .map(|m| {
+            let path = m.crate_path.display().to_string().replace('\\', "/");
+            format!("{} = {{ path = {:?} }}\n", m.package_name, path)
+        })
+        .collect();
+
+    let mut more_deps = String::new();
+    if !native_deps.is_empty() {
+        more_deps.push_str(&format!("\n{}", native_deps));
+    }
+    if !extra_dependencies_toml.trim().is_empty() {
+        more_deps.push_str(&format!("\n{}", extra_dependencies_toml));
+    }
+
+    let lib_rs = if generated_native_rs.is_some() {
+        inject_generated_native_mod(rust_code)
+    } else {
+        rust_code.to_string()
+    };
+
+    let cargo_toml = format!(
+        r#"[package]
+name = "{name}"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "{name}"
+crate-type = ["rlib"]
+path = "src/lib.rs"
+
+[dependencies]
+tishlang_runtime = {{ path = {runtime:?}{version}{features} }}
+{more}"#,
+        name = crate_name,
+        runtime = runtime_path,
+        version = runtime_version,
+        features = features_str,
+        more = more_deps,
+    );
+
+    let src_dir = output_path.join("src");
+    fs::create_dir_all(&src_dir)
+        .map_err(|e| format!("Cannot create {}: {}", src_dir.display(), e))?;
+    fs::write(output_path.join("Cargo.toml"), cargo_toml)
+        .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
+    if let Some(gen) = generated_native_rs {
+        fs::write(src_dir.join("generated_native.rs"), gen)
+            .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
+    }
+    fs::write(src_dir.join("lib.rs"), lib_rs)
+        .map_err(|e| format!("Cannot write lib.rs: {}", e))?;
+
+    println!("Emitted Rust library crate: {}", output_path.display());
+    Ok(())
+}
+
 fn build_gba_rom(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
@@ -500,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() {
@@ -518,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_native/src/config.rs

@@ -11,6 +11,10 @@ pub enum NativeArtifact {
     /// A GBA ROM: cargo builds an ELF for `thumbv4t-none-eabi`, then `agb-gbafix`
     /// converts it to a `.gba`.
     GbaRom,
+    /// A Rust *library source crate* (`crate-type = ["rlib"]`) whose public API is the entry
+    /// module's `export fn`s. Unlike every other artifact, cargo is **not** run — the emitted
+    /// crate directory is itself the output, for the consumer to add as a path/registry dependency.
+    RustLib,
 }
 
 /// Options passed from the CLI into nested `cargo build`.
@@ -45,6 +49,16 @@ impl NativeBuildConfig {
         }
     }
 
+    /// `tish build --target rust --emit lib`: emit a Cargo library crate and stop. Host target —
+    /// the consumer decides what to build it for.
+    pub fn rust_lib() -> Self {
+        Self {
+            artifact: NativeArtifact::RustLib,
+            cargo_target: None,
+            emit_mode: NativeEmitMode::RustLib,
+        }
+    }
+
     pub fn is_cross_compile(&self) -> bool {
         self.cargo_target.is_some()
     }

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

@@ -266,6 +266,52 @@ pub fn get_index(obj: &Value, index: &Value) -> Value {
     }
 }
 
+/// `&str` `s[i]` — char at a non-negative integer `idx`; non-int / negative / OOB → null.
+///
+/// Mirrors `tish_runtime::str_index`, and exists here because codegen emits a call to it whenever
+/// the indexed expression is statically a `&str` rather than a `Value` — which is what a module
+/// `const` string lowers to. Without it, `const D = "0123456789"` followed by `D[i]` is a hard
+/// E0425 on the GBA target only, while the identical code compiles and runs everywhere else.
+#[inline]
+pub fn str_index(s: &str, idx: &Value) -> Value {
+    match idx {
+        Value::Number(n) if *n >= 0.0 && n.fract() == 0.0 => match s.chars().nth(*n as usize) {
+            Some(c) => Value::String(c.to_string().into()),
+            None => Value::Null,
+        },
+        _ => Value::Null,
+    }
+}
+
+/// `&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-format",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {