save

Author: taikoonwang

Cargo.toml

@@ -46,23 +46,27 @@ explicit_into_iter_loop = "warn"
 explicit_iter_loop = "warn"
 flat_map_option = "warn"
 from_iter_instead_of_collect = "warn"
-if_not_else = "warn"
-if_then_some_else_none = "warn"
 implicit_clone = "warn"
 imprecise_flops = "warn"
 iter_on_empty_collections = "warn"
-iter_on_single_items = "warn"
 iter_with_drain = "warn"
 iter_without_into_iter = "warn"
 large_stack_frames = "warn"
 manual-string-new = "warn"
+naive_bytecount = "warn"
+needless_bitwise_bool = "warn"
+needless_continue = "warn"
+needless_for_each = "warn"
+needless_pass_by_ref_mut = "warn"
+nonstandard_macro_braces = "warn"
 uninlined-format-args = "warn"
 use-self = "warn"
-redundant-clone = "warn"
+read_zero_byte_vec = "warn"
+result_large_err = "allow"
+redundant_clone = "warn"
 octal-escapes = "allow"
 # until <https://github.com/rust-lang/rust-clippy/issues/13885> is fixed
 literal-string-with-formatting-args = "allow"
-result_large_err = "allow"
 
 [workspace.lints.rust]
 rust-2018-idioms = "warn"

crates/anvil/tests/it/fork.rs

@@ -1466,12 +1466,12 @@ async fn test_reset_dev_account_nonce() {
 async fn test_reset_updates_cache_path_when_rpc_url_not_provided() {
     let config: NodeConfig = fork_config();
 
-    let (mut api, _handle) = spawn(config).await;
+    let (api, _handle) = spawn(config).await;
     let info = api.anvil_node_info().await.unwrap();
     let number = info.fork_config.fork_block_number.unwrap();
     assert_eq!(number, BLOCK_NUMBER);
 
-    async fn get_block_from_cache_path(api: &mut EthApi) -> u64 {
+    async fn get_block_from_cache_path(api: &EthApi) -> u64 {
         let db = api.backend.get_db().read().await;
         let cache_path = db.maybe_inner().unwrap().cache().cache_path().unwrap();
         cache_path
@@ -1485,7 +1485,7 @@ async fn test_reset_updates_cache_path_when_rpc_url_not_provided() {
             .expect("must be valid number")
     }
 
-    assert_eq!(BLOCK_NUMBER, get_block_from_cache_path(&mut api).await);
+    assert_eq!(BLOCK_NUMBER, get_block_from_cache_path(&api).await);
 
     // Reset to older block without specifying a new rpc url
     api.anvil_reset(Some(Forking {
@@ -1495,7 +1495,7 @@ async fn test_reset_updates_cache_path_when_rpc_url_not_provided() {
     .await
     .unwrap();
 
-    assert_eq!(BLOCK_NUMBER - 1_000_000, get_block_from_cache_path(&mut api).await);
+    assert_eq!(BLOCK_NUMBER - 1_000_000, get_block_from_cache_path(&api).await);
 }
 
 #[tokio::test(flavor = "multi_thread")]

crates/cheatcodes/src/evm.rs

@@ -1180,7 +1180,7 @@ fn genesis_account(account: &Account) -> GenesisAccount {
 }
 
 /// Helper function to returns state diffs recorded for each changed account.
-fn get_recorded_state_diffs(state: &mut Cheatcodes) -> BTreeMap<Address, AccountStateDiffs> {
+fn get_recorded_state_diffs(state: &Cheatcodes) -> BTreeMap<Address, AccountStateDiffs> {
     let mut state_diffs: BTreeMap<Address, AccountStateDiffs> = BTreeMap::default();
     if let Some(records) = &state.recorded_account_diffs_stack {
         records

crates/cheatcodes/src/inspector.rs

@@ -1777,7 +1777,7 @@ impl Cheatcodes {
     }
 
     #[cold]
-    fn meter_gas_record(&mut self, interpreter: &mut Interpreter, ecx: Ecx) {
+    fn meter_gas_record(&mut self, interpreter: &Interpreter, ecx: Ecx) {
         if matches!(interpreter.instruction_result, InstructionResult::Continue) {
             self.gas_metering.gas_records.iter_mut().for_each(|record| {
                 if ecx.journaled_state.depth() == record.depth {

crates/cli/src/opts/dependency.rs

@@ -160,7 +160,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),
             (
@@ -242,15 +242,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]
@@ -270,28 +268,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())
-        });
+        }
     }
 
     #[test]

crates/cli/src/utils/cmd.rs

@@ -455,12 +455,12 @@ pub fn cache_local_signatures(output: &ProjectCompileOutput, cache_path: PathBuf
             }
             // External libraries doesn't have functions included in abi, but `methodIdentifiers`.
             if let Some(method_identifiers) = &artifact.method_identifiers {
-                method_identifiers.iter().for_each(|(signature, selector)| {
+                for (signature, selector) in method_identifiers {
                     cached_signatures
                         .functions
                         .entry(format!("0x{selector}"))
                         .or_insert(signature.to_string());
-                });
+                }
             }
         }
     });

crates/common/fmt/src/console.rs

@@ -127,15 +127,15 @@ impl<'a> Parser<'a> {
         self.input[start..end].parse().ok()
     }
 
-    fn current_pos(&mut self) -> usize {
+    fn current_pos(&self) -> usize {
         self.peek().map(|(n, _)| n).unwrap_or(self.input.len())
     }
 
-    fn peek(&mut self) -> Option<(usize, char)> {
+    fn peek(&self) -> Option<(usize, char)> {
         self.peek_n(0)
     }
 
-    fn peek_n(&mut self, n: usize) -> Option<(usize, char)> {
+    fn peek_n(&self, n: usize) -> Option<(usize, char)> {
         self.chars.clone().nth(n)
     }
 }

crates/doc/src/parser/mod.rs

@@ -99,18 +99,18 @@ impl Parser {
     }
 
     /// Create new [ParseItem] with comments and formatted code.
-    fn new_item(&mut self, source: ParseSource, loc_start: usize) -> ParserResult<ParseItem> {
+    fn new_item(&self, source: ParseSource, loc_start: usize) -> ParserResult<ParseItem> {
         let docs = self.parse_docs(loc_start)?;
         ParseItem::new(source).with_comments(docs).with_code(&self.source, self.fmt.clone())
     }
 
     /// Parse the doc comments from the current start location.
-    fn parse_docs(&mut self, end: usize) -> ParserResult<Comments> {
+    fn parse_docs(&self, end: usize) -> ParserResult<Comments> {
         self.parse_docs_range(self.context.doc_start_loc, end)
     }
 
     /// Parse doc comments from the within specified range.
-    fn parse_docs_range(&mut self, start: usize, end: usize) -> ParserResult<Comments> {
+    fn parse_docs_range(&self, start: usize, end: usize) -> ParserResult<Comments> {
         let mut res = vec![];
         for comment in parse_doccomments(&self.comments, start, end) {
             match comment {

crates/evm/traces/src/folded_stack_trace.rs

@@ -179,7 +179,7 @@ impl FoldedStackTraceBuilder {
 
     /// Internal method to build the folded stack trace without subtracting gas consumed by
     /// the children function calls.
-    fn build_without_subtraction(&mut self) -> Vec<String> {
+    fn build_without_subtraction(&self) -> Vec<String> {
         let mut lines = Vec::new();
         for TraceEntry { names, gas } in &self.traces {
             lines.push(format!("{} {}", names.join(";"), gas));

crates/fmt/src/comments.rs

@@ -338,7 +338,7 @@ impl<'a> CommentStateCharIndices<'a> {
     }
 
     #[inline]
-    pub fn peek(&mut self) -> Option<(usize, char)> {
+    pub fn peek(&self) -> Option<(usize, char)> {
         self.iter.clone().next()
     }
 }

crates/fmt/src/formatter.rs

@@ -323,7 +323,7 @@ impl<'a, W: Write> Formatter<'a, W> {
     /// lookup whether there was a newline introduced in `[start_from, end_at]` range
     /// where `end_at` is the start of the block.
     fn should_attempt_block_single_line(
-        &mut self,
+        &self,
         stmt: &mut Statement,
         start_from: usize,
     ) -> bool {

crates/forge/src/cmd/clone.rs

@@ -645,7 +645,7 @@ mod tests {
         stripped_creation_code: &str,
     ) {
         compiled.compiled_contracts_by_compiler_version().iter().for_each(|(_, contracts)| {
-            contracts.iter().for_each(|(name, contract)| {
+            for (name, contract) in contracts {
                 if name == contract_name {
                     let compiled_creation_code =
                         contract.bin_ref().expect("creation code not found");
@@ -655,7 +655,7 @@ mod tests {
                         "inconsistent creation code"
                     );
                 }
-            });
+            }
         });
     }
 

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

@@ -472,7 +472,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.
@@ -482,7 +482,7 @@ impl TestArgs {
                         test_result.logs = vec![];
                     }
                 }
-            });
+            }
             sh_println!("{}", serde_json::to_string(&results)?)?;
             return Ok(TestOutcome::new(results, self.allow_failure));
         }

crates/forge/src/multi_runner.rs

@@ -211,9 +211,9 @@ impl MultiContractRunner {
 
             tests_progress.inner.lock().clear();
 
-            results.iter().for_each(|result| {
+            for result in &results {
                 let _ = tx.send(result.to_owned());
-            });
+            }
         } else {
             contracts.par_iter().for_each(|&(id, contract)| {
                 let _guard = tokio_handle.enter();

crates/forge/src/progress.rs

@@ -61,7 +61,7 @@ impl TestsProgressState {
     /// phase. Test progress is placed under test suite progress entry so all tests within suite
     /// are grouped.
     pub fn start_fuzz_progress(
-        &mut self,
+        &self,
         suite_name: &str,
         test_name: &String,
         runs: u32,
@@ -84,7 +84,7 @@ impl TestsProgressState {
     }
 
     /// Removes overall test progress.
-    pub fn clear(&mut self) {
+    pub fn clear(&self) {
         self.multi.clear().unwrap();
     }
 }

crates/forge/src/runner.rs

@@ -241,7 +241,7 @@ impl<'a> ContractRunner<'a> {
     /// `function fixture_owner() public returns (address[] memory){}`
     /// returns an array of addresses to be used for fuzzing `owner` named parameter in scope of the
     /// current test.
-    fn fuzz_fixtures(&mut self, address: Address) -> FuzzFixtures {
+    fn fuzz_fixtures(&self, address: Address) -> FuzzFixtures {
         let mut fixtures = HashMap::default();
         let fixture_functions = self.contract.abi.functions().filter(|func| func.is_fixture());
         for func in fixture_functions {

crates/script/src/progress.rs

@@ -121,7 +121,7 @@ impl SequenceProgressState {
     }
 
     /// Sets status for the current sequence progress.
-    pub fn set_status(&mut self, status: &str) {
+    pub fn set_status(&self, status: &str) {
         self.top_spinner.set_message(format!(" | {status}"));
     }
 

crates/verify/src/etherscan/mod.rs

@@ -387,7 +387,7 @@ impl EtherscanVerificationProvider {
     /// match provided creation code with local bytecode of the target contract.
     /// If bytecode match, returns latest bytes of on-chain creation code as constructor arguments.
     async fn guess_constructor_args(
-        &mut self,
+        &self,
         args: &VerifyArgs,
         context: &VerificationContext,
     ) -> Result<String> {