review: Use a new version of kill_storage instead of a new interface

frame/contracts/src/rent.rs

@@ -240,6 +240,7 @@ where
 				<ContractInfoOf<T>>::remove(account);
 				child::kill_storage(
 					&alive_contract_info.child_trie_info(),
+					None,
 				);
 				<Module<T>>::deposit_event(RawEvent::Evicted(account.clone(), false));
 				None
@@ -263,6 +264,7 @@ where
 
 				child::kill_storage(
 					&alive_contract_info.child_trie_info(),
+					None,
 				);
 
 				<Module<T>>::deposit_event(RawEvent::Evicted(account.clone(), true));

frame/contracts/src/storage.rs

@@ -195,7 +195,7 @@ where
 	/// This function doesn't affect the account.
 	pub fn destroy_contract(address: &AccountIdOf<T>, trie_id: &TrieId) {
 		<ContractInfoOf<T>>::remove(address);
-		child::kill_storage(&crate::child_trie_info(&trie_id));
+		child::kill_storage(&crate::child_trie_info(&trie_id), None);
 	}
 
 	/// This generator uses inner counter for account id and applies the hash over `AccountId +

frame/support/src/storage/child.rs

@@ -25,6 +25,14 @@ use crate::sp_std::prelude::*;
 use codec::{Codec, Encode, Decode};
 pub use sp_core::storage::{ChildInfo, ChildType};
 
+/// The outcome of calling [`kill_storage`].
+pub enum KillOutcome {
+	/// No key remains in the child trie.
+	AllRemoved,
+	/// At least one key still resides in the child trie due to the supplied limit.
+	SomeRemaining,
+}
+
 /// Return the value of the item in storage under `key`, or `None` if there is no explicit entry.
 pub fn get<T: Decode + Sized>(
 	child_info: &ChildInfo,
@@ -148,13 +156,37 @@ pub fn exists(
 }
 
 /// Remove all `storage_key` key/values
+///
+/// Deletes all keys from the overlay and up to `limit` keys from the backend if
+/// it is set to `Some`. No limit is applied when `limit` is set to `None`.
+///
+/// The limit can be used to partially delete a child trie in case it is too large
+/// to delete in one go (block).
+///
+/// # Note
+///
+/// Please note that keys that are residing in the overlay for that child trie when
+/// issuing this call are all deleted without counting towards the `limit`. Only keys
+/// written during the current block are part of the overlay. Deleting with a `limit`
+/// mostly makes sense with an empty overlay for that child trie.
+///
+/// Calling this function multiple times per block for the same `storage_key` does
+/// not make much sense because it is not cumulative when called inside the same block.
+/// Use this function to distribute the deletion of a single child trie across multiple
+/// blocks.
 pub fn kill_storage(
 	child_info: &ChildInfo,
-) {
-	match child_info.child_type() {
+	limit: Option<u32>,
+) -> KillOutcome {
+	let all_removed = match child_info.child_type() {
 		ChildType::ParentKeyId => sp_io::default_child_storage::storage_kill(
 			child_info.storage_key(),
+			limit
 		),
+	};
+	match all_removed {
+		true => KillOutcome::AllRemoved,
+		false => KillOutcome::SomeRemaining,
 	}
 }
 

primitives/io/src/lib.rs

@@ -282,30 +282,32 @@ pub trait DefaultChildStorage {
 		self.kill_child_storage(&child_info, None);
 	}
 
-	/// Clear at most `limit` keys from the specified child storage.
+	/// Clear a child storage key.
 	///
-	/// Deletes all keys from the overlay and up to `limit` keys from the backend.
-	/// This can be used to partially delete a child trie in case it is too large
-	/// to delete in one go (block). It returns false iff some keys are remaining in
-	/// the child trie after the functions returns.
+	/// Deletes all keys from the overlay and up to `limit` keys from the backend if
+	/// it is set to `Some`. No limit is applied when `limit` is set to `None`.
 	///
-	/// Please note that keys that are residing in the overlay for that child tie when
-	/// issuing this call are all deleted without counting towards the `limit`. Only keys
-	/// written during the current block are part of the overlay.
+	/// The limit can be used to partially delete a child trie in case it is too large
+	/// to delete in one go (block).
+	///
+	/// It returns false iff some keys are remaining in
+	/// the child trie after the functions returns.
 	///
 	/// # Note
 	///
+	/// Please note that keys that are residing in the overlay for that child trie when
+	/// issuing this call are all deleted without counting towards the `limit`. Only keys
+	/// written during the current block are part of the overlay. Deleting with a `limit`
+	/// mostly makes sense with an empty overlay for that child trie.
+	///
 	/// Calling this function multiple times per block for the same `storage_key` does
 	/// not make much sense because it is not cumulative when called inside the same block.
 	/// Use this function to distribute the deletion of a single child trie across multiple
 	/// blocks.
-	fn storage_kill_limited(
-		&mut self,
-		storage_key: &[u8],
-		limit: u32,
-	) -> bool {
+	#[version(2)]
+	fn storage_kill(&mut self, storage_key: &[u8], limit: Option<u32>) -> bool {
 		let child_info = ChildInfo::new_default(storage_key);
-		self.kill_child_storage(&child_info, Some(limit))
+		self.kill_child_storage(&child_info, limit)
 	}
 
 	/// Check a child storage key.