@tishlang/tish-format 3.1.0 → 3.3.0

package/crates/tish_compile/src/lib.rs

@@ -40,6 +40,19 @@ pub enum NativeEmitMode {
     DesktopBin,
     /// `[lib] crate-type = ["staticlib"]` — no `fn main()`, host calls `tish_ios_launch`.
     EmbeddedLib,
+    /// `[lib] crate-type = ["rlib"]` — a Rust *library* crate whose public API is the entry
+    /// module's `export fn`s, so a Tish library can be consumed from Rust the way `--target js`
+    /// lets it be consumed from JS. No `fn main()`, no `tish_ios_launch`.
+    ///
+    /// The module body still lowers to the ordinary whole-program `run()`; what differs is that
+    /// `run()` is invoked lazily behind an `ensure_init()` and its exported bindings are parked in
+    /// a `thread_local!` so they outlive the call. That keeps module-level state alive between
+    /// `pub fn` calls with the same semantics an ESM module has — including reassignment, since
+    /// top-level `let`s are captured by the emitted closures as `VmRef` cells.
+    ///
+    /// `thread_local!` (rather than a global) is forced by `Value`: `send-values` is off unless
+    /// `http` is enabled, so `VmRef` is `Rc<RefCell<_>>` and `Value` is `!Send`.
+    RustLib,
     /// Game Boy Advance ROM: `#![no_std]`, `#[agb::entry] fn agb_main(gba)`, links the
     /// `tishlang_runtime_gba` facade. Numbers/async lowering diverge; see codegen `emit_program`.
     Gba,
@@ -49,7 +62,7 @@ pub use codegen::CompileError;
 pub use codegen::{
     compile, compile_project, compile_project_full, compile_project_full_emit,
     compile_with_features, compile_with_native_modules, compile_with_native_modules_emit,
-    compile_with_project_root,
+    compile_with_native_modules_emit_exports, compile_with_project_root,
 };
 pub use platform_resolve::{
     apply_resolve_env, parse_platform, parse_surface, platform_suffixes, platform_virtual_keys,

package/crates/tish_compile/src/types.rs

@@ -30,6 +30,12 @@ fn gba_numerics() -> bool {
     GBA_NUMERICS.with(|c| c.get())
 }
 
+/// Public view of the same switch, for passes that must behave differently only where the extended
+/// numeric vocabulary exists — see the native-fn bitwise widening in `codegen.rs`.
+pub fn gba_numerics_enabled() -> bool {
+    gba_numerics()
+}
+
 /// Concrete Rust type representation for code generation.
 #[derive(Debug, Clone, PartialEq)]
 pub enum RustType {

package/crates/tish_compile/tests/perf_codegen_i32_native_abi.rs

@@ -0,0 +1,113 @@
+//! M5 native fns, with an `i32` calling convention.
+//!
+//! `collect_native_fns` gated parameters and returns on `RustType::F64`, so `: number` qualified for
+//! a native free `fn` and `: i32` did not — and `: i32` is the annotation a device with no FPU
+//! wants. Every argument and every return of such a call was therefore an i32→f64→i32 round trip,
+//! which on ARM7TDMI is a soft-float call apiece.
+//!
+//! The shape is ALL-OR-NOTHING: every parameter and the return annotated `: i32`. Mixing is what
+//! makes it unsound — an `: i32` parameter reached through the boxed path is ToInt32-coerced on
+//! entry, and promoted to a native `f64` parameter it would not be, so 3.7 would arrive as 3 one
+//! way and 3.7 the other.
+
+use std::path::PathBuf;
+
+use tishlang_compile::{compile_project_full_emit, NativeEmitMode};
+
+/// Compile for GBA — `: i32` is only a native scalar under the GBA numeric vocabulary
+/// (`types.rs`: `"i32" if gba_numerics()`), so on a desktop target this ABI cannot exist and the
+/// assertions below would be vacuous.
+fn compile_src(stem: &str, src: &str) -> String {
+    let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/perf_codegen_i32_abi");
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join(format!("{stem}.tish"));
+    std::fs::write(&path, src).unwrap();
+    let path = path.canonicalize().unwrap();
+    let (rust, _, _, _) =
+        compile_project_full_emit(&path, path.parent(), &[], true, NativeEmitMode::Gba, None)
+            .unwrap();
+    rust
+}
+
+const ALL_I32: &str = r#"
+function mix(a: i32, b: i32): i32 { return ((a * 3) ^ (b << 2)) & 65535 }
+let acc: i32 = 0
+let j: i32 = 0
+while (j < 10) { acc = (acc + mix(j, acc)) & 65535; j = j + 1 }
+console.log(acc)
+"#;
+
+#[test]
+fn an_all_i32_signature_gets_an_i32_native_fn() {
+    let rust = compile_src("all_i32", ALL_I32);
+    assert!(
+        rust.contains("fn mix_native(mut a: i32, mut b: i32) -> i32"),
+        "expected an i32-signature native fn, got:\n{}",
+        rust.lines().filter(|l| l.contains("mix_native")).collect::<Vec<_>>().join("\n")
+    );
+    // And the call must reach it directly rather than through `value_call`.
+    assert!(rust.contains("mix_native("), "the call site should target the native fn");
+}
+
+const MIXED: &str = r#"
+function half(a: i32, b: number): i32 { return (a + b) | 0 }
+console.log(half(7, 2.5))
+"#;
+
+#[test]
+fn a_mixed_signature_does_not_get_the_i32_abi() {
+    let rust = compile_src("mixed", MIXED);
+    assert!(
+        !rust.contains("fn half_native(mut a: i32"),
+        "a mixed i32/number signature must not take the i32 ABI — an `: i32` param is \
+         ToInt32-coerced on entry and an f64 native param is not"
+    );
+}
+
+const LIAR: &str = r#"
+function liar(x: i32): i32 {
+  if (x > 0) { return "not a number" }
+  return 7
+}
+console.log(liar(1))
+"#;
+
+#[test]
+fn the_annotation_alone_does_not_qualify_a_fn() {
+    // Return annotations are erased and unchecked: this program prints the STRING today. The i32
+    // ABI must not be handed out on the strength of `: i32`, only on the fixpoint's proof that
+    // every return is numeric — otherwise this would unbox a string as a number.
+    let rust = compile_src("liar", LIAR);
+    assert!(
+        !rust.contains("fn liar_native"),
+        "a fn with a non-numeric return path must stay boxed regardless of its annotation"
+    );
+}
+
+const READS_MODULE_STATE: &str = r#"
+let ARR: i32[] = []
+let k: i32 = 0
+while (k < 8) { ARR.push(k); k = k + 1 }
+function pure(a: i32, b: i32): i32 { return (a ^ b) & 255 }
+function reads(i: i32): i32 { return ARR[i] & 255 }
+let x: i32 = pure(1, 2) + reads(3)
+console.log(x)
+"#;
+
+#[test]
+fn a_fn_reading_module_state_stays_boxed() {
+    // A native fn is emitted at TOP LEVEL, where a module-scope `let` — a local of `run()`, closed
+    // over by the boxed closures — does not exist. `native_safe_expr`'s index arm accepted any
+    // identifier as the indexed object, so this compiled to a `reads_native` whose body named
+    // `ARR` and rustc rejected the generated program with E0425. The sibling `pure` must still be
+    // promoted: the check has to reject the out-of-scope read, not indexing as such.
+    let rust = compile_src("reads_module_state", READS_MODULE_STATE);
+    assert!(
+        !rust.contains("fn reads_native"),
+        "a fn indexing a module-scope binding cannot become a top-level free fn"
+    );
+    assert!(
+        rust.contains("fn pure_native(mut a: i32, mut b: i32) -> i32"),
+        "its parameter-only sibling must still get the native i32 fn"
+    );
+}

package/crates/tish_compile/tests/regr_andor_rhs_move.rs

@@ -0,0 +1,85 @@
+//! Regression: `&&` / `||` yield the deciding OPERAND (JS semantics, #240). #328 fixed the left
+//! operand to bind by `.clone()` rather than by move; the right operand had the identical hazard.
+//!
+//! When the right operand lowers to a bare local — `inGenBlock && currentTrack` — yielding it moved
+//! that local out of scope, so any later read was `E0382: use of moved value`. It only bites when
+//! the operand is a plain non-`Copy` `Value` local that is read again (typically the next iteration
+//! of the enclosing loop), which is why it survived: the common right operand is a call or an
+//! already-cloned expression, which are temporaries.
+//!
+//! Found compiling `@spacedevin/deck`'s `Parser.tish`, whose statement loop does exactly this. The
+//! source runs fine under `--target js` and the interpreter, so the divergence was Rust-backend-only.
+use tishlang_compile::compile;
+use tishlang_parser::parse;
+
+fn rust_for(src: &str) -> String {
+    compile(&parse(src).unwrap()).unwrap()
+}
+
+#[test]
+fn bare_ident_right_operand_is_cloned_not_moved() {
+    let rust = rust_for(
+        r#"
+fn f() {
+  let cur = null
+  let flag = true
+  let i = 0
+  while (i < 3) {
+    if (flag && cur) { return 1 }
+    if (flag && cur) { return 2 }
+    i = i + 1
+  }
+  return 0
+}
+"#,
+    );
+    assert!(
+        rust.contains("if __l.is_truthy() { cur.clone() }"),
+        "a bare-ident right operand must be cloned out, not moved:\n{rust}"
+    );
+    assert!(
+        !rust.contains("if __l.is_truthy() { cur }"),
+        "found the moving form, which is E0382 on the second read:\n{rust}"
+    );
+}
+
+#[test]
+fn or_right_operand_gets_the_same_treatment() {
+    let rust = rust_for(
+        r#"
+fn f() {
+  let a = null
+  let b = null
+  let i = 0
+  while (i < 3) {
+    let x = a || b
+    let y = a || b
+    i = i + 1
+  }
+  return 0
+}
+"#,
+    );
+    assert!(
+        rust.contains("else { b.clone() }"),
+        "`||` must clone a bare-ident right operand too:\n{rust}"
+    );
+}
+
+#[test]
+fn non_ident_right_operands_are_not_given_a_redundant_clone() {
+    // A call result is already a temporary — cloning it would be pure overhead on a hot path.
+    let rust = rust_for(
+        r#"
+fn g() { return 1 }
+fn f() {
+  let flag = true
+  return flag && g()
+}
+"#,
+    );
+    assert!(
+        !rust.contains("))).clone().clone()"),
+        "an already-temporary right operand must not gain a second clone:\n{rust}"
+    );
+}