@tishlang/tish 1.9.2 → 1.12.0

package/crates/tishlang_cargo_bindgen/src/infer.rs

@@ -28,7 +28,8 @@ pub fn select_glue_crate_from_package_json(
             e
         )
     })?;
-    let j: Value = serde_json::from_str(&raw).map_err(|e| format!("{}: {}", pkg_json_path.display(), e))?;
+    let j: Value =
+        serde_json::from_str(&raw).map_err(|e| format!("{}: {}", pkg_json_path.display(), e))?;
     let rust_deps = j
         .get("tish")
         .and_then(|t| t.get("rustDependencies"))
@@ -123,7 +124,8 @@ fn dep_version_req_string_glue(spec: &toml::Value) -> Result<String, String> {
 }
 
 /// Crates we ignore when inferring bindgen **upstream** from the **app** `Cargo.toml` (not the glue crate).
-const ROOT_MANIFEST_SKIP_DEPS: &[&str] = &["tishlang_runtime", "tishlang_core", "tishlang_build_utils"];
+const ROOT_MANIFEST_SKIP_DEPS: &[&str] =
+    &["tishlang_runtime", "tishlang_core", "tishlang_build_utils"];
 
 /// Registry semver for bindgen metadata probe; skips path/git/workspace-only entries (project root fallback).
 fn dep_version_req_string_root(spec: &toml::Value) -> Option<String> {
@@ -136,7 +138,9 @@ fn dep_version_req_string_root(spec: &toml::Value) -> Option<String> {
             if t.get("path").is_some() || t.get("git").is_some() {
                 return None;
             }
-            t.get("version").and_then(|v| v.as_str()).map(|s| s.to_string())
+            t.get("version")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
         }
         _ => None,
     }
@@ -209,13 +213,15 @@ fn disambiguate_upstream_candidates(
 /// disambiguating when `serde_json` is present as a JSON-bridge helper alongside another crate.
 pub fn parse_upstream_from_glue_cargo(cargo_toml_path: &Path) -> Result<(String, String), String> {
     let s = fs::read_to_string(cargo_toml_path).map_err(|e| e.to_string())?;
-    let root: toml::Value = toml::from_str(&s).map_err(|e| format!("{}: {}", cargo_toml_path.display(), e))?;
+    let root: toml::Value =
+        toml::from_str(&s).map_err(|e| format!("{}: {}", cargo_toml_path.display(), e))?;
     let deps = root
         .get("dependencies")
         .and_then(|d| d.as_table())
         .ok_or_else(|| format!("{} has no [dependencies]", cargo_toml_path.display()))?;
 
-    let candidates = collect_upstream_candidates_from_table(deps, &[], dep_version_req_string_glue)?;
+    let candidates =
+        collect_upstream_candidates_from_table(deps, &[], dep_version_req_string_glue)?;
     disambiguate_upstream_candidates(
         candidates,
         cargo_toml_path,
@@ -226,9 +232,12 @@ pub fn parse_upstream_from_glue_cargo(cargo_toml_path: &Path) -> Result<(String,
 /// Infer upstream from the **project** `Cargo.toml` when the glue crate does not exist yet.
 /// Uses `[dependencies]` and `[dev-dependencies]`, skips Tish toolchain path crates (`tishlang_core`, …),
 /// and only keeps entries with a registry semver (skips bare `path =` / `git` deps).
-pub fn parse_upstream_from_root_package_cargo(cargo_toml_path: &Path) -> Result<(String, String), String> {
+pub fn parse_upstream_from_root_package_cargo(
+    cargo_toml_path: &Path,
+) -> Result<(String, String), String> {
     let s = fs::read_to_string(cargo_toml_path).map_err(|e| e.to_string())?;
-    let root: toml::Value = toml::from_str(&s).map_err(|e| format!("{}: {}", cargo_toml_path.display(), e))?;
+    let root: toml::Value =
+        toml::from_str(&s).map_err(|e| format!("{}: {}", cargo_toml_path.display(), e))?;
 
     let mut candidates = root
         .get("dependencies")
@@ -255,7 +264,8 @@ pub fn infer_from_project_root(
     project_root: &Path,
     rust_dep_key: Option<&str>,
 ) -> Result<InferredProjectBindgen, String> {
-    let (output_crate_name, out_dir) = select_glue_crate_from_package_json(project_root, rust_dep_key)?;
+    let (output_crate_name, out_dir) =
+        select_glue_crate_from_package_json(project_root, rust_dep_key)?;
     let glue_cargo = out_dir.join("Cargo.toml");
     let root_cargo = project_root.join("Cargo.toml");
 

package/crates/tishlang_cargo_bindgen/src/lib.rs

@@ -22,7 +22,9 @@ mod metadata;
 
 pub use classify::SignatureClass;
 pub use discover::rust_public_fn_location;
-pub use metadata::{resolve_dependency_from_manifest, resolve_registry_dependency, ResolvedDependency};
+pub use metadata::{
+    resolve_dependency_from_manifest, resolve_registry_dependency, ResolvedDependency,
+};
 
 use std::fs;
 use std::io;
@@ -69,7 +71,10 @@ pub fn generate_from_manifest(
     generate_from_resolved(cfg, &resolved)
 }
 
-fn generate_from_resolved(cfg: &BindgenConfig, resolved: &ResolvedDependency) -> Result<(), String> {
+fn generate_from_resolved(
+    cfg: &BindgenConfig,
+    resolved: &ResolvedDependency,
+) -> Result<(), String> {
     let root = resolved.source_root();
     let fns = discover::discover_public_functions(&root)?;
 
@@ -102,17 +107,9 @@ fn generate_from_resolved(cfg: &BindgenConfig, resolved: &ResolvedDependency) ->
         emitted.push((export.clone(), class));
     }
 
-    let lib_rs = render_generated_lib(
-        &cfg.dependency_name,
-        &emitted,
-        need_json_helpers,
-    )?;
+    let lib_rs = render_generated_lib(&cfg.dependency_name, &emitted, need_json_helpers)?;
 
-    let cargo_toml = render_output_cargo_toml(
-        cfg,
-        resolved.version(),
-        need_json_helpers,
-    )?;
+    let cargo_toml = render_output_cargo_toml(cfg, resolved.version(), need_json_helpers)?;
 
     fs::create_dir_all(cfg.out_dir.join("src")).map_err(|e| e.to_string())?;
     fs::write(cfg.out_dir.join("Cargo.toml"), cargo_toml).map_err(|e| e.to_string())?;
@@ -128,16 +125,18 @@ impl BindgenConfig {
     }
 }
 
-fn render_output_cargo_toml(cfg: &BindgenConfig, dep_exact_version: &str, need_serde_json: bool) -> Result<String, String> {
+fn render_output_cargo_toml(
+    cfg: &BindgenConfig,
+    dep_exact_version: &str,
+    need_serde_json: bool,
+) -> Result<String, String> {
     let rt_line = match &cfg.tishlang_runtime {
-        TishlangRuntimeDep::Path(p) => format!(
-            "tishlang_runtime = {{ path = {} }}\n",
-            toml_string_value(p)
-        ),
-        TishlangRuntimeDep::Version(req) => format!(
-            "tishlang_runtime = {}\n",
-            toml_string_value(req)
-        ),
+        TishlangRuntimeDep::Path(p) => {
+            format!("tishlang_runtime = {{ path = {} }}\n", toml_string_value(p))
+        }
+        TishlangRuntimeDep::Version(req) => {
+            format!("tishlang_runtime = {}\n", toml_string_value(req))
+        }
     };
     let dep_line = format!(
         "{} = {}\n",
@@ -185,10 +184,7 @@ fn render_generated_lib(
          use tishlang_runtime::{ObjectMap, Value, VmRef};\n\n",
     );
 
-    out.push_str(&format!(
-        "use {} as _tish_upstream;\n\n",
-        crate_ident
-    ));
+    out.push_str(&format!("use {} as _tish_upstream;\n\n", crate_ident));
 
     if need_json_helpers {
         out.push_str(JSON_HELPERS);
@@ -318,7 +314,10 @@ fn canonical_path_string(p: &Path) -> Result<String, String> {
 }
 
 /// Relative path from `out_dir` to `runtime` for Cargo.toml `path =`.
-pub fn runtime_path_relative_to_out_dir(out_dir: &Path, runtime: impl AsRef<Path>) -> Result<String, String> {
+pub fn runtime_path_relative_to_out_dir(
+    out_dir: &Path,
+    runtime: impl AsRef<Path>,
+) -> Result<String, String> {
     let abs_rt = runtime
         .as_ref()
         .canonicalize()

package/crates/tishlang_cargo_bindgen/src/main.rs

@@ -8,7 +8,8 @@ use std::path::PathBuf;
 use clap::Parser;
 use tishlang_cargo_bindgen::{
     generate_from_manifest, generate_from_registry_dependency, infer,
-    resolve_runtime_path_for_output, runtime_path_relative_to_out_dir, BindgenConfig, TishlangRuntimeDep,
+    resolve_runtime_path_for_output, runtime_path_relative_to_out_dir, BindgenConfig,
+    TishlangRuntimeDep,
 };
 
 #[derive(Parser, Debug)]
@@ -83,49 +84,51 @@ fn run() -> Result<(), String> {
 
     let current_dir = std::env::current_dir().map_err(|e| e.to_string())?;
 
-    let (
-        output_crate_name,
-        out_dir,
-        dependency_name,
-        dependency_version_req,
-        search_root,
-    ) = if let Some(dep) = args.dependency.as_ref() {
-        if let Some(out) = args.out_dir.as_ref() {
+    let (output_crate_name, out_dir, dependency_name, dependency_version_req, search_root) =
+        if let Some(dep) = args.dependency.as_ref() {
+            if let Some(out) = args.out_dir.as_ref() {
+                let root = args
+                    .project_root
+                    .clone()
+                    .unwrap_or_else(|| out.parent().unwrap_or(out).to_path_buf());
+                (
+                    args.crate_name
+                        .clone()
+                        .unwrap_or_else(|| "tish_serde_json".into()),
+                    out.clone(),
+                    dep.clone(),
+                    args.dependency_version.clone(),
+                    root,
+                )
+            } else {
+                let root = args
+                    .project_root
+                    .clone()
+                    .unwrap_or_else(|| current_dir.clone());
+                let (crate_key, od) =
+                    infer::infer_glue_paths_only(&root, args.crate_name.as_deref())?;
+                (
+                    crate_key,
+                    od,
+                    dep.clone(),
+                    args.dependency_version.clone(),
+                    root,
+                )
+            }
+        } else {
             let root = args
                 .project_root
                 .clone()
-                .unwrap_or_else(|| out.parent().unwrap_or(out).to_path_buf());
+                .unwrap_or_else(|| current_dir.clone());
+            let inf = infer::infer_from_project_root(&root, args.crate_name.as_deref())?;
             (
-                args.crate_name
-                    .clone()
-                    .unwrap_or_else(|| "tish_serde_json".into()),
-                out.clone(),
-                dep.clone(),
-                args.dependency_version.clone(),
+                inf.output_crate_name,
+                inf.out_dir,
+                inf.dependency_name,
+                inf.dependency_version_req,
                 root,
             )
-        } else {
-            let root = args.project_root.clone().unwrap_or_else(|| current_dir.clone());
-            let (crate_key, od) = infer::infer_glue_paths_only(&root, args.crate_name.as_deref())?;
-            (
-                crate_key,
-                od,
-                dep.clone(),
-                args.dependency_version.clone(),
-                root,
-            )
-        }
-    } else {
-        let root = args.project_root.clone().unwrap_or_else(|| current_dir.clone());
-        let inf = infer::infer_from_project_root(&root, args.crate_name.as_deref())?;
-        (
-            inf.output_crate_name,
-            inf.out_dir,
-            inf.dependency_name,
-            inf.dependency_version_req,
-            root,
-        )
-    };
+        };
 
     let tishlang_runtime = if let Some(req) = args.tishlang_runtime_version.clone() {
         TishlangRuntimeDep::Version(req)

package/crates/tishlang_cargo_bindgen/src/metadata.rs

@@ -35,7 +35,10 @@ fn from_package(pkg: &Package) -> ResolvedDependency {
 }
 
 /// Build a tiny probe crate, run `cargo metadata`, and return the named package.
-pub fn resolve_registry_dependency(name: &str, version_req: &str) -> Result<ResolvedDependency, String> {
+pub fn resolve_registry_dependency(
+    name: &str,
+    version_req: &str,
+) -> Result<ResolvedDependency, String> {
     let probe_dir = tempfile::tempdir().map_err(|e| format!("tempdir: {}", e))?;
     let probe_toml = format!(
         r#"[package]

package/justfile

@@ -125,15 +125,15 @@ test *ARGS:
 
 # Run only tish package tests (same as CI: integration tests only)
 test-tish *ARGS:
-    cargo nextest run -p tishlang--features full -- {{ARGS}}
+    cargo nextest run -p tishlang --features full -- {{ARGS}}
 
 # Skip slow backend tests (native/cranelift/wasi) for fast local iteration
 test-quick:
-    cargo nextest run -p tishlang--features full -- --skip test_mvp_programs_native --skip test_mvp_programs_cranelift --skip test_mvp_programs_wasi
+    cargo nextest run -p tishlang --features full -- --skip test_mvp_programs_native --skip test_mvp_programs_cranelift --skip test_mvp_programs_wasi
 
 # Run tests with coverage (requires llvm-tools: rustup component add llvm-tools-preview)
 test-coverage:
-    cargo llvm-cov nextest -p tishlang--features full --lcov --output-path lcov.info --html coverage-html
+    cargo llvm-cov nextest -p tishlang --features full --lcov --output-path lcov.info --html coverage-html
 
 # Plain cargo test (whole workspace)
 test-cargo:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.9.2",
+  "version": "1.12.0",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {