@tishlang/tish-format 3.0.0 → 3.2.2

package/crates/tish/src/cli_help.rs

@@ -404,6 +404,10 @@ pub fn build_after_help() -> String {
           Native executable (see --native-backend)
   {t}js{r}
           JavaScript bundle
+  {t}rust-lib{r}
+          Rust library source crate (crate-type = \"rlib\") at `-o <dir>` — one `pub fn` per
+          `export fn` of the entry module, over `tishlang_runtime::Value`. Cargo is NOT run; the
+          crate is the output, for the consumer to depend on. The Rust counterpart of `--target js`
   {t}wasm{r}
           WebAssembly (.tish project; .js source supported on some paths)
   {t}wasm-gpu{r}

package/crates/tish/src/main.rs

@@ -914,9 +914,9 @@ fn build_file(
         .map_err(|e| e.to_string());
     }
 
-    if target != "native" && target != "gba" {
+    if target != "native" && target != "gba" && target != "rust-lib" {
         return Err(format!(
-            "Unknown target: {}. Use 'native', 'gba', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
+            "Unknown target: {}. Use 'native', 'gba', 'rust-lib', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
             target
         ));
     }
@@ -935,6 +935,11 @@ fn build_file(
             return Err("tish build --target gba requires a .tish entry file.".to_string());
         }
         tishlang_native::NativeBuildConfig::gba()
+    } else if target == "rust-lib" {
+        if is_js {
+            return Err("tish build --target rust-lib requires a .tish entry file.".to_string());
+        }
+        tishlang_native::NativeBuildConfig::rust_lib()
     } else if let Some(triple) = ios_triple {
         tishlang_native::NativeBuildConfig::ios_staticlib(triple)
     } else if crate_type == "staticlib" {
@@ -982,6 +987,12 @@ fn build_file(
         .map_err(|e| e.to_string())?;
     }
 
+    // `rust-lib` writes a crate DIRECTORY at `-o`, and already reported it — the artifact-path
+    // rewriting below is all about locating a single built file, which does not apply.
+    if build_config.artifact == tishlang_native::NativeArtifact::RustLib {
+        return Ok(());
+    }
+
     let out_name = Path::new(output_path)
         .file_stem()
         .and_then(|s| s.to_str())

package/crates/tish/tests/rust_lib_crate.rs

@@ -0,0 +1,140 @@
+//! `tish build --target rust-lib` end to end: the emitted artifact is a Cargo **source crate**, and
+//! cargo is deliberately not run — the consumer decides what to build it for.
+//!
+//! The fast test pins the crate layout. The behavioural test — module state surviving between
+//! `pub fn` calls, a `clear*()` reassignment being visible to other exports, and the module body
+//! running exactly once — actually builds the crate and a consumer, so it is gated behind
+//! `TISH_SLOW_TESTS=1` to keep the default `cargo test` fast.
+use std::path::{Path, PathBuf};
+
+fn fixture() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../../tests/regression/rust_lib_emit.tish")
+        .canonicalize()
+        .unwrap()
+}
+
+fn emit_crate(out: &Path) {
+    let entry = fixture();
+    tishlang_native::compile_to_native_with_config(
+        &entry,
+        entry.parent(),
+        out,
+        &[],
+        "rust",
+        true,
+        &tishlang_native::NativeBuildConfig::rust_lib(),
+    )
+    .expect("rust-lib emit");
+}
+
+#[test]
+fn emits_an_rlib_source_crate_and_does_not_run_cargo() {
+    let out = std::env::temp_dir().join("tish_rustlib_layout");
+    let _ = std::fs::remove_dir_all(&out);
+    emit_crate(&out);
+
+    let manifest = std::fs::read_to_string(out.join("Cargo.toml")).expect("Cargo.toml");
+    assert!(
+        manifest.contains(r#"crate-type = ["rlib"]"#),
+        "expected an rlib library crate:\n{manifest}"
+    );
+    assert!(
+        manifest.contains("path = \"src/lib.rs\""),
+        "expected a lib entry point:\n{manifest}"
+    );
+    // Both `path` and `version` on the runtime dep: cargo prefers the path locally and falls back to
+    // the registry when the emitted crate is published, so it is publishable as-is.
+    assert!(
+        manifest.contains("tishlang_runtime = { path =") && manifest.contains("version = \""),
+        "the runtime dep must carry both path and version:\n{manifest}"
+    );
+
+    assert!(out.join("src/lib.rs").is_file(), "expected src/lib.rs");
+    assert!(
+        !out.join("src/main.rs").exists(),
+        "a library crate must not emit src/main.rs"
+    );
+    // Cargo was not invoked: no build output next to the emitted crate.
+    assert!(
+        !out.join("target").exists(),
+        "--target rust-lib must emit the crate and stop, not build it"
+    );
+}
+
+/// `TISH_SLOW_TESTS=1 cargo test -p tishlang --test rust_lib_crate` — compiles the emitted crate
+/// plus a consumer that exercises the module-state guarantees.
+#[test]
+fn consumer_observes_persistent_module_state() {
+    if std::env::var("TISH_SLOW_TESTS").as_deref() != Ok("1") {
+        eprintln!("skipped (set TISH_SLOW_TESTS=1 to run the full cargo build)");
+        return;
+    }
+    let root = std::env::temp_dir().join("tish_rustlib_e2e");
+    let _ = std::fs::remove_dir_all(&root);
+    let lib = root.join("lib");
+    emit_crate(&lib);
+
+    let consumer = root.join("consumer");
+    std::fs::create_dir_all(consumer.join("src")).unwrap();
+    std::fs::write(
+        consumer.join("Cargo.toml"),
+        format!(
+            "[package]\nname = \"consumer\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n\
+             [workspace]\n\n[dependencies]\nlib = {{ package = \"lib\", path = {:?} }}\n",
+            lib.display().to_string()
+        ),
+    )
+    .unwrap();
+    std::fs::write(
+        consumer.join("src/main.rs"),
+        r#"
+use lib::Value;
+fn num(v: &Value) -> f64 { match v { Value::Number(x) => *x, _ => f64::NAN } }
+fn text(v: &Value) -> String { match v { Value::String(x) => x.to_string(), _ => String::new() } }
+fn main() {
+    // First call is not the first declared export: init must already have run.
+    assert_eq!(num(&lib::add(Value::Number(2.0), Value::Number(40.0))), 42.0, "add");
+    assert_eq!(num(&lib::initRuns()), 1.0, "module top level runs once");
+
+    lib::register(Value::String("kick".into()), Value::String("noiseBurst".into()));
+    assert_eq!(text(&lib::lookup(Value::String("kick".into()))), "noiseBurst", "state persists");
+
+    // `clearAll` REASSIGNS the module-level binding; other exports must see that.
+    assert_eq!(num(&lib::clearAll()), 0.0, "clearAll empties");
+    assert_eq!(text(&lib::lookup(Value::String("kick".into()))), "miss", "reassignment visible");
+
+    assert_eq!(num(&lib::initRuns()), 1.0, "still initialised once");
+
+    // A throw is parked for the next checkpoint, not unwound. Across the `pub fn` boundary there is
+    // no Tish frame to surface it in, so a parked throw used to sit latched and make every LATER
+    // call bail and return null. Reading a property off a null is all it takes.
+    let _ = lib::runtime::get_index(&Value::Null, &Value::String("nope".into()));
+    assert_eq!(
+        num(&lib::add(Value::Number(1.0), Value::Number(2.0))),
+        3.0,
+        "a parked throw must not brick the module"
+    );
+    for _ in 0..20 {
+        let _ = lib::runtime::get_index(&Value::Null, &Value::String("nope".into()));
+    }
+    assert_eq!(text(&lib::lookup(Value::String("kick".into()))), "miss", "still working after 20");
+
+    println!("ALL_OK");
+}
+"#,
+    )
+    .unwrap();
+
+    let out = std::process::Command::new("cargo")
+        .args(["run", "-q"])
+        .current_dir(&consumer)
+        .output()
+        .expect("cargo run");
+    assert!(
+        String::from_utf8_lossy(&out.stdout).contains("ALL_OK"),
+        "consumer failed:\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+}

package/crates/tish/tests/scope_merge.rs

@@ -77,3 +77,34 @@ fn scope_exports_tish_merges_as_source() {
 fn scope_plain_main_merges_as_source() {
     assert_merged_as_source(&setup(r#","main":"index.tish""#));
 }
+
+/// The other half of the #38 split: a `@scope/pkg` that opts in via `tish.crate` (the tish-apple
+/// hosts, published as `@tishlang/tish-macos` / `@tishlang/tish-ios`) routes to the NATIVE path —
+/// lowered to `NativeModuleLoad`, not merged as source.
+#[test]
+fn scope_tish_crate_routes_native() {
+    let dir = setup(r#","tish":{"module":true,"crate":"test-greet","export":"greet_object"}"#);
+    let root = dir.path();
+    let modules = resolve_project(&root.join("main.tish"), Some(root)).expect("resolve");
+    let merged = merge_modules(modules).expect("merge");
+    let native_scope = merged.program.statements.iter().any(|s| {
+        matches!(
+            s,
+            Statement::VarDecl { init: Some(Expr::NativeModuleLoad { spec, .. }), .. }
+            if spec.as_ref() == "@test/greet"
+        )
+    });
+    assert!(
+        native_scope,
+        "@scope package with tish.crate must lower to NativeModuleLoad (native Rust-crate path)"
+    );
+    let has_greet = merged
+        .program
+        .statements
+        .iter()
+        .any(|s| matches!(s, Statement::FunDecl { name, .. } if name.as_ref() == "greet"));
+    assert!(
+        !has_greet,
+        "@scope package with tish.crate must NOT be merged as Tish source"
+    );
+}

package/crates/tish_build_utils/src/lib.rs

@@ -3,10 +3,11 @@
 //! Provides workspace discovery, path resolution, and Cargo build orchestration
 //! used by tishlang_wasm, tishlang_cranelift, tishlang_native, and the tish CLI.
 
+use std::collections::BTreeSet;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::sync::Mutex;
+use std::sync::{Mutex, OnceLock};
 
 /// Serialize nested `cargo build` calls that share the workspace `target/` dir (tests + `tish build`).
 static NESTED_CARGO_MUTEX: Mutex<()> = Mutex::new(());
@@ -19,6 +20,56 @@ fn mold_available() -> bool {
         .unwrap_or(false)
 }
 
+/// The `target_feature="..."` values in `rustc --print cfg` output.
+fn parse_target_features(print_cfg_stdout: &str) -> BTreeSet<String> {
+    print_cfg_stdout
+        .lines()
+        .filter_map(|l| l.trim().strip_prefix("target_feature=\""))
+        .filter_map(|l| l.strip_suffix('"'))
+        .map(str::to_owned)
+        .collect()
+}
+
+/// Host target features rustc reports, optionally under one extra `-C` flag.
+fn rustc_target_features(codegen_flag: Option<&str>) -> Option<BTreeSet<String>> {
+    let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string());
+    let mut cmd = Command::new(rustc);
+    cmd.args(["--print", "cfg"]);
+    if let Some(flag) = codegen_flag {
+        cmd.args(["-C", flag]);
+    }
+    let out = cmd.output().ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    Some(parse_target_features(&String::from_utf8_lossy(&out.stdout)))
+}
+
+/// True when `-C target-cpu=native` is worth passing on this host.
+///
+/// `native` asks LLVM to identify the host core. On hosts it cannot identify — notably
+/// the virtualized Apple Silicon behind GitHub Actions' macOS runners — it answers
+/// `generic`, which is *narrower* than the target's own default CPU. On
+/// aarch64-apple-darwin that silently drops `aes` and `sha2`, and crates that assert
+/// those are statically present then fail to compile at all; `ring` 0.17 trips
+/// `assertion failed: CAPS_STATIC == MIN_STATIC_FEATURES` in const-eval.
+///
+/// So this compares feature sets rather than trusting `native` blindly: keep the flag
+/// only when it is a strict win (every default feature survives). If rustc cannot be
+/// queried, skip the flag — the target default is always correct, just less tuned.
+fn native_target_cpu_is_safe() -> bool {
+    static SAFE: OnceLock<bool> = OnceLock::new();
+    *SAFE.get_or_init(|| {
+        match (
+            rustc_target_features(None),
+            rustc_target_features(Some("target-cpu=native")),
+        ) {
+            (Some(default), Some(native)) => default.is_subset(&native),
+            _ => false,
+        }
+    })
+}
+
 /// True if `root` looks like the Tish language repo (has `crates/tish_runtime`).
 ///
 /// Used so we do not treat unrelated workspaces (e.g. a parent `zectre-platform` repo) as Tish
@@ -347,7 +398,13 @@ pub fn cargo_target_name(stem: &str) -> String {
     // A leading digit is prefixed with `_`; an empty result falls back to a fixed default.
     let mut name: String = stem
         .chars()
-        .map(|c| if c.is_ascii_alphanumeric() || c == '_' { c } else { '_' })
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '_' {
+                c
+            } else {
+                '_'
+            }
+        })
         .collect();
     if name.is_empty() {
         return "tish_output".to_string();
@@ -371,6 +428,10 @@ pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String>
 }
 
 /// Run cargo build in the given directory.
+///
+/// `-C target-cpu=native` is added only for host builds, only when the caller has not
+/// already pinned a `target-cpu` in `RUSTFLAGS`, and only when `native` does not lose
+/// target features against the target default (see `native_target_cpu_is_safe`).
 /// If `cross_target` is Some, passes `--target` and skips `-C target-cpu=native`.
 pub fn run_cargo_build(
     build_dir: &Path,
@@ -395,10 +456,14 @@ pub fn run_cargo_build(
             merged_rustflags = format!("{} -C link-arg=-fuse-ld=mold", merged_rustflags.trim());
             merged_rustflags = merged_rustflags.trim().to_string();
         }
-    } else if merged_rustflags.is_empty() {
-        merged_rustflags = "-C target-cpu=native".to_string();
-    } else if !merged_rustflags.contains("target-cpu") {
-        merged_rustflags = format!("{} -C target-cpu=native", merged_rustflags);
+    } else if !merged_rustflags.contains("target-cpu") && native_target_cpu_is_safe() {
+        // Caller did not pin a CPU and `native` resolves to something at least as
+        // capable as the target default — see `native_target_cpu_is_safe`.
+        merged_rustflags = if merged_rustflags.is_empty() {
+            "-C target-cpu=native".to_string()
+        } else {
+            format!("{} -C target-cpu=native", merged_rustflags)
+        };
     }
 
     let mut cmd = Command::new("cargo");
@@ -438,6 +503,66 @@ pub fn run_cargo_build(
 mod protoc_tests {
     use super::*;
 
+    /// Trimmed `rustc --print cfg --target aarch64-apple-darwin`.
+    const APPLE_DARWIN_DEFAULT_CFG: &str = r#"
+debug_assertions
+panic="unwind"
+target_arch="aarch64"
+target_feature="aes"
+target_feature="neon"
+target_feature="sha2"
+target_feature="sha3"
+target_os="macos"
+"#;
+
+    #[test]
+    fn parses_target_features_from_print_cfg() {
+        let features = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        assert_eq!(
+            features.iter().map(String::as_str).collect::<Vec<_>>(),
+            ["aes", "neon", "sha2", "sha3"]
+        );
+        // Non-`target_feature` keys never leak in, and neither do the quotes.
+        assert!(!features.contains("aarch64"));
+        assert!(!features.contains("\"aes\""));
+    }
+
+    #[test]
+    fn native_cpu_rejected_when_it_drops_target_features() {
+        // What GitHub's virtualized Apple Silicon reports: `native` -> `generic`, which
+        // keeps only `neon`. Pinning it would break `ring`'s static feature assertions.
+        let default = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        let generic = parse_target_features("target_feature=\"neon\"\n");
+        assert!(!default.is_subset(&generic));
+    }
+
+    #[test]
+    fn native_cpu_accepted_when_it_only_adds() {
+        let default = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        let apple_m1 = parse_target_features(
+            "target_feature=\"aes\"\ntarget_feature=\"neon\"\n\
+             target_feature=\"sha2\"\ntarget_feature=\"sha3\"\ntarget_feature=\"lse\"\n",
+        );
+        assert!(default.is_subset(&apple_m1));
+        // Identical sets count as safe too — `native` matching the default is a no-op.
+        assert!(default.is_subset(&default));
+    }
+
+    #[test]
+    fn live_rustc_probe_still_parses() {
+        // Guards the parse against a `rustc --print cfg` format change: every target Tish
+        // builds on has at least one baseline target feature (x86_64 sse2, aarch64 neon).
+        // If this ever comes back empty the probe would silently disable target-cpu=native
+        // everywhere rather than only on hosts LLVM cannot identify.
+        let Some(features) = rustc_target_features(None) else {
+            return; // no rustc on PATH — nothing to assert
+        };
+        assert!(
+            !features.is_empty(),
+            "no target_feature in rustc --print cfg"
+        );
+    }
+
     #[test]
     fn cargo_target_name_replaces_hyphens() {
         assert_eq!(cargo_target_name("hello-ios"), "hello_ios");