Activate clippy::manual_let_else lint (#4889)

## Issue Addressed

#4888

## Proposed Changes

Enabled `clippy::manual_let_else` lint and resolved the warning messages.

Makefile

@@ -208,6 +208,7 @@ test-full: cargo-fmt test-release test-debug test-ef test-exec-engine
 lint:
 	cargo clippy --workspace --tests $(EXTRA_CLIPPY_OPTS) --features "$(TEST_FEATURES)" -- \
 		-D clippy::fn_to_numeric_cast_any \
+		-D clippy::manual_let_else \
 		-D warnings \
 		-A clippy::derive_partial_eq_without_eq \
 		-A clippy::from-over-into \

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -601,11 +601,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         spec: &ChainSpec,
         log: &Logger,
     ) -> Result<Option<BeaconForkChoice<T>>, Error> {
-        let persisted_fork_choice =
-            match store.get_item::<PersistedForkChoice>(&FORK_CHOICE_DB_KEY)? {
-                Some(fc) => fc,
-                None => return Ok(None),
-            };
+        let Some(persisted_fork_choice) =
+            store.get_item::<PersistedForkChoice>(&FORK_CHOICE_DB_KEY)?
+        else {
+            return Ok(None);
+        };
 
         let fc_store =
             BeaconForkChoiceStore::from_persisted(persisted_fork_choice.fork_choice_store, store)?;
@@ -3485,9 +3485,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         state: &BeaconState<T::EthSpec>,
     ) -> Result<(), BlockError<T::EthSpec>> {
         // Only perform the weak subjectivity check if it was configured.
-        let wss_checkpoint = if let Some(checkpoint) = self.config.weak_subjectivity_checkpoint {
-            checkpoint
-        } else {
+        let Some(wss_checkpoint) = self.config.weak_subjectivity_checkpoint else {
             return Ok(());
         };
         // Note: we're using the finalized checkpoint from the head state, rather than fork
@@ -5336,14 +5334,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             )
             .await??;
 
-        let (forkchoice_update_params, pre_payload_attributes) =
-            if let Some((fcu, Some(pre_payload))) = maybe_prep_data {
-                (fcu, pre_payload)
-            } else {
-                // Appropriate log messages have already been logged above and in
-                // `get_pre_payload_attributes`.
-                return Ok(());
-            };
+        let Some((forkchoice_update_params, Some(pre_payload_attributes))) = maybe_prep_data else {
+            // Appropriate log messages have already been logged above and in
+            // `get_pre_payload_attributes`.
+            return Ok(());
+        };
 
         // If the execution layer doesn't have any proposer data for this validator then we assume
         // it's not connected to this BN and no action is required.
@@ -5436,23 +5431,20 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             }
         }
 
-        let till_prepare_slot =
-            if let Some(duration) = self.slot_clock.duration_to_slot(prepare_slot) {
-                duration
-            } else {
-                // `SlotClock::duration_to_slot` will return `None` when we are past the start
-                // of `prepare_slot`. Don't bother sending a `forkchoiceUpdated` in that case,
-                // it's too late.
-                //
-                // This scenario might occur on an overloaded/under-resourced node.
-                warn!(
-                    self.log,
-                    "Delayed proposer preparation";
-                    "prepare_slot" => prepare_slot,
-                    "validator" => proposer,
-                );
-                return Ok(());
-            };
+        let Some(till_prepare_slot) = self.slot_clock.duration_to_slot(prepare_slot) else {
+            // `SlotClock::duration_to_slot` will return `None` when we are past the start
+            // of `prepare_slot`. Don't bother sending a `forkchoiceUpdated` in that case,
+            // it's too late.
+            //
+            // This scenario might occur on an overloaded/under-resourced node.
+            warn!(
+                self.log,
+                "Delayed proposer preparation";
+                "prepare_slot" => prepare_slot,
+                "validator" => proposer,
+            );
+            return Ok(());
+        };
 
         // If we are close enough to the proposal slot, send an fcU, which will have payload
         // attributes filled in by the execution layer cache we just primed.

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -451,23 +451,21 @@ async fn availability_cache_maintenance_service<T: BeaconChainTypes>(
                 let additional_delay = (epoch_duration * 3) / 4;
                 tokio::time::sleep(duration + additional_delay).await;
 
-                let deneb_fork_epoch = match chain.spec.deneb_fork_epoch {
-                    Some(epoch) => epoch,
-                    None => break, // shutdown service if deneb fork epoch not set
+                let Some(deneb_fork_epoch) = chain.spec.deneb_fork_epoch else {
+                    // shutdown service if deneb fork epoch not set
+                    break;
                 };
 
                 debug!(
                     chain.log,
                     "Availability cache maintenance service firing";
                 );
-
-                let current_epoch = match chain
+                let Some(current_epoch) = chain
                     .slot_clock
                     .now()
                     .map(|slot| slot.epoch(T::EthSpec::slots_per_epoch()))
-                {
-                    Some(epoch) => epoch,
-                    None => continue, // we'll have to try again next time I suppose..
+                else {
+                    continue;
                 };
 
                 if current_epoch < deneb_fork_epoch {

beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

@@ -547,9 +547,8 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
                 .peek_lru()
                 .map(|(key, value)| (*key, value.clone()));
 
-            let (lru_root, lru_pending_components) = match lru_entry {
-                Some((r, p)) => (r, p),
-                None => break,
+            let Some((lru_root, lru_pending_components)) = lru_entry else {
+                break;
             };
 
             if lru_pending_components
@@ -605,9 +604,8 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
         let delete_if_outdated = |cache: &OverflowLRUCache<T>,
                                   block_data: Option<BlockData>|
          -> Result<(), AvailabilityCheckError> {
-            let block_data = match block_data {
-                Some(block_data) => block_data,
-                None => return Ok(()),
+            let Some(block_data) = block_data else {
+                return Ok(());
             };
             let not_in_store_keys = !cache.critical.read().store_keys.contains(&block_data.root);
             if not_in_store_keys {

beacon_node/beacon_chain/src/early_attester_cache.rs

@@ -99,9 +99,7 @@ impl<E: EthSpec> EarlyAttesterCache<E> {
         spec: &ChainSpec,
     ) -> Result<Option<Attestation<E>>, Error> {
         let lock = self.item.read();
-        let item = if let Some(item) = lock.as_ref() {
-            item
-        } else {
+        let Some(item) = lock.as_ref() else {
             return Ok(None);
         };
 

beacon_node/beacon_chain/src/schema_change/migration_schema_v12.rs

@@ -16,15 +16,14 @@ pub fn upgrade_to_v12<T: BeaconChainTypes>(
     let spec = db.get_chain_spec();
 
     // Load a V5 op pool and transform it to V12.
-    let PersistedOperationPoolV5 {
+    let Some(PersistedOperationPoolV5 {
         attestations_v5,
         sync_contributions,
         attester_slashings_v5,
         proposer_slashings_v5,
         voluntary_exits_v5,
-    } = if let Some(op_pool) = db.get_item(&OP_POOL_DB_KEY)? {
-        op_pool
-    } else {
+    }) = db.get_item(&OP_POOL_DB_KEY)?
+    else {
         debug!(log, "Nothing to do, no operation pool stored");
         return Ok(vec![]);
     };
@@ -168,15 +167,14 @@ pub fn downgrade_from_v12<T: BeaconChainTypes>(
     log: Logger,
 ) -> Result<Vec<KeyValueStoreOp>, Error> {
     // Load a V12 op pool and transform it to V5.
-    let PersistedOperationPoolV12::<T::EthSpec> {
+    let Some(PersistedOperationPoolV12::<T::EthSpec> {
         attestations,
         sync_contributions,
         attester_slashings,
         proposer_slashings,
         voluntary_exits,
-    } = if let Some(op_pool_v12) = db.get_item(&OP_POOL_DB_KEY)? {
-        op_pool_v12
-    } else {
+    }) = db.get_item(&OP_POOL_DB_KEY)?
+    else {
         debug!(log, "Nothing to do, no operation pool stored");
         return Ok(vec![]);
     };

beacon_node/beacon_chain/src/schema_change/migration_schema_v14.rs

@@ -18,19 +18,14 @@ fn get_slot_clock<T: BeaconChainTypes>(
     log: &Logger,
 ) -> Result<Option<T::SlotClock>, Error> {
     let spec = db.get_chain_spec();
-    let genesis_block = if let Some(block) = db.get_blinded_block(&Hash256::zero())? {
-        block
-    } else {
+    let Some(genesis_block) = db.get_blinded_block(&Hash256::zero())? else {
         error!(log, "Missing genesis block");
         return Ok(None);
     };
-    let genesis_state =
-        if let Some(state) = db.get_state(&genesis_block.state_root(), Some(Slot::new(0)))? {
-            state
-        } else {
-            error!(log, "Missing genesis state"; "state_root" => ?genesis_block.state_root());
-            return Ok(None);
-        };
+    let Some(genesis_state) = db.get_state(&genesis_block.state_root(), Some(Slot::new(0)))? else {
+        error!(log, "Missing genesis state"; "state_root" => ?genesis_block.state_root());
+        return Ok(None);
+    };
     Ok(Some(T::SlotClock::new(
         spec.genesis_slot,
         Duration::from_secs(genesis_state.genesis_time()),
@@ -43,15 +38,14 @@ pub fn upgrade_to_v14<T: BeaconChainTypes>(
     log: Logger,
 ) -> Result<Vec<KeyValueStoreOp>, Error> {
     // Load a V12 op pool and transform it to V14.
-    let PersistedOperationPoolV12::<T::EthSpec> {
+    let Some(PersistedOperationPoolV12::<T::EthSpec> {
         attestations,
         sync_contributions,
         attester_slashings,
         proposer_slashings,
         voluntary_exits,
-    } = if let Some(op_pool_v12) = db.get_item(&OP_POOL_DB_KEY)? {
-        op_pool_v12
-    } else {
+    }) = db.get_item(&OP_POOL_DB_KEY)?
+    else {
         debug!(log, "Nothing to do, no operation pool stored");
         return Ok(vec![]);
     };
@@ -94,16 +88,15 @@ pub fn downgrade_from_v14<T: BeaconChainTypes>(
     }
 
     // Load a V14 op pool and transform it to V12.
-    let PersistedOperationPoolV14::<T::EthSpec> {
+    let Some(PersistedOperationPoolV14::<T::EthSpec> {
         attestations,
         sync_contributions,
         attester_slashings,
         proposer_slashings,
         voluntary_exits,
         bls_to_execution_changes,
-    } = if let Some(op_pool) = db.get_item(&OP_POOL_DB_KEY)? {
-        op_pool
-    } else {
+    }) = db.get_item(&OP_POOL_DB_KEY)?
+    else {
         debug!(log, "Nothing to do, no operation pool stored");
         return Ok(vec![]);
     };

beacon_node/beacon_chain/src/schema_change/migration_schema_v15.rs

@@ -11,16 +11,15 @@ pub fn upgrade_to_v15<T: BeaconChainTypes>(
     log: Logger,
 ) -> Result<Vec<KeyValueStoreOp>, Error> {
     // Load a V14 op pool and transform it to V15.
-    let PersistedOperationPoolV14::<T::EthSpec> {
+    let Some(PersistedOperationPoolV14::<T::EthSpec> {
         attestations,
         sync_contributions,
         attester_slashings,
         proposer_slashings,
         voluntary_exits,
         bls_to_execution_changes,
-    } = if let Some(op_pool_v14) = db.get_item(&OP_POOL_DB_KEY)? {
-        op_pool_v14
-    } else {
+    }) = db.get_item(&OP_POOL_DB_KEY)?
+    else {
         debug!(log, "Nothing to do, no operation pool stored");
         return Ok(vec![]);
     };
@@ -43,17 +42,16 @@ pub fn downgrade_from_v15<T: BeaconChainTypes>(
     log: Logger,
 ) -> Result<Vec<KeyValueStoreOp>, Error> {
     // Load a V15 op pool and transform it to V14.
-    let PersistedOperationPoolV15::<T::EthSpec> {
+    let Some(PersistedOperationPoolV15::<T::EthSpec> {
         attestations,
         sync_contributions,
         attester_slashings,
         proposer_slashings,
         voluntary_exits,
         bls_to_execution_changes,
         capella_bls_change_broadcast_indices,
-    } = if let Some(op_pool) = db.get_item(&OP_POOL_DB_KEY)? {
-        op_pool
-    } else {
+    }) = db.get_item(&OP_POOL_DB_KEY)?
+    else {
         debug!(log, "Nothing to do, no operation pool stored");
         return Ok(vec![]);
     };

beacon_node/beacon_chain/src/schema_change/migration_schema_v18.rs

@@ -17,19 +17,14 @@ fn get_slot_clock<T: BeaconChainTypes>(
     log: &Logger,
 ) -> Result<Option<T::SlotClock>, Error> {
     let spec = db.get_chain_spec();
-    let genesis_block = if let Some(block) = db.get_blinded_block(&Hash256::zero())? {
-        block
-    } else {
+    let Some(genesis_block) = db.get_blinded_block(&Hash256::zero())? else {
         error!(log, "Missing genesis block");
         return Ok(None);
     };
-    let genesis_state =
-        if let Some(state) = db.get_state(&genesis_block.state_root(), Some(Slot::new(0)))? {
-            state
-        } else {
-            error!(log, "Missing genesis state"; "state_root" => ?genesis_block.state_root());
-            return Ok(None);
-        };
+    let Some(genesis_state) = db.get_state(&genesis_block.state_root(), Some(Slot::new(0)))? else {
+        error!(log, "Missing genesis state"; "state_root" => ?genesis_block.state_root());
+        return Ok(None);
+    };
     Ok(Some(T::SlotClock::new(
         spec.genesis_slot,
         Duration::from_secs(genesis_state.genesis_time()),

beacon_node/beacon_chain/src/state_advance_timer.rs

@@ -113,14 +113,11 @@ async fn state_advance_timer<T: BeaconChainTypes>(
     let slot_duration = slot_clock.slot_duration();
 
     loop {
-        let duration_to_next_slot = match beacon_chain.slot_clock.duration_to_next_slot() {
-            Some(duration) => duration,
-            None => {
-                error!(log, "Failed to read slot clock");
-                // If we can't read the slot clock, just wait another slot.
-                sleep(slot_duration).await;
-                continue;
-            }
+        let Some(duration_to_next_slot) = beacon_chain.slot_clock.duration_to_next_slot() else {
+            error!(log, "Failed to read slot clock");
+            // If we can't read the slot clock, just wait another slot.
+            sleep(slot_duration).await;
+            continue;
         };
 
         // Run the state advance 3/4 of the way through the slot (9s on mainnet).

beacon_node/execution_layer/src/lib.rs

@@ -1799,13 +1799,11 @@ impl<T: EthSpec> ExecutionLayer<T> {
             };
         }
 
-        let block = if let Some(block) = engine
+        let Some(block) = engine
             .api
             .get_block_by_hash_with_txns::<T>(hash, fork)
             .await?
-        {
-            block
-        } else {
+        else {
             return Ok(None);
         };
 

beacon_node/execution_layer/src/test_utils/execution_block_generator.rs

@@ -426,9 +426,7 @@ impl<T: EthSpec> ExecutionBlockGenerator<T> {
     }
 
     pub fn new_payload(&mut self, payload: ExecutionPayload<T>) -> PayloadStatusV1 {
-        let parent = if let Some(parent) = self.blocks.get(&payload.parent_hash()) {
-            parent
-        } else {
+        let Some(parent) = self.blocks.get(&payload.parent_hash()) else {
             return PayloadStatusV1 {
                 status: PayloadStatusV1Status::Syncing,
                 latest_valid_hash: None,

beacon_node/http_api/src/sync_committees.rs

@@ -30,9 +30,7 @@ pub fn sync_committee_duties<T: BeaconChainTypes>(
     request_indices: &[u64],
     chain: &BeaconChain<T>,
 ) -> Result<SyncDuties, warp::reject::Rejection> {
-    let altair_fork_epoch = if let Some(altair_fork_epoch) = chain.spec.altair_fork_epoch {
-        altair_fork_epoch
-    } else {
+    let Some(altair_fork_epoch) = chain.spec.altair_fork_epoch else {
         // Empty response for networks with Altair disabled.
         return Ok(convert_to_response(vec![], false));
     };