style: prefer then_some over if else (#1810)

bin/reth/src/test_eth_chain/runner.rs

@@ -152,7 +152,7 @@ pub async fn run_test(path: PathBuf) -> eyre::Result<TestOutcome> {
 
         pre_state.into_iter().try_for_each(|(address, account)| -> eyre::Result<()> {
             let has_code = !account.code.is_empty();
-            let code_hash = if has_code { Some(keccak256(&account.code)) } else { None };
+            let code_hash = has_code.then(|| keccak256(&account.code));
             tx.put::<tables::PlainAccountState>(
                 address,
                 RethAccount {

crates/executor/src/executor.rs

@@ -573,7 +573,7 @@ mod tests {
             Ok(self
                 .block_hash
                 .iter()
-                .filter_map(|(block, hash)| if range.contains(block) { Some(*hash) } else { None })
+                .filter_map(|(block, hash)| range.contains(block).then_some(*hash))
                 .collect())
         }
     }

crates/metrics/metrics-derive/tests/metrics.rs

@@ -303,21 +303,21 @@ impl Recorder for TestRecorder {
 
     fn register_counter(&self, key: &Key) -> Counter {
         let labels_vec: Vec<Label> = key.labels().cloned().collect();
-        let labels = if labels_vec.is_empty() { None } else { Some(labels_vec) };
+        let labels = (!labels_vec.is_empty()).then_some(labels_vec);
         self.record_metric(key.name(), TestMetricTy::Counter, None, labels);
         Counter::noop()
     }
 
     fn register_gauge(&self, key: &Key) -> Gauge {
         let labels_vec: Vec<Label> = key.labels().cloned().collect();
-        let labels = if labels_vec.is_empty() { None } else { Some(labels_vec) };
+        let labels = (!labels_vec.is_empty()).then_some(labels_vec);
         self.record_metric(key.name(), TestMetricTy::Gauge, None, labels);
         Gauge::noop()
     }
 
     fn register_histogram(&self, key: &Key) -> Histogram {
         let labels_vec: Vec<Label> = key.labels().cloned().collect();
-        let labels = if labels_vec.is_empty() { None } else { Some(labels_vec) };
+        let labels = (!labels_vec.is_empty()).then_some(labels_vec);
         self.record_metric(key.name(), TestMetricTy::Histogram, None, labels);
         Histogram::noop()
     }

crates/revm/revm-primitives/src/compat.rs

@@ -29,6 +29,6 @@ pub fn to_reth_acc(revm_acc: &AccountInfo) -> Account {
     Account {
         balance: revm_acc.balance,
         nonce: revm_acc.nonce,
-        bytecode_hash: if code_hash == KECCAK_EMPTY { None } else { Some(code_hash) },
+        bytecode_hash: (code_hash != KECCAK_EMPTY).then_some(code_hash),
     }
 }

crates/rpc/rpc/src/eth/api/server.rs

@@ -446,8 +446,7 @@ mod tests {
             let hash = H256::random();
             let gas_limit: u64 = random();
             let gas_used: u64 = random();
-            let base_fee_per_gas: Option<u64> =
-                if random::<bool>() { Some(random()) } else { None };
+            let base_fee_per_gas: Option<u64> = random::<bool>().then(|| random());
 
             let header = Header {
                 number: newest_block - i,

crates/rpc/rpc/src/eth/filter.rs

@@ -202,8 +202,7 @@ where
         let mut all_logs = Vec::new();
         let filter_params = FilteredParams::new(Some(filter.clone()));
 
-        let topics =
-            if filter.has_topics() { Some(filter_params.flat_topics.clone()) } else { None };
+        let topics = filter.has_topics().then(|| filter_params.flat_topics.clone());
 
         // derive bloom filters from filter input
         let address_filter = FilteredParams::address_filter(&filter.address);

crates/storage/provider/src/test_utils/mock.rs

@@ -179,8 +179,7 @@ impl BlockHashProvider for MockEthProvider {
     fn block_hash(&self, number: u64) -> Result<Option<H256>> {
         let lock = self.blocks.lock();
 
-        let hash =
-            lock.iter().find_map(|(hash, b)| if b.number == number { Some(*hash) } else { None });
+        let hash = lock.iter().find_map(|(hash, b)| (b.number == number).then_some(*hash));
         Ok(hash)
     }
 
@@ -213,7 +212,7 @@ impl BlockIdProvider for MockEthProvider {
 
     fn block_number(&self, hash: H256) -> Result<Option<reth_primitives::BlockNumber>> {
         let lock = self.blocks.lock();
-        let num = lock.iter().find_map(|(h, b)| if *h == hash { Some(b.number) } else { None });
+        let num = lock.iter().find_map(|(h, b)| (*h == hash).then_some(b.number));
         Ok(num)
     }
 }