@tishlang/tish 1.5.0 → 1.7.0

package/crates/tish_vm/tests/peephole_jump_chain_logical_or.rs

@@ -41,7 +41,10 @@ fn string_strict_eq_logical_or_inside_ternary_repl_last_expr() {
     let opt = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
     let v_peep = run_chunk(&compile_for_repl(&opt).expect("compile repl"));
     let v_unopt = run_chunk(&compile_for_repl_unoptimized(&opt).expect("compile repl unopt"));
-    assert!(v_peep.strict_eq(&v_unopt), "peep={v_peep:?} unopt={v_unopt:?}");
+    assert!(
+        v_peep.strict_eq(&v_unopt),
+        "peep={v_peep:?} unopt={v_unopt:?}"
+    );
     assert!(
         matches!(&v_peep, Value::Number(n) if *n == 1.0),
         "expected 1, got {v_peep:?}"
@@ -62,7 +65,8 @@ fn logical_or_strict_eq_peephole_matches_unoptimized() {
     );
 
     let v_peep_repl = run_chunk(&compile_for_repl(&program).expect("compile repl"));
-    let v_raw_repl = run_chunk(&compile_for_repl_unoptimized(&program).expect("compile repl unopt"));
+    let v_raw_repl =
+        run_chunk(&compile_for_repl_unoptimized(&program).expect("compile repl unopt"));
     assert!(
         v_peep_repl.strict_eq(&v_raw_repl),
         "repl: peep={v_peep_repl:?} raw={v_raw_repl:?}"
@@ -111,7 +115,8 @@ fn string_strict_eq_logical_or_peephole_matches_unoptimized() {
 /// `tish run path/to/file.tish` uses merge_modules; ensure that matches plain parse for the fixture.
 #[test]
 fn merged_module_program_bytecode_matches_parse_for_string_or_fixture() {
-    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/or_string_cmd.tish");
+    let fixture =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/or_string_cmd.tish");
     let src = std::fs::read_to_string(&fixture).expect("read fixture");
     let modules = tishlang_compile::resolve_project(&fixture, Some(fixture.parent().unwrap()))
         .expect("resolve");

package/crates/tish_wasm/src/lib.rs

@@ -107,27 +107,33 @@ fn emit_wasm_from_chunk(chunk: &Chunk, output_path: &Path) -> Result<(), WasmErr
     std::fs::create_dir_all(&out_dir_abs).map_err(|e| WasmError {
         message: format!("Cannot create output directory: {}", e),
     })?;
-    let workspace_root = tishlang_build_utils::find_workspace_root().map_err(|e| WasmError {
-        message: e,
-    })?;
+    let workspace_root =
+        tishlang_build_utils::find_workspace_root().map_err(|e| WasmError { message: e })?;
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
     let build_status = Command::new(&cargo)
         .current_dir(&workspace_root)
         .args([
-            "build", "-p", "tishlang_wasm_runtime",
-            "--target", "wasm32-unknown-unknown",
-            "--release", "--features", "browser",
+            "build",
+            "-p",
+            "tishlang_wasm_runtime",
+            "--target",
+            "wasm32-unknown-unknown",
+            "--release",
+            "--features",
+            "browser",
         ])
         .status()
-        .map_err(|e| WasmError { message: format!("Failed to run cargo: {}", e) })?;
+        .map_err(|e| WasmError {
+            message: format!("Failed to run cargo: {}", e),
+        })?;
     if !build_status.success() {
         return Err(WasmError {
             message: "Failed to build wasm runtime. Run: rustup target add wasm32-unknown-unknown"
                 .to_string(),
         });
     }
-    let wasm_artifact = workspace_root
-        .join("target/wasm32-unknown-unknown/release/tishlang_wasm_runtime.wasm");
+    let wasm_artifact =
+        workspace_root.join("target/wasm32-unknown-unknown/release/tishlang_wasm_runtime.wasm");
     if !wasm_artifact.exists() {
         return Err(WasmError {
             message: format!("Wasm artifact not found: {}", wasm_artifact.display()),
@@ -137,17 +143,25 @@ fn emit_wasm_from_chunk(chunk: &Chunk, output_path: &Path) -> Result<(), WasmErr
     let out_name = stem.to_string();
     let bindgen_status = Command::new(&wasm_bindgen)
         .args([
-            "--target", "web",
-            "--out-dir", out_dir_abs.to_str().unwrap(),
-            "--out-name", &out_name,
+            "--target",
+            "web",
+            "--out-dir",
+            out_dir_abs.to_str().unwrap(),
+            "--out-name",
+            &out_name,
             wasm_artifact.to_str().unwrap(),
         ])
         .status()
         .map_err(|e| WasmError {
-            message: format!("Failed to run wasm-bindgen: {}. Install with: cargo install wasm-bindgen-cli", e),
+            message: format!(
+                "Failed to run wasm-bindgen: {}. Install with: cargo install wasm-bindgen-cli",
+                e
+            ),
         })?;
     if !bindgen_status.success() {
-        return Err(WasmError { message: "wasm-bindgen failed".to_string() });
+        return Err(WasmError {
+            message: "wasm-bindgen failed".to_string(),
+        });
     }
     let js_name = format!("{}.js", stem);
     let html = format!(
@@ -171,7 +185,12 @@ run(chunk);
     std::fs::write(&html_path, html).map_err(|e| WasmError {
         message: format!("Cannot write {}: {}", html_path.display(), e),
     })?;
-    println!("Built: {}_bg.wasm, {}.js, {}", stem, stem, html_path.display());
+    println!(
+        "Built: {}_bg.wasm, {}.js, {}",
+        stem,
+        stem,
+        html_path.display()
+    );
     Ok(())
 }
 
@@ -233,9 +252,8 @@ pub fn compile_to_wasi(
         message: format!("Cannot create output directory: {}", e),
     })?;
 
-    let workspace_root = tishlang_build_utils::find_workspace_root().map_err(|e| WasmError {
-        message: e,
-    })?;
+    let workspace_root =
+        tishlang_build_utils::find_workspace_root().map_err(|e| WasmError { message: e })?;
 
     // Create generated project: wasi_build/{stem}/
     let build_dir = out_dir_abs.join("wasi_build").join(stem);
@@ -249,9 +267,7 @@ pub fn compile_to_wasi(
     })?;
 
     // Cargo.toml - path to tishlang_wasm_runtime (crate in crates/tish_wasm_runtime)
-    let runtime_path = workspace_root
-        .join("crates")
-        .join("tish_wasm_runtime");
+    let runtime_path = workspace_root.join("crates").join("tish_wasm_runtime");
     let runtime_path_str = runtime_path
         .canonicalize()
         .unwrap_or(runtime_path)
@@ -314,12 +330,7 @@ fn main() {
     let build_status = Command::new(&cargo)
         .current_dir(&build_dir)
         .env("CARGO_TARGET_DIR", &target_dir)
-        .args([
-            "build",
-            "--target",
-            "wasm32-wasip1",
-            "--release",
-        ])
+        .args(["build", "--target", "wasm32-wasip1", "--release"])
         .status()
         .map_err(|e| WasmError {
             message: format!("Failed to run cargo: {}", e),
@@ -355,4 +366,3 @@ fn main() {
     );
     Ok(())
 }
-

package/crates/tishlang_cargo_bindgen/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "tishlang_cargo_bindgen"
+version = "0.1.0"
+edition = "2021"
+description = "Generate Rust glue for Tish cargo: imports (bindgen-style, pre-commit friendly)"
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[[bin]]
+name = "tishlang-cargo-bindgen"
+path = "src/main.rs"
+
+[lib]
+name = "tishlang_cargo_bindgen"
+path = "src/lib.rs"
+
+[dependencies]
+cargo_metadata = "0.19"
+clap = { version = "4.6", features = ["derive", "color"] }
+pathdiff = "0.2"
+serde_json = "1"
+syn = { version = "2.0", features = ["full", "extra-traits"] }
+tempfile = "3"
+toml = "0.8"
+walkdir = "2"

package/crates/tishlang_cargo_bindgen/src/classify.rs

@@ -0,0 +1,265 @@
+//! Classify a `pub fn` from syn for glue emission (driven by signature shape, not crate name).
+
+use syn::{
+    FnArg, GenericArgument, ItemFn, PathArguments, ReturnType, Type, TypeReference,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SignatureClass {
+    /// `fn foo(args: &[Value]) -> Value` (or `tishlang_runtime::Value`).
+    TishValueAbi,
+    /// First parameter `&T` (or `&mut T`), `T: Serialize` (or `?Sized + Serialize`), returns `Result<String, _>`-like.
+    SerializeRefToResultString,
+    /// First parameter `&str` (or `& 'a str`), returns `Result<_, _>`, and has `Deserialize` bound on a type param.
+    DeserializeStrToResult,
+}
+
+pub fn classify_public_fn(item: &ItemFn) -> Option<SignatureClass> {
+    if matches!(classify_tish_abi(item), Some(SignatureClass::TishValueAbi)) {
+        return Some(SignatureClass::TishValueAbi);
+    }
+    if is_deserialize_str_result(item) {
+        return Some(SignatureClass::DeserializeStrToResult);
+    }
+    if is_serialize_ref_to_result_string(item) {
+        return Some(SignatureClass::SerializeRefToResultString);
+    }
+    None
+}
+
+fn classify_tish_abi(item: &ItemFn) -> Option<SignatureClass> {
+    let sig = &item.sig;
+    let mut value_args = 0;
+    for arg in &sig.inputs {
+        let FnArg::Typed(t) = arg else {
+            continue;
+        };
+        if is_slice_value(&t.ty) {
+            value_args += 1;
+        }
+    }
+    if value_args != 1 || sig.inputs.len() != 1 {
+        return None;
+    }
+    let Some(ret_ty) = return_type_inner(&sig.output) else {
+        return None;
+    };
+    if !is_value_type(ret_ty) {
+        return None;
+    }
+    Some(SignatureClass::TishValueAbi)
+}
+
+fn return_type_inner(ret: &ReturnType) -> Option<&Type> {
+    match ret {
+        ReturnType::Default => None,
+        ReturnType::Type(_, ty) => Some(ty),
+    }
+}
+
+fn is_slice_value(ty: &Type) -> bool {
+    let Some(inner) = strip_reference(ty) else {
+        return false;
+    };
+    let Type::Slice(s) = inner else {
+        return false;
+    };
+    is_value_type(&s.elem)
+}
+
+fn strip_reference(ty: &Type) -> Option<&Type> {
+    match ty {
+        Type::Reference(TypeReference { elem, .. }) => Some(elem.as_ref()),
+        _ => None,
+    }
+}
+
+fn is_value_type(ty: &Type) -> bool {
+    let Type::Path(p) = ty else {
+        return false;
+    };
+    let seg = p.path.segments.last();
+    let Some(seg) = seg else {
+        return false;
+    };
+    if seg.ident != "Value" {
+        return false;
+    }
+    // Accept `Value`, `tishlang_runtime::Value`, `tishlang_core::Value`
+    if p.path.segments.len() == 1 {
+        return true;
+    }
+    let prev = &p.path.segments[p.path.segments.len() - 2];
+    prev.ident == "tishlang_runtime" || prev.ident == "tishlang_core"
+}
+
+fn is_str_ref(ty: &Type) -> bool {
+    match ty {
+        Type::Reference(TypeReference { elem, .. }) => matches!(
+            elem.as_ref(),
+            Type::Path(p) if p.path.is_ident("str")
+        ),
+        _ => false,
+    }
+}
+
+fn is_deserialize_str_result(item: &ItemFn) -> bool {
+    let sig = &item.sig;
+    if sig.inputs.len() != 1 {
+        return false;
+    }
+    let FnArg::Typed(arg) = sig.inputs.first().unwrap() else {
+        return false;
+    };
+    if !is_str_ref(&arg.ty) {
+        return false;
+    }
+    let Some(ret) = return_type_inner(&sig.output) else {
+        return false;
+    };
+    if result_ok_type(ret).is_none() {
+        return false;
+    }
+    has_deserialize_bound(item)
+}
+
+fn has_deserialize_bound(item: &ItemFn) -> bool {
+    for p in &item.sig.generics.params {
+        if let syn::GenericParam::Type(t) = p {
+            for b in &t.bounds {
+                if bound_name_is(b, "Deserialize") {
+                    return true;
+                }
+            }
+        }
+    }
+    if let Some(wc) = &item.sig.generics.where_clause {
+        for pred in &wc.predicates {
+            if let syn::WherePredicate::Type(t) = pred {
+                for b in &t.bounds {
+                    if bound_name_is(b, "Deserialize") {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    false
+}
+
+fn bound_name_is(b: &syn::TypeParamBound, want: &str) -> bool {
+    let syn::TypeParamBound::Trait(t) = b else {
+        return false;
+    };
+    let path = &t.path;
+    path.segments.last().is_some_and(|s| s.ident == want)
+}
+
+fn is_serialize_ref_to_result_string(item: &ItemFn) -> bool {
+    let sig = &item.sig;
+    if sig.inputs.len() != 1 {
+        return false;
+    }
+    let FnArg::Typed(arg) = sig.inputs.first().unwrap() else {
+        return false;
+    };
+    if strip_reference(&arg.ty).is_none() {
+        return false;
+    }
+    let Some(ret) = return_type_inner(&sig.output) else {
+        return false;
+    };
+    let Some(ok_ty) = result_ok_type(ret) else {
+        return false;
+    };
+    if !type_is_string_or_str(ok_ty) {
+        return false;
+    }
+    has_serialize_bound(item)
+}
+
+fn has_serialize_bound(item: &ItemFn) -> bool {
+    for p in &item.sig.generics.params {
+        if let syn::GenericParam::Type(t) = p {
+            for b in &t.bounds {
+                if bound_name_is(b, "Serialize") {
+                    return true;
+                }
+            }
+        }
+    }
+    if let Some(wc) = &item.sig.generics.where_clause {
+        for pred in &wc.predicates {
+            if let syn::WherePredicate::Type(t) = pred {
+                for b in &t.bounds {
+                    if bound_name_is(b, "Serialize") {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    false
+}
+
+fn result_ok_type(ty: &Type) -> Option<&Type> {
+    let Type::Path(p) = ty else {
+        return None;
+    };
+    let seg = p.path.segments.last()?;
+    if seg.ident != "Result" {
+        return None;
+    }
+    let PathArguments::AngleBracketed(ab) = &seg.arguments else {
+        return None;
+    };
+    let first = ab.args.first()?;
+    let GenericArgument::Type(t) = first else {
+        return None;
+    };
+    Some(t)
+}
+
+fn type_is_string_or_str(ty: &Type) -> bool {
+    match ty {
+        Type::Path(p) => {
+            if p.path.is_ident("String") {
+                return true;
+            }
+            p.path.segments.len() == 1 && p.path.segments[0].ident == "str"
+        }
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use syn::parse_quote;
+
+    #[test]
+    fn classify_serde_to_string_shape() {
+        let item: ItemFn = parse_quote! {
+            pub fn to_string<T: ?Sized + Serialize>(value: &T) -> Result<String, ()> {
+                unimplemented!()
+            }
+        };
+        assert_eq!(
+            classify_public_fn(&item),
+            Some(SignatureClass::SerializeRefToResultString)
+        );
+    }
+
+    #[test]
+    fn classify_from_str_shape() {
+        let item: ItemFn = parse_quote! {
+            pub fn from_str<'a, T: Deserialize<'a>>(s: &'a str) -> Result<T, ()> {
+                unimplemented!()
+            }
+        };
+        assert_eq!(
+            classify_public_fn(&item),
+            Some(SignatureClass::DeserializeStrToResult)
+        );
+    }
+}

package/crates/tishlang_cargo_bindgen/src/discover.rs

@@ -0,0 +1,52 @@
+//! Walk dependency `src/**/*.rs` and collect `pub fn` items by name.
+
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use syn::{Item, ItemFn, Visibility};
+use walkdir::WalkDir;
+
+fn is_pub(vis: &Visibility) -> bool {
+    matches!(vis, Visibility::Public(_))
+}
+
+/// Map export name (Rust ident) to the function AST (must be unique).
+pub fn discover_public_functions(crate_root: &Path) -> Result<HashMap<String, ItemFn>, String> {
+    let src = crate_root.join("src");
+    if !src.is_dir() {
+        return Err(format!("no src/ under {}", crate_root.display()));
+    }
+
+    let mut map: HashMap<String, (PathBuf, ItemFn)> = HashMap::new();
+
+    for entry in WalkDir::new(&src)
+        .into_iter()
+        .filter_map(|e| e.ok())
+        .filter(|e| e.path().extension().map(|x| x == "rs").unwrap_or(false))
+    {
+        let path = entry.path();
+        let text = fs::read_to_string(path).map_err(|e| format!("read {}: {}", path.display(), e))?;
+        let file = syn::parse_file(&text).map_err(|e| format!("parse {}: {}", path.display(), e))?;
+
+        for item in file.items {
+            if let Item::Fn(f) = item {
+                if !is_pub(&f.vis) {
+                    continue;
+                }
+                let name = f.sig.ident.to_string();
+                if let Some((prev_path, _)) = map.get(&name) {
+                    return Err(format!(
+                        "ambiguous public fn `{}`: found in {} and {}",
+                        name,
+                        prev_path.display(),
+                        path.display()
+                    ));
+                }
+                map.insert(name, (path.to_path_buf(), f));
+            }
+        }
+    }
+
+    Ok(map.into_iter().map(|(k, (_, v))| (k, v)).collect())
+}