refactor: workspace-wide clippy and idiom cleanup

Non-functional lint-driven cleanups across the workspace:
- use is_multiple_of / checked_div instead of manual modulo and zero guards
- derive Default for CacheSlot instead of a hand-written impl
- add a default MemoryRegion::is_empty
- drop needless borrows (wat::parse_str(wrap(...))) and collapse a
  redundant if/else in the copy-BST emitter
- minor tidy-ups in benches, tests, and the wasmtime host/imported paths

Also gate the rust-cache step on !ACT so the local act runner skips it.

Author: Zachary Whitley

.github/workflows/ci.yml

@@ -15,6 +15,7 @@ jobs:
           components: clippy, rustfmt
           targets: wasm32-unknown-unknown
       - uses: Swatinem/rust-cache@v2
+        if: ${{ !env.ACT }} # act's runner image has no node on PATH; cache is a no-op locally
       - name: cargo fmt --check
         run: cargo fmt --all -- --check
       - name: cargo clippy

bench-framework/runner/src/main.rs

@@ -331,7 +331,7 @@ fn run_tvm_mm_sequential(size: u32, data: &[u8]) -> anyhow::Result<Sample> {
     let engine = enable_multi_memory()?;
     let module = Module::new(&engine, MM_WAT)?;
     // Pre-create two memories sized to comfortably hold our test data.
-    let pages_needed = ((size as u64 + 65535) / 65536).max(1) as u32;
+    let pages_needed = (size as u64).div_ceil(65536).max(1) as u32;
     let mut store = Store::new(&engine, ());
     let mem0 = Memory::new(
         &mut store,
@@ -361,7 +361,7 @@ fn run_tvm_mm_list(size: u32, bytes: &[u8], head_offset: u32) -> anyhow::Result<
     use wasmtime::{Memory, MemoryType};
     let engine = enable_multi_memory()?;
     let module = Module::new(&engine, MM_WAT)?;
-    let pages_needed = ((size as u64 + 65535) / 65536).max(1) as u32;
+    let pages_needed = (size as u64).div_ceil(65536).max(1) as u32;
     let mut store = Store::new(&engine, ());
     let mem0 = Memory::new(
         &mut store,
@@ -397,7 +397,7 @@ fn run_tvm_mm_columnar(
     use wasmtime::{Memory, MemoryType};
     let engine = enable_multi_memory()?;
     let module = Module::new(&engine, MM_WAT)?;
-    let pages_needed = ((size as u64 + 65535) / 65536).max(1) as u32;
+    let pages_needed = (size as u64).div_ceil(65536).max(1) as u32;
     let mut store = Store::new(&engine, ());
     // Each column gets its own imported memory.
     let mem_a = Memory::new(
@@ -1156,7 +1156,7 @@ fn bench_spill_driven(
         let h = store.data_mut().directory.alloc(r, resident_budget)?;
         let packed = (h.region_id as i64) << 48 | (h.generation as i64) << 32 | (h.offset as i64);
         // Write a few bytes so the spill has something real to persist.
-        store.data_mut().directory.write(h, &vec![0xAA; 64])?;
+        store.data_mut().directory.write(h, &[0xAA; 64])?;
         handles.push(packed);
     }
 
@@ -1299,10 +1299,10 @@ fn bench_large_ws(
         handles_bytes.extend_from_slice(&p.to_le_bytes());
     }
     // Grow memory if needed.
-    let needed_pages = ((handles_offset as usize + handles_bytes.len()) + 65535) / 65536;
+    let needed_pages = (handles_offset as usize + handles_bytes.len()).div_ceil(65536);
     let current_size = memory.data_size(&store);
     if current_size < needed_pages * 65536 {
-        let extra = (needed_pages * 65536 - current_size + 65535) / 65536;
+        let extra = (needed_pages * 65536 - current_size).div_ceil(65536);
         memory.grow(&mut store, extra as u64)?;
     }
     memory.write(&mut store, handles_offset as usize, &handles_bytes)?;

crates/tvm-core/src/allocator.rs

@@ -239,11 +239,7 @@ pub struct SlabAllocator {
 
 impl SlabAllocator {
     pub fn new(capacity: u32, class_size: u32) -> Self {
-        let n_slots = if class_size == 0 {
-            0
-        } else {
-            capacity / class_size
-        };
+        let n_slots = capacity.checked_div(class_size).unwrap_or(0);
         // Push slots in reverse so `pop()` hands out offset 0 first.
         let free_slots: Vec<u32> = (0..n_slots).rev().map(|i| i * class_size).collect();
         Self {
@@ -283,7 +279,7 @@ impl SlabAllocator {
     pub fn dealloc(&mut self, offset: u32) -> Result<u32> {
         if self.class_size == 0
             || offset >= self.n_slots * self.class_size
-            || offset % self.class_size != 0
+            || !offset.is_multiple_of(self.class_size)
         {
             return Err(TvmError::OutOfBounds);
         }

crates/tvm-core/src/cache.rs

@@ -13,7 +13,7 @@ use crate::residency::Residency;
 const CACHE_SLOTS: usize = 8;
 const CACHE_MASK: u16 = (CACHE_SLOTS - 1) as u16;
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default)]
 struct CacheSlot {
     valid: bool,
     region_id: u16,
@@ -28,20 +28,6 @@ struct CacheSlot {
     data_len: u32,
 }
 
-impl Default for CacheSlot {
-    fn default() -> Self {
-        Self {
-            valid: false,
-            region_id: 0,
-            generation: 0,
-            capacity: 0,
-            residency_hot: false,
-            data_ptr: 0,
-            data_len: 0,
-        }
-    }
-}
-
 #[derive(Debug, Default)]
 pub struct ResolveCache {
     slots: [CacheSlot; CACHE_SLOTS],

crates/tvm-core/src/concurrent.rs

@@ -438,7 +438,7 @@ impl<M: MemoryRegion + Send> ConcurrentDirectory<M> {
         warm.sort_by(cmp);
         hot.sort_by(cmp);
 
-        for (id, used) in warm.into_iter().chain(hot.into_iter()) {
+        for (id, used) in warm.into_iter().chain(hot) {
             if current <= target {
                 break;
             }

crates/tvm-core/src/directory.rs

@@ -587,7 +587,7 @@ impl<M: MemoryRegion> RegionDirectory<M> {
         let entry = self.entry_mut(region_id)?;
         let cap = entry.meta.capacity;
         let used = entry.allocator.used();
-        let offset = entry.allocator.alloc(size, align).map_err(|e| {
+        let offset = entry.allocator.alloc(size, align).inspect_err(|_e| {
             crate::error::set_last_error_context(crate::error::ErrorContext {
                 region_id: Some(region_id),
                 len: Some(size),
@@ -596,7 +596,6 @@ impl<M: MemoryRegion> RegionDirectory<M> {
                 ..Default::default()
             });
             let _ = used;
-            e
         })?;
         entry.meta.used = entry.allocator.used();
         entry.metrics.record_alloc(size as u64);

crates/tvm-core/src/error.rs

@@ -35,7 +35,7 @@ mod context {
 
     std::thread_local! {
         static LAST_ERROR_CONTEXT: std::cell::RefCell<Option<ErrorContext>> =
-            std::cell::RefCell::new(None);
+            const { std::cell::RefCell::new(None) };
     }
 
     /// Set the per-thread last-error context. Called internally by

crates/tvm-core/src/memory_region.rs

@@ -16,6 +16,9 @@ use crate::error::Result;
 /// guest-side adapters that wrap a wasm linear memory range.
 pub trait MemoryRegion {
     fn len(&self) -> u32;
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
     fn read(&self, offset: u32, buf: &mut [u8]) -> Result<()>;
     fn write(&mut self, offset: u32, buf: &[u8]) -> Result<()>;
     fn snapshot(&self) -> Vec<u8>;

crates/tvm-guest-mm/benches/full_matrix.rs

@@ -222,7 +222,7 @@ const HOST_MM_WAT: &str = r#"
 "#;
 
 fn run_host_mm(size: u32, data: &[u8]) -> anyhow::Result<Vec<Duration>> {
-    let pages = ((size as u64 + 65535) / 65536).max(1) as u32;
+    let pages = (size as u64).div_ceil(65536).max(1) as u32;
     let mut config = Config::new();
     config.wasm_multi_memory(true);
     let engine = Engine::new(&config)?;
@@ -260,7 +260,7 @@ fn run_guest_mm_bulk(size: u32, data: &[u8]) -> anyhow::Result<Vec<Duration>> {
     "#;
     let p = ModuleParams {
         n_pools: 4,
-        initial_pages_per_pool: ((size as u64 + 65535) / 65536).max(1) as u32,
+        initial_pages_per_pool: (size as u64).div_ceil(65536).max(1) as u32,
         max_pages_per_pool: 16,
         user_body: user_body.to_string(),
     };
@@ -305,7 +305,7 @@ fn run_guest_mm_bulk_specialized(size: u32, data: &[u8]) -> anyhow::Result<Vec<D
     "#;
     let p = ModuleParams {
         n_pools: 4,
-        initial_pages_per_pool: ((size as u64 + 65535) / 65536).max(1) as u32,
+        initial_pages_per_pool: (size as u64).div_ceil(65536).max(1) as u32,
         max_pages_per_pool: 16,
         user_body: user_body.to_string(),
     };
@@ -335,7 +335,7 @@ fn run_guest_mm_popcount_simd(size: u32, data: &[u8]) -> anyhow::Result<Vec<Dura
     "#;
     let p = ModuleParams {
         n_pools: 4,
-        initial_pages_per_pool: ((size as u64 + 65535) / 65536).max(1) as u32,
+        initial_pages_per_pool: (size as u64).div_ceil(65536).max(1) as u32,
         max_pages_per_pool: 16,
         user_body: user_body.to_string(),
     };
@@ -375,7 +375,7 @@ fn run_guest_mm_popcount_scalar(size: u32, data: &[u8]) -> anyhow::Result<Vec<Du
     "#;
     let p = ModuleParams {
         n_pools: 4,
-        initial_pages_per_pool: ((size as u64 + 65535) / 65536).max(1) as u32,
+        initial_pages_per_pool: (size as u64).div_ceil(65536).max(1) as u32,
         max_pages_per_pool: 16,
         user_body: user_body.to_string(),
     };
@@ -409,7 +409,7 @@ fn run_guest_mm_simd(size: u32, data: &[u8]) -> anyhow::Result<Vec<Duration>> {
     "#;
     let p = ModuleParams {
         n_pools: 4,
-        initial_pages_per_pool: ((size as u64 + 65535) / 65536).max(1) as u32,
+        initial_pages_per_pool: (size as u64).div_ceil(65536).max(1) as u32,
         max_pages_per_pool: 16,
         user_body: user_body.to_string(),
     };

crates/tvm-guest-mm/benches/guest_mm_dispatch.rs

@@ -47,7 +47,7 @@ fn time_loop<F: FnMut() -> anyhow::Result<()>>(mut f: F) -> anyhow::Result<Vec<D
     Ok(t)
 }
 
-fn report(label: &str, size: u32, t: &mut Vec<Duration>) {
+fn report(label: &str, size: u32, t: &mut [Duration]) {
     t.sort();
     let mean_ns = t.iter().map(|d| d.as_nanos() as f64).sum::<f64>() / t.len() as f64;
     let p99 = stats::pct(t, 99.0);
@@ -111,7 +111,7 @@ fn run_guest_mm_bulk(size: u32, data: &[u8], n_pools: u32) -> anyhow::Result<Vec
     "#;
     let p = ModuleParams {
         n_pools,
-        initial_pages_per_pool: ((size as u32 + 65535) / 65536).max(1),
+        initial_pages_per_pool: size.div_ceil(65536).max(1),
         max_pages_per_pool: 16,
         user_body: user_body.to_string(),
     };
@@ -154,7 +154,7 @@ fn run_guest_mm(size: u32, data: &[u8], n_pools: u32) -> anyhow::Result<Vec<Dura
     "#;
     let p = ModuleParams {
         n_pools,
-        initial_pages_per_pool: ((size as u32 + 65535) / 65536).max(1),
+        initial_pages_per_pool: size.div_ceil(65536).max(1),
         max_pages_per_pool: 16,
         user_body: user_body.to_string(),
     };
@@ -274,7 +274,7 @@ fn run_dispatch_named(
     );
     let p = ModuleParams {
         n_pools,
-        initial_pages_per_pool: ((size as u32 + 65535) / 65536).max(1),
+        initial_pages_per_pool: size.div_ceil(65536).max(1),
         max_pages_per_pool: 16,
         user_body,
     };