@tishlang/tish 1.9.2 → 1.12.0

package/crates/tish_native/src/build.rs

@@ -5,9 +5,18 @@ use std::path::Path;
 
 use tishlang_compile::ResolvedNativeModule;
 
+use crate::config::{NativeArtifact, NativeBuildConfig};
+
 /// `tishlang_runtime` Cargo feature names (subset of CLI / compile feature names).
-const RUNTIME_CARGO_FEATURES: &[&str] =
-    &["http", "http-hyper", "http-io-uring", "fs", "process", "regex", "ws"];
+const RUNTIME_CARGO_FEATURES: &[&str] = &[
+    "http",
+    "http-hyper",
+    "http-io-uring",
+    "fs",
+    "process",
+    "regex",
+    "ws",
+];
 
 /// Map CLI/compile features to flags passed to `tishlang_runtime` in the temp crate's Cargo.toml.
 /// `full` enables every optional runtime capability (matches `tish build --feature full` / LANGUAGE.md).
@@ -29,6 +38,29 @@ fn runtime_features_for_cargo(features: &[String]) -> Vec<String> {
     out
 }
 
+/// `[profile.release]` for nested `cargo build` of generated crates.
+fn nested_release_profile_toml() -> &'static str {
+    if std::env::var("TISH_FAST_NATIVE_BUILD").as_deref() == Ok("1") {
+        r#"[profile.release]
+opt-level = 1
+lto = false
+codegen-units = 16
+incremental = true
+strip = false
+debug = 0
+panic = "abort"
+"#
+    } else {
+        r#"[profile.release]
+# Reduce binary size: strip symbols, abort on panic (no unwinding), single codegen unit
+strip = true
+panic = "abort"
+codegen-units = 1
+lto = "fat"
+"#
+    }
+}
+
 /// Inject `mod generated_native;` after the crate attribute so the binary crate can call `crate::generated_native::…`.
 fn inject_generated_native_mod(rust_code: &str) -> String {
     if let Some(pos) = rust_code.find("\n\n") {
@@ -39,6 +71,10 @@ fn inject_generated_native_mod(rust_code: &str) -> String {
     }
 }
 
+pub(crate) fn rust_code_needs_tokio(rust_code: &str) -> bool {
+    rust_code.contains("#[tokio::main]") || rust_code.contains("tokio::runtime::Runtime")
+}
+
 pub fn build_via_cargo(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
@@ -48,11 +84,34 @@ pub fn build_via_cargo(
     generated_native_rs: Option<&str>,
     project_root: Option<&Path>,
 ) -> Result<(), String> {
-    let out_name = output_path
+    build_via_cargo_with_config(
+        rust_code,
+        native_modules,
+        output_path,
+        features,
+        extra_dependencies_toml,
+        generated_native_rs,
+        project_root,
+        &NativeBuildConfig::desktop(),
+    )
+}
+
+pub fn build_via_cargo_with_config(
+    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>,
+    build_config: &NativeBuildConfig,
+) -> Result<(), String> {
+    let out_stem = output_path
         .file_stem()
         .and_then(|s| s.to_str())
         .unwrap_or("tish_out");
-    let build_dir = tishlang_build_utils::create_build_dir("tish_build", out_name)?;
+    let cargo_name = tishlang_build_utils::cargo_target_name(out_stem);
+    let build_dir = tishlang_build_utils::create_build_dir("tish_build", out_stem)?;
 
     let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
 
@@ -64,7 +123,7 @@ pub fn build_via_cargo(
         format!(", features = {:?}", runtime_refs)
     };
 
-    let needs_tokio = rust_code.contains("#[tokio::main]");
+    let needs_tokio = rust_code_needs_tokio(rust_code);
     let tokio_dep = if needs_tokio {
         "\ntokio = { version = \"1\", features = [\"rt-multi-thread\", \"macros\"] }\n"
     } else {
@@ -108,27 +167,43 @@ pub fn build_via_cargo(
         String::new()
     };
 
+    let profile = nested_release_profile_toml();
+    let src_file = if build_config.artifact == NativeArtifact::StaticLib {
+        "lib.rs"
+    } else {
+        "main.rs"
+    };
+    let crate_section = if build_config.artifact == NativeArtifact::StaticLib {
+        format!(
+            r#"[lib]
+name = "{}"
+crate-type = ["staticlib"]
+path = "src/lib.rs"
+
+"#,
+            cargo_name
+        )
+    } else {
+        format!(
+            r#"[[bin]]
+name = "{}"
+path = "src/main.rs"
+
+"#,
+            cargo_name
+        )
+    };
     let cargo_toml = format!(
         r#"[package]
 name = "tish_output"
 version = "0.1.0"
 edition = "2021"
 
-[[bin]]
-name = "{}"
-path = "src/main.rs"
-
-[profile.release]
-# Reduce binary size: strip symbols, abort on panic (no unwinding), single codegen unit
-strip = true
-panic = "abort"
-codegen-units = 1
-lto = "fat"
-
+{}{}
 [dependencies]
 tishlang_runtime = {{ path = {:?}{} }}
 {}{}"#,
-        out_name, runtime_path, features_str, more_deps, ui_dep
+        crate_section, profile, runtime_path, features_str, more_deps, ui_dep
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)
@@ -137,8 +212,173 @@ tishlang_runtime = {{ path = {:?}{} }}
         fs::write(build_dir.join("src/generated_native.rs"), gen)
             .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
     }
-    fs::write(build_dir.join("src/main.rs"), rust_main)
-        .map_err(|e| format!("Cannot write main.rs: {}", e))?;
+    fs::write(build_dir.join("src").join(src_file), rust_main)
+        .map_err(|e| format!("Cannot write {}: {}", src_file, e))?;
+
+    let workspace_target = Path::new(&runtime_path)
+        .parent()
+        .and_then(|p| p.parent())
+        .map(|ws| ws.join("target"));
+    let target_dir = workspace_target.filter(|p| p.exists());
+    let cross = build_config.cargo_target.as_deref();
+    let release_sub = if let Some(triple) = cross {
+        format!("{triple}/release")
+    } else {
+        "release".to_string()
+    };
+    let binary_dir = target_dir
+        .as_ref()
+        .map(|t| t.join(&release_sub))
+        .unwrap_or_else(|| build_dir.join("target").join(&release_sub));
+
+    tishlang_build_utils::run_cargo_build(&build_dir, target_dir.as_deref(), cross)?;
+
+    let artifact = if build_config.artifact == NativeArtifact::StaticLib {
+        tishlang_build_utils::find_release_staticlib(&binary_dir, &cargo_name)?
+    } else {
+        tishlang_build_utils::find_release_binary(&binary_dir, &cargo_name)?
+    };
+    let target = if build_config.artifact == NativeArtifact::StaticLib {
+        if output_path.extension().is_some_and(|e| e == "a") {
+            output_path.to_path_buf()
+        } else if output_path.to_string_lossy().ends_with('/') || output_path.is_dir() {
+            output_path.join(format!("lib{out_stem}.a"))
+        } else {
+            output_path.with_extension("a")
+        }
+    } else {
+        tishlang_build_utils::resolve_output_path(output_path, out_stem)
+    };
+    tishlang_build_utils::copy_binary_to_output(&artifact, &target)?;
+
+    Ok(())
+}
+
+/// Build several native binaries in **one** nested Cargo project (shared `tishlang_runtime` compile).
+///
+/// `bins` order must match `outputs`: each `(stem, rust_code, generated_native_rs)` pairs with
+/// `outputs[i].0` (entry path — used only for validation) and `outputs[i].1` (final binary path).
+pub(crate) fn build_many_via_cargo(
+    bins: Vec<(String, String, Option<String>)>,
+    native_modules: Vec<ResolvedNativeModule>,
+    features: &[String],
+    extra_dependencies_toml: &str,
+    needs_tokio: bool,
+    needs_ui: bool,
+    outputs: &[(&Path, &Path)],
+    project_root: Option<&Path>,
+) -> Result<(), String> {
+    if bins.len() != outputs.len() {
+        return Err(format!(
+            "build_many_via_cargo: bins ({}) != outputs ({})",
+            bins.len(),
+            outputs.len()
+        ));
+    }
+    for (i, (stem, _, _)) in bins.iter().enumerate() {
+        let entry = outputs[i].0;
+        let expect = entry.file_stem().and_then(|s| s.to_str()).unwrap_or("");
+        if expect != stem {
+            return Err(format!(
+                "build_many_via_cargo: stem mismatch at {}: {} vs {}",
+                i, stem, expect
+            ));
+        }
+    }
+
+    let batch_id = format!("many_{}", std::process::id());
+    let build_dir = tishlang_build_utils::create_build_dir("tish_build_many", &batch_id)?;
+
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
+
+    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 tokio_dep = if needs_tokio {
+        "\ntokio = { version = \"1\", features = [\"rt-multi-thread\", \"macros\"] }\n"
+    } else {
+        ""
+    };
+
+    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();
+    more_deps.push_str(tokio_dep);
+    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 tish_ui_path = std::path::Path::new(&runtime_path)
+        .parent()
+        .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
+        .join("tish_ui");
+    let ui_dep = if needs_ui {
+        format!(
+            "\ntishlang_ui = {{ path = {:?}, default-features = false, features = [\"runtime\"] }}\n",
+            tish_ui_path.display().to_string().replace('\\', "/")
+        )
+    } else {
+        String::new()
+    };
+
+    let mut bin_tables = String::new();
+    for (stem, rust_code, generated_native_rs) in &bins {
+        let bin_dir = build_dir.join("src/bin").join(stem);
+        fs::create_dir_all(&bin_dir).map_err(|e| format!("create bin dir: {}", e))?;
+
+        let rust_main = if generated_native_rs.is_some() {
+            inject_generated_native_mod(rust_code)
+        } else {
+            rust_code.clone()
+        };
+
+        fs::write(bin_dir.join("main.rs"), rust_main)
+            .map_err(|e| format!("write main.rs for {}: {}", stem, e))?;
+        if let Some(gen) = generated_native_rs {
+            fs::write(bin_dir.join("generated_native.rs"), gen)
+                .map_err(|e| format!("write generated_native.rs for {}: {}", stem, e))?;
+        }
+
+        bin_tables.push_str(&format!(
+            r#"[[bin]]
+name = "{stem}"
+path = "src/bin/{stem}/main.rs"
+
+"#
+        ));
+    }
+
+    let profile = nested_release_profile_toml();
+    let cargo_toml = format!(
+        r#"[package]
+name = "tish_output_many"
+version = "0.1.0"
+edition = "2021"
+
+{}{}
+[dependencies]
+tishlang_runtime = {{ path = {:?}{} }}
+{}{}"#,
+        bin_tables, profile, runtime_path, features_str, more_deps, ui_dep
+    );
+
+    fs::write(build_dir.join("Cargo.toml"), cargo_toml)
+        .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
 
     let workspace_target = Path::new(&runtime_path)
         .parent()
@@ -150,11 +390,15 @@ tishlang_runtime = {{ path = {:?}{} }}
         .map(|t| t.join("release"))
         .unwrap_or_else(|| build_dir.join("target").join("release"));
 
-    tishlang_build_utils::run_cargo_build(&build_dir, target_dir.as_deref())?;
+    tishlang_build_utils::run_cargo_build(&build_dir, target_dir.as_deref(), None)?;
 
-    let binary = tishlang_build_utils::find_release_binary(&binary_dir, out_name)?;
-    let target = tishlang_build_utils::resolve_output_path(output_path, out_name);
-    tishlang_build_utils::copy_binary_to_output(&binary, &target)?;
+    for i in 0..bins.len() {
+        let stem = bins[i].0.as_str();
+        let output_path = outputs[i].1;
+        let binary = tishlang_build_utils::find_release_binary(binary_dir.as_path(), stem)?;
+        let target = tishlang_build_utils::resolve_output_path(output_path, stem);
+        tishlang_build_utils::copy_binary_to_output(&binary, &target)?;
+    }
 
     Ok(())
 }
@@ -176,6 +420,8 @@ mod tests {
     #[test]
     fn runtime_features_merges_full_and_specific() {
         let f = runtime_features_for_cargo(&["full".to_string(), "http".to_string()]);
-        assert_eq!(f.len(), 5);
+        // `full` expands to every RUNTIME_CARGO_FEATURES entry; redundant `http` must not duplicate.
+        assert_eq!(f.len(), super::RUNTIME_CARGO_FEATURES.len());
+        assert_eq!(f.iter().filter(|x| *x == "http").count(), 1);
     }
 }

package/crates/tish_native/src/config.rs

@@ -0,0 +1,48 @@
+//! Native build configuration (desktop binary vs iOS staticlib, cross-target).
+
+use tishlang_compile::NativeEmitMode;
+
+/// Output artifact kind for `tish build --target native`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum NativeArtifact {
+    #[default]
+    Bin,
+    StaticLib,
+}
+
+/// Options passed from the CLI into nested `cargo build`.
+#[derive(Debug, Clone, Default)]
+pub struct NativeBuildConfig {
+    pub artifact: NativeArtifact,
+    /// When set, run `cargo build --target <triple>` and skip `-C target-cpu=native`.
+    pub cargo_target: Option<String>,
+    pub emit_mode: NativeEmitMode,
+}
+
+impl NativeBuildConfig {
+    pub fn desktop() -> Self {
+        Self::default()
+    }
+
+    pub fn ios_staticlib(triple: &str) -> Self {
+        Self {
+            artifact: NativeArtifact::StaticLib,
+            cargo_target: Some(triple.to_string()),
+            emit_mode: NativeEmitMode::EmbeddedLib,
+        }
+    }
+
+    pub fn is_cross_compile(&self) -> bool {
+        self.cargo_target.is_some()
+    }
+}
+
+/// Filter runtime features for iOS sandbox builds.
+pub fn ios_runtime_features(features: &[String]) -> Vec<String> {
+    const ALLOW: &[&str] = &["http", "http-hyper", "regex", "timers"];
+    features
+        .iter()
+        .filter(|f| ALLOW.contains(&f.as_str()))
+        .cloned()
+        .collect()
+}

package/crates/tish_native/src/lib.rs

@@ -10,10 +10,29 @@
 //! emit Rust using `Vec<f64>` / fixed primitives instead of `Value` on hot paths.
 
 mod build;
+mod config;
+
+pub use config::{ios_runtime_features, NativeArtifact, NativeBuildConfig};
 
 use std::path::Path;
 use tishlang_ast::Program;
 
+/// Features for the embeddable VM (`cranelift` / `llvm` backends): merge CLI capability flags
+/// (same set as `tish run` / `tish build --target native`) with features inferred from
+/// `import … from 'tish:…'`. Programs that use globals only (`Promise`, `fetch`, `setTimeout`)
+/// still need the former so [`tishlang_cranelift_runtime`] links `tishlang_vm` with matching gates.
+fn merged_embed_runtime_features(cli: &[String], program: &Program) -> Vec<String> {
+    let mut out = cli.to_vec();
+    for f in tishlang_compile::extract_native_import_features(program) {
+        if !out.contains(&f) {
+            out.push(f);
+        }
+    }
+    out.sort();
+    out.dedup();
+    out
+}
+
 /// Error from native compilation.
 #[derive(Debug)]
 pub struct NativeError {
@@ -40,6 +59,27 @@ pub fn compile_to_native(
     features: &[String],
     native_backend: &str,
     optimize: bool,
+) -> Result<(), NativeError> {
+    compile_to_native_with_config(
+        entry_path,
+        project_root,
+        output_path,
+        features,
+        native_backend,
+        optimize,
+        &NativeBuildConfig::desktop(),
+    )
+}
+
+/// Compile a Tish project to a native binary or static library.
+pub fn compile_to_native_with_config(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    features: &[String],
+    native_backend: &str,
+    optimize: bool,
+    build_config: &NativeBuildConfig,
 ) -> Result<(), NativeError> {
     let backend = match native_backend {
         "rust" => Backend::Rust,
@@ -57,25 +97,44 @@ pub fn compile_to_native(
 
     match backend {
         Backend::Rust => {
+            let ios_cap = build_config.cargo_target.as_ref().map(|_| {
+                ios_runtime_features(features)
+                    .into_iter()
+                    .collect::<std::collections::HashSet<_>>()
+            });
+            let compile_features = if ios_cap.is_some() {
+                ios_runtime_features(features)
+            } else {
+                features.to_vec()
+            };
             let (rust_code, native_modules, effective_features, native_build) =
-                tishlang_compile::compile_project_full(
+                tishlang_compile::compile_project_full_emit(
                     entry_path,
                     project_root,
-                    features,
+                    &compile_features,
                     optimize,
+                    build_config.emit_mode,
+                    ios_cap.as_ref(),
                 )
                 .map_err(|e| NativeError {
                     message: e.to_string(),
                 })?;
 
-            crate::build::build_via_cargo(
+            let features_for_cargo = if build_config.cargo_target.is_some() {
+                ios_runtime_features(&effective_features)
+            } else {
+                effective_features
+            };
+
+            crate::build::build_via_cargo_with_config(
                 &rust_code,
                 native_modules,
                 output_path,
-                &effective_features,
+                &features_for_cargo,
                 &native_build.rust_dependencies_toml,
                 native_build.generated_native_rs.as_deref(),
                 project_root,
+                build_config,
             )
             .map_err(|e| NativeError { message: e })
         }
@@ -93,8 +152,8 @@ pub fn compile_to_native(
                 let prog = tishlang_compile::merge_modules(modules)
                     .map(|m| m.program)
                     .map_err(|e| NativeError {
-                    message: e.to_string(),
-                })?;
+                        message: e.to_string(),
+                    })?;
                 if optimize {
                     tishlang_opt::optimize(&prog)
                 } else {
@@ -118,7 +177,7 @@ pub fn compile_to_native(
                 })?
             };
 
-            let cranelift_features = tishlang_compile::extract_native_import_features(&program);
+            let cranelift_features = merged_embed_runtime_features(features, &program);
             tishlang_cranelift::compile_chunk_to_native(&chunk, output_path, &cranelift_features)
                 .map_err(|e| NativeError {
                     message: e.to_string(),
@@ -138,8 +197,8 @@ pub fn compile_to_native(
                 let prog = tishlang_compile::merge_modules(modules)
                     .map(|m| m.program)
                     .map_err(|e| NativeError {
-                    message: e.to_string(),
-                })?;
+                        message: e.to_string(),
+                    })?;
                 if optimize {
                     tishlang_opt::optimize(&prog)
                 } else {
@@ -160,7 +219,7 @@ pub fn compile_to_native(
                     message: e.to_string(),
                 })?
             };
-            let llvm_features = tishlang_compile::extract_native_import_features(&program);
+            let llvm_features = merged_embed_runtime_features(features, &program);
             tishlang_llvm::compile_chunk_to_native(&chunk, output_path, &llvm_features)
                 .map_err(|e| NativeError { message: e.message })
         }
@@ -249,7 +308,7 @@ pub fn compile_program_to_native(
                     message: e.to_string(),
                 })?
             };
-            let cranelift_features = tishlang_compile::extract_native_import_features(&program);
+            let cranelift_features = merged_embed_runtime_features(features, &program);
             tishlang_cranelift::compile_chunk_to_native(&chunk, output_path, &cranelift_features)
                 .map_err(|e| NativeError {
                     message: e.to_string(),
@@ -275,13 +334,81 @@ pub fn compile_program_to_native(
                     message: e.to_string(),
                 })?
             };
-            let llvm_features = tishlang_compile::extract_native_import_features(&program);
+            let llvm_features = merged_embed_runtime_features(features, &program);
             tishlang_llvm::compile_chunk_to_native(&chunk, output_path, &llvm_features)
                 .map_err(|e| NativeError { message: e.message })
         }
     }
 }
 
+/// Compile multiple entry `.tish` files to native binaries in **one** nested Cargo build.
+///
+/// Intended for integration tests and batch tooling; keeps production [`compile_to_native`] behavior
+/// unchanged when `TISH_FAST_NATIVE_BUILD` is unset.
+pub fn compile_many_to_native(
+    entries: &[(&Path, &Path)],
+    project_root: Option<&Path>,
+    features: &[String],
+    optimize: bool,
+) -> Result<(), NativeError> {
+    let mut bins: Vec<(String, String, Option<String>)> = Vec::with_capacity(entries.len());
+    let mut merged_native_modules: Vec<tishlang_compile::ResolvedNativeModule> = Vec::new();
+    let mut merged_features: Vec<String> = features.to_vec();
+    let mut merged_extra_deps = String::new();
+    let mut needs_tokio = false;
+    let mut needs_ui = false;
+
+    for (entry_path, _) in entries {
+        let (rust_code, native_modules, effective_features, native_build) =
+            tishlang_compile::compile_project_full(entry_path, project_root, features, optimize)
+                .map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?;
+        let stem = entry_path
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .ok_or_else(|| NativeError {
+                message: format!("invalid entry path: {}", entry_path.display()),
+            })?
+            .to_string();
+
+        for f in &effective_features {
+            if !merged_features.contains(f) {
+                merged_features.push(f.clone());
+            }
+        }
+        for m in native_modules {
+            let dup = merged_native_modules
+                .iter()
+                .any(|x| x.package_name == m.package_name && x.crate_path == m.crate_path);
+            if !dup {
+                merged_native_modules.push(m);
+            }
+        }
+        let extra = native_build.rust_dependencies_toml.trim();
+        if !extra.is_empty() {
+            merged_extra_deps.push_str(extra);
+            merged_extra_deps.push('\n');
+        }
+        needs_tokio |= crate::build::rust_code_needs_tokio(&rust_code);
+        needs_ui |= rust_code.contains("tishlang_ui");
+        bins.push((stem, rust_code, native_build.generated_native_rs));
+    }
+
+    let merged_extra = merged_extra_deps.trim();
+    crate::build::build_many_via_cargo(
+        bins,
+        merged_native_modules,
+        &merged_features,
+        merged_extra,
+        needs_tokio,
+        needs_ui,
+        entries,
+        project_root,
+    )
+    .map_err(|e| NativeError { message: e })
+}
+
 enum Backend {
     Rust,
     Cranelift,

package/crates/tish_parser/src/lib.rs

@@ -320,10 +320,13 @@ mod tests {
             Statement::Block { statements, .. } => statements,
             _ => panic!("expected block body"),
         };
-        assert_eq!(stmts.len(), 3, "expected expr; const; if as siblings — got {stmts:?}");
+        assert_eq!(
+            stmts.len(),
+            3,
+            "expected expr; const; if as siblings — got {stmts:?}"
+        );
         assert!(matches!(stmts[0], Statement::ExprStmt { .. }));
         assert!(matches!(stmts[1], Statement::VarDecl { .. }));
         assert!(matches!(stmts[2], Statement::If { .. }));
     }
-
 }