@tishlang/tish 1.9.2 → 1.12.0

package/crates/tish_wasm/src/lib.rs

@@ -30,6 +30,22 @@ impl std::fmt::Display for WasmError {
 
 impl std::error::Error for WasmError {}
 
+/// Map CLI / import capability names to `tishlang_wasm_runtime` Cargo features for wasm32-wasip1.
+/// The full `http` stack (tokio/socket2/…) does not build on WASI here; `http` maps to `promise`
+/// so `Promise` / `await` work. `ws` is skipped for the same reason.
+fn insert_wasi_runtime_cap(out: &mut BTreeSet<String>, cap: &str) {
+    match cap {
+        "http" => {
+            out.insert("promise".to_string());
+        }
+        "ws" => {}
+        "fs" | "process" | "promise" | "timers" | "regex" => {
+            out.insert(cap.to_string());
+        }
+        _ => {}
+    }
+}
+
 /// Resolve project, merge modules, and compile to bytecode chunk.
 /// Returns (Chunk, Program) so WASI can extract features for the runtime.
 fn resolve_and_compile_to_chunk(
@@ -47,8 +63,8 @@ fn resolve_and_compile_to_chunk(
         let prog = merge_modules(modules)
             .map(|m| m.program)
             .map_err(|e| WasmError {
-            message: e.to_string(),
-        })?;
+                message: e.to_string(),
+            })?;
         if optimize {
             tishlang_opt::optimize(&prog)
         } else {
@@ -215,17 +231,49 @@ pub fn compile_to_wasm(
     emit_wasm_from_chunk(&chunk, output_path)
 }
 
+/// Compile a Tish project to a raw serialized bytecode chunk.
+///
+/// Writes a single `{output}` file of the exact bytes that the wasm/WASI runtime entry points
+/// (`start` / `run`) deserialize directly — the same chunk `--target wasm` embeds as base64 in
+/// its generated HTML loader, but written raw with no VM binary, JS glue, or HTML wrapper. Lets a
+/// host that already ships the VM runtime (e.g. a bundler) consume the bytecode without the
+/// throwaway standalone build.
+pub fn compile_to_bytecode(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    optimize: bool,
+) -> Result<(), WasmError> {
+    let (chunk, _) = resolve_and_compile_to_chunk(entry_path, project_root, optimize)?;
+    let bytes = serialize(&chunk);
+    if let Some(parent) = output_path.parent().filter(|p| !p.as_os_str().is_empty()) {
+        std::fs::create_dir_all(parent).map_err(|e| WasmError {
+            message: format!("Cannot create output directory: {}", e),
+        })?;
+    }
+    std::fs::write(output_path, &bytes).map_err(|e| WasmError {
+        message: format!("Cannot write {}: {}", output_path.display(), e),
+    })?;
+    println!("Built: {} ({} bytes)", output_path.display(), bytes.len());
+    Ok(())
+}
+
 /// Compile a Tish project for Wasmtime/WASI.
 ///
 /// Produces a single `{output}.wasm` with embedded bytecode. Run with:
 /// `wasmtime {output}.wasm`
 ///
 /// Requires: `rustup target add wasm32-wasip1`
+///
+/// `capabilities` is the same capability list as `tish build --target native` (e.g. from
+/// `native_build_features_from_cli`): merged with `import`-inferred features so globals like
+/// `Promise` / `fetch` work without a top-level `import … from 'http'`.
 pub fn compile_to_wasi(
     entry_path: &Path,
     project_root: Option<&Path>,
     output_path: &Path,
     optimize: bool,
+    capabilities: &[String],
 ) -> Result<(), WasmError> {
     let (chunk, program) = resolve_and_compile_to_chunk(entry_path, project_root, optimize)?;
     if has_external_native_imports(&program) {
@@ -233,7 +281,16 @@ pub fn compile_to_wasi(
             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);
+    let mut wasi_feature_set: BTreeSet<String> = BTreeSet::new();
+    for f in extract_native_import_features(&program) {
+        insert_wasi_runtime_cap(&mut wasi_feature_set, f.as_str());
+    }
+    for f in capabilities {
+        insert_wasi_runtime_cap(&mut wasi_feature_set, f.as_str());
+    }
+    // Many scripts use global setTimeout without `import` from timers.
+    wasi_feature_set.insert("timers".to_string());
+
     let chunk_bytes = serialize(&chunk);
 
     let stem = output_path
@@ -277,10 +334,6 @@ pub fn compile_to_wasi(
         .to_string_lossy()
         .replace('\\', "/");
 
-    // 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

package/crates/tish_wasm_runtime/Cargo.toml

@@ -12,16 +12,25 @@ 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, timers
+# Browser WebGPU / JS-interop FFI + requestAnimationFrame render loop (the
+# `start(chunk, env)` entry). Reflection-based bridge over js-sys; no web-sys
+# WebGPU bindings needed since the WebGPU command API is synchronous.
+gpu = ["browser", "dep:js-sys"]
+# Built-in modules for WASI (wasm32-wasip1): align with `tishlang_cranelift_runtime` / CLI caps
 fs = ["tishlang_vm/fs"]
 process = ["tishlang_vm/process"]
 http = ["tishlang_vm/http"]
+promise = ["tishlang_vm/promise"]
 timers = ["tishlang_vm/timers"]
+regex = ["tishlang_vm/regex"]
+ws = ["tishlang_vm/ws"]
 
 [dependencies]
 tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
 tishlang_vm = { path = "../tish_vm", version = ">=0.1" }
+tishlang_core = { path = "../tish_core", version = ">=0.1" }
 wasm-bindgen = { version = "0.2", optional = true }
+js-sys = { version = "0.3", optional = true }
 
 # rand_core → getrandom 0.4 needs wasm_js on wasm32-unknown-unknown (browser VM build).
 [target.'cfg(target_arch = "wasm32")'.dependencies]

package/crates/tish_wasm_runtime/src/gpu.rs

@@ -0,0 +1,413 @@
+//! Browser WebGPU / JS-interop FFI for the tish bytecode VM.
+//!
+//! Lets a tish program compiled to wasm drive the browser's WebGPU (and any
+//! Web API) without hand-binding each call. The bridge is a tiny set of
+//! reflection-based primitives exposed as VM globals:
+//!
+//! - `js_global(name)` — read a JS global (e.g. `navigator`, `GPUBufferUsage`)
+//! - `js_get(handle, key)` / `js_set(handle, key, val)`
+//! - `js_call(handle, method, argsArray)` — call a method (the whole WebGPU
+//!   command API is synchronous, so this covers it)
+//! - `js_new(ctorNameOrHandle, argsArray)`
+//! - `js_typeof(handle)` — debugging
+//! - `f32a(arr)` / `u16a(arr)` / `u8a(arr)` — tish `number[]` → real typed array
+//! - `request_animation_frame(cb)` — drive a render loop
+//!
+//! GPU/JS objects (device, queue, context, buffers, pipelines, textures,
+//! ImageBitmaps, the host env object …) round-trip through the VM as opaque
+//! [`JsHandle`] values. Async startup (requestAdapter/requestDevice/fetch/
+//! createImageBitmap) is done in JS glue; the ready handles are handed to the
+//! VM via the `host` global by [`start`].
+
+use std::any::Any;
+use std::cell::{Cell, RefCell};
+use std::sync::Arc;
+
+use tishlang_bytecode::deserialize;
+use tishlang_core::{value_call, NativeFn, TishOpaque, Value};
+use tishlang_vm::Vm;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+
+// ---------------------------------------------------------------------------
+// Opaque JS handle
+// ---------------------------------------------------------------------------
+
+/// Opaque tish value wrapping a browser `JsValue`. `JsValue` is `!Send`, which
+/// is why `TishOpaque`'s `Send + Sync` bound is gated off in the browser
+/// (`!send-values`) build — see `tish_core/src/value.rs`.
+struct JsHandle(JsValue);
+
+impl TishOpaque for JsHandle {
+    fn type_name(&self) -> &'static str {
+        "JsHandle"
+    }
+    fn get_method(&self, _name: &str) -> Option<NativeFn> {
+        None
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+fn wrap(v: JsValue) -> Value {
+    Value::Opaque(Arc::new(JsHandle(v)))
+}
+
+fn unwrap_handle(v: &Value) -> Option<JsValue> {
+    match v {
+        Value::Opaque(o) => o.as_any().downcast_ref::<JsHandle>().map(|h| h.0.clone()),
+        _ => None,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Marshalling  tish Value <-> JsValue
+// ---------------------------------------------------------------------------
+
+/// Convert a tish value to a JS value. Objects/arrays recurse; an opaque
+/// `JsHandle` is spliced in **by reference** (so descriptors can embed live GPU
+/// handles, e.g. `beginRenderPass({ colorAttachments:[{ view:<handle> }] })`).
+/// Functions/promises/symbols are not marshalled (return `null`).
+fn value_to_js(v: &Value) -> JsValue {
+    match v {
+        Value::Number(n) => JsValue::from_f64(*n),
+        Value::String(s) => JsValue::from_str(s.as_ref()),
+        Value::Bool(b) => JsValue::from_bool(*b),
+        Value::Null => JsValue::NULL,
+        Value::Opaque(o) => match o.as_any().downcast_ref::<JsHandle>() {
+            Some(h) => h.0.clone(),
+            None => JsValue::NULL,
+        },
+        Value::Array(arr) => {
+            let out = js_sys::Array::new();
+            for item in arr.borrow().iter() {
+                out.push(&value_to_js(item));
+            }
+            out.into()
+        }
+        Value::Object(obj) => {
+            let out = js_sys::Object::new();
+            let b = obj.borrow();
+            for (k, val) in b.strings.iter() {
+                let _ = js_sys::Reflect::set(
+                    &out,
+                    &JsValue::from_str(k.as_ref()),
+                    &value_to_js(val),
+                );
+            }
+            out.into()
+        }
+        _ => JsValue::NULL,
+    }
+}
+
+/// Convert a JS value back to tish. Primitives map directly; everything else
+/// (objects, functions, typed arrays, GPU objects) becomes an opaque handle —
+/// we deliberately do **not** expand JS containers into tish arrays/objects
+/// (that would re-introduce boxing and lose typed-array identity).
+fn js_to_value(v: JsValue) -> Value {
+    if v.is_null() || v.is_undefined() {
+        Value::Null
+    } else if let Some(n) = v.as_f64() {
+        Value::Number(n)
+    } else if let Some(b) = v.as_bool() {
+        Value::Bool(b)
+    } else if let Some(s) = v.as_string() {
+        Value::String(s.into())
+    } else {
+        wrap(v)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// FFI builtins
+// ---------------------------------------------------------------------------
+
+fn ffi_js_global() -> Value {
+    Value::native(|args: &[Value]| {
+        let name = match args.first() {
+            Some(Value::String(s)) => s.clone(),
+            _ => return Value::Null,
+        };
+        match js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str(name.as_ref())) {
+            Ok(v) => js_to_value(v),
+            Err(_) => Value::Null,
+        }
+    })
+}
+
+fn ffi_js_get() -> Value {
+    Value::native(|args: &[Value]| {
+        let obj = match args.first().and_then(unwrap_handle) {
+            Some(o) => o,
+            None => return Value::Null,
+        };
+        let key = args.get(1).map(value_to_js).unwrap_or(JsValue::NULL);
+        match js_sys::Reflect::get(&obj, &key) {
+            Ok(v) => js_to_value(v),
+            Err(_) => Value::Null,
+        }
+    })
+}
+
+fn ffi_js_set() -> Value {
+    Value::native(|args: &[Value]| {
+        let obj = match args.first().and_then(unwrap_handle) {
+            Some(o) => o,
+            None => return Value::Null,
+        };
+        let key = args.get(1).map(value_to_js).unwrap_or(JsValue::NULL);
+        let val = args.get(2).map(value_to_js).unwrap_or(JsValue::NULL);
+        let _ = js_sys::Reflect::set(&obj, &key, &val);
+        Value::Null
+    })
+}
+
+fn ffi_js_call() -> Value {
+    Value::native(|args: &[Value]| {
+        let obj = match args.first().and_then(unwrap_handle) {
+            Some(o) => o,
+            None => return Value::Null,
+        };
+        let method = match args.get(1) {
+            Some(Value::String(s)) => s.clone(),
+            _ => return Value::Null,
+        };
+        let func = match js_sys::Reflect::get(&obj, &JsValue::from_str(method.as_ref())) {
+            Ok(f) => match f.dyn_into::<js_sys::Function>() {
+                Ok(f) => f,
+                Err(_) => return Value::Null,
+            },
+            Err(_) => return Value::Null,
+        };
+        let js_args = js_sys::Array::new();
+        if let Some(Value::Array(a)) = args.get(2) {
+            for item in a.borrow().iter() {
+                js_args.push(&value_to_js(item));
+            }
+        }
+        match js_sys::Reflect::apply(&func, &obj, &js_args) {
+            Ok(v) => js_to_value(v),
+            Err(_) => Value::Null,
+        }
+    })
+}
+
+fn ffi_js_new() -> Value {
+    Value::native(|args: &[Value]| {
+        let ctor: JsValue = match args.first() {
+            Some(Value::String(s)) => {
+                match js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str(s.as_ref())) {
+                    Ok(v) => v,
+                    Err(_) => return Value::Null,
+                }
+            }
+            Some(v @ Value::Opaque(_)) => match unwrap_handle(v) {
+                Some(h) => h,
+                None => return Value::Null,
+            },
+            _ => return Value::Null,
+        };
+        let ctor_fn = match ctor.dyn_into::<js_sys::Function>() {
+            Ok(f) => f,
+            Err(_) => return Value::Null,
+        };
+        let js_args = js_sys::Array::new();
+        if let Some(Value::Array(a)) = args.get(1) {
+            for item in a.borrow().iter() {
+                js_args.push(&value_to_js(item));
+            }
+        }
+        match js_sys::Reflect::construct(&ctor_fn, &js_args) {
+            Ok(v) => js_to_value(v),
+            Err(_) => Value::Null,
+        }
+    })
+}
+
+fn ffi_js_typeof() -> Value {
+    Value::native(|args: &[Value]| {
+        let v = args.first().map(value_to_js).unwrap_or(JsValue::NULL);
+        match v.js_typeof().as_string() {
+            Some(s) => Value::String(s.into()),
+            None => Value::Null,
+        }
+    })
+}
+
+/// `f32a(numberArray)` -> opaque `Float32Array` handle (one-shot copy). Use for
+/// per-frame uniform/transform staging. Large static buffers should instead be
+/// materialised host-side and passed in opaque (never boxed into a tish array).
+fn ffi_f32a() -> Value {
+    Value::native(|args: &[Value]| {
+        let arr = match args.first() {
+            Some(Value::Array(a)) => a.clone(),
+            _ => return Value::Null,
+        };
+        let b = arr.borrow();
+        let ta = js_sys::Float32Array::new_with_length(b.len() as u32);
+        for (i, v) in b.iter().enumerate() {
+            ta.set_index(i as u32, v.as_number().unwrap_or(0.0) as f32);
+        }
+        wrap(ta.into())
+    })
+}
+
+fn ffi_u16a() -> Value {
+    Value::native(|args: &[Value]| {
+        let arr = match args.first() {
+            Some(Value::Array(a)) => a.clone(),
+            _ => return Value::Null,
+        };
+        let b = arr.borrow();
+        let ta = js_sys::Uint16Array::new_with_length(b.len() as u32);
+        for (i, v) in b.iter().enumerate() {
+            ta.set_index(i as u32, v.as_number().unwrap_or(0.0) as u16);
+        }
+        wrap(ta.into())
+    })
+}
+
+fn ffi_u8a() -> Value {
+    Value::native(|args: &[Value]| {
+        let arr = match args.first() {
+            Some(Value::Array(a)) => a.clone(),
+            _ => return Value::Null,
+        };
+        let b = arr.borrow();
+        let ta = js_sys::Uint8Array::new_with_length(b.len() as u32);
+        for (i, v) in b.iter().enumerate() {
+            ta.set_index(i as u32, v.as_number().unwrap_or(0.0) as u8);
+        }
+        wrap(ta.into())
+    })
+}
+
+// ---------------------------------------------------------------------------
+// requestAnimationFrame render loop
+// ---------------------------------------------------------------------------
+
+thread_local! {
+    static RAF_CALLBACK: RefCell<Option<Value>> = const { RefCell::new(None) };
+    static RAF_CLOSURE: RefCell<Option<Closure<dyn FnMut(f64)>>> = const { RefCell::new(None) };
+    // True while a frame is pending, so repeated request_animation_frame calls
+    // within one frame don't compound into runaway scheduling.
+    static RAF_SCHEDULED: Cell<bool> = const { Cell::new(false) };
+}
+
+/// Browser-driven per-frame entry: invoke the stored tish callback, then
+/// re-arm for the next frame. We re-schedule from Rust (rather than requiring
+/// the tish callback to call `request_animation_frame` again each frame) so the
+/// loop runs continuously as long as a callback is registered. `cancel`-ing the
+/// loop = clearing `RAF_CALLBACK`. The `value_call` runs the frame closure to
+/// completion; all WebGPU recording happens synchronously inside.
+fn tick(ts: f64) {
+    let cb = RAF_CALLBACK.with(|c| c.borrow().clone());
+    // This frame's pending schedule is now consumed.
+    RAF_SCHEDULED.with(|f| f.set(false));
+    if let Some(cb) = cb {
+        if matches!(cb, Value::Function(_)) {
+            value_call(&cb, &[Value::Number(ts)]);
+        }
+        // Re-arm only if the callback is still registered (allows a future
+        // cancel by clearing RAF_CALLBACK).
+        if RAF_CALLBACK.with(|c| c.borrow().is_some()) {
+            schedule_raf();
+        }
+    }
+}
+
+fn schedule_raf() {
+    // Coalesce: at most one rAF in flight at a time.
+    if RAF_SCHEDULED.with(|f| f.get()) {
+        return;
+    }
+    RAF_SCHEDULED.with(|f| f.set(true));
+    RAF_CLOSURE.with(|slot| {
+        let mut s = slot.borrow_mut();
+        if s.is_none() {
+            *s = Some(Closure::wrap(Box::new(|ts: f64| tick(ts)) as Box<dyn FnMut(f64)>));
+        }
+        let g = js_sys::global();
+        if let Ok(raf) = js_sys::Reflect::get(&g, &JsValue::from_str("requestAnimationFrame")) {
+            if let Ok(raf_fn) = raf.dyn_into::<js_sys::Function>() {
+                let _ = raf_fn.call1(&g, s.as_ref().unwrap().as_ref().unchecked_ref());
+            }
+        }
+    });
+}
+
+fn ffi_request_animation_frame() -> Value {
+    Value::native(|args: &[Value]| {
+        if let Some(cb) = args.first() {
+            RAF_CALLBACK.with(|c| *c.borrow_mut() = Some(cb.clone()));
+        }
+        schedule_raf();
+        Value::Null
+    })
+}
+
+// ---------------------------------------------------------------------------
+// Install + entry point
+// ---------------------------------------------------------------------------
+
+fn install_ffi(vm: &mut Vm) {
+    vm.set_global("js_global".into(), ffi_js_global());
+    vm.set_global("js_get".into(), ffi_js_get());
+    vm.set_global("js_set".into(), ffi_js_set());
+    vm.set_global("js_call".into(), ffi_js_call());
+    vm.set_global("js_new".into(), ffi_js_new());
+    vm.set_global("js_typeof".into(), ffi_js_typeof());
+    vm.set_global("f32a".into(), ffi_f32a());
+    vm.set_global("u16a".into(), ffi_u16a());
+    vm.set_global("u8a".into(), ffi_u8a());
+    vm.set_global("request_animation_frame".into(), ffi_request_animation_frame());
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = console, js_name = error)]
+    fn console_error(s: &str);
+}
+
+fn set_panic_hook() {
+    use std::sync::Once;
+    static HOOK: Once = Once::new();
+    HOOK.call_once(|| {
+        std::panic::set_hook(Box::new(|info| {
+            console_error(&format!("tish wasm panic: {}", info));
+        }));
+    });
+}
+
+/// Browser entry: run a tish bytecode `chunk` with the JS-interop FFI installed
+/// and the host environment object (device/queue/context/format/canvas/assets,
+/// built by the page's async startup glue) exposed as the `host` global.
+///
+/// Returns after top-level tish runs; the `requestAnimationFrame` loop keeps
+/// the captured globals alive via the stored callback, so the VM state persists
+/// across frames even though this call returns.
+/// Invoke the registered frame callback exactly once, without re-scheduling.
+/// For driving frames deterministically from JS when `requestAnimationFrame` is
+/// throttled (e.g. a hidden/offscreen preview tab) — verification & debugging.
+#[wasm_bindgen]
+pub fn tick_once(ts: f64) {
+    let cb = RAF_CALLBACK.with(|c| c.borrow().clone());
+    if let Some(cb) = cb {
+        if matches!(cb, Value::Function(_)) {
+            value_call(&cb, &[Value::Number(ts)]);
+        }
+    }
+}
+
+#[wasm_bindgen]
+pub fn start(chunk: Vec<u8>, env: JsValue) -> Result<(), JsValue> {
+    set_panic_hook();
+    let chunk = deserialize(&chunk).map_err(|e| JsValue::from_str(&e))?;
+    let mut vm = Vm::new();
+    install_ffi(&mut vm);
+    vm.set_global("host".into(), wrap(env));
+    vm.run(&chunk).map_err(|e| JsValue::from_str(&e))?;
+    Ok(())
+}

package/crates/tish_wasm_runtime/src/lib.rs

@@ -2,11 +2,17 @@
 //!
 //! Two targets:
 //! - **Browser** (wasm32-unknown-unknown): use `--features browser`, wasm-bindgen, console output
-//! - **WASI/Wasmtime** (wasm32-wasip1): optional `timers` / `http` / … via Cargo features; `compile_to_wasi` enables `timers` by default.
+//! - **WASI/Wasmtime** (wasm32-wasip1): optional `timers` / `http` / … via Cargo features; `compile_to_wasi`
+//!   merges CLI capability flags with imports and always enables `timers` when globals use `setTimeout`.
 
 use tishlang_bytecode::deserialize;
 use tishlang_vm::Vm;
 
+/// Browser WebGPU / JS-interop FFI + requestAnimationFrame render loop.
+/// Adds the `start(chunk, env)` wasm-bindgen entry used by the engine.
+#[cfg(feature = "gpu")]
+pub mod gpu;
+
 /// Run serialized Tish bytecode (WASI/Wasmtime or native).
 ///
 /// `chunk` is the output of `tishlang_bytecode::serialize(chunk)`.

package/crates/tishlang_cargo_bindgen/src/classify.rs

@@ -1,8 +1,6 @@
 //! 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,
-};
+use syn::{FnArg, GenericArgument, ItemFn, PathArguments, ReturnType, Type, TypeReference};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum SignatureClass {

package/crates/tishlang_cargo_bindgen/src/discover.rs

@@ -26,8 +26,10 @@ pub fn discover_public_functions(crate_root: &Path) -> Result<HashMap<String, It
         .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))?;
+        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 {
@@ -70,8 +72,10 @@ pub fn rust_public_fn_location(
         .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))?;
+        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 {
@@ -85,7 +89,8 @@ pub fn rust_public_fn_location(
                 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())?;
+                let col =
+                    u32::try_from(lc.column).map_err(|_| "span column out of range".to_string())?;
                 return Ok((path.to_path_buf(), line, col));
             }
         }