Fix collapsible_if and collapsible_match

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

stackslib/src/burnchains/bitcoin/address.rs

@@ -591,10 +591,10 @@ impl BitcoinAddress {
         } else {
             BitcoinNetworkType::Testnet
         };
-        if let Some(addr) = BitcoinAddress::from_scriptpubkey(network_id, scriptpubkey) {
-            if let BitcoinAddress::Segwit(sw) = addr {
-                return Some(BitcoinAddress::Segwit(sw));
-            }
+        if let Some(BitcoinAddress::Segwit(sw)) =
+            BitcoinAddress::from_scriptpubkey(network_id, scriptpubkey)
+        {
+            return Some(BitcoinAddress::Segwit(sw));
         }
         return None;
     }

stackslib/src/burnchains/bitcoin/indexer.rs

@@ -503,13 +503,11 @@ impl BitcoinIndexer {
         start_block: u64,
         remove_old: bool,
     ) -> Result<SpvClient, btc_error> {
-        if remove_old {
-            if PathBuf::from(&reorg_headers_path).exists() {
-                fs::remove_file(&reorg_headers_path).map_err(|e| {
-                    error!("Failed to remove {}", reorg_headers_path);
-                    btc_error::Io(e)
-                })?;
-            }
+        if remove_old && PathBuf::from(&reorg_headers_path).exists() {
+            fs::remove_file(&reorg_headers_path).map_err(|e| {
+                error!("Failed to remove {}", reorg_headers_path);
+                btc_error::Io(e)
+            })?;
         }
 
         // bootstrap reorg client

stackslib/src/chainstate/burn/db/sortdb.rs

@@ -5774,10 +5774,9 @@ impl<'a> SortitionHandleTx<'a> {
             .map(|parent_commit_sn| parent_commit_sn.sortition_id)
             .unwrap_or(SortitionId([0x00; 32]));
 
-        if !cfg!(test) {
-            if block_commit.parent_block_ptr != 0 || block_commit.parent_vtxindex != 0 {
-                assert!(parent_sortition_id != SortitionId([0x00; 32]));
-            }
+        if !cfg!(test) && (block_commit.parent_block_ptr != 0 || block_commit.parent_vtxindex != 0)
+        {
+            assert!(parent_sortition_id != SortitionId([0x00; 32]));
         }
 
         let args = params![

stackslib/src/chainstate/burn/operations/leader_block_commit.rs

@@ -313,11 +313,9 @@ impl LeaderBlockCommitOp {
         })?;
 
         // basic sanity checks
-        if data.parent_block_ptr == 0 {
-            if data.parent_vtxindex != 0 {
-                warn!("Invalid tx: parent block back-pointer must be positive");
-                return Err(op_error::ParseError);
-            }
+        if data.parent_block_ptr == 0 && data.parent_vtxindex != 0 {
+            warn!("Invalid tx: parent block back-pointer must be positive");
+            return Err(op_error::ParseError);
             // if parent block ptr and parent vtxindex are both 0, then this block's parent is
             // the genesis block.
         }

stackslib/src/chainstate/coordinator/mod.rs

@@ -373,11 +373,11 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
             cur_epoch,
         )?;
 
-        if is_nakamoto_reward_set {
-            if reward_set.signers.is_none() || reward_set.signers == Some(vec![]) {
-                error!("FATAL: Signer sets are empty in a reward set that will be used in nakamoto"; "reward_set" => ?reward_set);
-                return Err(Error::PoXAnchorBlockRequired);
-            }
+        if is_nakamoto_reward_set
+            && (reward_set.signers.is_none() || reward_set.signers == Some(vec![]))
+        {
+            error!("FATAL: Signer sets are empty in a reward set that will be used in nakamoto"; "reward_set" => ?reward_set);
+            return Err(Error::PoXAnchorBlockRequired);
         }
 
         Ok(reward_set)
@@ -1398,21 +1398,20 @@ impl<
             }
         };
 
-        if sortition_changed_reward_cycle_opt.is_none() {
-            if sortition_tip_affirmation_map.len() >= heaviest_am.len()
-                && sortition_tip_affirmation_map.len() <= canonical_affirmation_map.len()
+        if sortition_changed_reward_cycle_opt.is_none()
+            && sortition_tip_affirmation_map.len() >= heaviest_am.len()
+            && sortition_tip_affirmation_map.len() <= canonical_affirmation_map.len()
+        {
+            if let Some(divergence_rc) =
+                canonical_affirmation_map.find_divergence(&sortition_tip_affirmation_map)
             {
-                if let Some(divergence_rc) =
-                    canonical_affirmation_map.find_divergence(&sortition_tip_affirmation_map)
-                {
-                    if divergence_rc + 1 >= (heaviest_am.len() as u64) {
-                        // this can arise if there are unaffirmed PoX anchor blocks that are not
-                        // reflected in the sortiiton affirmation map
-                        debug!("Update sortition-changed reward cycle to {} from canonical affirmation map `{}` (sortition AM is `{}`)",
-                            divergence_rc, &canonical_affirmation_map, &sortition_tip_affirmation_map);
+                if divergence_rc + 1 >= (heaviest_am.len() as u64) {
+                    // this can arise if there are unaffirmed PoX anchor blocks that are not
+                    // reflected in the sortiiton affirmation map
+                    debug!("Update sortition-changed reward cycle to {} from canonical affirmation map `{}` (sortition AM is `{}`)",
+                        divergence_rc, &canonical_affirmation_map, &sortition_tip_affirmation_map);
 
-                        sortition_changed_reward_cycle_opt = Some(divergence_rc);
-                    }
+                    sortition_changed_reward_cycle_opt = Some(divergence_rc);
                 }
             }
         }

stackslib/src/chainstate/nakamoto/miner.rs

@@ -572,20 +572,18 @@ impl NakamotoBlockBuilder {
             );
             let mut remaining_limit = block_limit.clone();
             let cost_so_far = tenure_tx.cost_so_far();
-            if remaining_limit.sub(&cost_so_far).is_ok() {
-                if remaining_limit.divide(100).is_ok() {
-                    remaining_limit.multiply(percentage.into()).expect(
-                        "BUG: failed to multiply by {percentage} when previously divided by 100",
-                    );
-                    remaining_limit.add(&cost_so_far).expect("BUG: unexpected overflow when adding cost_so_far, which was previously checked");
-                    debug!(
-                        "Setting soft limit for clarity cost to {percentage}% of remaining block limit";
-                        "remaining_limit" => %remaining_limit,
-                        "cost_so_far" => %cost_so_far,
-                        "block_limit" => %block_limit,
-                    );
-                    soft_limit = Some(remaining_limit);
-                }
+            if remaining_limit.sub(&cost_so_far).is_ok() && remaining_limit.divide(100).is_ok() {
+                remaining_limit.multiply(percentage.into()).expect(
+                    "BUG: failed to multiply by {percentage} when previously divided by 100",
+                );
+                remaining_limit.add(&cost_so_far).expect("BUG: unexpected overflow when adding cost_so_far, which was previously checked");
+                debug!(
+                    "Setting soft limit for clarity cost to {percentage}% of remaining block limit";
+                    "remaining_limit" => %remaining_limit,
+                    "cost_so_far" => %cost_so_far,
+                    "block_limit" => %block_limit,
+                );
+                soft_limit = Some(remaining_limit);
             };
         }
 

stackslib/src/chainstate/nakamoto/mod.rs

@@ -4179,17 +4179,15 @@ impl NakamotoChainState {
                         "Bitvec does not match the block commit's PoX handling".into(),
                     ));
                 }
-            } else if all_0 {
-                if treated_addr.is_reward() {
-                    warn!(
-                        "Invalid Nakamoto block: rewarded PoX address when bitvec contained 0s for the address";
-                        "reward_address" => %treated_addr.deref(),
-                        "bitvec_values" => ?bitvec_values,
-                    );
-                    return Err(ChainstateError::InvalidStacksBlock(
-                        "Bitvec does not match the block commit's PoX handling".into(),
-                    ));
-                }
+            } else if all_0 && treated_addr.is_reward() {
+                warn!(
+                    "Invalid Nakamoto block: rewarded PoX address when bitvec contained 0s for the address";
+                    "reward_address" => %treated_addr.deref(),
+                    "bitvec_values" => ?bitvec_values,
+                );
+                return Err(ChainstateError::InvalidStacksBlock(
+                    "Bitvec does not match the block commit's PoX handling".into(),
+                ));
             }
         }
 

stackslib/src/chainstate/stacks/auth.rs

@@ -1407,12 +1407,10 @@ impl TransactionAuth {
                 };
                 origin_supported && sponsor_supported
             }
-            TransactionAuth::Standard(ref origin) => match origin {
-                TransactionSpendingCondition::OrderIndependentMultisig(..) => {
-                    epoch_id >= StacksEpochId::Epoch30
-                }
-                _ => true,
-            },
+            TransactionAuth::Standard(TransactionSpendingCondition::OrderIndependentMultisig(
+                ..,
+            )) => epoch_id >= StacksEpochId::Epoch30,
+            _ => true,
         }
     }
 }

stackslib/src/chainstate/stacks/db/blocks.rs

@@ -883,12 +883,10 @@ impl StacksChainState {
 
     /// Closure for defaulting to an empty microblock stream if a microblock stream file is not found
     fn empty_stream(e: Error) -> Result<Option<Vec<StacksMicroblock>>, Error> {
-        match e {
-            Error::DBError(ref dbe) => match dbe {
-                db_error::NotFoundError => Ok(Some(vec![])),
-                _ => Err(e),
-            },
-            _ => Err(e),
+        if matches!(e, Error::DBError(db_error::NotFoundError)) {
+            Ok(Some(vec![]))
+        } else {
+            Err(e)
         }
     }
 
@@ -1209,17 +1207,17 @@ impl StacksChainState {
                     }
                 };
 
-            if processed_only {
-                if !StacksChainState::has_processed_microblocks_indexed(
+            if processed_only
+                && !StacksChainState::has_processed_microblocks_indexed(
                     blocks_conn,
                     &StacksBlockHeader::make_index_block_hash(
                         parent_consensus_hash,
                         &microblock.block_hash(),
                     ),
-                )? {
-                    debug!("Microblock {} is not processed", &microblock.block_hash());
-                    return Ok(None);
-                }
+                )?
+            {
+                debug!("Microblock {} is not processed", &microblock.block_hash());
+                return Ok(None);
             }
 
             debug!(
@@ -3287,17 +3285,16 @@ impl StacksChainState {
             blocks_conn,
             &parent_stacks_chain_tip.consensus_hash,
             &parent_stacks_chain_tip.winning_stacks_block_hash,
-        )? {
-            if block.has_microblock_parent() {
-                warn!(
-                    "Invalid block {}/{}: its parent {}/{} crossed the epoch boundary but this block confirmed its microblocks",
-                    &consensus_hash,
-                    &block.block_hash(),
-                    &parent_stacks_chain_tip.consensus_hash,
-                    &parent_stacks_chain_tip.winning_stacks_block_hash
-                );
-                return Ok(None);
-            }
+        )? && block.has_microblock_parent()
+        {
+            warn!(
+                "Invalid block {}/{}: its parent {}/{} crossed the epoch boundary but this block confirmed its microblocks",
+                &consensus_hash,
+                &block.block_hash(),
+                &parent_stacks_chain_tip.consensus_hash,
+                &parent_stacks_chain_tip.winning_stacks_block_hash
+            );
+            return Ok(None);
         }
 
         let sortition_burns = SortitionDB::get_block_burn_amount(db_handle, &burn_chain_tip)
@@ -6095,34 +6092,33 @@ impl StacksChainState {
             SortitionDB::are_microblocks_disabled(sort_tx.tx(), u64::from(burn_header_height))?;
 
         // microblocks are not allowed after Epoch 2.5 starts
-        if microblocks_disabled_by_epoch_25 {
-            if next_staging_block.parent_microblock_seq != 0
-                || next_staging_block.parent_microblock_hash != BlockHeaderHash([0; 32])
-            {
-                let msg = format!(
-                    "Invalid stacks block {}/{} ({}). Confirms microblocks after Epoch 2.5 start.",
+        if microblocks_disabled_by_epoch_25
+            && (next_staging_block.parent_microblock_seq != 0
+                || next_staging_block.parent_microblock_hash != BlockHeaderHash([0; 32]))
+        {
+            let msg = format!(
+                "Invalid stacks block {}/{} ({}). Confirms microblocks after Epoch 2.5 start.",
+                &next_staging_block.consensus_hash,
+                &next_staging_block.anchored_block_hash,
+                &StacksBlockId::new(
                     &next_staging_block.consensus_hash,
-                    &next_staging_block.anchored_block_hash,
-                    &StacksBlockId::new(
-                        &next_staging_block.consensus_hash,
-                        &next_staging_block.anchored_block_hash
-                    ),
-                );
-                warn!("{msg}");
+                    &next_staging_block.anchored_block_hash
+                ),
+            );
+            warn!("{msg}");
 
-                // clear out
-                StacksChainState::set_block_processed(
-                    chainstate_tx.deref_mut(),
-                    None,
-                    &blocks_path,
-                    &next_staging_block.consensus_hash,
-                    &next_staging_block.anchored_block_hash,
-                    false,
-                )?;
-                chainstate_tx.commit().map_err(Error::DBError)?;
+            // clear out
+            StacksChainState::set_block_processed(
+                chainstate_tx.deref_mut(),
+                None,
+                &blocks_path,
+                &next_staging_block.consensus_hash,
+                &next_staging_block.anchored_block_hash,
+                false,
+            )?;
+            chainstate_tx.commit().map_err(Error::DBError)?;
 
-                return Err(Error::InvalidStacksBlock(msg));
-            }
+            return Err(Error::InvalidStacksBlock(msg));
         }
 
         debug!(
@@ -6812,24 +6808,24 @@ impl StacksChainState {
                 }
 
                 // if the payer for the tx is different from owner, check if they can afford fee
-                if origin != payer {
-                    if !payer.stx_balance.can_transfer_at_burn_block(
+                if origin != payer
+                    && !payer.stx_balance.can_transfer_at_burn_block(
                         u128::from(fee),
                         block_height,
                         v1_unlock_height,
                         v2_unlock_height,
                         v3_unlock_height,
-                    )? {
-                        return Err(MemPoolRejection::NotEnoughFunds(
-                            u128::from(fee),
-                            payer.stx_balance.get_available_balance_at_burn_block(
-                                block_height,
-                                v1_unlock_height,
-                                v2_unlock_height,
-                                v3_unlock_height,
-                            )?,
-                        ));
-                    }
+                    )?
+                {
+                    return Err(MemPoolRejection::NotEnoughFunds(
+                        u128::from(fee),
+                        payer.stx_balance.get_available_balance_at_burn_block(
+                            block_height,
+                            v1_unlock_height,
+                            v2_unlock_height,
+                            v3_unlock_height,
+                        )?,
+                    ));
                 }
             }
             TransactionPayload::ContractCall(TransactionContractCall {

stackslib/src/chainstate/stacks/index/mod.rs

@@ -333,10 +333,7 @@ impl error::Error for Error {
             Error::IOError(ref e) => Some(e),
             Error::SQLError(ref e) => Some(e),
             Error::RestoreMarfBlockError(ref e) => Some(e),
-            Error::BlockHashMapCorruptionError(ref opt_e) => match opt_e {
-                Some(ref e) => Some(e),
-                None => None,
-            },
+            Error::BlockHashMapCorruptionError(Some(ref e)) => Some(e),
             _ => None,
         }
     }