@tishlang/tish 1.7.0 → 1.9.0

package/crates/tish_vm/tests/peephole_jump_chain_logical_or.rs

@@ -120,7 +120,9 @@ fn merged_module_program_bytecode_matches_parse_for_string_or_fixture() {
     let src = std::fs::read_to_string(&fixture).expect("read fixture");
     let modules = tishlang_compile::resolve_project(&fixture, Some(fixture.parent().unwrap()))
         .expect("resolve");
-    let merged = tishlang_compile::merge_modules(modules).expect("merge");
+    let merged = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
     let flat = tishlang_parser::parse(&src).expect("parse");
     let m_opt = tishlang_opt::optimize(&merged);
     let f_opt = tishlang_opt::optimize(&flat);

package/crates/tish_wasm/src/lib.rs

@@ -3,6 +3,7 @@
 //! Compiles Tish to bytecode, then produces a .wasm VM binary + loader.
 //! The VM runs in the browser; your program runs as serialized bytecode.
 
+use std::collections::BTreeSet;
 use std::path::Path;
 use std::process::Command;
 
@@ -43,7 +44,9 @@ fn resolve_and_compile_to_chunk(
         message: e.to_string(),
     })?;
     let program = {
-        let prog = merge_modules(modules).map_err(|e| WasmError {
+        let prog = merge_modules(modules)
+            .map(|m| m.program)
+            .map_err(|e| WasmError {
             message: e.to_string(),
         })?;
         if optimize {
@@ -227,7 +230,7 @@ pub fn compile_to_wasi(
     let (chunk, program) = resolve_and_compile_to_chunk(entry_path, project_root, optimize)?;
     if has_external_native_imports(&program) {
         return Err(WasmError {
-            message: "WASI backend does not support external native imports (tish:egui, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
+            message: "WASI backend does not support external native imports (tish:egui, @scope/pkg). Built-in tish:fs, tish:http, tish:process, tish:timers are supported.".to_string(),
         });
     }
     let wasi_features = extract_native_import_features(&program);
@@ -274,18 +277,18 @@ pub fn compile_to_wasi(
         .to_string_lossy()
         .replace('\\', "/");
 
-    let features_str = if wasi_features.is_empty() {
-        String::new()
-    } else {
-        format!(
-            ", features = [{}]",
-            wasi_features
-                .iter()
-                .map(|f| format!("{:?}", f))
-                .collect::<Vec<_>>()
-                .join(", ")
-        )
-    };
+    // Bundled perf (`tests/main.tish`) and many scripts use global setTimeout without a top-level
+    // `import` (so `extract_native_import_features` is empty). Always link timers for WASI VM.
+    let mut wasi_feature_set: BTreeSet<String> = wasi_features.into_iter().collect();
+    wasi_feature_set.insert("timers".to_string());
+    let features_str = format!(
+        ", features = [{}]",
+        wasi_feature_set
+            .iter()
+            .map(|f| format!("{:?}", f))
+            .collect::<Vec<_>>()
+            .join(", ")
+    );
     let cargo_toml = format!(
         r#"[package]
 name = "tish_wasi_{stem}"

package/crates/tish_wasm_runtime/Cargo.toml

@@ -12,10 +12,11 @@ crate-type = ["cdylib", "rlib"]
 [features]
 # For wasm32-unknown-unknown (browser): wasm-bindgen, console output
 browser = ["dep:wasm-bindgen", "tishlang_vm/wasm"]
-# Built-in modules for WASI (wasm32-wasip1): file I/O, process, http
+# Built-in modules for WASI (wasm32-wasip1): file I/O, process, http, timers
 fs = ["tishlang_vm/fs"]
 process = ["tishlang_vm/process"]
 http = ["tishlang_vm/http"]
+timers = ["tishlang_vm/timers"]
 
 [dependencies]
 tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }

package/crates/tish_wasm_runtime/src/lib.rs

@@ -2,7 +2,7 @@
 //!
 //! Two targets:
 //! - **Browser** (wasm32-unknown-unknown): use `--features browser`, wasm-bindgen, console output
-//! - **WASI/Wasmtime** (wasm32-wasi): no features, println! via WASI, run with `wasmtime app.wasm`
+//! - **WASI/Wasmtime** (wasm32-wasip1): optional `timers` / `http` / … via Cargo features; `compile_to_wasi` enables `timers` by default.
 
 use tishlang_bytecode::deserialize;
 use tishlang_vm::Vm;

package/crates/tishlang_cargo_bindgen/Cargo.toml

@@ -18,6 +18,7 @@ path = "src/lib.rs"
 cargo_metadata = "0.19"
 clap = { version = "4.6", features = ["derive", "color"] }
 pathdiff = "0.2"
+proc-macro2 = { version = "1.0", features = ["span-locations"] }
 serde_json = "1"
 syn = { version = "2.0", features = ["full", "extra-traits"] }
 tempfile = "3"

package/crates/tishlang_cargo_bindgen/src/discover.rs

@@ -50,3 +50,71 @@ pub fn discover_public_functions(crate_root: &Path) -> Result<HashMap<String, It
 
     Ok(map.into_iter().map(|(k, (_, v))| (k, v)).collect())
 }
+
+/// On-disk location of a top-level `pub fn {fn_name}` under `crate_root/src` (LSP line/column, 0-based).
+///
+/// Requires `proc-macro2` built with `span-locations` (this crate enables it) so spans from
+/// `syn::parse_file` carry line/column.
+pub fn rust_public_fn_location(
+    crate_root: &Path,
+    fn_name: &str,
+) -> Result<(PathBuf, u32, u32), String> {
+    let src = crate_root.join("src");
+    if !src.is_dir() {
+        return Err(format!("no src/ under {}", crate_root.display()));
+    }
+
+    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;
+                }
+                if f.sig.ident != fn_name {
+                    continue;
+                }
+                let lc = f.sig.ident.span().start();
+                let line = u32::try_from(lc.line)
+                    .map_err(|_| "span line out of range".to_string())?
+                    .saturating_sub(1);
+                let col = u32::try_from(lc.column).map_err(|_| "span column out of range".to_string())?;
+                return Ok((path.to_path_buf(), line, col));
+            }
+        }
+    }
+
+    Err(format!(
+        "no public fn `{}` found under {}/src",
+        fn_name,
+        crate_root.display()
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn rust_public_fn_location_finds_fn() {
+        let tmp = tempdir().unwrap();
+        let src = tmp.path().join("src");
+        fs::create_dir_all(&src).unwrap();
+        fs::write(
+            src.join("lib.rs"),
+            "// comment\npub fn hello_tish_export() -> i32 { 0 }\n",
+        )
+        .unwrap();
+        let (path, line, _col) = rust_public_fn_location(tmp.path(), "hello_tish_export").unwrap();
+        assert!(path.ends_with("lib.rs"));
+        assert_eq!(line, 1);
+    }
+}

package/crates/tishlang_cargo_bindgen/src/lib.rs

@@ -21,6 +21,7 @@ pub mod infer;
 mod metadata;
 
 pub use classify::SignatureClass;
+pub use discover::rust_public_fn_location;
 pub use metadata::{resolve_dependency_from_manifest, resolve_registry_dependency, ResolvedDependency};
 
 use std::fs;
@@ -181,7 +182,7 @@ fn render_generated_lib(
          use std::cell::RefCell;\n\
          use std::rc::Rc;\n\
          use std::sync::Arc;\n\
-         use tishlang_runtime::{ObjectMap, Value};\n\n",
+         use tishlang_runtime::{ObjectMap, Value, VmRef};\n\n",
     );
 
     out.push_str(&format!(
@@ -244,15 +245,15 @@ fn json_to_tish(v: serde_json::Value) -> Value {
         serde_json::Value::Bool(b) => Value::Bool(b),
         serde_json::Value::Number(n) => Value::Number(n.as_f64().unwrap_or(0.0)),
         serde_json::Value::String(s) => Value::String(s.into()),
-        serde_json::Value::Array(a) => Value::Array(Rc::new(RefCell::new(
+        serde_json::Value::Array(a) => Value::Array(VmRef::new(
             a.into_iter().map(json_to_tish).collect(),
-        ))),
+        )),
         serde_json::Value::Object(m) => {
             let mut om = ObjectMap::default();
             for (k, v) in m {
                 om.insert(Arc::from(k), json_to_tish(v));
             }
-            Value::Object(Rc::new(RefCell::new(om)))
+            Value::Object(VmRef::new(om))
         }
     }
 }

package/justfile

@@ -250,6 +250,14 @@ optional-chaining-profile:
 perf *ARGS:
     ./scripts/run_performance_manual.sh {{ARGS}}
 
+# Bundled perf suite: per-test table + whole-program timings (tests/main.tish); add --verbose for full stdout
+perf-suite *ARGS:
+    ./scripts/run_performance_suite.sh {{ARGS}}
+
+# Regenerate tests/main.tish + tests/main.js after changing paired pure perf tests
+perf-suite-gen:
+    ./scripts/generate_perf_ci_main.sh
+
 # Show binary sizes for different builds
 sizes:
     @echo "Building secure binary..."

package/package.json

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