@tishlang/tish 1.10.0 → 1.13.0

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.10.0"
+version = "1.13.0"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/cli_help.rs

@@ -405,6 +405,8 @@ pub fn build_after_help() -> String {
           WebAssembly (.tish project; .js source supported on some paths)
   {t}wasi{r}
           WASI WebAssembly
+  {t}bytecode{r}
+          Raw serialized bytecode chunk (no VM binary/JS/HTML); for hosts that already ship the runtime
 
 {oh}Native backends{r} (--native-backend, only with --target native, default: rust):
   {t}rust{r}
@@ -506,7 +508,7 @@ pub(crate) struct BuildArgs {
         help_heading = "Options"
     )]
     pub output: String,
-    /// `native`, `js`, `wasm`, or `wasi` (see long help below).
+    /// `native`, `js`, `wasm`, `wasi`, or `bytecode` (see long help below).
     #[arg(
         long,
         default_value = "native",
@@ -530,6 +532,12 @@ pub(crate) struct BuildArgs {
         help_heading = "Options"
     )]
     pub features: Vec<String>,
+    /// Cross-compile to an Apple iOS triple (e.g. `aarch64-apple-ios-sim`). Implies `--crate-type staticlib`.
+    #[arg(long, value_name = "TRIPLE", help_heading = "Options")]
+    pub ios_triple: Option<String>,
+    /// Output artifact for `--target native` (default: `bin`; use `staticlib` for embedded iOS).
+    #[arg(long, value_name = "TYPE", default_value = "bin", help_heading = "Options")]
+    pub crate_type: String,
     #[arg(long, help_heading = "Options")]
     pub no_optimize: bool,
     /// For `--target js` project builds: emit `OUTPUT.js.map` and `//# sourceMappingURL=…` so JS/TS tools can jump to original `.tish` (implies `--no-optimize` for that build).

package/crates/tish/src/main.rs

@@ -111,6 +111,8 @@ fn main() {
             &a.features,
             a.no_optimize || no_opt_env,
             a.source_map,
+            a.ios_triple.as_deref(),
+            &a.crate_type,
         ),
         Some(Commands::DumpAst { file }) => dump_ast(&file),
         None => {
@@ -568,6 +570,8 @@ fn build_file(
     cli_features: &[String],
     no_optimize: bool,
     source_map: bool,
+    ios_triple: Option<&str>,
+    crate_type: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path = Path::new(input_path)
@@ -623,9 +627,26 @@ fn build_file(
         .map_err(|e| e.to_string());
     }
 
+    if target == "bytecode" {
+        let project_root = input_path.parent().and_then(|p| {
+            if p.file_name().and_then(|n| n.to_str()) == Some("src") {
+                p.parent()
+            } else {
+                Some(p)
+            }
+        });
+        return tishlang_wasm::compile_to_bytecode(
+            &input_path,
+            project_root,
+            Path::new(output_path),
+            optimize,
+        )
+        .map_err(|e| e.to_string());
+    }
+
     if target != "native" {
         return Err(format!(
-            "Unknown target: {}. Use 'native', 'js', 'wasm', or 'wasi'.",
+            "Unknown target: {}. Use 'native', 'js', 'wasm', 'wasi', or 'bytecode'.",
             target
         ));
     }
@@ -639,9 +660,31 @@ fn build_file(
     });
     let features: Vec<String> = native_build_features_from_cli(cli_features);
 
+    let build_config = if let Some(triple) = ios_triple {
+        tishlang_native::NativeBuildConfig::ios_staticlib(triple)
+    } else if crate_type == "staticlib" {
+        tishlang_native::NativeBuildConfig {
+            artifact: tishlang_native::NativeArtifact::StaticLib,
+            cargo_target: None,
+            emit_mode: tishlang_compile::NativeEmitMode::EmbeddedLib,
+        }
+    } else if crate_type != "bin" {
+        return Err(format!(
+            "Unknown --crate-type: {}. Use 'bin' or 'staticlib'.",
+            crate_type
+        ));
+    } else {
+        tishlang_native::NativeBuildConfig::desktop()
+    };
+
     if is_js {
         let source = fs::read_to_string(&input_path).map_err(|e| format!("{}", e))?;
         let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
+        if build_config.artifact != tishlang_native::NativeArtifact::Bin {
+            return Err(
+                "--crate-type staticlib / --ios-triple require a .tish entry file.".to_string(),
+            );
+        }
         tishlang_native::compile_program_to_native(
             &program,
             project_root,
@@ -652,13 +695,14 @@ fn build_file(
         )
         .map_err(|e| e.to_string())?;
     } else {
-        tishlang_native::compile_to_native(
+        tishlang_native::compile_to_native_with_config(
             &input_path,
             project_root,
             Path::new(output_path),
             &features,
             native_backend,
             optimize,
+            &build_config,
         )
         .map_err(|e| e.to_string())?;
     }
@@ -667,7 +711,15 @@ fn build_file(
         .file_stem()
         .and_then(|s| s.to_str())
         .unwrap_or("tish_out");
-    let built_path = if output_path.ends_with('/') || Path::new(output_path).is_dir() {
+    let built_path = if build_config.artifact == tishlang_native::NativeArtifact::StaticLib {
+        if output_path.ends_with('/') || Path::new(output_path).is_dir() {
+            Path::new(output_path).join(format!("lib{out_name}.a"))
+        } else if output_path.ends_with(".a") {
+            Path::new(output_path).to_path_buf()
+        } else {
+            Path::new(output_path).with_extension("a")
+        }
+    } else if output_path.ends_with('/') || Path::new(output_path).is_dir() {
         Path::new(output_path).join(out_name)
     } else {
         Path::new(output_path).to_path_buf()

package/crates/tish_build_utils/src/lib.rs

@@ -338,6 +338,11 @@ pub fn find_crate_path(crate_name: &str) -> Result<PathBuf, String> {
     Ok(crate_path)
 }
 
+/// Sanitize a user-chosen output stem for Cargo `[lib]` / `[[bin]]` target names.
+pub fn cargo_target_name(stem: &str) -> String {
+    stem.replace('-', "_")
+}
+
 /// Create a temp build directory with src subdir.
 pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String> {
     let build_dir =
@@ -380,8 +385,12 @@ fn protoc_for_nested_cargo() -> Option<PathBuf> {
 }
 
 /// Run cargo build in the given directory.
-/// If target_dir is Some, use that for --target-dir (e.g. workspace target for caching).
-pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<(), String> {
+/// If `cross_target` is Some, passes `--target` and skips `-C target-cpu=native`.
+pub fn run_cargo_build(
+    build_dir: &Path,
+    target_dir: Option<&Path>,
+    cross_target: Option<&str>,
+) -> Result<(), String> {
     let _nested_guard = NESTED_CARGO_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
     let target_dir = target_dir
@@ -389,11 +398,10 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
         .unwrap_or_else(|| build_dir.join("target"));
     let fast_native = std::env::var("TISH_FAST_NATIVE_BUILD").as_deref() == Ok("1");
 
-    // Default to target-cpu=native so the emitted binary uses every SIMD / ISA
-    // extension the build host supports. Callers can override by pre-setting
-    // RUSTFLAGS in the environment. Skipped for fast nested builds (integration tests).
     let mut merged_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
-    if fast_native {
+    if cross_target.is_some() {
+        // Cross-compiling (e.g. iOS): do not use host target-cpu.
+    } else if fast_native {
         if cfg!(target_os = "linux")
             && mold_available()
             && !merged_rustflags.contains("fuse-ld=mold")
@@ -407,10 +415,6 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
         merged_rustflags = format!("{} -C target-cpu=native", merged_rustflags);
     }
 
-    // Nested `cargo build` (e.g. `tish build --native-backend rust`) inherits the parent
-    // environment. CI often sets `RUSTC_WRAPPER=sccache`; wrapping this inner compile too can
-    // cause flaky or failed builds (LTO / temp-crate paths). Use plain rustc here; the main
-    // workspace build still benefits from the wrapper.
     let mut cmd = Command::new("cargo");
     cmd.args(["build", "--release", "--target-dir"])
         .arg(&target_dir)
@@ -421,6 +425,9 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
         .env_remove("CARGO_BUILD_RUSTC_WRAPPER")
         .env("CARGO_TERM_PROGRESS", "always")
         .env("RUSTFLAGS", &merged_rustflags);
+    if let Some(triple) = cross_target {
+        cmd.arg("--target").arg(triple);
+    }
     if fast_native {
         cmd.env("CARGO_INCREMENTAL", "1");
     } else {
@@ -448,6 +455,12 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
 mod protoc_tests {
     use super::*;
 
+    #[test]
+    fn cargo_target_name_replaces_hyphens() {
+        assert_eq!(cargo_target_name("hello-ios"), "hello_ios");
+        assert_eq!(cargo_target_name("tish_out"), "tish_out");
+    }
+
     #[test]
     fn protoc_for_nested_cargo_without_env_uses_vendored_or_path() {
         let _lock = std::sync::Mutex::new(());
@@ -458,6 +471,16 @@ mod protoc_tests {
     }
 }
 
+/// Find the built static library in target/release (or target/$TRIPLE/release).
+pub fn find_release_staticlib(binary_dir: &Path, lib_name: &str) -> Result<PathBuf, String> {
+    let path = binary_dir.join(format!("lib{lib_name}.a"));
+    if path.exists() {
+        Ok(path)
+    } else {
+        Err(format!("Static library not found at {}", path.display()))
+    }
+}
+
 /// Find the built binary in target/release.
 pub fn find_release_binary(binary_dir: &Path, bin_name: &str) -> Result<PathBuf, String> {
     let binary_no_ext = binary_dir.join(bin_name);

package/crates/tish_builtins/src/math.rs

@@ -80,3 +80,10 @@ pub fn hypot(args: &[Value]) -> Value {
     let y = extract_num(args.get(1)).unwrap_or(0.0);
     Value::Number(x.hypot(y))
 }
+
+/// ES6 `Math.imul`: 32-bit integer multiply (used by xmur3 PRNG in juke-cards).
+pub fn imul(args: &[Value]) -> Value {
+    let a = extract_num(args.first()).unwrap_or(0.0) as i32;
+    let b = extract_num(args.get(1)).unwrap_or(0.0) as i32;
+    Value::Number(a.wrapping_mul(b) as f64)
+}

package/crates/tish_builtins/src/string.rs

@@ -189,6 +189,32 @@ pub fn substring(s: &Value, start: &Value, end: &Value) -> Value {
     }
 }
 
+/// JS `String.prototype.substr(start, length)`.
+pub fn substr(s: &Value, start: &Value, length: &Value) -> Value {
+    if let Value::String(s) = s {
+        let chars: Vec<char> = s.chars().collect();
+        let len = chars.len();
+        let mut start_idx = match start {
+            Value::Number(n) => *n as i64,
+            _ => 0,
+        };
+        if start_idx < 0 {
+            start_idx = (len as i64 + start_idx).max(0);
+        }
+        let start_idx = (start_idx as usize).min(len);
+        let count = match length {
+            Value::Null => len - start_idx,
+            Value::Number(n) => (*n as i64).max(0) as usize,
+            _ => len - start_idx,
+        };
+        let end_idx = (start_idx + count).min(len);
+        let result: String = chars[start_idx..end_idx].iter().collect();
+        Value::String(result.into())
+    } else {
+        Value::Null
+    }
+}
+
 pub fn split(s: &Value, sep: &Value) -> Value {
     if let Value::String(s) = s {
         let separator = match sep {