fix clippy

Author: ColoCarletti

crypto/math-cuda/src/fri.rs

@@ -217,7 +217,8 @@ impl FriCommitState {
         // Keep the layer tree resident on device; copy only the 32-byte root so
         // R4 query openings gather paths on device instead of copying the tree.
         let mut root = [0u8; 32];
-        self.stream.memcpy_dtoh(&nodes_dev.slice(0..32), &mut root)?;
+        self.stream
+            .memcpy_dtoh(&nodes_dev.slice(0..32), &mut root)?;
         self.stream.synchronize()?;
 
         self.a_is_input = !self.a_is_input;

crypto/math-cuda/tests/keccak_leaves.rs

@@ -219,9 +219,8 @@ fn keccak_comp_poly_leaves_matches_cpu() {
 
             // Exercise the production keep path, then read the resident nodes
             // back to host to check the leaf bytes.
-            let tree =
-                math_cuda::merkle::build_comp_poly_tree_from_evals_ext3_keep(&parts_slices)
-                    .unwrap();
+            let tree = math_cuda::merkle::build_comp_poly_tree_from_evals_ext3_keep(&parts_slices)
+                .unwrap();
             let be = math_cuda::device::backend().unwrap();
             let stream = be.next_stream();
             let nodes: Vec<u8> = stream.clone_dtoh(&*tree.nodes).unwrap();

crypto/math-cuda/tests/merkle_root_parity.rs

@@ -299,15 +299,14 @@ fn new_row_major_pipeline_base_root_matches_cpu() {
                 let fwd_tw =
                     TwoHalfTwiddles::<GoldilocksField>::new(log_lde, false).expect("fwd twiddles");
 
-                let (handle, _lde) =
-                    math_cuda::lde::coset_lde_row_major_with_merkle_tree_keep(
-                        &row_major,
-                        n,
-                        num_cols,
-                        blowup,
-                        &weights_u64,
-                    )
-                    .expect("new row-major GPU pipeline");
+                let (handle, _lde) = math_cuda::lde::coset_lde_row_major_with_merkle_tree_keep(
+                    &row_major,
+                    n,
+                    num_cols,
+                    blowup,
+                    &weights_u64,
+                )
+                .expect("new row-major GPU pipeline");
                 let gpu_root = handle.tree.as_ref().expect("resident merkle tree").root;
 
                 let cpu_root = cpu_row_major_merkle_root(

crypto/stark/src/gpu_lde.rs

@@ -485,7 +485,11 @@ where
     // Transmute Vec<u64> → Vec<FieldElement<E>> (zero-copy, E == GoldilocksField).
     let lde_out: Vec<FieldElement<E>> = unsafe {
         let mut v = std::mem::ManuallyDrop::new(lde_u64);
-        Vec::from_raw_parts(v.as_mut_ptr() as *mut FieldElement<E>, v.len(), v.capacity())
+        Vec::from_raw_parts(
+            v.as_mut_ptr() as *mut FieldElement<E>,
+            v.len(),
+            v.capacity(),
+        )
     };
 
     // Root-only host tree: the device tree (`handle.tree`) holds the nodes and
@@ -554,7 +558,11 @@ where
             v.len() % 3 == 0 && v.capacity() % 3 == 0,
             "lde_u64 len/capacity must be a multiple of 3 for Fp3 reinterpret"
         );
-        Vec::from_raw_parts(v.as_mut_ptr() as *mut FieldElement<E>, v.len() / 3, v.capacity() / 3)
+        Vec::from_raw_parts(
+            v.as_mut_ptr() as *mut FieldElement<E>,
+            v.len() / 3,
+            v.capacity() / 3,
+        )
     };
 
     // Root-only host tree: the device tree (`handle.tree`) holds the nodes and

crypto/stark/src/prover.rs

@@ -36,15 +36,15 @@ use crate::trace::LDETraceTable;
 
 use super::config::{BatchedMerkleTree, BatchedMerkleTreeBackend, Commitment};
 use super::constraints::evaluator::ConstraintEvaluator;
-#[cfg(feature = "cuda")]
-use crypto::merkle_tree::proof::Proof;
 use super::domain::{Domain, DomainConstants};
 use super::fri::fri_decommit::FriDecommitment;
 use super::grinding;
 use super::lookup::BusPublicInputs;
 use super::proof::stark::{DeepPolynomialOpening, MultiProof, StarkProof};
 use super::trace::TraceTable;
 use super::traits::AIR;
+#[cfg(feature = "cuda")]
+use crypto::merkle_tree::proof::Proof;
 
 pub use crate::commitment::{keccak_leaves_bit_reversed, keccak_leaves_row_pair_bit_reversed};
 
@@ -1875,8 +1875,9 @@ pub trait IsStarkProver<
                 let stream = lde_trace
                     .bound_stream()
                     .expect("bound stream for device-resident composition-tree opening");
-                crate::gpu_lde::gather_proofs_dev(tree, indexes_to_open, &stream)
-                    .expect("device composition-tree gather failed; resident tree has no host fallback")
+                crate::gpu_lde::gather_proofs_dev(tree, indexes_to_open, &stream).expect(
+                    "device composition-tree gather failed; resident tree has no host fallback",
+                )
             });
 
         for (qi, index) in indexes_to_open.iter().enumerate() {
@@ -1892,12 +1893,9 @@ pub trait IsStarkProver<
                 #[cfg(feature = "cuda")]
                 {
                     if let Some(proofs) = &main_dev_proofs {
-                        Self::open_polys_with_proofs(
-                            domain,
-                            proofs[qi].clone(),
-                            *index,
-                            |row| lde_trace.gather_main_row(row),
-                        )
+                        Self::open_polys_with_proofs(domain, proofs[qi].clone(), *index, |row| {
+                            lde_trace.gather_main_row(row)
+                        })
                     } else {
                         Self::open_polys_with(domain, &main_commit.tree, *index, |row| {
                             lde_trace.gather_main_row(row)
@@ -1950,12 +1948,9 @@ pub trait IsStarkProver<
                 #[cfg(feature = "cuda")]
                 {
                     if let Some(proofs) = &aux_dev_proofs {
-                        Self::open_polys_with_proofs(
-                            domain,
-                            proofs[qi].clone(),
-                            *index,
-                            |row| lde_trace.gather_aux_row(row),
-                        )
+                        Self::open_polys_with_proofs(domain, proofs[qi].clone(), *index, |row| {
+                            lde_trace.gather_aux_row(row)
+                        })
                     } else {
                         Self::open_polys_with(domain, &aux.tree, *index, |row| {
                             lde_trace.gather_aux_row(row)
@@ -2098,8 +2093,8 @@ pub trait IsStarkProver<
                 .iter()
                 .enumerate()
                 .map(|(idx, (_, trace, _))| {
-                    let lde_size = domains[idx].interpolation_domain_size
-                        * domains[idx].blowup_factor;
+                    let lde_size =
+                        domains[idx].interpolation_domain_size * domains[idx].blowup_factor;
                     estimate_table_vram_bytes(trace.num_main_columns, 0, lde_size)
                 })
                 .collect();
@@ -2303,8 +2298,8 @@ pub trait IsStarkProver<
                 .iter()
                 .enumerate()
                 .map(|(idx, (_, trace, _))| {
-                    let lde_size = domains[idx].interpolation_domain_size
-                        * domains[idx].blowup_factor;
+                    let lde_size =
+                        domains[idx].interpolation_domain_size * domains[idx].blowup_factor;
                     estimate_table_vram_bytes(
                         trace.num_main_columns,
                         trace.num_aux_columns,