Formatting

frame/contracts/src/storage.rs

@@ -267,8 +267,7 @@ where
 			// Cannot panic due to loop condition
 			let trie = &mut queue[0];
 			#[allow(deprecated)]
-			let outcome =
-				child::kill_storage(&child_trie_info(&trie.trie_id), Some(remaining_key_budget));
+			let outcome = child::kill_storage(&child_trie_info(&trie.trie_id), Some(remaining_key_budget));
 			let keys_removed = match outcome {
 				// This happens when our budget wasn't large enough to remove all keys.
 				KillStorageResult::SomeRemaining(c) => c,

frame/support/src/storage/generator/double_map.rs

@@ -206,22 +206,24 @@ where
 	where
 		KArg1: EncodeLike<K1>,
 	{
-		unhashed::clear_prefix(
-			Self::storage_double_map_final_key1(k1).as_ref(),
-			maybe_limit,
-			None,
-		).into()
+		unhashed::clear_prefix(Self::storage_double_map_final_key1(k1).as_ref(), maybe_limit, None)
+			.into()
 	}
 
-	fn clear_prefix<KArg1>(k1: KArg1, limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::ClearPrefixResult
+	fn clear_prefix<KArg1>(
+		k1: KArg1,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::ClearPrefixResult
 	where
 		KArg1: EncodeLike<K1>,
 	{
 		unhashed::clear_prefix(
 			Self::storage_double_map_final_key1(k1).as_ref(),
 			Some(limit),
 			maybe_cursor,
-		).into()
+		)
+		.into()
 	}
 
 	fn iter_prefix_values<KArg1>(k1: KArg1) -> storage::PrefixIterator<V>

frame/support/src/storage/generator/nmap.rs

@@ -186,11 +186,19 @@ where
 		unhashed::clear_prefix(&Self::storage_n_map_partial_key(partial_key), limit, None).into()
 	}
 
-	fn clear_prefix<KP>(partial_key: KP, limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::ClearPrefixResult
+	fn clear_prefix<KP>(
+		partial_key: KP,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::ClearPrefixResult
 	where
 		K: HasKeyPrefix<KP>,
 	{
-		unhashed::clear_prefix(&Self::storage_n_map_partial_key(partial_key), Some(limit), maybe_cursor)
+		unhashed::clear_prefix(
+			&Self::storage_n_map_partial_key(partial_key),
+			Some(limit),
+			maybe_cursor,
+		)
 	}
 
 	fn iter_prefix_values<KP>(partial_key: KP) -> PrefixIterator<V>

frame/support/src/storage/migration.rs

@@ -285,7 +285,7 @@ pub fn clear_storage_prefix(
 	item: &[u8],
 	hash: &[u8],
 	maybe_limit: Option<u32>,
-	maybe_cursor: Option<&[u8]>
+	maybe_cursor: Option<&[u8]>,
 ) -> sp_io::ClearPrefixResult {
 	let mut key = vec![0u8; 32 + hash.len()];
 	let storage_prefix = storage_prefix(module, item);

frame/support/src/storage/types/double_map.rs

@@ -261,11 +261,19 @@ where
 	/// passed once (in the initial call) for any given storage map and `first_key`. Subsequent
 	/// calls operating on the same map/`first_key` should always pass `Some`, and this should be
 	/// equal to the previous call result's `maybe_cursor` field.
-	pub fn clear_prefix<KArg1>(first_key: KArg1, limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::ClearPrefixResult
+	pub fn clear_prefix<KArg1>(
+		first_key: KArg1,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::ClearPrefixResult
 	where
 		KArg1: ?Sized + EncodeLike<Key1>,
 	{
-		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::clear_prefix(first_key, limit, maybe_cursor)
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::clear_prefix(
+			first_key,
+			limit,
+			maybe_cursor,
+		)
 	}
 
 	/// Iterate over values that share the first key.

frame/support/src/storage/types/nmap.rs

@@ -217,11 +217,19 @@ where
 	/// passed once (in the initial call) for any given storage map and `partial_key`. Subsequent
 	/// calls operating on the same map/`partial_key` should always pass `Some`, and this should be
 	/// equal to the previous call result's `maybe_cursor` field.
-	pub fn clear_prefix<KP>(partial_key: KP, limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::ClearPrefixResult
+	pub fn clear_prefix<KP>(
+		partial_key: KP,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::ClearPrefixResult
 	where
 		Key: HasKeyPrefix<KP>,
 	{
-		<Self as crate::storage::StorageNMap<Key, Value>>::clear_prefix(partial_key, limit, maybe_cursor)
+		<Self as crate::storage::StorageNMap<Key, Value>>::clear_prefix(
+			partial_key,
+			limit,
+			maybe_cursor,
+		)
 	}
 
 	/// Iterate over values that share the first key.

primitives/io/src/lib.rs

@@ -200,7 +200,8 @@ pub trait Storage {
 	/// backend.
 	#[version(2)]
 	fn clear_prefix(&mut self, prefix: &[u8], limit: Option<u32>) -> KillStorageResult {
-		let (maybe_cursor, num_removed, ..) = Externalities::clear_prefix(*self, prefix, limit, None);
+		let (maybe_cursor, num_removed, ..) =
+			Externalities::clear_prefix(*self, prefix, limit, None);
 		match maybe_cursor {
 			None => KillStorageResult::AllRemoved(num_removed),
 			Some(_) => KillStorageResult::SomeRemaining(num_removed),
@@ -243,7 +244,7 @@ pub trait Storage {
 		&mut self,
 		maybe_prefix: &[u8],
 		maybe_limit: Option<u32>,
-		maybe_cursor: Option<Vec<u8>>,	//< TODO Make work or just Option<Vec<u8>>?
+		maybe_cursor: Option<Vec<u8>>, //< TODO Make work or just Option<Vec<u8>>?
 	) -> ClearPrefixResult {
 		let (maybe_cursor, db, total, loops) = Externalities::clear_prefix(
 			*self,
@@ -425,12 +426,17 @@ pub trait DefaultChildStorage {
 	///
 	/// See `Storage` module `clear_prefix` documentation for `limit` usage.
 	#[version(4, register_only)]
-	fn storage_kill(&mut self, storage_key: &[u8], maybe_limit: Option<u32>, maybe_cursor: Option<Vec<u8>>) -> ClearPrefixResult {
+	fn storage_kill(
+		&mut self,
+		storage_key: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<Vec<u8>>,
+	) -> ClearPrefixResult {
 		let child_info = ChildInfo::new_default(storage_key);
 		let (maybe_cursor, db, total, loops) = self.kill_child_storage(
 			&child_info,
 			maybe_limit,
-			maybe_cursor.as_ref().map(|x| &x[..])
+			maybe_cursor.as_ref().map(|x| &x[..]),
 		);
 		ClearPrefixResult { maybe_cursor, db, total, loops }
 	}
@@ -462,7 +468,8 @@ pub trait DefaultChildStorage {
 		limit: Option<u32>,
 	) -> KillStorageResult {
 		let child_info = ChildInfo::new_default(storage_key);
-		let (maybe_cursor, num_removed, ..) = self.clear_child_prefix(&child_info, prefix, limit, None);
+		let (maybe_cursor, num_removed, ..) =
+			self.clear_child_prefix(&child_info, prefix, limit, None);
 		match maybe_cursor {
 			None => KillStorageResult::AllRemoved(num_removed),
 			Some(..) => KillStorageResult::SomeRemaining(num_removed),

primitives/state-machine/src/ext.rs

@@ -449,7 +449,7 @@ where
 		self.mark_dirty();
 		let overlay_count = self.overlay.clear_child_storage(child_info);
 		let (next_cursor, backend_count, iterations) =
-		self.limit_remove_from_backend(Some(child_info), None, maybe_limit, maybe_cursor);
+			self.limit_remove_from_backend(Some(child_info), None, maybe_limit, maybe_cursor);
 		(next_cursor, backend_count, overlay_count + backend_count, iterations)
 	}
 
@@ -500,8 +500,12 @@ where
 
 		self.mark_dirty();
 		let overlay_count = self.overlay.clear_child_prefix(child_info, prefix);
-		let (next_cursor, backend_count, iterations) =
-		self.limit_remove_from_backend(Some(child_info), Some(prefix), maybe_limit, maybe_cursor);
+		let (next_cursor, backend_count, iterations) = self.limit_remove_from_backend(
+			Some(child_info),
+			Some(prefix),
+			maybe_limit,
+			maybe_cursor,
+		);
 		(next_cursor, backend_count, backend_count + overlay_count, iterations)
 	}
 
@@ -753,27 +757,28 @@ where
 		let mut delete_count: u32 = 0;
 		let mut loop_count: u32 = 0;
 		let mut maybe_next_key = None;
-		self.backend.apply_to_keys_while(maybe_child, maybe_prefix, maybe_cursor, |key| {
-			if maybe_limit.map_or(false, |limit| loop_count == limit) {
-				maybe_next_key = Some(key.to_vec());
-				return false
-			}
-			let overlay = match maybe_child {
-				Some(child_info) => self.overlay.child_storage(child_info, key),
-				None => self.overlay.storage(key),
-			};
-			if !matches!(overlay, Some(None)) {
-				// already pending deletion from the backend - no need to delete it again.
-				if let Some(child_info) = maybe_child {
-					self.overlay.set_child_storage(child_info, key.to_vec(), None);
-				} else {
-					self.overlay.set_storage(key.to_vec(), None);
+		self.backend
+			.apply_to_keys_while(maybe_child, maybe_prefix, maybe_cursor, |key| {
+				if maybe_limit.map_or(false, |limit| loop_count == limit) {
+					maybe_next_key = Some(key.to_vec());
+					return false
 				}
-				delete_count = delete_count.saturating_add(1);
-			}
-			loop_count = loop_count.saturating_add(1);
-			true
-		});
+				let overlay = match maybe_child {
+					Some(child_info) => self.overlay.child_storage(child_info, key),
+					None => self.overlay.storage(key),
+				};
+				if !matches!(overlay, Some(None)) {
+					// already pending deletion from the backend - no need to delete it again.
+					if let Some(child_info) = maybe_child {
+						self.overlay.set_child_storage(child_info, key.to_vec(), None);
+					} else {
+						self.overlay.set_storage(key.to_vec(), None);
+					}
+					delete_count = delete_count.saturating_add(1);
+				}
+				loop_count = loop_count.saturating_add(1);
+				true
+			});
 		(maybe_next_key, delete_count, loop_count)
 	}
 }

primitives/state-machine/src/lib.rs

@@ -1348,6 +1348,7 @@ mod execution {
 mod tests {
 	use super::{ext::Ext, *};
 	use crate::execution::CallResult;
+	use assert_matches::assert_matches;
 	use codec::{Decode, Encode};
 	use sp_core::{
 		map,
@@ -1357,7 +1358,6 @@ mod tests {
 		NativeOrEncoded, NeverNativeValue,
 	};
 	use sp_runtime::traits::BlakeTwo256;
-	use assert_matches::assert_matches;
 	use std::{
 		collections::{BTreeMap, HashMap},
 		panic::UnwindSafe,

primitives/state-machine/src/testing.rs

@@ -381,7 +381,10 @@ mod tests {
 		{
 			let mut ext = ext.ext();
 
-			assert!(ext.kill_child_storage(&child_info, Some(2), None).0.is_some(), "Should not delete all keys");
+			assert!(
+				ext.kill_child_storage(&child_info, Some(2), None).0.is_some(),
+				"Should not delete all keys"
+			);
 
 			assert!(ext.child_storage(&child_info, &b"doe"[..]).is_none());
 			assert!(ext.child_storage(&child_info, &b"dog"[..]).is_none());

primitives/state-machine/src/trie_backend_essence.rs

@@ -342,7 +342,8 @@ where
 			let trie = TrieDB::<H>::new(db, root)?;
 			let prefix = maybe_prefix.unwrap_or(&[]);
 			let iter = match maybe_start_at {
-				Some(start_at) => TrieDBKeyIterator::new_prefixed_then_seek(&trie, prefix, start_at),
+				Some(start_at) =>
+					TrieDBKeyIterator::new_prefixed_then_seek(&trie, prefix, start_at),
 				None => TrieDBKeyIterator::new_prefixed(&trie, prefix),
 			}?;