Apply miscellaneous clippy fixes

- Rename `foo` variables to `result` in tests
- Use `let-else` and `?` operator where appropriate
- Derive `Default` for `Error` instead of manual impl
- Replace `format!` with `write!` for string appending
- Add `IntoIterator` impl for `&CounterDetails`
- Use iterator-based loops instead of manual indexing
- Replace `site_domain.as_bytes().len()` with `site_domain.len()`
- Remove unnecessary trailing semicolons in match arms
- Replace `Ok(assert_eq!(...))` with `assert_eq!(...); Ok(())`
- Use `const { assert!(...) }` for compile-time assertions
- Rename `receiver` field to `state` in `Receiver` struct
- Use `vec!` instead of fixed-size arrays for large allocations

Author: akoshelev

src/config.rs

@@ -480,7 +480,7 @@ mod tests {
                     "http config is not the same: {:?} vs {:?}",
                     expected.http_config, actual.http_config
                 ),
-            };
+            }
         }
 
         assert!(serde_json::from_str::<ClientConfig>(

src/error.rs

@@ -12,13 +12,14 @@ use crate::{report::InvalidReportError, task::JoinError};
 ///  * `ipa::ff::Error`, for finite field routines
 ///  * `ipa::net::Error`, for the HTTP transport
 ///  * `ipa::app::Error`, for the report collector query APIs
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Default)]
 pub enum Error {
     #[error("already exists")]
     AlreadyExists,
     #[error("already setup")]
     AlreadySetup,
     #[error("internal")]
+    #[default]
     Internal,
     #[error("invalid id found: {0}")]
     InvalidId(String),
@@ -62,12 +63,6 @@ pub enum Error {
     DecompressingInvalidCurvePoint(String),
 }
 
-impl Default for Error {
-    fn default() -> Self {
-        Self::Internal
-    }
-}
-
 impl Error {
     #[must_use]
     pub fn path_parse_error(source: &str) -> Error {

src/helpers/buffers/unordered_receiver.rs

@@ -24,7 +24,7 @@ where
     M: Message,
 {
     i: usize,
-    receiver: Arc<Mutex<OperatingState<S, C>>>,
+    state: Arc<Mutex<OperatingState<S, C>>>,
     _marker: PhantomData<M>,
 }
 
@@ -38,7 +38,7 @@ where
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.as_ref();
-        let mut recv = this.receiver.lock().unwrap();
+        let mut recv = this.state.lock().unwrap();
         if recv.is_next(this.i) {
             recv.poll_next(cx)
         } else {
@@ -339,7 +339,7 @@ where
     pub fn recv<M: Message, I: Into<usize>>(&self, i: I) -> Receiver<S, C, M> {
         Receiver {
             i: i.into(),
-            receiver: Arc::clone(&self.inner),
+            state: Arc::clone(&self.inner),
             _marker: PhantomData,
         }
     }

src/net/server/handlers/query/create.rs

@@ -223,7 +223,8 @@ mod tests {
                 self.num_multi_bits
             );
             if let Some(window) = self.attribution_window_seconds {
-                query.push_str(&format!("&attribution_window_seconds={window}"));
+                use std::fmt::Write;
+                write!(query, "&attribution_window_seconds={window}").unwrap();
             }
             OverrideReq {
                 field_type: self.field_type,

src/net/server/mod.rs

@@ -265,9 +265,10 @@ async fn certificate_and_key(
     };
 
     let cert = rustls_pemfile::certs(&mut cert.as_ref())?;
-    let key = match rustls_pemfile::read_one(&mut key.as_ref())? {
-        Some(Item::RSAKey(key) | Item::PKCS8Key(key) | Item::ECKey(key)) => key,
-        _ => return Err("private key format not supported".into()),
+    let Some(Item::RSAKey(key) | Item::PKCS8Key(key) | Item::ECKey(key)) =
+        rustls_pemfile::read_one(&mut key.as_ref())?
+    else {
+        return Err("private key format not supported".into());
     };
 
     let cert = cert.into_iter().map(Certificate).collect();
@@ -350,9 +351,7 @@ impl ClientCertRecognizingAcceptor {
         network_config: &NetworkConfig,
         cert_option: Option<&Certificate>,
     ) -> Option<ClientIdentity> {
-        let Some(cert) = cert_option else {
-            return None;
-        };
+        let cert = cert_option?;
         // We currently require an exact match with the peer cert (i.e. we don't support verifying
         // the certificate against a truststore and identifying the peer by the certificate
         // subject). This could be changed if the need arises.

src/protocol/boolean/saturating_sum.rs

@@ -302,7 +302,7 @@ mod tests {
         let a_bits = get_bits::<Gf2>(a, num_a_bits);
         let b_bits = get_bits::<Gf2>(b, num_b_bits);
 
-        let foo = world
+        let result = world
             .semi_honest(
                 (a_bits, b_bits),
                 |ctx, (a_bits, b_bits): (BitDecomposed<_>, BitDecomposed<_>)| async move {
@@ -314,15 +314,15 @@ mod tests {
             )
             .await;
 
-        foo.reconstruct()
+        result.reconstruct()
     }
 
     async fn truncated_delta_to_saturation_point(a: u32, num_a_bits: u32, num_b_bits: u32) -> u128 {
         let world = TestWorld::default();
 
         let a_bits = get_bits::<Gf2>(a, num_a_bits);
 
-        let foo = world
+        let result = world
             .semi_honest(a_bits, |ctx, a_bits: BitDecomposed<_>| async move {
                 let a = SaturatingSum::new(a_bits, Replicated::ZERO);
                 a.truncated_delta_to_saturation_point(
@@ -335,6 +335,6 @@ mod tests {
             })
             .await;
 
-        foo.reconstruct()
+        result.reconstruct()
     }
 }

src/protocol/boolean/solved_bits.rs

@@ -46,7 +46,7 @@ where
 
         // Note that this clones the values rather than moving them.
         // This code is only used in test code, so that's probably OK.
-        assert!(cfg!(test), "This code isn't ideal outside of tests");
+        const { assert!(cfg!(test), "This code isn't ideal outside of tests") };
         let Self { b_b, b_p, .. } = self;
         let b_b = BitDecomposed::new(
             b_b.into_iter()

src/protocol/dp/insecure.rs

@@ -170,7 +170,7 @@ mod test {
         const CHI2_INV_LB: f64 = 10_686.0;
 
         let mut rng = StdRng::seed_from_u64(seed);
-        let mut sample = [0_f64; N];
+        let mut sample = vec![0_f64; N];
         let dp = Dp::new(f64::from(epsilon), delta, f64::from(cap)).unwrap();
         #[allow(clippy::cast_precision_loss)]
         let n = N as f64;
@@ -219,7 +219,7 @@ mod test {
         #[allow(clippy::cast_precision_loss)]
         for epsilon in 1..11_u8 {
             let mut rng = thread_rng();
-            let mut sample = [0; N];
+            let mut sample = vec![0; N];
             let dp = DiscreteDp::new(f64::from(epsilon), delta, f64::from(cap)).unwrap();
             let n = N as f64;
             dp.apply(&mut sample, &mut rng);

src/protocol/modulus_conversion/convert_shares.rs

@@ -357,9 +357,7 @@ where
     let stream = unfold(
         (ctx, locally_converted, first_record),
         |(ctx, mut locally_converted, record_id)| async move {
-            let Some((triple, residual)) = locally_converted.next().await else {
-                return None;
-            };
+            let (triple, residual) = locally_converted.next().await?;
             let bit_contexts = (0..).map(|i| ctx.narrow(&ConvertSharesStep::ConvertBit(i)));
             let converted =
                 ctx.parallel_join(zip(bit_contexts, triple).map(|(ctx, triple)| async move {

src/protocol/sort/multi_bit_permutation.rs

@@ -74,11 +74,11 @@ where
     let mut prefix_sum = Vec::with_capacity(num_records);
     let mut cumulative_sum = <S as SecretSharing<F>>::ZERO;
     for bit_idx in 0..num_possible_bit_values {
-        for record_idx in 0..num_records {
+        for (record_idx, eq_checks) in equality_checks.iter().enumerate() {
             if bit_idx == 0 {
                 prefix_sum.push(Vec::with_capacity(num_multi_bits));
             }
-            cumulative_sum += &equality_checks[record_idx][bit_idx];
+            cumulative_sum += &eq_checks[bit_idx];
             prefix_sum[record_idx].push(cumulative_sum.clone());
         }
     }