Satisfy the lint gate

`cargo fmt --all`, plus a `clone()` on a `Copy` field that the new
out-of-domain tamper arm introduced.

Author: MauroToscano

bin/cli/src/main.rs

@@ -51,15 +51,19 @@ fn keep_large_buffers_warm() {
                     // Not fatal, but the run is then indistinguishable from one
                     // where the knob worked — which is exactly what makes a
                     // memory measurement unreadable. Say so.
-                    log::warn!("keep_large_buffers_warm: cannot read opt.narenas ({e}); \
-                                the oversize arena keeps jemalloc's default decay");
+                    log::warn!(
+                        "keep_large_buffers_warm: cannot read opt.narenas ({e}); \
+                                the oversize arena keeps jemalloc's default decay"
+                    );
                     return;
                 }
             };
             let decay = format!("arena.{huge_arena}.dirty_decay_ms\0");
             if let Err(e) = raw::write(decay.as_bytes(), -1i64) {
-                log::warn!("keep_large_buffers_warm: cannot disable decay on arena \
-                            {huge_arena} ({e}); the oversize arena keeps jemalloc's default");
+                log::warn!(
+                    "keep_large_buffers_warm: cannot disable decay on arena \
+                            {huge_arena} ({e}); the oversize arena keeps jemalloc's default"
+                );
                 return;
             }
             log::debug!("keep_large_buffers_warm: decay disabled on arena {huge_arena}");

crypto/crypto/src/merkle_tree/merkle.rs

@@ -330,15 +330,20 @@ where
         leaves_len: usize,
         sibling_leaf: B::Node,
     ) -> Option<Proof<B::Node>> {
-        if leaves_len <= 1 || pos >= leaves_len {
+        if leaves_len <= 1 || pos >= leaves_len || self.is_root_only() {
             return None;
         }
         let mut merkle_path = Vec::with_capacity(leaves_len.trailing_zeros() as usize);
         merkle_path.push(sibling_leaf);
 
         let mut node = parent_index(pos + leaves_len - 1);
         while node != ROOT {
-            merkle_path.push(self.nodes.get(sibling_index(node))?.clone());
+            // `node_get`, not `self.nodes` directly: every other read in this
+            // file goes through it for the disk-spill mmap indirection. The two
+            // are mutually exclusive today — `drop_leaves` refuses an mmap-backed
+            // tree — but a direct read would silently yield `None` here if that
+            // ever stopped holding, and the prover's opening path unwraps this.
+            merkle_path.push(self.node_get(sibling_index(node))?.clone());
             node = parent_index(node);
         }
         self.create_proof(merkle_path)

crypto/stark/src/prover.rs

@@ -691,10 +691,6 @@ pub struct TableDeep<FieldExtension: IsField> {
     pub trace_rows: usize,
     /// The DEEP composition codeword, `lde_size` long.
     pub deep: Vec<FieldElement<FieldExtension>>,
-    /// Where the table sits in the AIR order, carried so the batch can say
-    /// which group each table ended up in once the codewords are sorted by
-    /// domain rather than by position.
-    pub air_index: usize,
     /// What the batch's coefficient is drawn from: this table's public round-3
     /// data, in the order a transcript absorbs it.
     ///
@@ -2186,7 +2182,6 @@ pub trait IsStarkProver<
             lde_size: domain.interpolation_domain_size * domain.blowup_factor,
             trace_rows: domain.interpolation_domain_size,
             deep,
-            air_index: usize::MAX,
             bus_contribution: round_1_result
                 .bus_public_inputs
                 .as_ref()

prover/src/batched_verifier.rs

@@ -124,7 +124,10 @@ pub fn replay(
         coefficients[idx] = seed.sample_field_element();
     }
 
-    Ok(Replay { logup, coefficients })
+    Ok(Replay {
+        logup,
+        coefficients,
+    })
 }
 
 /// Verify a batched proof of `elf_bytes`.

prover/src/logup_phase.rs

@@ -626,13 +626,9 @@ pub fn run_batched(
     // One FRI per accumulator, and the mapping from table to group.
     let mut group_of = vec![usize::MAX; n];
     let sizes: Vec<usize> = acc.keys().copied().collect();
-    for (&idx, _) in tables.iter().map(|(i, t)| (i, t)) {
-        let rows = tables
-            .iter()
-            .find(|(i, _)| *i == idx)
-            .map(|(_, t)| t.trace_rows)
-            .expect("table just listed");
-        let lde = rows * proof_options.blowup_factor as usize;
+    for (idx, table) in tables.iter() {
+        let lde = table.trace_rows * proof_options.blowup_factor as usize;
+        let idx = *idx;
         group_of[idx] = sizes.iter().position(|s| *s == lde).ok_or_else(|| {
             Error::Prover(format!(
                 "batched phase: table {idx} has no group of size {lde}"

prover/src/tests/batched_fri_tests.rs

@@ -146,7 +146,6 @@ fn alpha_moves_when_any_table_moves() {
         lde_size: 8,
         trace_rows: 4,
         deep: Vec::new(),
-        air_index: seed as usize,
         bus_contribution: Some(FieldElement::<E>::from(seed)),
         main_roots: stark::prover::MainRoots {
             precomputed: None,
@@ -673,7 +672,7 @@ fn a_tampered_batched_proof_is_rejected() {
     accepted(&proof);
 
     // An out-of-domain value, the other thing the fold seed binds.
-    let orig = proof.tables[0].trace_ood.get(0, 0).clone();
+    let orig = *proof.tables[0].trace_ood.get(0, 0);
     proof.tables[0].trace_ood.set(0, 0, &orig + &one);
     rejected(&proof, "an out-of-domain trace value");
     proof.tables[0].trace_ood.set(0, 0, orig);