chore: enforce new clippy lints surfaced on newer rust toolchains (#12712)

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: AztecBot

Cargo.toml

@@ -106,6 +106,11 @@ implicit_clone = "warn"
 map_unwrap_or = "warn"
 needless_borrows_for_generic_args = "warn"
 redundant_field_names = "warn"
+while_let_loop = "warn"
+for_kv_map = "warn"
+iter_kv_map = "warn"
+unnecessary_sort_by = "warn"
+useless_conversion = "warn"
 
 [workspace.dependencies]
 

acvm-repo/acir/src/native_types/expression/mod.rs

@@ -141,7 +141,7 @@ impl<F> Expression<F> {
             }
         }
         self.mul_terms.sort_by(|a, b| a.1.cmp(&b.1).then(a.2.cmp(&b.2)));
-        self.linear_combinations.sort_by(|a, b| a.1.cmp(&b.1));
+        self.linear_combinations.sort_by_key(|a| a.1);
     }
 
     #[cfg(test)]

acvm-repo/acvm/src/compiler/validator.rs

@@ -79,8 +79,7 @@ pub fn validate_witness<F: AcirField>(
                             iv,
                             key,
                         )?;
-                        for (output_witness, value) in outputs.iter().zip_eq(ciphertext.into_iter())
-                        {
+                        for (output_witness, value) in outputs.iter().zip_eq(ciphertext) {
                             let witness_value = witness_value(output_witness, &witness_map)?;
                             let output_value = F::from(u128::from(value));
                             if witness_value != output_value {
@@ -301,9 +300,7 @@ pub fn validate_witness<F: AcirField>(
                             *it = lane.unwrap();
                         }
                         let output_state = keccakf1600(state)?;
-                        for (output_witness, value) in
-                            outputs.iter().zip_eq(output_state.into_iter())
-                        {
+                        for (output_witness, value) in outputs.iter().zip_eq(output_state) {
                             let witness_value = witness_value(output_witness, &witness_map)?;
                             if witness_value != F::from(u128::from(value)) {
                                 return Err(unsatisfied_constraint(
@@ -323,7 +320,7 @@ pub fn validate_witness<F: AcirField>(
                             &witness_map,
                             inputs,
                         )?;
-                        for (output_witness, value) in outputs.iter().zip_eq(state.into_iter()) {
+                        for (output_witness, value) in outputs.iter().zip_eq(state) {
                             let witness_value = witness_map
                                 .get(output_witness)
                                 .ok_or(OpcodeNotSolvable::MissingAssignment(output_witness.0))?;
@@ -344,7 +341,7 @@ pub fn validate_witness<F: AcirField>(
                             hash_values,
                         )?;
 
-                        for (output_witness, value) in outputs.iter().zip_eq(state.into_iter()) {
+                        for (output_witness, value) in outputs.iter().zip_eq(state) {
                             let witness_value = witness_map
                                 .get(output_witness)
                                 .ok_or(OpcodeNotSolvable::MissingAssignment(output_witness.0))?;

acvm-repo/acvm/src/pwg/blackbox/aes128.rs

@@ -20,7 +20,7 @@ pub(super) fn solve_aes128_encryption_opcode<F: AcirField>(
     let ciphertext = execute_aes128_encryption_opcode(initial_witness, inputs, iv, key)?;
 
     // Write witness assignments
-    for (output_witness, value) in outputs.iter().zip_eq(ciphertext.into_iter()) {
+    for (output_witness, value) in outputs.iter().zip_eq(ciphertext) {
         insert_value(output_witness, F::from(u128::from(value)), initial_witness)?;
     }
 

acvm-repo/acvm/src/pwg/blackbox/hash.rs

@@ -72,7 +72,7 @@ fn write_digest_to_outputs<F: AcirField>(
     outputs: &[Witness; 32],
     digest: [u8; 32],
 ) -> Result<(), OpcodeResolutionError<F>> {
-    for (output_witness, value) in outputs.iter().zip_eq(digest.into_iter()) {
+    for (output_witness, value) in outputs.iter().zip_eq(digest) {
         insert_value(output_witness, F::from_be_bytes_reduce(&[value]), initial_witness)?;
     }
 
@@ -103,7 +103,7 @@ pub(crate) fn solve_sha_256_permutation_opcode<F: AcirField>(
 ) -> Result<(), OpcodeResolutionError<F>> {
     let state = execute_sha_256_permutation_opcode(initial_witness, inputs, hash_values)?;
 
-    for (output_witness, value) in outputs.iter().zip_eq(state.into_iter()) {
+    for (output_witness, value) in outputs.iter().zip_eq(state) {
         insert_value(output_witness, F::from(u128::from(value)), initial_witness)?;
     }
 
@@ -143,7 +143,7 @@ pub(crate) fn solve_poseidon2_permutation_opcode<F: AcirField>(
     let state = execute_poseidon2_permutation_opcode(backend, initial_witness, inputs)?;
 
     // Write witness assignments
-    for (output_witness, value) in outputs.iter().zip_eq(state.into_iter()) {
+    for (output_witness, value) in outputs.iter().zip_eq(state) {
         insert_value(output_witness, value, initial_witness)?;
     }
     Ok(())

acvm-repo/acvm/src/pwg/blackbox/mod.rs

@@ -106,7 +106,7 @@ pub(crate) fn solve<F: AcirField>(
                 *it = lane.unwrap();
             }
             let output_state = keccakf1600(state)?;
-            for (output_witness, value) in outputs.iter().zip_eq(output_state.into_iter()) {
+            for (output_witness, value) in outputs.iter().zip_eq(output_state) {
                 insert_value(output_witness, F::from(u128::from(value)), initial_witness)?;
             }
             Ok(())

acvm-repo/acvm/tests/solver.rs

@@ -969,7 +969,7 @@ where
         + Clone,
 {
     let equal_inputs = drop_use_constant_eq(&inputs, &distinct_inputs);
-    let message = format!("not injective:\n{:?}\n{:?}", &inputs, &distinct_inputs);
+    let message = format!("not injective:\n{inputs:?}\n{distinct_inputs:?}");
     let outputs_not_equal =
         solve_array_input_blackbox_call(inputs, num_outputs, num_bits, op.clone())
             .expect("injectivity test operations to have valid input")

acvm-repo/brillig_vm/src/black_box.rs

@@ -268,7 +268,7 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             if inputs.len() != 16 {
                 return Err(BlackBoxResolutionError::Failed(
                     BlackBoxFunc::Sha256Compression,
-                    format!("Expected 16 inputs but encountered {}", &inputs.len()),
+                    format!("Expected 16 inputs but encountered {}", inputs.len()),
                 ));
             }
             for (i, &input) in inputs.iter().enumerate() {
@@ -279,7 +279,7 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             if values.len() != 8 {
                 return Err(BlackBoxResolutionError::Failed(
                     BlackBoxFunc::Sha256Compression,
-                    format!("Expected 8 values but encountered {}", &values.len()),
+                    format!("Expected 8 values but encountered {}", values.len()),
                 ));
             }
             for (i, &value) in values.iter().enumerate() {

compiler/noirc_evaluator/src/acir/arrays.rs

@@ -929,7 +929,7 @@ impl Context<'_> {
         if !matches!(&dfg[array_id], Value::Instruction { .. } | Value::Param { .. }) {
             return Err(InternalError::Unexpected {
                 expected: "array or instruction".to_owned(),
-                found: format!("{:?}", &dfg[array_id]),
+                found: format!("{:?}", dfg[array_id]),
                 call_stack: self.acir_context.get_call_stack(),
             }
             .into());

compiler/noirc_evaluator/src/brillig/brillig_gen/constant_allocation.rs

@@ -61,9 +61,9 @@ impl ConstantAllocation {
 
     /// Collect all constants allocated in a given block.
     pub(crate) fn allocated_in_block(&self, block_id: BasicBlockId) -> Vec<ValueId> {
-        self.allocation_points.get(&block_id).map_or(Vec::default(), |allocations| {
-            allocations.iter().flat_map(|(_, constants)| constants).copied().collect()
-        })
+        self.allocation_points
+            .get(&block_id)
+            .map_or(Vec::default(), |allocations| allocations.values().flatten().copied().collect())
     }
 
     /// Collect all constants allocated in a given block at a specific location.