From ad8f391494e346c4b035969460ae7206ae880862 Mon Sep 17 00:00:00 2001
From: Keith Yeung <kungfukeith11@gmail.com>
Date: Thu, 22 Apr 2021 22:53:49 -0700
Subject: [PATCH] Rename KeyGenerator::Arg to KeyGenerator::KArg

---
 frame/support/src/storage/generator/nmap.rs | 30 ++++++++++-----------
 frame/support/src/storage/mod.rs            | 30 ++++++++++-----------
 frame/support/src/storage/types/key.rs      | 12 ++++-----
 frame/support/src/storage/types/nmap.rs     | 30 ++++++++++-----------
 4 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/frame/support/src/storage/generator/nmap.rs b/frame/support/src/storage/generator/nmap.rs
index 375a321f483d9..41438b077f475 100755
--- a/frame/support/src/storage/generator/nmap.rs
+++ b/frame/support/src/storage/generator/nmap.rs
@@ -97,7 +97,7 @@ pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
 	fn storage_n_map_final_key<KG, KArg>(key: KArg) -> Vec<u8>
 	where
 		KG: KeyGenerator,
-		KArg: EncodeLike<KG::Arg> + TupleToEncodedIter,
+		KArg: EncodeLike<KG::KArg> + TupleToEncodedIter,
 	{
 		let module_prefix_hashed = Twox128::hash(Self::module_prefix());
 		let storage_prefix_hashed = Twox128::hash(Self::storage_prefix());
@@ -123,23 +123,23 @@ where
 {
 	type Query = G::Query;
 
-	fn hashed_key_for<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
+	fn hashed_key_for<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
 		Self::storage_n_map_final_key::<K, _>(key)
 	}
 
-	fn contains_key<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> bool {
+	fn contains_key<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> bool {
 		unhashed::exists(&Self::storage_n_map_final_key::<K, _>(key))
 	}
 
-	fn get<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Self::Query {
+	fn get<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Self::Query {
 		G::from_optional_value_to_query(unhashed::get(&Self::storage_n_map_final_key::<K, _>(key)))
 	}
 
-	fn try_get<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Result<V, ()> {
+	fn try_get<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Result<V, ()> {
 		unhashed::get(&Self::storage_n_map_final_key::<K, _>(key)).ok_or(())
 	}
 
-	fn take<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Self::Query {
+	fn take<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Self::Query {
 		let final_key = Self::storage_n_map_final_key::<K, _>(key);
 
 		let value = unhashed::take(&final_key);
@@ -149,8 +149,8 @@ where
 	fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
 	where
 		KOther: KeyGenerator,
-		KArg1: EncodeLike<K::Arg> + TupleToEncodedIter,
-		KArg2: EncodeLike<KOther::Arg> + TupleToEncodedIter,
+		KArg1: EncodeLike<K::KArg> + TupleToEncodedIter,
+		KArg2: EncodeLike<KOther::KArg> + TupleToEncodedIter,
 	{
 		let final_x_key = Self::storage_n_map_final_key::<K, _>(key1);
 		let final_y_key = Self::storage_n_map_final_key::<KOther, _>(key2);
@@ -168,11 +168,11 @@ where
 		}
 	}
 
-	fn insert<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, VArg: EncodeLike<V>>(key: KArg, val: VArg) {
+	fn insert<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, VArg: EncodeLike<V>>(key: KArg, val: VArg) {
 		unhashed::put(&Self::storage_n_map_final_key::<K, _>(key), &val.borrow());
 	}
 
-	fn remove<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) {
+	fn remove<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) {
 		unhashed::kill(&Self::storage_n_map_final_key::<K, _>(key));
 	}
 
@@ -193,14 +193,14 @@ where
 		}
 	}
 
-	fn mutate<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, R, F: FnOnce(&mut Self::Query) -> R>(
+	fn mutate<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, R, F: FnOnce(&mut Self::Query) -> R>(
 		key: KArg,
 		f: F,
 	) -> R {
 		Self::try_mutate(key, |v| Ok::<R, Never>(f(v))).expect("`Never` can not be constructed; qed")
 	}
 
-	fn try_mutate<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, R, E, F: FnOnce(&mut Self::Query) -> Result<R, E>>(
+	fn try_mutate<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, R, E, F: FnOnce(&mut Self::Query) -> Result<R, E>>(
 		key: KArg,
 		f: F,
 	) -> Result<R, E> {
@@ -217,14 +217,14 @@ where
 		ret
 	}
 
-	fn mutate_exists<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, R, F: FnOnce(&mut Option<V>) -> R>(
+	fn mutate_exists<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, R, F: FnOnce(&mut Option<V>) -> R>(
 		key: KArg,
 		f: F,
 	) -> R {
 		Self::try_mutate_exists(key, |v| Ok::<R, Never>(f(v))).expect("`Never` can not be constructed; qed")
 	}
 
-	fn try_mutate_exists<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, R, E, F: FnOnce(&mut Option<V>) -> Result<R, E>>(
+	fn try_mutate_exists<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, R, E, F: FnOnce(&mut Option<V>) -> Result<R, E>>(
 		key: KArg,
 		f: F,
 	) -> Result<R, E> {
@@ -243,7 +243,7 @@ where
 
 	fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
 	where
-		KArg: EncodeLike<K::Arg> + TupleToEncodedIter,
+		KArg: EncodeLike<K::KArg> + TupleToEncodedIter,
 		Item: Encode,
 		EncodeLikeItem: EncodeLike<Item>,
 		V: StorageAppend<Item>
diff --git a/frame/support/src/storage/mod.rs b/frame/support/src/storage/mod.rs
index a8717ca0f6b5a..8ab17a4cd4ec7 100644
--- a/frame/support/src/storage/mod.rs
+++ b/frame/support/src/storage/mod.rs
@@ -552,31 +552,31 @@ pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
 	type Query;
 
 	/// Get the storage key used to fetch a value corresponding to a specific key.
-	fn hashed_key_for<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Vec<u8>;
+	fn hashed_key_for<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8>;
 
 	/// Does the value (explicitly) exist in storage?
-	fn contains_key<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> bool;
+	fn contains_key<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> bool;
 
 	/// Load the value associated with the given key from the map.
-	fn get<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Self::Query;
+	fn get<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Self::Query;
 
 	/// Try to get the value for the given key from the map.
 	///
 	/// Returns `Ok` if it exists, `Err` if not.
-	fn try_get<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Result<V, ()>;
+	fn try_get<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Result<V, ()>;
 
 	/// Swap the values of two keys.
 	fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
 	where
 		KOther: KeyGenerator,
-		KArg1: EncodeLike<K::Arg> + TupleToEncodedIter,
-		KArg2: EncodeLike<KOther::Arg> + TupleToEncodedIter;
+		KArg1: EncodeLike<K::KArg> + TupleToEncodedIter,
+		KArg2: EncodeLike<KOther::KArg> + TupleToEncodedIter;
 
 	/// Store a value to be associated with the given key from the map.
-	fn insert<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, VArg: EncodeLike<V>>(key: KArg, val: VArg);
+	fn insert<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, VArg: EncodeLike<V>>(key: KArg, val: VArg);
 
 	/// Remove the value under a key.
-	fn remove<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg);
+	fn remove<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg);
 
 	/// Remove all values under the partial prefix key.
 	fn remove_prefix<KP>(partial_key: KP) where K: HasKeyPrefix<KP>;
@@ -585,10 +585,10 @@ pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
 	fn iter_prefix_values<KP>(partial_key: KP) -> PrefixIterator<V> where K: HasKeyPrefix<KP>;
 
 	/// Mutate the value under a key.
-	fn mutate<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, R, F: FnOnce(&mut Self::Query) -> R>(key: KArg, f: F) -> R;
+	fn mutate<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, R, F: FnOnce(&mut Self::Query) -> R>(key: KArg, f: F) -> R;
 
 	/// Mutate the item, only if an `Ok` value is returned.
-	fn try_mutate<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, R, E, F: FnOnce(&mut Self::Query) -> Result<R, E>>(
+	fn try_mutate<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, R, E, F: FnOnce(&mut Self::Query) -> Result<R, E>>(
 		key: KArg,
 		f: F,
 	) -> Result<R, E>;
@@ -596,16 +596,16 @@ pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
 	/// Mutate the value under a key.
 	///
 	/// Deletes the item if mutated to a `None`.
-	fn mutate_exists<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, R, F: FnOnce(&mut Option<V>) -> R>(key: KArg, f: F) -> R;
+	fn mutate_exists<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, R, F: FnOnce(&mut Option<V>) -> R>(key: KArg, f: F) -> R;
 
 	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
-	fn try_mutate_exists<KArg: EncodeLike<K::Arg> + TupleToEncodedIter, R, E, F: FnOnce(&mut Option<V>) -> Result<R, E>>(
+	fn try_mutate_exists<KArg: EncodeLike<K::KArg> + TupleToEncodedIter, R, E, F: FnOnce(&mut Option<V>) -> Result<R, E>>(
 		key: KArg,
 		f: F,
 	) -> Result<R, E>;
 
 	/// Take the value under a key.
-	fn take<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Self::Query;
+	fn take<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Self::Query;
 
 	/// Append the given items to the value in the storage.
 	///
@@ -618,7 +618,7 @@ pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
 	/// on overwrite.
 	fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
 	where
-		KArg: EncodeLike<K::Arg> + TupleToEncodedIter,
+		KArg: EncodeLike<K::KArg> + TupleToEncodedIter,
 		Item: Encode,
 		EncodeLikeItem: EncodeLike<Item>,
 		V: StorageAppend<Item>;
@@ -635,7 +635,7 @@ pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
 	///
 	/// `None` does not mean that `get()` does not return a value. The default value is completly
 	/// ignored by this function.
-	fn decode_len<KArg: EncodeLike<K::Arg> + TupleToEncodedIter>(key: KArg) -> Option<usize>
+	fn decode_len<KArg: EncodeLike<K::KArg> + TupleToEncodedIter>(key: KArg) -> Option<usize>
 	where
 		V: StorageDecodeLength,
 	{
diff --git a/frame/support/src/storage/types/key.rs b/frame/support/src/storage/types/key.rs
index fa3dbe0ffbd11..012d5c75888a7 100755
--- a/frame/support/src/storage/types/key.rs
+++ b/frame/support/src/storage/types/key.rs
@@ -38,17 +38,17 @@ pub struct Key<Hasher, KeyType>(
 /// A trait that contains the current key as an associated type.
 pub trait KeyGenerator {
 	type Key: EncodeLike<Self::Key>;
-	type Arg: Encode;
+	type KArg: Encode;
 
-	fn final_key<KArg: EncodeLike<Self::Arg> + TupleToEncodedIter>(key: KArg) -> Vec<u8>;
+	fn final_key<KArg: EncodeLike<Self::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8>;
 	fn final_hash(encoded: &[u8]) -> Vec<u8>;
 }
 
 impl<H: StorageHasher, K: FullCodec> KeyGenerator for Key<H, K> {
 	type Key = K;
-	type Arg = (K,);
+	type KArg = (K,);
 
-	fn final_key<KArg: EncodeLike<Self::Arg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
+	fn final_key<KArg: EncodeLike<Self::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
 		H::hash(&key.to_encoded_iter().next().expect("should have at least one element!")).as_ref().to_vec()
 	}
 
@@ -60,9 +60,9 @@ impl<H: StorageHasher, K: FullCodec> KeyGenerator for Key<H, K> {
 #[impl_trait_for_tuples::impl_for_tuples(2, 18)]
 impl KeyGenerator for Tuple {
 	for_tuples!( type Key = ( #(Tuple::Key),* ); );
-	for_tuples!( type Arg = ( #(Tuple::Key),* ); );
+	for_tuples!( type KArg = ( #(Tuple::Key),* ); );
 
-	fn final_key<KArg: EncodeLike<Self::Arg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
+	fn final_key<KArg: EncodeLike<Self::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
 		let mut final_key = Vec::new();
 		let mut iter = key.to_encoded_iter();
 		for_tuples!(
diff --git a/frame/support/src/storage/types/nmap.rs b/frame/support/src/storage/types/nmap.rs
index ea8d5292ded79..7141899fb5b1c 100755
--- a/frame/support/src/storage/types/nmap.rs
+++ b/frame/support/src/storage/types/nmap.rs
@@ -103,29 +103,29 @@ where
 	OnEmpty: crate::traits::Get<QueryKind::Query> + 'static,
 {
 	/// Get the storage key used to fetch a value corresponding to a specific key.
-	pub fn hashed_key_for<KArg: EncodeLike<Key::Arg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
+	pub fn hashed_key_for<KArg: EncodeLike<Key::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
 		<Self as crate::storage::StorageNMap<Key, Value>>::hashed_key_for(key)
 	}
 
 	/// Does the value (explicitly) exist in storage?
-	pub fn contains_key<KArg: EncodeLike<Key::Arg> + TupleToEncodedIter>(key: KArg) -> bool {
+	pub fn contains_key<KArg: EncodeLike<Key::KArg> + TupleToEncodedIter>(key: KArg) -> bool {
 		<Self as crate::storage::StorageNMap<Key, Value>>::contains_key(key)
 	}
 
 	/// Load the value associated with the given key from the map.
-	pub fn get<KArg: EncodeLike<Key::Arg> + TupleToEncodedIter>(key: KArg) -> QueryKind::Query {
+	pub fn get<KArg: EncodeLike<Key::KArg> + TupleToEncodedIter>(key: KArg) -> QueryKind::Query {
 		<Self as crate::storage::StorageNMap<Key, Value>>::get(key)
 	}
 
 	/// Try to get the value for the given key from the map.
 	///
 	/// Returns `Ok` if it exists, `Err` if not.
-	pub fn try_get<KArg: EncodeLike<Key::Arg> + TupleToEncodedIter>(key: KArg) -> Result<Value, ()> {
+	pub fn try_get<KArg: EncodeLike<Key::KArg> + TupleToEncodedIter>(key: KArg) -> Result<Value, ()> {
 		<Self as crate::storage::StorageNMap<Key, Value>>::try_get(key)
 	}
 
 	/// Take a value from storage, removing it afterwards.
-	pub fn take<KArg: EncodeLike<Key::Arg> + TupleToEncodedIter>(key: KArg) -> QueryKind::Query {
+	pub fn take<KArg: EncodeLike<Key::KArg> + TupleToEncodedIter>(key: KArg) -> QueryKind::Query {
 		<Self as crate::storage::StorageNMap<Key, Value>>::take(key)
 	}
 
@@ -133,19 +133,19 @@ where
 	pub fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
 	where
 		KOther: KeyGenerator,
-		KArg1: EncodeLike<Key::Arg> + TupleToEncodedIter,
-		KArg2: EncodeLike<KOther::Arg> + TupleToEncodedIter,
+		KArg1: EncodeLike<Key::KArg> + TupleToEncodedIter,
+		KArg2: EncodeLike<KOther::KArg> + TupleToEncodedIter,
 	{
 		<Self as crate::storage::StorageNMap<Key, Value>>::swap::<KOther, _, _>(key1, key2)
 	}
 
 	/// Store a value to be associated with the given keys from the map.
-	pub fn insert<KArg: EncodeLike<Key::Arg> + TupleToEncodedIter, VArg: EncodeLike<Value>>(key: KArg, val: VArg) {
+	pub fn insert<KArg: EncodeLike<Key::KArg> + TupleToEncodedIter, VArg: EncodeLike<Value>>(key: KArg, val: VArg) {
 		<Self as crate::storage::StorageNMap<Key, Value>>::insert(key, val)
 	}
 
 	/// Remove the value under the given keys.
-	pub fn remove<KArg: EncodeLike<Key::Arg> + TupleToEncodedIter>(key: KArg) {
+	pub fn remove<KArg: EncodeLike<Key::KArg> + TupleToEncodedIter>(key: KArg) {
 		<Self as crate::storage::StorageNMap<Key, Value>>::remove(key)
 	}
 
@@ -165,7 +165,7 @@ where
 	/// Mutate the value under the given keys.
 	pub fn mutate<KArg, R, F>(key: KArg, f: F) -> R
 	where
-		KArg: EncodeLike<Key::Arg> + TupleToEncodedIter,
+		KArg: EncodeLike<Key::KArg> + TupleToEncodedIter,
 		F: FnOnce(&mut QueryKind::Query) -> R,
 	{
 		<Self as crate::storage::StorageNMap<Key, Value>>::mutate(key, f)
@@ -174,7 +174,7 @@ where
 	/// Mutate the value under the given keys when the closure returns `Ok`.
 	pub fn try_mutate<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
 	where
-		KArg: EncodeLike<Key::Arg> + TupleToEncodedIter,
+		KArg: EncodeLike<Key::KArg> + TupleToEncodedIter,
 		F: FnOnce(&mut QueryKind::Query) -> Result<R, E>,
 	{
 		<Self as crate::storage::StorageNMap<Key, Value>>::try_mutate(key, f)
@@ -183,7 +183,7 @@ where
 	/// Mutate the value under the given keys. Deletes the item if mutated to a `None`.
 	pub fn mutate_exists<KArg, R, F>(key: KArg, f: F) -> R
 	where
-		KArg: EncodeLike<Key::Arg> + TupleToEncodedIter,
+		KArg: EncodeLike<Key::KArg> + TupleToEncodedIter,
 		F: FnOnce(&mut Option<Value>) -> R,
 	{
 		<Self as crate::storage::StorageNMap<Key, Value>>::mutate_exists(key, f)
@@ -192,7 +192,7 @@ where
 	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
 	pub fn try_mutate_exists<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
 	where
-		KArg: EncodeLike<Key::Arg> + TupleToEncodedIter,
+		KArg: EncodeLike<Key::KArg> + TupleToEncodedIter,
 		F: FnOnce(&mut Option<Value>) -> Result<R, E>,
 	{
 		<Self as crate::storage::StorageNMap<Key, Value>>::try_mutate_exists(key, f)
@@ -209,7 +209,7 @@ where
 	/// on overwrite.
 	pub fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
 	where
-		KArg: EncodeLike<Key::Arg> + TupleToEncodedIter,
+		KArg: EncodeLike<Key::KArg> + TupleToEncodedIter,
 		Item: Encode,
 		EncodeLikeItem: EncodeLike<Item>,
 		Value: StorageAppend<Item>
@@ -229,7 +229,7 @@ where
 	///
 	/// `None` does not mean that `get()` does not return a value. The default value is completly
 	/// ignored by this function.
-	pub fn decode_len<KArg: EncodeLike<Key::Arg> + TupleToEncodedIter>(key: KArg) -> Option<usize>
+	pub fn decode_len<KArg: EncodeLike<Key::KArg> + TupleToEncodedIter>(key: KArg) -> Option<usize>
 	where
 		Value: StorageDecodeLength,
 	{