Use mem::take instead of mem::replace where appropriate (#5846)

* replace replace with take

* Update client/api/src/cht.rs

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* Update client/api/src/cht.rs

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

substrate/client/api/src/cht.rs

@@ -232,7 +232,7 @@ pub fn for_each_cht_group<Header, I, F, P>(
 			functor_param = functor(
 				functor_param,
 				current_cht_num,
-				::std::mem::replace(&mut current_cht_blocks, Vec::new()),
+				std::mem::take(&mut current_cht_blocks),
 			)?;
 		}
 
@@ -244,7 +244,7 @@ pub fn for_each_cht_group<Header, I, F, P>(
 		functor(
 			functor_param,
 			current_cht_num,
-			::std::mem::replace(&mut current_cht_blocks, Vec::new()),
+			std::mem::take(&mut current_cht_blocks),
 		)?;
 	}
 

substrate/client/consensus/babe/src/tests.rs

@@ -436,7 +436,7 @@ fn authoring_blocks() {
 #[should_panic]
 fn rejects_missing_inherent_digest() {
 	run_one_test(|header: &mut TestHeader, stage| {
-		let v = std::mem::replace(&mut header.digest_mut().logs, vec![]);
+		let v = std::mem::take(&mut header.digest_mut().logs);
 		header.digest_mut().logs = v.into_iter()
 			.filter(|v| stage == Stage::PostSeal || v.as_babe_pre_digest().is_none())
 			.collect()
@@ -447,7 +447,7 @@ fn rejects_missing_inherent_digest() {
 #[should_panic]
 fn rejects_missing_seals() {
 	run_one_test(|header: &mut TestHeader, stage| {
-		let v = std::mem::replace(&mut header.digest_mut().logs, vec![]);
+		let v = std::mem::take(&mut header.digest_mut().logs);
 		header.digest_mut().logs = v.into_iter()
 			.filter(|v| stage == Stage::PreSeal || v.as_babe_seal().is_none())
 			.collect()
@@ -458,7 +458,7 @@ fn rejects_missing_seals() {
 #[should_panic]
 fn rejects_missing_consensus_digests() {
 	run_one_test(|header: &mut TestHeader, stage| {
-		let v = std::mem::replace(&mut header.digest_mut().logs, vec![]);
+		let v = std::mem::take(&mut header.digest_mut().logs);
 		header.digest_mut().logs = v.into_iter()
 			.filter(|v| stage == Stage::PostSeal || v.as_next_epoch_descriptor().is_none())
 			.collect()

substrate/client/consensus/manual-seal/src/lib.rs

@@ -231,7 +231,7 @@ mod tests {
 			.map(move |_| {
 				// we're only going to submit one tx so this fn will only be called once.
 				let mut_sender =  Arc::get_mut(&mut sender).unwrap();
-				let sender = std::mem::replace(mut_sender, None);
+				let sender = std::mem::take(mut_sender);
 				EngineCommand::SealNewBlock {
 					create_empty: false,
 					finalize: true,

substrate/client/finality-grandpa/src/finality_proof.rs

@@ -341,7 +341,7 @@ pub(crate) fn prove_finality<Block: BlockT, B: BlockchainBackend<Block>, J>(
 			let proof_fragment = FinalityProofFragment {
 				block: current,
 				justification,
-				unknown_headers: ::std::mem::replace(&mut unknown_headers, Vec::new()),
+				unknown_headers: ::std::mem::take(&mut unknown_headers),
 				authorities_proof: new_authorities_proof,
 			};
 

substrate/client/network/src/protocol/sync.rs

@@ -122,7 +122,7 @@ impl PendingRequests {
 	}
 
 	fn take(&mut self) -> PendingRequests {
-		std::mem::replace(self, Default::default())
+		std::mem::take(self)
 	}
 
 	fn set_all(&mut self) {
@@ -1270,7 +1270,7 @@ impl<B: BlockT> ChainSync<B> {
 		self.best_queued_number = std::cmp::max(info.best_number, self.best_imported_number);
 		self.pending_requests.set_all();
 		debug!(target:"sync", "Restarted with {} ({})", self.best_queued_number, self.best_queued_hash);
-		let old_peers = std::mem::replace(&mut self.peers, HashMap::new());
+		let old_peers = std::mem::take(&mut self.peers);
 		old_peers.into_iter().filter_map(move |(id, p)| {
 			match self.new_peer(id.clone(), p.best_hash, p.best_number) {
 				Ok(None) => None,

substrate/client/state-db/src/pruning.rs

@@ -169,7 +169,7 @@ impl<BlockHash: Hash, Key: Hash> RefWindow<BlockHash, Key> {
 		} else {
 			Default::default()
 		};
-		let deleted = ::std::mem::replace(&mut commit.data.deleted, Vec::new());
+		let deleted = ::std::mem::take(&mut commit.data.deleted);
 		let journal_record = JournalRecord {
 			hash: hash.clone(),
 			inserted,

substrate/primitives/core/src/offchain/testing.rs

@@ -105,7 +105,7 @@ impl OffchainState {
 	fn fulfill_expected(&mut self, id: u16) {
 		if let Some(mut req) = self.expected_requests.remove(&RequestId(id)) {
 			let response = req.response.take().expect("Response checked while added.");
-			let headers = std::mem::replace(&mut req.response_headers, vec![]);
+			let headers = std::mem::take(&mut req.response_headers);
 			self.fulfill_pending_request(id, req, response, headers);
 		}
 	}

substrate/primitives/io/src/batch_verifier.rs

@@ -109,13 +109,13 @@ impl BatchVerifier {
 		self.sr25519_items.push(Sr25519BatchItem { signature, pub_key, message });
 
 		if self.sr25519_items.len() >= 128 {
-			let items = std::mem::replace(&mut self.sr25519_items, vec![]);
+			let items = std::mem::take(&mut self.sr25519_items);
 			if self.spawn_verification_task(move || Self::verify_sr25519_batch(items)).is_err() {
 				log::debug!(
 					target: "runtime",
 					"Batch-verification returns false because failed to spawn background task.",
 				);
-	
+
 				return false;
 			}
 		}
@@ -135,7 +135,7 @@ impl BatchVerifier {
 	/// aggregated result.
 	#[must_use]
 	pub fn verify_and_clear(&mut self) -> bool {
-		let pending = std::mem::replace(&mut self.pending_tasks, vec![]);
+		let pending = std::mem::take(&mut self.pending_tasks);
 		let started = std::time::Instant::now();
 
 		log::trace!(
@@ -145,7 +145,7 @@ impl BatchVerifier {
 			self.sr25519_items.len(),
 		);
 
-		if !Self::verify_sr25519_batch(std::mem::replace(&mut self.sr25519_items, vec![])) {
+		if !Self::verify_sr25519_batch(std::mem::take(&mut self.sr25519_items)) {
 			return false;
 		}
 

substrate/primitives/state-machine/src/basic.rs

@@ -82,8 +82,8 @@ impl BasicExternalities {
 	) -> R {
 		let mut ext = Self {
 			inner: Storage {
-				top: std::mem::replace(&mut storage.top, Default::default()),
+				top: std::mem::take(&mut storage.top),
-				children_default: std::mem::replace(&mut storage.children_default, Default::default()),
+				children_default: std::mem::take(&mut storage.children_default),
 			},
 			extensions: Default::default(),
 		};

substrate/primitives/state-machine/src/overlayed_changes.rs

@@ -489,10 +489,10 @@ impl OverlayedChanges {
 	) {
 		assert!(self.prospective.is_empty());
 		(
-			std::mem::replace(&mut self.committed.top, Default::default())
+			std::mem::take(&mut self.committed.top)
 				.into_iter()
 				.map(|(k, v)| (k, v.value)),
-			std::mem::replace(&mut self.committed.children_default, Default::default())
+			std::mem::take(&mut self.committed.children_default)
 				.into_iter()
 				.map(|(sk, (v, ci))| (sk, (v.into_iter().map(|(k, v)| (k, v.value)), ci))),
 		)

substrate/utils/fork-tree/src/lib.rs

@@ -114,7 +114,7 @@ impl<H, N, V> ForkTree<H, N, V> where
 		)?;
 
 		let removed = if let Some(mut root_index) = new_root_index {
-			let mut old_roots = std::mem::replace(&mut self.roots, Vec::new());
+			let mut old_roots = std::mem::take(&mut self.roots);
 
 			let mut root = None;
 			let mut cur_children = Some(&mut old_roots);
@@ -137,7 +137,7 @@ impl<H, N, V> ForkTree<H, N, V> where
 
 			// we found the deepest ancestor of the finalized block, so we prune
 			// out any children that don't include the finalized block.
-			let root_children = std::mem::replace(&mut root.children, Vec::new());
+			let root_children = std::mem::take(&mut root.children);
 			let mut is_first = true;
 
 			for child in root_children {