@tishlang/tish-format 3.10.11 → 3.12.0

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "3.10.11"
+version = "3.12.0"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/crates/tish_native/src/build.rs

@@ -45,6 +45,13 @@ fn runtime_features_for_cargo(features: &[String]) -> Vec<String> {
 }
 
 /// `[profile.release]` for nested `cargo build` of generated crates.
+///
+/// - default: fat LTO, one codegen unit — smallest and fastest binary, slowest to produce (the
+///   final link is single-threaded and dominates a warm build of a large app).
+/// - `TISH_FAST_NATIVE_BUILD=1`: iteration profile, no LTO, opt-level 1.
+/// - `TISH_NATIVE_THIN_LTO=1`: thin LTO over 8 codegen units — keeps most of fat's size/speed win
+///   while letting rustc parallelise the link. Same trade the GBA path offers via
+///   `TISH_GBA_THIN_LTO`; for desktop apps this is the CI-friendly shipping profile.
 fn nested_release_profile_toml() -> &'static str {
     if std::env::var("TISH_FAST_NATIVE_BUILD").as_deref() == Ok("1") {
         r#"[profile.release]
@@ -55,6 +62,13 @@ incremental = true
 strip = false
 debug = 0
 panic = "abort"
+"#
+    } else if std::env::var("TISH_NATIVE_THIN_LTO").as_deref() == Ok("1") {
+        r#"[profile.release]
+strip = true
+panic = "abort"
+codegen-units = 8
+lto = "thin"
 "#
     } else {
         r#"[profile.release]
@@ -287,7 +301,9 @@ edition = "2021"
         .parent()
         .and_then(|p| p.parent())
         .map(|ws| ws.join("target"));
-    let target_dir = workspace_target.filter(|p| p.exists());
+    let target_dir = workspace_target
+        .filter(|p| p.exists())
+        .or_else(shared_native_target_dir);
     let cross = build_config.cargo_target.as_deref();
     let release_sub = if let Some(triple) = cross {
         format!("{triple}/release")
@@ -456,7 +472,10 @@ fn runtime_dep_toml(runtime_path: &str, features_str: &str) -> String {
     if let Some(v) = released_compiler_version() {
         format!("tishlang_runtime = {{ version = {:?}{} }}", v, features_str)
     } else {
-        format!("tishlang_runtime = {{ path = {:?}{} }}", runtime_path, features_str)
+        format!(
+            "tishlang_runtime = {{ path = {:?}{} }}",
+            runtime_path, features_str
+        )
     }
 }
 
@@ -693,8 +712,7 @@ tishlang_runtime = {{ path = {runtime:?}{version}{features} }}
         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))?;
+    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(())
@@ -739,8 +757,7 @@ fn build_gba_rom(
     // the source of truth. The generated ROM crate must depend on the SAME agb: a skew would pull in
     // two agb crates and mismatch types at the sprite-registration boundary. Falls back to a known
     // pin only if the line can't be read (never blocks the build on a parse miss).
-    let agb_version =
-        read_facade_agb_version(&facade_path).unwrap_or_else(|| "0.25.0".to_string());
+    let agb_version = read_facade_agb_version(&facade_path).unwrap_or_else(|| "0.25.0".to_string());
 
     let out_stem = output_path
         .file_stem()
@@ -816,11 +833,13 @@ agb = "{agb_version}"
     // Only the channel is inherited. `components` stays `rust-src` because that is what build-std
     // needs — copying a project's `clippy`/`rustfmt` entries in would fail the ROM build whenever
     // the pinned toolchain lacks a component the ROM never uses.
-    let channel =
-        find_project_toolchain_channel(&base).unwrap_or_else(|| "nightly".to_string());
+    let channel = find_project_toolchain_channel(&base).unwrap_or_else(|| "nightly".to_string());
     fs::write(
         build_dir.join("rust-toolchain.toml"),
-        format!("[toolchain]\nchannel = \"{}\"\ncomponents = [\"rust-src\"]\n", channel),
+        format!(
+            "[toolchain]\nchannel = \"{}\"\ncomponents = [\"rust-src\"]\n",
+            channel
+        ),
     )
     .map_err(|e| format!("Cannot write rust-toolchain.toml: {}", e))?;
 
@@ -971,6 +990,30 @@ fn find_project_toolchain_channel(start: &Path) -> Option<String> {
     None
 }
 
+/// `TISH_NATIVE_TARGET_DIR` — opt-in shared cargo target dir for native (desktop) builds.
+///
+/// Native builds compile the generated crate under a per-process temp dir that is deleted on
+/// success (`cleanup_build_dir`), so nothing survives between two `tish build --target native`
+/// invocations and CI recompiles every dependency each run. Inside the tish workspace the
+/// workspace `target/` is shared automatically; a released compiler has no workspace, and this
+/// env var is the equivalent for it: point it at a directory that persists (a CI cache) and
+/// cargo reuses the dependency artifacts across builds. Deliberately NOT the ambient
+/// `CARGO_TARGET_DIR` — see the GBA path for why that is scrubbed (`TISH_GBA_TARGET_DIR` is the
+/// same opt-in for ROM builds). The directory is created if missing.
+fn shared_native_target_dir() -> Option<PathBuf> {
+    let dir = std::env::var_os("TISH_NATIVE_TARGET_DIR")
+        .map(PathBuf::from)
+        .filter(|p| !p.as_os_str().is_empty())?;
+    if let Err(e) = fs::create_dir_all(&dir) {
+        eprintln!(
+            "warning: TISH_NATIVE_TARGET_DIR={} is not usable ({e}); building in the temp dir",
+            dir.display()
+        );
+        return None;
+    }
+    Some(dir)
+}
+
 /// Remove a finished build's per-PID source directory (#384). Called only on SUCCESS, after the
 /// binary is copied out — the dir is then disposable (it holds only the generated crate source;
 /// compiled artifacts live in the shared workspace `target/`). Left in place on any earlier error so a
@@ -1126,7 +1169,9 @@ edition = "2021"
         .parent()
         .and_then(|p| p.parent())
         .map(|ws| ws.join("target"));
-    let target_dir = workspace_target.filter(|p| p.exists());
+    let target_dir = workspace_target
+        .filter(|p| p.exists())
+        .or_else(shared_native_target_dir);
     let binary_dir = target_dir
         .as_ref()
         .map(|t| t.join("release"))
@@ -1148,6 +1193,7 @@ edition = "2021"
 
 #[cfg(test)]
 mod tests {
+    use super::nested_release_profile_toml;
     use super::runtime_features_for_cargo;
 
     /// The generated ROM crate must inherit the project's pin, or GBA builds float against whatever
@@ -1188,14 +1234,62 @@ mod tests {
         let _ = fs::remove_dir_all(&base);
     }
 
+    /// `TISH_NATIVE_THIN_LTO=1` selects thin LTO for native release builds; fast wins over it.
+    #[test]
+    fn native_release_profile_follows_env() {
+        use std::sync::Mutex;
+        static ENV_LOCK: Mutex<()> = Mutex::new(());
+        let _g = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        std::env::remove_var("TISH_FAST_NATIVE_BUILD");
+        std::env::remove_var("TISH_NATIVE_THIN_LTO");
+        assert!(nested_release_profile_toml().contains("lto = \"fat\""));
+        std::env::set_var("TISH_NATIVE_THIN_LTO", "1");
+        let thin = nested_release_profile_toml();
+        assert!(thin.contains("lto = \"thin\"") && thin.contains("codegen-units = 8"));
+        std::env::set_var("TISH_FAST_NATIVE_BUILD", "1");
+        assert!(
+            nested_release_profile_toml().contains("lto = false"),
+            "fast wins over thin"
+        );
+        std::env::remove_var("TISH_FAST_NATIVE_BUILD");
+        std::env::remove_var("TISH_NATIVE_THIN_LTO");
+    }
+
+    /// `TISH_NATIVE_TARGET_DIR`: unset/empty → None (temp-dir build); set → that dir, created.
+    #[test]
+    fn shared_native_target_dir_follows_env() {
+        use super::shared_native_target_dir;
+        use std::fs;
+        use std::path::PathBuf;
+        // Only this test touches TISH_NATIVE_TARGET_DIR; the lock keeps it single-threaded anyway.
+        use std::sync::Mutex;
+        static ENV_LOCK: Mutex<()> = Mutex::new(());
+        let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        std::env::remove_var("TISH_NATIVE_TARGET_DIR");
+        assert!(shared_native_target_dir().is_none());
+        std::env::set_var("TISH_NATIVE_TARGET_DIR", "");
+        assert!(shared_native_target_dir().is_none());
+        // Scratch under the workspace target/ (never /tmp), unique per case.
+        let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("../../target/tmp_shared_target_test")
+            .join(format!("t_{}", std::process::id()));
+        let _ = fs::remove_dir_all(&dir);
+        std::env::set_var("TISH_NATIVE_TARGET_DIR", &dir);
+        let got = shared_native_target_dir().expect("set → Some");
+        assert_eq!(got, dir);
+        assert!(dir.is_dir(), "the shared target dir is created on demand");
+        std::env::remove_var("TISH_NATIVE_TARGET_DIR");
+        let _ = fs::remove_dir_all(dir.parent().unwrap());
+    }
+
     /// #384: `cleanup_build_dir` removes a finished build's dir by default, and preserves it under
     /// `TISH_KEEP_BUILD_DIR=1`.
     #[test]
     fn cleanup_build_dir_removes_by_default_and_keeps_on_flag() {
         use std::path::PathBuf;
         // Scratch under the workspace target/ (never /tmp), unique per case.
-        let base: PathBuf = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("../../target/tmp_cleanup_test");
+        let base: PathBuf =
+            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/tmp_cleanup_test");
         let removed = base.join("to_remove");
         let kept = base.join("to_keep");
         for d in [&removed, &kept] {
@@ -1209,7 +1303,10 @@ mod tests {
 
         std::env::set_var("TISH_KEEP_BUILD_DIR", "1");
         super::cleanup_build_dir(&kept);
-        assert!(kept.exists(), "TISH_KEEP_BUILD_DIR=1 should preserve the build dir");
+        assert!(
+            kept.exists(),
+            "TISH_KEEP_BUILD_DIR=1 should preserve the build dir"
+        );
         std::env::remove_var("TISH_KEEP_BUILD_DIR");
 
         let _ = std::fs::remove_dir_all(&base);

package/crates/tish_runtime/src/fs_ext.rs

@@ -218,9 +218,25 @@ pub fn copy_file_core(args: &[Value]) -> Result<Value, Value> {
 }
 pub fn realpath_core(args: &[Value]) -> Result<Value, Value> {
     std::fs::canonicalize(path_arg(args, 0))
-        .map(|p| Value::String(p.to_string_lossy().into()))
+        .map(|p| Value::String(strip_verbatim_prefix(&p.to_string_lossy()).into()))
         .map_err(io_err)
 }
+
+/// `std::fs::canonicalize` on Windows returns the verbatim form — `\\?\C:\Users\…` for a drive
+/// path, `\\?\UNC\server\share\…` for a network one. Node's `fs.realpath` never does: it hands
+/// back `C:\Users\…` / `\\server\share\…`, and programs treat the result as a display / URL /
+/// comparison string, not just an OS handle (Dune showed `\\?\C:\…` as its workspace title, and a
+/// `?` inside a URL path starts the query string). Match Node. No-op on POSIX and for paths
+/// that carry no prefix.
+pub(crate) fn strip_verbatim_prefix(p: &str) -> String {
+    if let Some(rest) = p.strip_prefix("\\\\?\\UNC\\") {
+        format!("\\\\{rest}")
+    } else if let Some(rest) = p.strip_prefix("\\\\?\\") {
+        rest.to_string()
+    } else {
+        p.to_string()
+    }
+}
 pub fn readlink_core(args: &[Value]) -> Result<Value, Value> {
     std::fs::read_link(path_arg(args, 0))
         .map(|p| Value::String(p.to_string_lossy().into()))
@@ -393,3 +409,16 @@ pub fn constants() -> Value {
     m.insert("X_OK".into(), Value::Number(1.0));
     Value::object(m)
 }
+
+#[cfg(test)]
+mod verbatim_prefix_tests {
+    use super::strip_verbatim_prefix;
+
+    #[test]
+    fn strips_windows_verbatim_prefixes_like_node() {
+        assert_eq!(strip_verbatim_prefix("\\\\?\\C:\\Users\\x\\ui"), "C:\\Users\\x\\ui");
+        assert_eq!(strip_verbatim_prefix("\\\\?\\UNC\\srv\\share\\d"), "\\\\srv\\share\\d");
+        assert_eq!(strip_verbatim_prefix("C:\\Users\\x"), "C:\\Users\\x");
+        assert_eq!(strip_verbatim_prefix("/Users/x/ui"), "/Users/x/ui");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "3.10.11",
+  "version": "3.12.0",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {