clippy: enable needless_for_each (manual) (foundry-rs#14301)

clippy: enable `needless_for_each`


Amp-Thread-ID: https://ampcode.com/threads/T-019d8707-07ff-77cf-b7f2-5dc0f64200ec

Co-authored-by: zerosnacks <95942363+zerosnacks@users.noreply.github.com>

Author: decofe

Cargo.toml

@@ -73,6 +73,7 @@ mutex_integer = "warn"
 naive_bytecount = "warn"
 needless_bitwise_bool = "warn"
 needless_continue = "warn"
+needless_for_each = "warn"
 nonstandard_macro_braces = "warn"
 option_as_ref_cloned = "warn"
 path_buf_push_overwrite = "warn"

crates/cast/src/cmd/storage.rs

@@ -374,11 +374,11 @@ fn print_storage(layout: StorageLayout, values: Vec<StorageValue>) -> Result<()>
 fn add_storage_layout_output<C: Compiler<CompilerContract = Contract>>(project: &mut Project<C>) {
     project.artifacts.additional_values.storage_layout = true;
     project.update_output_selection(|selection| {
-        selection.0.values_mut().for_each(|contract_selection| {
-            contract_selection
-                .values_mut()
-                .for_each(|selection| selection.push("storageLayout".to_string()))
-        });
+        for contract_selection in selection.0.values_mut() {
+            for selection in contract_selection.values_mut() {
+                selection.push("storageLayout".to_string());
+            }
+        }
     })
 }
 

crates/cheatcodes/src/inspector.rs

@@ -1468,13 +1468,12 @@ impl<FEN: FoundryEvmNetwork> Inspector<FoundryContextFor<'_, FEN>> for Cheatcode
                 // Update the reverted status of all deeper calls if this call reverted, in
                 // accordance with EVM behavior
                 if outcome.result.is_revert() {
-                    last_recorded_depth.iter_mut().for_each(|element| {
+                    for element in &mut *last_recorded_depth {
                         element.reverted = true;
-                        element
-                            .storageAccesses
-                            .iter_mut()
-                            .for_each(|storage_access| storage_access.reverted = true);
-                    })
+                        for storage_access in &mut element.storageAccesses {
+                            storage_access.reverted = true;
+                        }
+                    }
                 }
 
                 if let Some(call_access) = last_recorded_depth.first_mut() {
@@ -1914,13 +1913,12 @@ impl<FEN: FoundryEvmNetwork> Inspector<FoundryContextFor<'_, FEN>> for Cheatcode
                 // Update the reverted status of all deeper calls if this call reverted, in
                 // accordance with EVM behavior
                 if outcome.result.is_revert() {
-                    last_depth.iter_mut().for_each(|element| {
+                    for element in &mut *last_depth {
                         element.reverted = true;
-                        element
-                            .storageAccesses
-                            .iter_mut()
-                            .for_each(|storage_access| storage_access.reverted = true);
-                    })
+                        for storage_access in &mut element.storageAccesses {
+                            storage_access.reverted = true;
+                        }
+                    }
                 }
 
                 if let Some(create_access) = last_depth.first_mut() {

crates/cli/src/opts/dependency.rs

@@ -162,7 +162,7 @@ mod tests {
 
     #[test]
     fn parses_dependencies() {
-        [
+        for (input, expected_path, expected_tag, expected_alias) in [
             ("gakonst/lootloose", "https://github.com/gakonst/lootloose", None, None),
             ("github.com/gakonst/lootloose", "https://github.com/gakonst/lootloose", None, None),
             (
@@ -239,15 +239,13 @@ mod tests {
                 Some("v1"),
                 Some("loot"),
             ),
-        ]
-        .iter()
-        .for_each(|(input, expected_path, expected_tag, expected_alias)| {
+        ] {
             let dep = Dependency::from_str(input).unwrap();
             assert_eq!(dep.url, Some(expected_path.to_string()));
             assert_eq!(dep.tag, expected_tag.map(ToString::to_string));
             assert_eq!(dep.name, "lootloose");
             assert_eq!(dep.alias, expected_alias.map(ToString::to_string));
-        });
+        }
     }
 
     #[test]
@@ -267,28 +265,26 @@ mod tests {
 
     #[test]
     fn parses_contract_info() {
-        [
+        for (input, expected_path, expected_name) in [
             (
                 "src/contracts/Contracts.sol:Contract",
                 Some("src/contracts/Contracts.sol"),
                 "Contract",
             ),
             ("Contract", None, "Contract"),
-        ]
-        .iter()
-        .for_each(|(input, expected_path, expected_name)| {
+        ] {
             let contract = ContractInfo::from_str(input).unwrap();
             assert_eq!(contract.path, expected_path.map(ToString::to_string));
             assert_eq!(contract.name, expected_name.to_string());
-        });
+        }
     }
 
     #[test]
     fn contract_info_should_reject_without_name() {
-        ["src/contracts/", "src/contracts/Contracts.sol"].iter().for_each(|input| {
+        for input in ["src/contracts/", "src/contracts/Contracts.sol"] {
             let contract = ContractInfo::from_str(input);
-            assert!(contract.is_err())
-        });
+            assert!(contract.is_err());
+        }
     }
 
     #[test]

crates/evm/core/src/fork/multi.rs

@@ -509,7 +509,9 @@ impl<
             std::thread::Builder::new()
                 .name("flusher".into())
                 .spawn(move || {
-                    forks.into_iter().for_each(|fork| fork.flush_cache());
+                    for fork in forks {
+                        fork.flush_cache();
+                    }
                 })
                 .expect("failed to spawn thread");
         }

crates/evm/fuzz/src/strategies/mutators.rs

@@ -485,7 +485,9 @@ fn apply_scale_to_bytes(bytes: &mut [u8], scale_factor: f64) -> Option<()> {
         let scaled = (byte_val + carry_down * 256.0) * scale_factor;
 
         if i == 0 && scaled >= 256.0 {
-            bytes.iter_mut().for_each(|b| *b = 0xFF);
+            for b in bytes.iter_mut() {
+                *b = 0xFF;
+            }
             return Some(());
         }
 
@@ -500,7 +502,9 @@ fn apply_scale_to_bytes(bytes: &mut [u8], scale_factor: f64) -> Option<()> {
             j -= 1;
             let new_val = bytes[j] as f64 + carry_up;
             if j == 0 && new_val >= 256.0 {
-                bytes.iter_mut().for_each(|b| *b = 0xFF);
+                for b in bytes.iter_mut() {
+                    *b = 0xFF;
+                }
                 return Some(());
             }
             bytes[j] = (new_val % 256.0).floor() as u8;

crates/forge/src/cmd/clone.rs

@@ -1016,8 +1016,8 @@ mod tests {
         contract_name: &str,
         stripped_creation_code: &str,
     ) {
-        compiled.compiled_contracts_by_compiler_version().iter().for_each(|(_, contracts)| {
-            contracts.iter().for_each(|(name, contract)| {
+        for contracts in compiled.compiled_contracts_by_compiler_version().values() {
+            for (name, contract) in contracts {
                 if name == contract_name {
                     let compiled_creation_code =
                         contract.bin_ref().expect("creation code not found");
@@ -1027,8 +1027,8 @@ mod tests {
                         "inconsistent creation code"
                     );
                 }
-            });
-        });
+            }
+        }
     }
 
     fn mock_etherscan(address: Address) -> impl super::ExplorerClient {

crates/forge/src/cmd/compiler.rs

@@ -109,7 +109,9 @@ impl ResolveArgs {
                 // Clear paths if verbosity is 0, performed only after filtering to avoid being
                 // skipped.
                 if shell::verbosity() == 0 {
-                    versions_with_paths.iter_mut().for_each(|version| version.paths.clear());
+                    for version in &mut versions_with_paths {
+                        version.paths.clear();
+                    }
                 }
 
                 output.insert(language.to_string(), versions_with_paths);

crates/forge/src/cmd/test/mod.rs

@@ -557,7 +557,7 @@ impl TestArgs {
         // Run tests in a non-streaming fashion and collect results for serialization.
         if !self.gas_report && !self.summary && shell::is_json() {
             let mut results = runner.test_collect(filter)?;
-            results.values_mut().for_each(|suite_result| {
+            for suite_result in results.values_mut() {
                 for test_result in suite_result.test_results.values_mut() {
                     if verbosity >= 2 {
                         // Decode logs at level 2 and above.
@@ -567,7 +567,7 @@ impl TestArgs {
                         test_result.logs = vec![];
                     }
                 }
-            });
+            }
             sh_println!("{}", serde_json::to_string(&results)?)?;
             let kc = runner.known_contracts.clone();
             return Ok(TestOutcome::new(Some(kc), results, self.allow_failure, fuzz_seed));

crates/forge/src/gas_report.rs

@@ -231,8 +231,8 @@ impl GasReport {
             Cell::new("# Calls").fg(Color::Cyan),
         ]);
 
-        contract.functions.iter().for_each(|(fname, sigs)| {
-            sigs.iter().for_each(|(sig, gas_info)| {
+        for (fname, sigs) in &contract.functions {
+            for (sig, gas_info) in sigs {
                 // Show function signature if overloaded else display function name.
                 let display_name =
                     if sigs.len() == 1 { fname.clone() } else { sig.replace(':', "") };
@@ -253,8 +253,8 @@ impl GasReport {
                         .set_alignment(CellAlignment::Right),
                     Cell::new(gas_info.calls.to_string()).set_alignment(CellAlignment::Right),
                 ]);
-            })
-        });
+            }
+        }
 
         table
     }