chore: silence clippy 1.95 lint regressions across workspace (#18)

* chore: silence clippy 1.95 lint regressions across workspace

Rust 1.95.0 promoted several lints to default-warn (and CI runs with
`-D warnings`), causing a cascade of build failures across mlxcel-core
and mlxcel-surgery that had nothing to do with their underlying logic.
This commit makes the workspace lint-clean again under the new toolchain.

Auto-fixed via `cargo clippy --fix`:

- `manual_is_multiple_of` → `.is_multiple_of()` (pack3, quant3, utils)
- `manual_div_ceil` → `.div_ceil()` (utils)
- `unnecessary_cast` (quant, codebook, generate, etc.)
- `useless_conversion` (generate)
- `double_parens` (mtp/tests)

Manually rewritten:

- `needless_range_loop` → iterator + take/enumerate where the conversion
  was clear (utils, quant, quant3, sampling, boundary, turbo_tests).
- `field_reassign_with_default` → struct-init form (generate, speculative).
- `doc_overindented_list_items` → list-continuation indent normalised
  (speculative/mtp/generator).
- `doc_lazy_continuation` → reworded the `softmax + cold-V` paragraph in
  turbo_tests so a leading `+` no longer parses as a markdown list marker.
- `unusual_byte_groupings` → `0xC0FF_EE42` (pack3, quant).
- `duplicated_attribute` → drop inner `#![cfg(test)]` where the parent
  module already gates with `#[cfg(test)]` (mlxcel-surgery).
- Added a `# Safety` section to `attention_from_ptr` (layers).

Targeted `#[allow(...)]` (intentional shape, not worth restructuring):

- `too_many_arguments` on the attention-dispatch helpers in `layers.rs`
  and the `attention_sparse_v_turbo4{,_fused}` kernels: positional
  signatures intentionally mirror Metal/MLX call sites.
- `needless_range_loop` on `forward_batched`: mixed indexing into
  `input_ids` slices and `batch_caches[i]` is clearer than enumerate.
- `large_enum_variant` / `result_large_err` on the paged-cache adopt
  path: shrinking the variant would force callers through `Box` for no
  runtime gain on a cold path.
- `type_complexity` on the `SyntheticTarget` test fixture's
  `rollback_events`: it is a one-off test type.

`cargo clippy --workspace --all-targets -- -D warnings` is clean and
`cargo test --workspace` matches the pre-existing baseline (the same two
`multimodal::video` fd-variant tests fail on `main` too, due to runtime
ffmpeg policy mismatches unrelated to this change).

* chore: silence two more clippy errors gated by metal,accelerate features

The earlier sweep ran without `--features metal,accelerate`, so the CI
build (which uses that exact feature set) still tripped on two finds:

- `quant.rs:422` unnecessary `as usize` cast on an already-usize index
- `generate.rs:826` explicit `.into_iter()` inside `zip(...)` which
  already accepts any `IntoIterator`

`cargo clippy --workspace --all-targets --features metal,accelerate
-- -D warnings` is now clean.

* chore: drop another useless into_iter in speculative_burst zip

server::batch::speculative_burst::zip already accepts IntoIterator, so
the explicit `.into_iter()` on rows_tokens is redundant. Missed in the
prior sweep because the local check ran against a cached clippy result
where this file was unchanged; `cargo clean` followed by a fresh
`cargo clippy --workspace --all-targets --features metal,accelerate --
-D warnings` confirms the workspace is now clean.

Author: inureyes

src/lib/mlxcel-core/src/cache/paged_detach.rs

@@ -258,6 +258,7 @@ impl Drop for DetachedPagedCacheSet {
 
 /// Internal parked-cache representation. Used by the pool so both dense and
 /// paged detached sets share a single [`DetachedHandle`] space.
+#[allow(clippy::large_enum_variant)]
 pub(super) enum ParkedCache {
     Dense(super::detach::DetachedCacheSet),
     Paged(DetachedPagedCacheSet),
@@ -434,6 +435,7 @@ impl CachePool {
     ///
     /// Retained block pins are preserved across failure paths so the caller
     /// can still call [`CachePool::release_detached_paged`] manually or retry.
+    #[allow(clippy::result_large_err)]
     pub fn adopt_paged_preserving(
         &mut self,
         model: &dyn crate::generate::LanguageModel,

src/lib/mlxcel-core/src/cache/turbo/boundary.rs

@@ -373,9 +373,9 @@ mod tests {
         // Cross-check the single-layer helper against the bulk helper.
         let n = 16;
         let bulk = resolve_layer_modes(KVCacheMode::Turbo4Asym, n, 2);
-        for i in 0..n {
+        for (i, &expected) in bulk.iter().enumerate().take(n) {
             let single = resolve_layer_mode(KVCacheMode::Turbo4Asym, i, n, 2);
-            assert_eq!(bulk[i], single, "layer {i} mismatch");
+            assert_eq!(expected, single, "layer {i} mismatch");
         }
     }
 }

src/lib/mlxcel-core/src/cache/turbo/codebook.rs

@@ -507,7 +507,7 @@ mod tests {
 
         // Φ(−1) ≈ 0.15865525393145702
         let v = gaussian_cdf(-1.0);
-        assert!((v - 0.158_655_253_931_457_0).abs() < 1e-12, "Φ(-1) = {v}");
+        assert!((v - 0.158_655_253_931_457).abs() < 1e-12, "Φ(-1) = {v}");
     }
 
     #[test]

src/lib/mlxcel-core/src/cache/turbo/pack3.rs

@@ -87,7 +87,7 @@ pub const V_BIT_WIDTH_3: u8 = 3;
 #[inline]
 pub fn packed_bytes_per_token_3bit(head_dim: i32) -> i32 {
     debug_assert!(
-        head_dim > 0 && (head_dim as usize) % COORDS_PER_GROUP == 0,
+        head_dim > 0 && (head_dim as usize).is_multiple_of(COORDS_PER_GROUP),
         "packed_bytes_per_token_3bit: head_dim must be a positive multiple of 8; \
          got {head_dim}"
     );
@@ -109,7 +109,7 @@ pub fn packed_bytes_per_token_3bit(head_dim: i32) -> i32 {
 /// pipeline).
 pub fn pack_3bit_indices(indices: &[u8], out: &mut [u8]) {
     debug_assert!(
-        indices.len() % COORDS_PER_GROUP == 0,
+        indices.len().is_multiple_of(COORDS_PER_GROUP),
         "pack_3bit_indices: index count ({}) must be a multiple of {}",
         indices.len(),
         COORDS_PER_GROUP
@@ -147,7 +147,7 @@ pub fn pack_3bit_indices(indices: &[u8], out: &mut [u8]) {
 /// dequant path).
 pub fn unpack_3bit_indices(packed: &[u8], out: &mut [u8]) {
     debug_assert!(
-        packed.len() % BYTES_PER_GROUP == 0,
+        packed.len().is_multiple_of(BYTES_PER_GROUP),
         "unpack_3bit_indices: packed byte count ({}) must be a multiple of {}",
         packed.len(),
         BYTES_PER_GROUP
@@ -311,7 +311,7 @@ mod tests {
     #[test]
     fn round_trip_random_multi_group() {
         // 32 indices = 4 groups = 12 bytes packed. Use a deterministic LCG.
-        let mut state: u32 = 0xC0FFEE_42;
+        let mut state: u32 = 0xC0FF_EE42;
         let mut indices = vec![0u8; 32];
         for x in &mut indices {
             state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);

src/lib/mlxcel-core/src/cache/turbo/quant.rs

@@ -419,7 +419,7 @@ fn quantize_into_packed(
         let idx_off = tok * coords_per_token;
         let mut sum_sq = 0.0_f32;
         for d_i in 0..coords_per_token {
-            let c = centroids[indices[idx_off + d_i] as usize];
+            let c = centroids[indices[idx_off + d_i]];
             sum_sq += c * c;
         }
         let y_hat_norm = sum_sq.sqrt();
@@ -874,8 +874,7 @@ mod tests {
         let hd_usize = head_dim as usize;
         let mut k_data: Vec<f32> = Vec::with_capacity(n_tokens * hd_usize);
         let token_scales = [0.5_f32, 1.5, 4.0, 12.0];
-        for tok in 0..n_tokens {
-            let scale = token_scales[tok];
+        for &scale in token_scales.iter().take(n_tokens) {
             for _ in 0..head_dim {
                 let mut acc = 0.0_f32;
                 for _ in 0..6 {
@@ -981,8 +980,7 @@ mod tests {
         // norm storage, which is acceptable in production but would noise
         // up this test.
         let token_scales = [0.5_f32, 1.5, 4.0, 12.0];
-        for tok in 0..4 {
-            let scale = token_scales[tok];
+        for &scale in &token_scales {
             for _ in 0..head_dim {
                 // Pseudo-Gaussian via summed uniform bits → ~normal in [-1, 1].
                 let mut acc = 0.0_f32;
@@ -1057,7 +1055,7 @@ mod tests {
         let head_dim: i32 = 128;
         let params = TurboQuantParams::new(head_dim as u32, 0xC1_DECAFu32);
 
-        let mut rng = Lcg32::new(0xC0FFEE_42);
+        let mut rng = Lcg32::new(0xC0FF_EE42);
         let n_tokens = 4usize;
         let hd_usize = head_dim as usize;
         let mut v_data: Vec<f32> = Vec::with_capacity(n_tokens * hd_usize);

src/lib/mlxcel-core/src/cache/turbo/quant3.rs

@@ -111,7 +111,7 @@ impl TurboQuantParams3 {
             "TurboQuantParams3::new: head_dim must be a non-zero power of two; got {head_dim}"
         );
         assert!(
-            head_dim % 8 == 0,
+            head_dim.is_multiple_of(8),
             "TurboQuantParams3::new: head_dim must be a multiple of 8 \
              for the 24-bit packing layout; got {head_dim}"
         );
@@ -373,8 +373,7 @@ mod tests {
         let mut state: u32 = 123;
         let mut v_data: Vec<f32> = Vec::with_capacity(4 * head_dim as usize);
         let token_scales = [0.5_f32, 1.5, 4.0, 12.0];
-        for tok in 0..4 {
-            let scale = token_scales[tok];
+        for &scale in &token_scales {
             for _ in 0..head_dim {
                 let mut acc = 0.0_f32;
                 for _ in 0..6 {

src/lib/mlxcel-core/src/cache/turbo/sparse_v.rs

@@ -380,6 +380,7 @@ pub fn compute_alive_mask(
 /// Used by: tests under `cache/turbo_tests.rs` (issue #480 unit tests).
 /// Production attention call sites continue to use the standard
 /// `attention()` path until the Metal kernel lands.
+#[allow(clippy::too_many_arguments)]
 pub fn attention_sparse_v_turbo4(
     q: &MlxArray,
     k: &MlxArray,
@@ -526,6 +527,7 @@ pub fn attention_sparse_v_turbo4(
 /// case.
 ///
 /// Used by: [`KVCache::sparse_v_attention`] (issue #505).
+#[allow(clippy::too_many_arguments)]
 pub fn attention_sparse_v_turbo4_fused(
     q: &MlxArray,
     k: &MlxArray,

src/lib/mlxcel-core/src/cache/turbo_tests.rs

@@ -364,8 +364,8 @@ fn turbo4_asym_clone_handle_install_then_dequant_matches_pre_detach() {
     let v_data: Vec<f32> = (0..2 * head_dim)
         .map(|i| (((i * 7) % 13) as f32 / 13.0) - 0.5)
         .collect();
-    let k = ffi::from_slice_f32(&k_data, &[1, 1, 2, head_dim as i32]);
-    let v = ffi::from_slice_f32(&v_data, &[1, 1, 2, head_dim as i32]);
+    let k = ffi::from_slice_f32(&k_data, &[1, 1, 2, head_dim]);
+    let v = ffi::from_slice_f32(&v_data, &[1, 1, 2, head_dim]);
 
     let (_k1, v1_out) = cache.update_and_fetch(k, v);
     let v1 = flatten_fp32(&v1_out);
@@ -901,13 +901,13 @@ mod boundary_v {
     fn typical_32_layer_split_protects_first_two_and_last_two() {
         let n = 32;
         let modes = resolve_layer_modes(KVCacheMode::Turbo4Asym, n, 2);
-        for i in 0..n {
+        for (i, &actual) in modes.iter().enumerate().take(n) {
             let expected = if i < 2 || i >= n - 2 {
                 KVCacheMode::Fp16
             } else {
                 KVCacheMode::Turbo4Asym
             };
-            assert_eq!(modes[i], expected, "layer {i}");
+            assert_eq!(actual, expected, "layer {i}");
         }
     }
 
@@ -922,10 +922,10 @@ mod boundary_v {
             KVCacheMode::Turbo4Delegated,
         ] {
             let bulk = resolve_layer_modes(mode, n, 2);
-            for i in 0..n {
+            for (i, &expected) in bulk.iter().enumerate().take(n) {
                 let single = resolve_layer_mode(mode, i, n, 2);
                 assert_eq!(
-                    bulk[i], single,
+                    expected, single,
                     "{mode:?} layer {i}: bulk vs single helper disagree"
                 );
             }
@@ -1414,8 +1414,8 @@ fn turbo3_asym_clone_handle_install_then_dequant_matches_pre_detach() {
     let v_data: Vec<f32> = (0..2 * head_dim)
         .map(|i| (((i * 7) % 13) as f32 / 13.0) - 0.5)
         .collect();
-    let k = ffi::from_slice_f32(&k_data, &[1, 1, 2, head_dim as i32]);
-    let v = ffi::from_slice_f32(&v_data, &[1, 1, 2, head_dim as i32]);
+    let k = ffi::from_slice_f32(&k_data, &[1, 1, 2, head_dim]);
+    let v = ffi::from_slice_f32(&v_data, &[1, 1, 2, head_dim]);
 
     let (_k1, v1_out) = cache.update_and_fetch(k, v);
     let v1 = flatten_fp32(&v1_out);
@@ -1667,7 +1667,7 @@ fn turbo3_asym_layer_modes_apply_boundary_upgrade() {
     assert_eq!(modes.len(), 8);
     // First 2 + last 2 are upgraded to FP16; middle 4 stay Turbo3Asym.
     for (i, m) in modes.iter().enumerate() {
-        if i < 2 || i >= 6 {
+        if !(2..6).contains(&i) {
             assert_eq!(*m, KVCacheMode::Fp16, "layer {i} must be FP16 boundary");
         } else {
             assert_eq!(
@@ -2608,8 +2608,8 @@ fn delegated_dequant_sdpa_matches_reference_attention() {
 /// Steel-envelope vs cold-only fused composition parity (issue #531).
 ///
 /// `update_and_turbo4_delegated_attention` first tries the steel-envelope
-/// kernel (issue #531, single Metal dispatch covering softmax + cold-V dequant
-/// + hot-V accumulate). On the same hardware where the cold-only fused
+/// kernel (issue #531, single Metal dispatch covering softmax, cold-V dequant,
+/// and hot-V accumulate). On the same hardware where the cold-only fused
 /// composition path (issue #528) already produces correct output, the
 /// steel-envelope path must produce numerically equivalent output (within
 /// FP16 round-off) — both paths funnel through the same MLX softmax algebra

src/lib/mlxcel-core/src/drafter/dflash/round_loop_batched.rs

@@ -714,6 +714,7 @@ mod tests {
     ///
     /// `argmax_fn(row, position, prev_token) -> next_token`. Tests seed
     /// this so the accept pattern is deterministic.
+    #[allow(clippy::type_complexity)]
     struct SyntheticTarget {
         argmax_fn: Box<SyntheticArgmaxFn>,
         concat_hidden_dim: i32,

src/lib/mlxcel-core/src/generate.rs

@@ -411,6 +411,7 @@ pub trait LanguageModel {
     /// amortizes weight-loading bandwidth across the batch.
     ///
     /// Used by: BatchScheduler (server continuous batching)
+    #[allow(clippy::needless_range_loop)]
     fn forward_batched(
         &self,
         input_ids: &MlxArray,
@@ -822,7 +823,7 @@ impl CxxGenerator {
         let n_layers = self.caches.len();
         let requested = crate::cache::turbo::boundary_v_layers_from_env();
         let layer_modes = crate::cache::turbo::resolve_layer_modes(nominal, n_layers, requested);
-        for (cache, mode) in self.caches.iter_mut().zip(layer_modes.into_iter()) {
+        for (cache, mode) in self.caches.iter_mut().zip(layer_modes) {
             cache.mode = mode;
         }
     }
@@ -2096,7 +2097,7 @@ mod tests {
         // n=0 is the very first decode iteration after prefill. Clearing here
         // would discard tensors needed for the pipelined next-step computation.
         let n = 0_usize;
-        assert!(!(n % 256 == 0 && n > 0));
+        assert!(!(n.is_multiple_of(256) && n > 0));
     }
 
     #[test]
@@ -2259,8 +2260,10 @@ mod tests {
         let caller_bias = make_bias(&[(99, -3.0)]);
         let g = CxxGenerator::new(2).with_token_bias(cached);
 
-        let mut caller = SamplingConfig::default();
-        caller.token_bias = caller_bias;
+        let caller = SamplingConfig {
+            token_bias: caller_bias,
+            ..SamplingConfig::default()
+        };
         let composed = g.compose_sampling(&caller);
 
         // Caller's explicit bias is preserved verbatim, cached bias is ignored.