diff --git a/bucket_map/src/bucket.rs b/bucket_map/src/bucket.rs index 55d5833bf1..f3d1e44042 100644 --- a/bucket_map/src/bucket.rs +++ b/bucket_map/src/bucket.rs @@ -733,14 +733,11 @@ impl<'b, T: Clone + Copy + 'static> Bucket { pub fn insert(&mut self, key: &Pubkey, value: (&[T], RefCount)) { let (new, refct) = value; loop { - let rv = self.try_write(key, new.iter(), new.len(), refct); - match rv { - Ok(_) => return, - Err(err) => { - self.grow(err); - self.handle_delayed_grows(); - } - } + let Err(err) = self.try_write(key, new.iter(), new.len(), refct) else { + return; + }; + self.grow(err); + self.handle_delayed_grows(); } } diff --git a/ci/test-checks.sh b/ci/test-checks.sh index 86fc49e0c1..029df388bc 100755 --- a/ci/test-checks.sh +++ b/ci/test-checks.sh @@ -90,6 +90,7 @@ _ scripts/cargo-for-all-lock-files.sh -- "+${rust_nightly}" clippy --workspace - --deny=warnings \ --deny=clippy::default_trait_access \ --deny=clippy::integer_arithmetic \ + --deny=clippy::manual_let_else \ --deny=clippy::used_underscore_binding \ "${nightly_clippy_allows[@]}" @@ -103,6 +104,7 @@ _ scripts/cargo-for-all-lock-files.sh -- clippy --workspace --tests --bins --ex --deny=warnings \ --deny=clippy::default_trait_access \ --deny=clippy::integer_arithmetic \ + --deny=clippy::manual_let_else \ --deny=clippy::used_underscore_binding if [[ -n $CI ]]; then diff --git a/core/src/cluster_info_vote_listener.rs b/core/src/cluster_info_vote_listener.rs index 13a7f99127..30fcab28a7 100644 --- a/core/src/cluster_info_vote_listener.rs +++ b/core/src/cluster_info_vote_listener.rs @@ -447,17 +447,14 @@ impl ClusterInfoVoteListener { verified_packets_sender: &BankingPacketSender, verified_vote_packets: &VerifiedVotePackets, ) -> Result<()> { - let current_working_bank = match current_working_bank { - Some(current_working_bank) => current_working_bank, - None => { - // We are not the leader! - if let Some(bank_vote_sender_state) = bank_vote_sender_state_option { - // This ensures we report the last slot's metrics - bank_vote_sender_state.report_metrics(); - *bank_vote_sender_state_option = None; - } - return Ok(()); + let Some(current_working_bank) = current_working_bank else { + // We are not the leader! + if let Some(bank_vote_sender_state) = bank_vote_sender_state_option { + // This ensures we report the last slot's metrics + bank_vote_sender_state.report_metrics(); + *bank_vote_sender_state_option = None; } + return Ok(()); }; // We will take this lock at most once every `BANK_SEND_VOTES_LOOP_SLEEP_MS` if let Some(bank_vote_sender_state) = bank_vote_sender_state_option { diff --git a/core/src/cluster_slots_service/cluster_slots.rs b/core/src/cluster_slots_service/cluster_slots.rs index 10b0291dbc..137e153a7a 100644 --- a/core/src/cluster_slots_service/cluster_slots.rs +++ b/core/src/cluster_slots_service/cluster_slots.rs @@ -186,9 +186,8 @@ impl ClusterSlots { }) .collect() }; - let slot_peers = match self.lookup(slot) { - None => return stakes, - Some(slot_peers) => slot_peers, + let Some(slot_peers) = self.lookup(slot) else { + return stakes; }; let slot_peers = slot_peers.read().unwrap(); repair_peers diff --git a/core/src/consensus.rs b/core/src/consensus.rs index db03bb7a49..7b2622ac3f 100644 --- a/core/src/consensus.rs +++ b/core/src/consensus.rs @@ -746,9 +746,8 @@ impl Tower { latest_validator_votes_for_frozen_banks: &LatestValidatorVotesForFrozenBanks, heaviest_subtree_fork_choice: &HeaviestSubtreeForkChoice, ) -> SwitchForkDecision { - let (last_voted_slot, last_voted_hash) = match self.last_voted_slot_hash() { - None => return SwitchForkDecision::SameFork, - Some(slot_hash) => slot_hash, + let Some((last_voted_slot, last_voted_hash)) = self.last_voted_slot_hash() else { + return SwitchForkDecision::SameFork; }; let root = self.root(); let empty_ancestors = HashSet::default(); diff --git a/core/src/repair/ancestor_hashes_service.rs b/core/src/repair/ancestor_hashes_service.rs index a66544c28c..e5d24df75b 100644 --- a/core/src/repair/ancestor_hashes_service.rs +++ b/core/src/repair/ancestor_hashes_service.rs @@ -358,31 +358,22 @@ impl AncestorHashesService { ancestor_socket: &UdpSocket, ) -> Option { let from_addr = packet.meta().socket_addr(); - let packet_data = match packet.data(..) { - Some(data) => data, - None => { - stats.invalid_packets += 1; - return None; - } + let Some(packet_data) = packet.data(..) else { + stats.invalid_packets += 1; + return None; }; let mut cursor = Cursor::new(packet_data); - let response = match deserialize_from_with_limit(&mut cursor) { - Ok(response) => response, - Err(_) => { - stats.invalid_packets += 1; - return None; - } + let Ok(response) = deserialize_from_with_limit(&mut cursor) else { + stats.invalid_packets += 1; + return None; }; match response { AncestorHashesResponse::Hashes(ref hashes) => { // deserialize trailing nonce - let nonce = match deserialize_from_with_limit(&mut cursor) { - Ok(nonce) => nonce, - Err(_) => { - stats.invalid_packets += 1; - return None; - } + let Ok(nonce) = deserialize_from_with_limit(&mut cursor) else { + stats.invalid_packets += 1; + return None; }; // verify that packet does not contain extraneous data diff --git a/core/src/repair/duplicate_repair_status.rs b/core/src/repair/duplicate_repair_status.rs index 69b9b1f2eb..9d58a5c682 100644 --- a/core/src/repair/duplicate_repair_status.rs +++ b/core/src/repair/duplicate_repair_status.rs @@ -884,10 +884,9 @@ pub mod tests { // We don't have the earlier ancestors because we just started up, however sample should // not be rejected as invalid. - let DuplicateAncestorDecision::EarliestMismatchFound(repair_status) = run_add_multiple_correct_and_incorrect_responses( - vec![], - &mut test_setup, - ) else { + let DuplicateAncestorDecision::EarliestMismatchFound(repair_status) = + run_add_multiple_correct_and_incorrect_responses(vec![], &mut test_setup) + else { panic!("Incorrect decision") }; assert_eq!( @@ -938,10 +937,12 @@ pub mod tests { )]; // We have no entries in the blockstore, so all the ancestors will be missing - let DuplicateAncestorDecision::EarliestMismatchFound(repair_status) = run_add_multiple_correct_and_incorrect_responses( - desired_incorrect_responses, - &mut test_setup, - ) else { + let DuplicateAncestorDecision::EarliestMismatchFound(repair_status) = + run_add_multiple_correct_and_incorrect_responses( + desired_incorrect_responses, + &mut test_setup, + ) + else { panic!("Incorrect decision") }; assert_eq!( @@ -1089,10 +1090,9 @@ pub mod tests { } // All the ancestors matched, only the requested slot should be dumped - let DuplicateAncestorDecision::EarliestMismatchFound(repair_status) = run_add_multiple_correct_and_incorrect_responses( - vec![], - &mut test_setup, - ) else { + let DuplicateAncestorDecision::EarliestMismatchFound(repair_status) = + run_add_multiple_correct_and_incorrect_responses(vec![], &mut test_setup) + else { panic!("Incorrect decision") }; assert_eq!( @@ -1133,10 +1133,9 @@ pub mod tests { .add_tree(tree, true, true, 2, Hash::default()); // All the ancestors matched, only the requested slot should be dumped - let DuplicateAncestorDecision::EarliestPrunedMismatchFound(repair_status) = run_add_multiple_correct_and_incorrect_responses( - vec![], - &mut test_setup, - ) else { + let DuplicateAncestorDecision::EarliestPrunedMismatchFound(repair_status) = + run_add_multiple_correct_and_incorrect_responses(vec![], &mut test_setup) + else { panic!("Incorrect decision") }; assert_eq!( diff --git a/core/src/repair/serve_repair.rs b/core/src/repair/serve_repair.rs index 735804a910..b7b48cdfc0 100644 --- a/core/src/repair/serve_repair.rs +++ b/core/src/repair/serve_repair.rs @@ -867,25 +867,19 @@ impl ServeRepair { if u128::from(time_diff_ms) > SIGNED_REPAIR_TIME_WINDOW.as_millis() { return Err(Error::from(RepairVerifyError::TimeSkew)); } - let leading_buf = match packet.data(..4) { - Some(buf) => buf, - None => { - debug_assert!( - false, - "request should have failed deserialization: {request:?}", - ); - return Err(Error::from(RepairVerifyError::Malformed)); - } + let Some(leading_buf) = packet.data(..4) else { + debug_assert!( + false, + "request should have failed deserialization: {request:?}", + ); + return Err(Error::from(RepairVerifyError::Malformed)); }; - let trailing_buf = match packet.data(4 + SIGNATURE_BYTES..) { - Some(buf) => buf, - None => { - debug_assert!( - false, - "request should have failed deserialization: {request:?}", - ); - return Err(Error::from(RepairVerifyError::Malformed)); - } + let Some(trailing_buf) = packet.data(4 + SIGNATURE_BYTES..) else { + debug_assert!( + false, + "request should have failed deserialization: {request:?}", + ); + return Err(Error::from(RepairVerifyError::Malformed)); }; let from_id = request.sender(); let signed_data = [leading_buf, trailing_buf].concat(); @@ -978,11 +972,10 @@ impl ServeRepair { } } stats.processed += 1; - let rsp = match Self::handle_repair( - recycler, &from_addr, blockstore, request, stats, ping_cache, - ) { - None => continue, - Some(rsp) => rsp, + let Some(rsp) = + Self::handle_repair(recycler, &from_addr, blockstore, request, stats, ping_cache) + else { + continue; }; let num_response_packets = rsp.len(); let num_response_bytes = rsp.iter().map(|p| p.meta().size).sum(); diff --git a/core/src/replay_stage.rs b/core/src/replay_stage.rs index a03bb69b18..03e6c43ca9 100644 --- a/core/src/replay_stage.rs +++ b/core/src/replay_stage.rs @@ -2272,17 +2272,14 @@ impl ReplayStage { return None; } - let authorized_voter_pubkey = - if let Some(authorized_voter_pubkey) = vote_state.get_authorized_voter(bank.epoch()) { - authorized_voter_pubkey - } else { - warn!( - "Vote account {} has no authorized voter for epoch {}. Unable to vote", - vote_account_pubkey, - bank.epoch() - ); - return None; - }; + let Some(authorized_voter_pubkey) = vote_state.get_authorized_voter(bank.epoch()) else { + warn!( + "Vote account {} has no authorized voter for epoch {}. Unable to vote", + vote_account_pubkey, + bank.epoch() + ); + return None; + }; let authorized_voter_keypair = match authorized_voter_keypairs .iter() diff --git a/entry/src/entry.rs b/entry/src/entry.rs index 351c74b9b3..e0dc22adb0 100644 --- a/entry/src/entry.rs +++ b/entry/src/entry.rs @@ -782,9 +782,8 @@ impl EntrySlice for [Entry] { recyclers: VerifyRecyclers, ) -> EntryVerificationState { let start = Instant::now(); - let api = match perf_libs::api() { - None => return self.verify_cpu(start_hash), - Some(api) => api, + let Some(api) = perf_libs::api() else { + return self.verify_cpu(start_hash); }; inc_new_counter_info!("entry_verify-num_entries", self.len()); diff --git a/genesis/src/main.rs b/genesis/src/main.rs index fb6b3de347..875655d42b 100644 --- a/genesis/src/main.rs +++ b/genesis/src/main.rs @@ -531,9 +531,8 @@ fn main() -> Result<(), Box> { let mut bootstrap_validator_pubkeys_iter = bootstrap_validator_pubkeys.iter(); loop { - let identity_pubkey = match bootstrap_validator_pubkeys_iter.next() { - None => break, - Some(identity_pubkey) => identity_pubkey, + let Some(identity_pubkey) = bootstrap_validator_pubkeys_iter.next() else { + break; }; let vote_pubkey = bootstrap_validator_pubkeys_iter.next().unwrap(); let stake_pubkey = bootstrap_validator_pubkeys_iter.next().unwrap(); diff --git a/gossip/src/cluster_info.rs b/gossip/src/cluster_info.rs index abff856a15..f3bccbf3a8 100644 --- a/gossip/src/cluster_info.rs +++ b/gossip/src/cluster_info.rs @@ -1412,9 +1412,8 @@ impl ClusterInfo { const THROTTLE_DELAY: u64 = CRDS_GOSSIP_PULL_CRDS_TIMEOUT_MS / 2; let entrypoint = { let mut entrypoints = self.entrypoints.write().unwrap(); - let entrypoint = match entrypoints.choose_mut(&mut rand::thread_rng()) { - Some(entrypoint) => entrypoint, - None => return, + let Some(entrypoint) = entrypoints.choose_mut(&mut rand::thread_rng()) else { + return; }; if !pulls.is_empty() { let now = timestamp(); diff --git a/gossip/src/contact_info.rs b/gossip/src/contact_info.rs index 42a079ab10..617328abe5 100644 --- a/gossip/src/contact_info.rs +++ b/gossip/src/contact_info.rs @@ -428,13 +428,11 @@ impl TryFrom for ContactInfo { let mut port = 0u16; for &SocketEntry { key, index, offset } in &node.sockets { port += offset; - let entry = match node.cache.get_mut(usize::from(key)) { - None => continue, - Some(entry) => entry, + let Some(entry) = node.cache.get_mut(usize::from(key)) else { + continue; }; - let addr = match node.addrs.get(usize::from(index)) { - None => continue, - Some(&addr) => addr, + let Some(&addr) = node.addrs.get(usize::from(index)) else { + continue; }; let socket = SocketAddr::new(addr, port); if sanitize_socket(&socket).is_ok() { diff --git a/gossip/src/crds.rs b/gossip/src/crds.rs index 429cd88045..a4ab600e16 100644 --- a/gossip/src/crds.rs +++ b/gossip/src/crds.rs @@ -518,9 +518,8 @@ impl Crds { } pub fn remove(&mut self, key: &CrdsValueLabel, now: u64) { - let (index, _ /*label*/, value) = match self.table.swap_remove_full(key) { - Some(entry) => entry, - None => return, + let Some((index, _ /*label*/, value)) = self.table.swap_remove_full(key) else { + return; }; self.purged.push_back((value.value_hash, now)); self.shards.remove(index, &value); diff --git a/gossip/src/crds_gossip.rs b/gossip/src/crds_gossip.rs index e064c0a5ca..6ab52edd26 100644 --- a/gossip/src/crds_gossip.rs +++ b/gossip/src/crds_gossip.rs @@ -405,9 +405,8 @@ pub(crate) fn maybe_ping_gossip_addresses( nodes .into_iter() .filter(|node| { - let node_gossip = match node.gossip() { - Err(_) => return false, - Ok(addr) => addr, + let Ok(node_gossip) = node.gossip() else { + return false; }; let (check, ping) = { let node = (*node.pubkey(), node_gossip); diff --git a/gossip/src/crds_value.rs b/gossip/src/crds_value.rs index d907f1cb93..82e53d32fa 100644 --- a/gossip/src/crds_value.rs +++ b/gossip/src/crds_value.rs @@ -462,9 +462,8 @@ impl NodeInstance { // the same owner. Otherwise returns true if self has more recent timestamp // than other, and so overrides it. pub(crate) fn overrides(&self, other: &CrdsValue) -> Option { - let other = match &other.data { - CrdsData::NodeInstance(other) => other, - _ => return None, + let CrdsData::NodeInstance(other) = &other.data else { + return None; }; if self.token == other.token || self.from != other.from { return None; diff --git a/ledger-tool/src/main.rs b/ledger-tool/src/main.rs index 5a63c537e2..6843ddeeb2 100644 --- a/ledger-tool/src/main.rs +++ b/ledger-tool/src/main.rs @@ -3016,10 +3016,9 @@ fn main() { let mut bootstrap_validator_pubkeys_iter = bootstrap_validator_pubkeys.iter(); loop { - let identity_pubkey = match bootstrap_validator_pubkeys_iter.next() - { - None => break, - Some(identity_pubkey) => identity_pubkey, + let Some(identity_pubkey) = bootstrap_validator_pubkeys_iter.next() + else { + break; }; let vote_pubkey = bootstrap_validator_pubkeys_iter.next().unwrap(); let stake_pubkey = bootstrap_validator_pubkeys_iter.next().unwrap(); diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs index dfa2e58e68..d7acbfd816 100644 --- a/ledger/src/blockstore.rs +++ b/ledger/src/blockstore.rs @@ -1966,12 +1966,9 @@ impl Blockstore { require_previous_blockhash: bool, ) -> Result { let slot_meta_cf = self.db.column::(); - let slot_meta = match slot_meta_cf.get(slot)? { - Some(slot_meta) => slot_meta, - None => { - info!("SlotMeta not found for slot {}", slot); - return Err(BlockstoreError::SlotUnavailable); - } + let Some(slot_meta) = slot_meta_cf.get(slot)? else { + info!("SlotMeta not found for slot {}", slot); + return Err(BlockstoreError::SlotUnavailable); }; if slot_meta.is_full() { let slot_entries = self.get_slot_entries(slot, 0)?; diff --git a/ledger/src/blockstore_meta.rs b/ledger/src/blockstore_meta.rs index 71755b3ac5..b638a8b448 100644 --- a/ledger/src/blockstore_meta.rs +++ b/ledger/src/blockstore_meta.rs @@ -345,9 +345,8 @@ impl ErasureMeta { // Returns true if the erasure fields on the shred // are consistent with the erasure-meta. pub(crate) fn check_coding_shred(&self, shred: &Shred) -> bool { - let mut other = match Self::from_coding_shred(shred) { - Some(erasure_meta) => erasure_meta, - None => return false, + let Some(mut other) = Self::from_coding_shred(shred) else { + return false; }; other.__unused_size = self.__unused_size; self == &other diff --git a/ledger/src/shred.rs b/ledger/src/shred.rs index ca6bd55837..479a0e3a46 100644 --- a/ledger/src/shred.rs +++ b/ledger/src/shred.rs @@ -586,9 +586,8 @@ pub mod layout { } pub(super) fn get_shred_variant(shred: &[u8]) -> Result { - let shred_variant = match shred.get(OFFSET_OF_SHRED_VARIANT) { - None => return Err(Error::InvalidPayloadSize(shred.len())), - Some(shred_variant) => *shred_variant, + let Some(&shred_variant) = shred.get(OFFSET_OF_SHRED_VARIANT) else { + return Err(Error::InvalidPayloadSize(shred.len())); }; ShredVariant::try_from(shred_variant).map_err(|_| Error::InvalidShredVariant) } @@ -673,9 +672,8 @@ pub mod layout { if get_shred_type(shred)? != ShredType::Data { return Err(Error::InvalidShredType); } - let flags = match shred.get(85) { - None => return Err(Error::InvalidPayloadSize(shred.len())), - Some(flags) => flags, + let Some(flags) = shred.get(85) else { + return Err(Error::InvalidPayloadSize(shred.len())); }; Ok(flags & ShredFlags::SHRED_TICK_REFERENCE_MASK.bits()) } @@ -915,12 +913,9 @@ pub fn should_discard_shred( } } } - let shred_variant = match layout::get_shred_variant(shred) { - Ok(shred_variant) => shred_variant, - Err(_) => { - stats.bad_shred_type += 1; - return true; - } + let Ok(shred_variant) = layout::get_shred_variant(shred) else { + stats.bad_shred_type += 1; + return true; }; let slot = match layout::get_slot(shred) { Some(slot) => { @@ -935,12 +930,9 @@ pub fn should_discard_shred( return true; } }; - let index = match layout::get_index(shred) { - Some(index) => index, - None => { - stats.index_bad_deserialize += 1; - return true; - } + let Some(index) = layout::get_index(shred) else { + stats.index_bad_deserialize += 1; + return true; }; match ShredType::from(shred_variant) { ShredType::Code => { @@ -958,19 +950,13 @@ pub fn should_discard_shred( stats.index_out_of_bounds += 1; return true; } - let parent_offset = match layout::get_parent_offset(shred) { - Some(parent_offset) => parent_offset, - None => { - stats.bad_parent_offset += 1; - return true; - } + let Some(parent_offset) = layout::get_parent_offset(shred) else { + stats.bad_parent_offset += 1; + return true; }; - let parent = match slot.checked_sub(Slot::from(parent_offset)) { - Some(parent) => parent, - None => { - stats.bad_parent_offset += 1; - return true; - } + let Some(parent) = slot.checked_sub(Slot::from(parent_offset)) else { + stats.bad_parent_offset += 1; + return true; }; if !blockstore::verify_shred_slots(slot, parent, root) { stats.slot_out_of_range += 1; diff --git a/ledger/src/shred/merkle.rs b/ledger/src/shred/merkle.rs index 10646edd39..046e81adec 100644 --- a/ledger/src/shred/merkle.rs +++ b/ledger/src/shred/merkle.rs @@ -186,9 +186,8 @@ impl ShredData { // Deserialize headers. let mut cursor = Cursor::new(&shard[..]); let common_header: ShredCommonHeader = deserialize_from_with_limit(&mut cursor)?; - let proof_size = match common_header.shred_variant { - ShredVariant::MerkleData(proof_size) => proof_size, - _ => return Err(Error::InvalidShredVariant), + let ShredVariant::MerkleData(proof_size) = common_header.shred_variant else { + return Err(Error::InvalidShredVariant); }; if ShredCode::capacity(proof_size)? != shard_size { return Err(Error::InvalidShardSize(shard_size)); @@ -293,9 +292,8 @@ impl ShredCode { coding_header: CodingShredHeader, mut shard: Vec, ) -> Result { - let proof_size = match common_header.shred_variant { - ShredVariant::MerkleCode(proof_size) => proof_size, - _ => return Err(Error::InvalidShredVariant), + let ShredVariant::MerkleCode(proof_size) = common_header.shred_variant else { + return Err(Error::InvalidShredVariant); }; let shard_size = shard.len(); if Self::capacity(proof_size)? != shard_size { @@ -630,9 +628,8 @@ pub(super) fn recover( ) -> Result, Error> { // Grab {common, coding} headers from first coding shred. let headers = shreds.iter().find_map(|shred| { - let shred = match shred { - Shred::ShredCode(shred) => shred, - Shred::ShredData(_) => return None, + let Shred::ShredCode(shred) = shred else { + return None; }; let position = u32::from(shred.coding_header.position); let common_header = ShredCommonHeader { diff --git a/ledger/src/sigverify_shreds.rs b/ledger/src/sigverify_shreds.rs index 5f315c0670..a73969c1bb 100644 --- a/ledger/src/sigverify_shreds.rs +++ b/ledger/src/sigverify_shreds.rs @@ -34,27 +34,22 @@ pub fn verify_shred_cpu( if packet.meta().discard() { return false; } - let shred = match shred::layout::get_shred(packet) { - None => return false, - Some(shred) => shred, + let Some(shred) = shred::layout::get_shred(packet) else { + return false; }; - let slot = match shred::layout::get_slot(shred) { - None => return false, - Some(slot) => slot, + let Some(slot) = shred::layout::get_slot(shred) else { + return false; }; trace!("slot {}", slot); - let pubkey = match slot_leaders.get(&slot) { - None => return false, - Some(pubkey) => pubkey, + let Some(pubkey) = slot_leaders.get(&slot) else { + return false; }; - let signature = match shred::layout::get_signature(shred) { - None => return false, - Some(signature) => signature, + let Some(signature) = shred::layout::get_signature(shred) else { + return false; }; trace!("signature {}", signature); - let data = match shred::layout::get_signed_data(shred) { - None => return false, - Some(data) => data, + let Some(data) = shred::layout::get_signed_data(shred) else { + return false; }; signature.verify(pubkey, data.as_ref()) } @@ -255,9 +250,8 @@ pub fn verify_shreds_gpu( slot_leaders: &HashMap, recycler_cache: &RecyclerCache, ) -> Vec> { - let api = match perf_libs::api() { - None => return verify_shreds_cpu(thread_pool, batches, slot_leaders), - Some(api) => api, + let Some(api) = perf_libs::api() else { + return verify_shreds_cpu(thread_pool, batches, slot_leaders); }; let (pubkeys, pubkey_offsets) = slot_key_data_for_gpu(thread_pool, batches, slot_leaders, recycler_cache); @@ -378,9 +372,8 @@ pub fn sign_shreds_gpu( if packet_count < SIGN_SHRED_GPU_MIN || pinned_keypair.is_none() { return sign_shreds_cpu(thread_pool, keypair, batches); } - let api = match perf_libs::api() { - None => return sign_shreds_cpu(thread_pool, keypair, batches), - Some(api) => api, + let Some(api) = perf_libs::api() else { + return sign_shreds_cpu(thread_pool, keypair, batches); }; let pinned_keypair = pinned_keypair.as_ref().unwrap(); diff --git a/perf/src/sigverify.rs b/perf/src/sigverify.rs index b7f04f7b9e..4cdb6c5f8b 100644 --- a/perf/src/sigverify.rs +++ b/perf/src/sigverify.rs @@ -131,21 +131,17 @@ fn verify_packet(packet: &mut Packet, reject_non_vote: bool) -> bool { for _ in 0..packet_offsets.sig_len { let pubkey_end = pubkey_start.saturating_add(size_of::()); - let sig_end = match sig_start.checked_add(size_of::()) { - Some(sig_end) => sig_end, - None => return false, + let Some(sig_end) = sig_start.checked_add(size_of::()) else { + return false; }; - let signature = match packet.data(sig_start..sig_end) { - Some(signature) => Signature::new(signature), - None => return false, + let Some(signature) = packet.data(sig_start..sig_end).map(Signature::new) else { + return false; }; - let pubkey = match packet.data(pubkey_start..pubkey_end) { - Some(pubkey) => pubkey, - None => return false, + let Some(pubkey) = packet.data(pubkey_start..pubkey_end) else { + return false; }; - let message = match packet.data(msg_start..) { - Some(message) => message, - None => return false, + let Some(message) = packet.data(msg_start..) else { + return false; }; if !signature.verify(pubkey, message) { return false; @@ -317,9 +313,8 @@ fn do_get_packet_offsets( pub fn check_for_tracer_packet(packet: &mut Packet) -> bool { let first_pubkey_start: usize = TRACER_KEY_OFFSET_IN_TRANSACTION; - let first_pubkey_end = match first_pubkey_start.checked_add(size_of::()) { - Some(offset) => offset, - None => return false, + let Some(first_pubkey_end) = first_pubkey_start.checked_add(size_of::()) else { + return false; }; // Check for tracer pubkey match packet.data(first_pubkey_start..first_pubkey_end) { @@ -610,9 +605,8 @@ pub fn ed25519_verify( reject_non_vote: bool, valid_packet_count: usize, ) { - let api = match perf_libs::api() { - None => return ed25519_verify_cpu(batches, reject_non_vote, valid_packet_count), - Some(api) => api, + let Some(api) = perf_libs::api() else { + return ed25519_verify_cpu(batches, reject_non_vote, valid_packet_count); }; let total_packet_count = count_packets_in_batches(batches); // micro-benchmarks show GPU time for smallest batch around 15-20ms diff --git a/program-runtime/src/log_collector.rs b/program-runtime/src/log_collector.rs index 57ac1cede6..ead575ddfb 100644 --- a/program-runtime/src/log_collector.rs +++ b/program-runtime/src/log_collector.rs @@ -23,12 +23,9 @@ impl Default for LogCollector { impl LogCollector { pub fn log(&mut self, message: &str) { - let limit = match self.bytes_limit { - Some(limit) => limit, - None => { - self.messages.push(message.to_string()); - return; - } + let Some(limit) = self.bytes_limit else { + self.messages.push(message.to_string()); + return; }; let bytes_written = self.bytes_written.saturating_add(message.len()); diff --git a/programs/bpf_loader/src/syscalls/mod.rs b/programs/bpf_loader/src/syscalls/mod.rs index 1a4aea1564..246b03e9d2 100644 --- a/programs/bpf_loader/src/syscalls/mod.rs +++ b/programs/bpf_loader/src/syscalls/mod.rs @@ -549,11 +549,8 @@ declare_syscall!( } else { align_of::() }; - let layout = match Layout::from_size_align(size as usize, align) { - Ok(layout) => layout, - Err(_) => { - return Ok(0); - } + let Ok(layout) = Layout::from_size_align(size as usize, align) else { + return Ok(0); }; let allocator = &mut invoke_context.get_syscall_context_mut()?.allocator; if free_addr == 0 { @@ -631,11 +628,8 @@ declare_syscall!( invoke_context.get_check_size(), )?; - let new_address = match Pubkey::create_program_address(&seeds, program_id) { - Ok(address) => address, - Err(_) => { - return Ok(1); - } + let Ok(new_address) = Pubkey::create_program_address(&seeds, program_id) else { + return Ok(1); }; let address = translate_slice_mut::( memory_mapping, @@ -879,23 +873,14 @@ declare_syscall!( invoke_context.get_check_size(), )?; - let message = match libsecp256k1::Message::parse_slice(hash) { - Ok(msg) => msg, - Err(_) => { - return Ok(Secp256k1RecoverError::InvalidHash.into()); - } + let Ok(message) = libsecp256k1::Message::parse_slice(hash) else { + return Ok(Secp256k1RecoverError::InvalidHash.into()); }; - let adjusted_recover_id_val = match recovery_id_val.try_into() { - Ok(adjusted_recover_id_val) => adjusted_recover_id_val, - Err(_) => { - return Ok(Secp256k1RecoverError::InvalidRecoveryId.into()); - } + let Ok(adjusted_recover_id_val) = recovery_id_val.try_into() else { + return Ok(Secp256k1RecoverError::InvalidRecoveryId.into()); }; - let recovery_id = match libsecp256k1::RecoveryId::parse(adjusted_recover_id_val) { - Ok(id) => id, - Err(_) => { - return Ok(Secp256k1RecoverError::InvalidRecoveryId.into()); - } + let Ok(recovery_id) = libsecp256k1::RecoveryId::parse(adjusted_recover_id_val) else { + return Ok(Secp256k1RecoverError::InvalidRecoveryId.into()); }; let sig_parse_result = if invoke_context .feature_set @@ -906,11 +891,8 @@ declare_syscall!( libsecp256k1::Signature::parse_overflowing_slice(signature) }; - let signature = match sig_parse_result { - Ok(sig) => sig, - Err(_) => { - return Ok(Secp256k1RecoverError::InvalidSignature.into()); - } + let Ok(signature) = sig_parse_result else { + return Ok(Secp256k1RecoverError::InvalidSignature.into()); }; let public_key = match libsecp256k1::recover(&message, &signature, &recovery_id) { diff --git a/programs/config/src/config_processor.rs b/programs/config/src/config_processor.rs index 3851d81524..628e77cb93 100644 --- a/programs/config/src/config_processor.rs +++ b/programs/config/src/config_processor.rs @@ -206,13 +206,13 @@ mod tests { let instructions = config_instruction::create_account::(&from_pubkey, &config_pubkey, 1, keys); let system_instruction = limited_deserialize(&instructions[0].data).unwrap(); - let space = match system_instruction { - SystemInstruction::CreateAccount { - lamports: _, - space, - owner: _, - } => space, - _ => panic!("Not a CreateAccount system instruction"), + let SystemInstruction::CreateAccount { + lamports: _, + space, + owner: _, + } = system_instruction + else { + panic!("Not a CreateAccount system instruction") }; let config_account = AccountSharedData::new(0, space as usize, &id()); let accounts = process_instruction( diff --git a/programs/sbf/tests/programs.rs b/programs/sbf/tests/programs.rs index 7894ee4ba8..373c7c3e1f 100644 --- a/programs/sbf/tests/programs.rs +++ b/programs/sbf/tests/programs.rs @@ -2464,11 +2464,11 @@ fn test_program_sbf_upgrade_via_cpi() { .advance_slot(1, &Pubkey::default()) .expect("Failed to advance the slot"); let program_account = bank_client.get_account(&program_id).unwrap().unwrap(); - let programdata_address = match program_account.state() { - Ok(bpf_loader_upgradeable::UpgradeableLoaderState::Program { - programdata_address, - }) => programdata_address, - _ => unreachable!(), + let Ok(bpf_loader_upgradeable::UpgradeableLoaderState::Program { + programdata_address, + }) = program_account.state() + else { + unreachable!() }; let original_programdata = bank_client .get_account_data(&programdata_address) diff --git a/rpc/src/rpc.rs b/rpc/src/rpc.rs index 48324ad0c1..e177a82c97 100644 --- a/rpc/src/rpc.rs +++ b/rpc/src/rpc.rs @@ -552,15 +552,13 @@ impl JsonRpcRequestProcessor { slot: first_slot_in_epoch, })?; - let first_confirmed_block = if let Ok(Some(first_confirmed_block)) = self + let Ok(Some(first_confirmed_block)) = self .get_block( first_confirmed_block_in_epoch, Some(RpcBlockConfig::rewards_with_commitment(config.commitment).into()), ) .await - { - first_confirmed_block - } else { + else { return Err(RpcCustomError::BlockNotAvailable { slot: first_confirmed_block_in_epoch, } diff --git a/rpc/src/rpc_pubsub_service.rs b/rpc/src/rpc_pubsub_service.rs index 2dd7e20b86..99eab0a235 100644 --- a/rpc/src/rpc_pubsub_service.rs +++ b/rpc/src/rpc_pubsub_service.rs @@ -407,13 +407,10 @@ async fn handle_connection( } } } - let data_str = match str::from_utf8(&data) { - Ok(str) => str, - Err(_) => { - // Old implementation just closes the connection, so we preserve that behavior - // for now. It would be more correct to respond with an error. - break; - } + let Ok(data_str) = str::from_utf8(&data) else { + // Old implementation just closes the connection, so we preserve that behavior + // for now. It would be more correct to respond with an error. + break; }; if let Some(response) = json_rpc_handler.handle_request(data_str).await { diff --git a/runtime/src/accounts_db.rs b/runtime/src/accounts_db.rs index 28450dfbc2..73a0f57c2f 100644 --- a/runtime/src/accounts_db.rs +++ b/runtime/src/accounts_db.rs @@ -4474,16 +4474,13 @@ impl AccountsDb { let len = sorted_slots.len(); for slot in sorted_slots { - let old_storage = match self.get_storage_to_move_to_ancient_append_vec( + let Some(old_storage) = self.get_storage_to_move_to_ancient_append_vec( slot, &mut current_ancient, can_randomly_shrink, - ) { - Some(old_storages) => old_storages, - None => { - // nothing to squash for this slot - continue; - } + ) else { + // nothing to squash for this slot + continue; }; if guard.is_none() { diff --git a/runtime/src/bank.rs b/runtime/src/bank.rs index 3816312214..ed232549a8 100644 --- a/runtime/src/bank.rs +++ b/runtime/src/bank.rs @@ -2667,15 +2667,12 @@ impl Bank { if invalid_vote_keys.contains_key(vote_pubkey) { return; } - let stake_account = match self.get_account_with_fixed_root(stake_pubkey) { - Some(stake_account) => stake_account, - None => { + let Some(stake_account) = self.get_account_with_fixed_root(stake_pubkey) else { invalid_stake_keys .insert(*stake_pubkey, InvalidCacheEntryReason::Missing); invalid_cached_stake_accounts.fetch_add(1, Relaxed); return; - } - }; + }; if cached_stake_account.account() != &stake_account { if self.rc.accounts.accounts_db.assert_stakes_cache_consistency { panic!( @@ -2886,23 +2883,17 @@ impl Bank { }; let invalid_vote_keys = DashMap::::new(); let make_vote_delegations_entry = |vote_pubkey| { - let vote_account = match get_vote_account(&vote_pubkey) { - Some(vote_account) => vote_account, - None => { - invalid_vote_keys.insert(vote_pubkey, InvalidCacheEntryReason::Missing); - return None; - } + let Some(vote_account) = get_vote_account(&vote_pubkey) else { + invalid_vote_keys.insert(vote_pubkey, InvalidCacheEntryReason::Missing); + return None; }; if vote_account.owner() != &solana_vote_program { invalid_vote_keys.insert(vote_pubkey, InvalidCacheEntryReason::WrongOwner); return None; } - let vote_state = match vote_account.vote_state().cloned() { - Ok(vote_state) => vote_state, - Err(_) => { - invalid_vote_keys.insert(vote_pubkey, InvalidCacheEntryReason::BadState); - return None; - } + let Ok(vote_state) = vote_account.vote_state().cloned() else { + invalid_vote_keys.insert(vote_pubkey, InvalidCacheEntryReason::BadState); + return None; }; let vote_with_stake_delegations = VoteWithStakeDelegations { vote_state: Arc::new(vote_state), @@ -2921,11 +2912,11 @@ impl Bank { // Join stake accounts with vote-accounts. let push_stake_delegation = |(stake_pubkey, stake_account): (&Pubkey, &StakeAccount<_>)| { let delegation = stake_account.delegation(); - let mut vote_delegations = - match vote_with_stake_delegations_map.get_mut(&delegation.voter_pubkey) { - Some(vote_delegations) => vote_delegations, - None => return, - }; + let Some(mut vote_delegations) = + vote_with_stake_delegations_map.get_mut(&delegation.voter_pubkey) + else { + return; + }; if let Some(reward_calc_tracer) = reward_calc_tracer.as_ref() { let delegation = InflationPointCalculationEvent::Delegation(delegation, solana_vote_program); @@ -3233,20 +3224,14 @@ impl Bank { let delegation = stake_account.delegation(); let vote_pubkey = delegation.voter_pubkey; - let vote_account = match get_vote_account(&vote_pubkey) { - Some(vote_account) => vote_account, - None => { - return 0; - } + let Some(vote_account) = get_vote_account(&vote_pubkey) else { + return 0; }; if vote_account.owner() != &solana_vote_program { return 0; } - let vote_state = match vote_account.vote_state() { - Ok(vote_state) => vote_state, - Err(_) => { - return 0; - } + let Ok(vote_state) = vote_account.vote_state() else { + return 0; }; stake_state::calculate_points( @@ -3355,20 +3340,14 @@ impl Bank { let (mut stake_account, stake_state) = <(AccountSharedData, StakeState)>::from(stake_account); let vote_pubkey = delegation.voter_pubkey; - let vote_account = match get_vote_account(&vote_pubkey) { - Some(vote_account) => vote_account, - None => { - return None; - } + let Some(vote_account) = get_vote_account(&vote_pubkey) else { + return None; }; if vote_account.owner() != &solana_vote_program { return None; } - let vote_state = match vote_account.vote_state().cloned() { - Ok(vote_state) => vote_state, - Err(_) => { - return None; - } + let Ok(vote_state) = vote_account.vote_state().cloned() else { + return None; }; let pre_lamport = stake_account.lamports(); @@ -4866,9 +4845,7 @@ impl Bank { } pub fn load_program(&self, pubkey: &Pubkey) -> Arc { - let program = if let Some(program) = self.get_account_with_fixed_root(pubkey) { - program - } else { + let Some(program) = self.get_account_with_fixed_root(pubkey) else { return Arc::new(LoadedProgram::new_tombstone( self.slot, LoadedProgramType::Closed, diff --git a/runtime/src/hardened_unpack.rs b/runtime/src/hardened_unpack.rs index e016fa1cae..6d12e29db3 100644 --- a/runtime/src/hardened_unpack.rs +++ b/runtime/src/hardened_unpack.rs @@ -251,9 +251,8 @@ fn sanitize_path(entry_path: &Path, dst: &Path) -> Result> { } // Skip entries without a parent (i.e. outside of FS root) - let parent = match file_dst.parent() { - Some(p) => p, - None => return SKIP, + let Some(parent) = file_dst.parent() else { + return SKIP; }; fs::create_dir_all(parent)?; diff --git a/runtime/src/read_only_accounts_cache.rs b/runtime/src/read_only_accounts_cache.rs index 9956af64bb..0532a57059 100644 --- a/runtime/src/read_only_accounts_cache.rs +++ b/runtime/src/read_only_accounts_cache.rs @@ -72,12 +72,9 @@ impl ReadOnlyAccountsCache { pub(crate) fn load(&self, pubkey: Pubkey, slot: Slot) -> Option { let key = (pubkey, slot); - let mut entry = match self.cache.get_mut(&key) { - None => { - self.misses.fetch_add(1, Ordering::Relaxed); - return None; - } - Some(entry) => entry, + let Some(mut entry) = self.cache.get_mut(&key) else { + self.misses.fetch_add(1, Ordering::Relaxed); + return None; }; self.hits.fetch_add(1, Ordering::Relaxed); // Move the entry to the end of the queue. @@ -122,9 +119,8 @@ impl ReadOnlyAccountsCache { // Evict entries from the front of the queue. let mut num_evicts = 0; while self.data_size.load(Ordering::Relaxed) > self.max_data_size { - let (pubkey, slot) = match self.queue.lock().unwrap().get_first() { - None => break, - Some(key) => *key, + let Some(&(pubkey, slot)) = self.queue.lock().unwrap().get_first() else { + break; }; num_evicts += 1; self.remove(pubkey, slot); diff --git a/runtime/src/stakes.rs b/runtime/src/stakes.rs index 2919db702c..8d39f03cc5 100644 --- a/runtime/src/stakes.rs +++ b/runtime/src/stakes.rs @@ -216,9 +216,8 @@ impl Stakes { F: Fn(&Pubkey) -> Option, { let stake_delegations = stakes.stake_delegations.iter().map(|(pubkey, delegation)| { - let stake_account = match get_account(pubkey) { - None => return Err(Error::StakeAccountNotFound(*pubkey)), - Some(account) => account, + let Some(stake_account) = get_account(pubkey) else { + return Err(Error::StakeAccountNotFound(*pubkey)); }; let stake_account = StakeAccount::try_from(stake_account)?; // Sanity check that the delegation is consistent with what is @@ -231,9 +230,8 @@ impl Stakes { }); // Assert that cached vote accounts are consistent with accounts-db. for (pubkey, vote_account) in stakes.vote_accounts.iter() { - let account = match get_account(pubkey) { - None => return Err(Error::VoteAccountNotFound(*pubkey)), - Some(account) => account, + let Some(account) = get_account(pubkey) else { + return Err(Error::VoteAccountNotFound(*pubkey)); }; let vote_account = vote_account.account(); if vote_account != &account { @@ -250,9 +248,8 @@ impl Stakes { .filter(|voter_pubkey| stakes.vote_accounts.get(voter_pubkey).is_none()) .collect(); for pubkey in voter_pubkeys { - let account = match get_account(&pubkey) { - None => continue, - Some(account) => account, + let Some(account) = get_account(&pubkey) else { + continue; }; if VoteStateVersions::is_correct_size_and_initialized(account.data()) && VoteAccount::try_from(account.clone()).is_ok() diff --git a/runtime/src/vote_account.rs b/runtime/src/vote_account.rs index 87aa91c6f7..e5e8e1cbbf 100644 --- a/runtime/src/vote_account.rs +++ b/runtime/src/vote_account.rs @@ -179,9 +179,8 @@ impl VoteAccounts { if stake == 0u64 { return; } - let staked_nodes = match self.staked_nodes.get_mut() { - None => return, - Some(staked_nodes) => staked_nodes, + let Some(staked_nodes) = self.staked_nodes.get_mut() else { + return; }; if let Some(node_pubkey) = vote_account.node_pubkey() { Arc::make_mut(staked_nodes) @@ -195,9 +194,8 @@ impl VoteAccounts { if stake == 0u64 { return; } - let staked_nodes = match self.staked_nodes.get_mut() { - None => return, - Some(staked_nodes) => staked_nodes, + let Some(staked_nodes) = self.staked_nodes.get_mut() else { + return; }; if let Some(node_pubkey) = vote_account.node_pubkey() { match Arc::make_mut(staked_nodes).entry(node_pubkey) { diff --git a/sdk/cargo-build-sbf/src/main.rs b/sdk/cargo-build-sbf/src/main.rs index 7397e1642c..b91f82588a 100644 --- a/sdk/cargo-build-sbf/src/main.rs +++ b/sdk/cargo-build-sbf/src/main.rs @@ -339,9 +339,8 @@ fn postprocess_dump(program_dump: &Path) { let mut rel: HashMap = HashMap::new(); let mut name = String::from(""); let mut state = 0; - let file = match File::open(program_dump) { - Ok(x) => x, - _ => return, + let Ok(file) = File::open(program_dump) else { + return; }; for line_result in BufReader::new(file).lines() { let line = line_result.unwrap(); @@ -371,14 +370,12 @@ fn postprocess_dump(program_dump: &Path) { } } } - let file = match File::create(&postprocessed_dump) { - Ok(x) => x, - _ => return, + let Ok(file) = File::create(&postprocessed_dump) else { + return; }; let mut out = BufWriter::new(file); - let file = match File::open(program_dump) { - Ok(x) => x, - _ => return, + let Ok(file) = File::open(program_dump) else { + return; }; let mut pc = 0u64; let mut step = 0u64; @@ -426,9 +423,8 @@ fn postprocess_dump(program_dump: &Path) { // not known to the runtime and warn about them if any. fn check_undefined_symbols(config: &Config, program: &Path) { let syscalls_txt = config.sbf_sdk.join("syscalls.txt"); - let file = match File::open(syscalls_txt) { - Ok(x) => x, - _ => return, + let Ok(file) = File::open(syscalls_txt) else { + return; }; let mut syscalls = HashSet::new(); for line_result in BufReader::new(file).lines() { diff --git a/sdk/gen-headers/src/main.rs b/sdk/gen-headers/src/main.rs index 9d81438f14..d40143bdc7 100644 --- a/sdk/gen-headers/src/main.rs +++ b/sdk/gen-headers/src/main.rs @@ -44,17 +44,14 @@ fn main() { */ fn transform(inc: &PathBuf) { let inc_path = PathBuf::from(inc); - let filename = match inc_path.file_name() { - Some(f) => f, - None => return, + let Some(filename) = inc_path.file_name() else { + return; }; - let parent = match inc_path.parent() { - Some(f) => f, - None => return, + let Some(parent) = inc_path.parent() else { + return; }; - let parent = match parent.parent() { - Some(f) => f, - None => return, + let Some(parent) = parent.parent() else { + return; }; let mut header_path = PathBuf::from(parent); let mut filename = PathBuf::from(filename); diff --git a/sdk/program/src/serde_varint.rs b/sdk/program/src/serde_varint.rs index 6476a1f0cf..40872be07f 100644 --- a/sdk/program/src/serde_varint.rs +++ b/sdk/program/src/serde_varint.rs @@ -73,10 +73,9 @@ macro_rules! impl_var_int { let mut out = 0; let mut shift = 0u32; while shift < <$type>::BITS { - let byte = match seq.next_element::()? { - None => return Err(A::Error::custom("Invalid Sequence")), - Some(byte) => byte, - }; + let Some(byte) = seq.next_element::()? else { + return Err(A::Error::custom("Invalid Sequence")); + }; out |= ((byte & 0x7F) as Self) << shift; if byte & 0x80 == 0 { // Last byte should not have been truncated when it was diff --git a/sdk/program/src/vote/state/mod.rs b/sdk/program/src/vote/state/mod.rs index 3e39d2f4df..45e1f19c30 100644 --- a/sdk/program/src/vote/state/mod.rs +++ b/sdk/program/src/vote/state/mod.rs @@ -686,15 +686,11 @@ pub mod serde_compact_vote_state_update { let lockout_offsets = vote_state_update.lockouts.iter().scan( vote_state_update.root.unwrap_or_default(), |slot, lockout| { - let offset = match lockout.slot().checked_sub(*slot) { - None => return Some(Err(serde::ser::Error::custom("Invalid vote lockout"))), - Some(offset) => offset, + let Some(offset) = lockout.slot().checked_sub(*slot) else { + return Some(Err(serde::ser::Error::custom("Invalid vote lockout"))); }; - let confirmation_count = match u8::try_from(lockout.confirmation_count()) { - Ok(confirmation_count) => confirmation_count, - Err(_) => { - return Some(Err(serde::ser::Error::custom("Invalid confirmation count"))) - } + let Ok(confirmation_count) = u8::try_from(lockout.confirmation_count()) else { + return Some(Err(serde::ser::Error::custom("Invalid confirmation count"))); }; let lockout_offset = LockoutOffset { offset, diff --git a/sdk/src/account.rs b/sdk/src/account.rs index 0657a5b176..4d1bbf3e75 100644 --- a/sdk/src/account.rs +++ b/sdk/src/account.rs @@ -560,12 +560,11 @@ impl AccountSharedData { } pub fn set_data_from_slice(&mut self, new_data: &[u8]) { - let data = match Arc::get_mut(&mut self.data) { - // The buffer isn't shared, so we're going to memcpy in place. - Some(data) => data, + // If the buffer isn't shared, we're going to memcpy in place. + let Some(data) = Arc::get_mut(&mut self.data) else { // If the buffer is shared, the cheapest thing to do is to clone the // incoming slice and replace the buffer. - None => return self.set_data(new_data.to_vec()), + return self.set_data(new_data.to_vec()); }; let new_len = new_data.len(); diff --git a/streamer/src/nonblocking/quic.rs b/streamer/src/nonblocking/quic.rs index 02614bbd14..2f5b9471bb 100644 --- a/streamer/src/nonblocking/quic.rs +++ b/streamer/src/nonblocking/quic.rs @@ -796,9 +796,8 @@ async fn handle_chunk( stats.total_invalid_chunks.fetch_add(1, Ordering::Relaxed); return true; } - let end_of_chunk = match chunk.offset.checked_add(chunk_len) { - Some(end) => end, - None => return true, + let Some(end_of_chunk) = chunk.offset.checked_add(chunk_len) else { + return true; }; if end_of_chunk > PACKET_DATA_SIZE as u64 { stats @@ -819,10 +818,9 @@ async fn handle_chunk( if let Some(accum) = packet_accum.as_mut() { let offset = chunk.offset; - let end_of_chunk = match (chunk.offset as usize).checked_add(chunk.bytes.len()) - { - Some(end) => end, - None => return true, + let Some(end_of_chunk) = (chunk.offset as usize).checked_add(chunk.bytes.len()) + else { + return true; }; accum.chunks.push(PacketChunk { bytes: chunk.bytes, diff --git a/test-validator/src/lib.rs b/test-validator/src/lib.rs index 29868bb019..56c3d5bd02 100644 --- a/test-validator/src/lib.rs +++ b/test-validator/src/lib.rs @@ -367,9 +367,8 @@ impl TestValidatorGenesis { accounts: &[AccountInfo], ) -> Result<&mut Self, String> { for account in accounts { - let account_path = match solana_program_test::find_file(account.filename) { - Some(path) => path, - None => return Err(format!("Unable to locate {}", account.filename)), + let Some(account_path) = solana_program_test::find_file(account.filename) else { + return Err(format!("Unable to locate {}", account.filename)); }; let mut file = File::open(&account_path).unwrap(); let mut account_info_raw = String::new(); diff --git a/turbine/src/broadcast_stage/broadcast_utils.rs b/turbine/src/broadcast_stage/broadcast_utils.rs index fe4c28b6ad..66cf942da6 100644 --- a/turbine/src/broadcast_stage/broadcast_utils.rs +++ b/turbine/src/broadcast_stage/broadcast_utils.rs @@ -42,9 +42,8 @@ pub(super) fn recv_slot_entries(receiver: &Receiver) -> Result // Drain channel while last_tick_height != bank.max_tick_height() { - let (try_bank, (entry, tick_height)) = match receiver.try_recv() { - Ok(working_bank_entry) => working_bank_entry, - Err(_) => break, + let Ok((try_bank, (entry, tick_height))) = receiver.try_recv() else { + break; }; // If the bank changed, that implies the previous slot was interrupted and we do not have to // broadcast its entries. @@ -65,11 +64,11 @@ pub(super) fn recv_slot_entries(receiver: &Receiver) -> Result while last_tick_height != bank.max_tick_height() && serialized_batch_byte_count < target_serialized_batch_byte_count { - let (try_bank, (entry, tick_height)) = - match receiver.recv_deadline(coalesce_start + ENTRY_COALESCE_DURATION) { - Ok(working_bank_entry) => working_bank_entry, - Err(_) => break, - }; + let Ok((try_bank, (entry, tick_height))) = + receiver.recv_deadline(coalesce_start + ENTRY_COALESCE_DURATION) + else { + break; + }; // If the bank changed, that implies the previous slot was interrupted and we do not have to // broadcast its entries. if try_bank.slot() != bank.slot() { diff --git a/turbine/src/retransmit_stage.rs b/turbine/src/retransmit_stage.rs index d2e751298b..1b30015b3b 100644 --- a/turbine/src/retransmit_stage.rs +++ b/turbine/src/retransmit_stage.rs @@ -224,13 +224,10 @@ fn retransmit( // and if the leader is unknown they should fail signature check. // So here we should expect to know the slot leader and otherwise // skip the shred. - let slot_leader = match leader_schedule_cache.slot_leader_at(slot, Some(&working_bank)) - { - Some(pubkey) => pubkey, - None => { - stats.unknown_shred_slot_leader += shreds.len(); - return None; - } + let Some(slot_leader) = leader_schedule_cache.slot_leader_at(slot, Some(&working_bank)) + else { + stats.unknown_shred_slot_leader += shreds.len(); + return None; }; let cluster_nodes = cluster_nodes_cache.get(slot, &root_bank, &working_bank, cluster_info); diff --git a/validator/src/dashboard.rs b/validator/src/dashboard.rs index d93798e998..f6df5693c0 100644 --- a/validator/src/dashboard.rs +++ b/validator/src/dashboard.rs @@ -71,14 +71,13 @@ impl Dashboard { let progress_bar = new_spinner_progress_bar(); progress_bar.set_message("Connecting..."); - let (rpc_addr, start_time) = match runtime.block_on(wait_for_validator_startup( + let Some((rpc_addr, start_time)) = runtime.block_on(wait_for_validator_startup( &ledger_path, &exit, progress_bar, refresh_interval, - )) { - None => continue, - Some(results) => results, + )) else { + continue; }; let rpc_client = RpcClient::new_socket(rpc_addr); diff --git a/validator/src/main.rs b/validator/src/main.rs index 2255ea9c0e..fb4794757b 100644 --- a/validator/src/main.rs +++ b/validator/src/main.rs @@ -125,9 +125,8 @@ fn wait_for_restart_window( .block_on(async move { admin_client.await?.rpc_addr().await }) .map_err(|err| format!("Unable to get validator RPC address: {err}"))?; - let rpc_client = match rpc_addr { - None => return Err("RPC not available".into()), - Some(rpc_addr) => RpcClient::new_socket(rpc_addr), + let Some(rpc_client) = rpc_addr.map(RpcClient::new_socket) else { + return Err("RPC not available".into()); }; let my_identity = rpc_client.get_identity()?;