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()
     }
 }