Rename pallet trait Trait to Config (#7599)

* rename Trait to Config

* add test asserting using Trait is still valid.

* fix ui tests

substrate/frame/system/src/extensions/check_genesis.rs

@@ -16,7 +16,7 @@
 // limitations under the License.
 
 use codec::{Encode, Decode};
-use crate::{Trait, Module};
+use crate::{Config, Module};
 use sp_runtime::{
 	traits::{SignedExtension, Zero},
 	transaction_validity::TransactionValidityError,
@@ -24,9 +24,9 @@ use sp_runtime::{
 
 /// Genesis hash check to provide replay protection between different networks.
 #[derive(Encode, Decode, Clone, Eq, PartialEq)]
-pub struct CheckGenesis<T: Trait + Send + Sync>(sp_std::marker::PhantomData<T>);
+pub struct CheckGenesis<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
 
-impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckGenesis<T> {
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckGenesis<T> {
 	#[cfg(feature = "std")]
 	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
 		write!(f, "CheckGenesis")
@@ -38,16 +38,16 @@ impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckGenesis<T> {
 	}
 }
 
-impl<T: Trait + Send + Sync> CheckGenesis<T> {
+impl<T: Config + Send + Sync> CheckGenesis<T> {
 	/// Creates new `SignedExtension` to check genesis hash.
 	pub fn new() -> Self {
 		Self(sp_std::marker::PhantomData)
 	}
 }
 
-impl<T: Trait + Send + Sync> SignedExtension for CheckGenesis<T> {
+impl<T: Config + Send + Sync> SignedExtension for CheckGenesis<T> {
 	type AccountId = T::AccountId;
-	type Call = <T as Trait>::Call;
+	type Call = <T as Config>::Call;
 	type AdditionalSigned = T::Hash;
 	type Pre = ();
 	const IDENTIFIER: &'static str = "CheckGenesis";

substrate/frame/system/src/extensions/check_mortality.rs

@@ -16,7 +16,7 @@
 // limitations under the License.
 
 use codec::{Encode, Decode};
-use crate::{Trait, Module, BlockHash};
+use crate::{Config, Module, BlockHash};
 use frame_support::StorageMap;
 use sp_runtime::{
 	generic::Era,
@@ -28,16 +28,16 @@ use sp_runtime::{
 
 /// Check for transaction mortality.
 #[derive(Encode, Decode, Clone, Eq, PartialEq)]
-pub struct CheckMortality<T: Trait + Send + Sync>(Era, sp_std::marker::PhantomData<T>);
+pub struct CheckMortality<T: Config + Send + Sync>(Era, sp_std::marker::PhantomData<T>);
 
-impl<T: Trait + Send + Sync> CheckMortality<T> {
+impl<T: Config + Send + Sync> CheckMortality<T> {
 	/// utility constructor. Used only in client/factory code.
 	pub fn from(era: Era) -> Self {
 		Self(era, sp_std::marker::PhantomData)
 	}
 }
 
-impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckMortality<T> {
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckMortality<T> {
 	#[cfg(feature = "std")]
 	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
 		write!(f, "CheckMortality({:?})", self.0)
@@ -49,7 +49,7 @@ impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckMortality<T> {
 	}
 }
 
-impl<T: Trait + Send + Sync> SignedExtension for CheckMortality<T> {
+impl<T: Config + Send + Sync> SignedExtension for CheckMortality<T> {
 	type AccountId = T::AccountId;
 	type Call = T::Call;
 	type AdditionalSigned = T::Hash;

substrate/frame/system/src/extensions/check_nonce.rs

@@ -16,7 +16,7 @@
 // limitations under the License.
 
 use codec::{Encode, Decode};
-use crate::Trait;
+use crate::Config;
 use frame_support::{
 	weights::DispatchInfo,
 	StorageMap,
@@ -35,16 +35,16 @@ use sp_std::vec;
 /// Note that this does not set any priority by default. Make sure that AT LEAST one of the signed
 /// extension sets some kind of priority upon validating transactions.
 #[derive(Encode, Decode, Clone, Eq, PartialEq)]
-pub struct CheckNonce<T: Trait>(#[codec(compact)] T::Index);
+pub struct CheckNonce<T: Config>(#[codec(compact)] T::Index);
 
-impl<T: Trait> CheckNonce<T> {
+impl<T: Config> CheckNonce<T> {
 	/// utility constructor. Used only in client/factory code.
 	pub fn from(nonce: T::Index) -> Self {
 		Self(nonce)
 	}
 }
 
-impl<T: Trait> sp_std::fmt::Debug for CheckNonce<T> {
+impl<T: Config> sp_std::fmt::Debug for CheckNonce<T> {
 	#[cfg(feature = "std")]
 	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
 		write!(f, "CheckNonce({})", self.0)
@@ -56,7 +56,7 @@ impl<T: Trait> sp_std::fmt::Debug for CheckNonce<T> {
 	}
 }
 
-impl<T: Trait> SignedExtension for CheckNonce<T> where
+impl<T: Config> SignedExtension for CheckNonce<T> where
 	T::Call: Dispatchable<Info=DispatchInfo>
 {
 	type AccountId = T::AccountId;

substrate/frame/system/src/extensions/check_spec_version.rs

@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::{Trait, Module};
+use crate::{Config, Module};
 use codec::{Encode, Decode};
 use sp_runtime::{
 	traits::SignedExtension,
@@ -24,9 +24,9 @@ use sp_runtime::{
 
 /// Ensure the runtime version registered in the transaction is the same as at present.
 #[derive(Encode, Decode, Clone, Eq, PartialEq)]
-pub struct CheckSpecVersion<T: Trait + Send + Sync>(sp_std::marker::PhantomData<T>);
+pub struct CheckSpecVersion<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
 
-impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckSpecVersion<T> {
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckSpecVersion<T> {
 	#[cfg(feature = "std")]
 	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
 		write!(f, "CheckSpecVersion")
@@ -38,16 +38,16 @@ impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckSpecVersion<T> {
 	}
 }
 
-impl<T: Trait + Send + Sync> CheckSpecVersion<T> {
+impl<T: Config + Send + Sync> CheckSpecVersion<T> {
 	/// Create new `SignedExtension` to check runtime version.
 	pub fn new() -> Self {
 		Self(sp_std::marker::PhantomData)
 	}
 }
 
-impl<T: Trait + Send + Sync> SignedExtension for CheckSpecVersion<T> {
+impl<T: Config + Send + Sync> SignedExtension for CheckSpecVersion<T> {
 	type AccountId = T::AccountId;
-	type Call = <T as Trait>::Call;
+	type Call = <T as Config>::Call;
 	type AdditionalSigned = u32;
 	type Pre = ();
 	const IDENTIFIER: &'static str = "CheckSpecVersion";

substrate/frame/system/src/extensions/check_tx_version.rs

@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::{Trait, Module};
+use crate::{Config, Module};
 use codec::{Encode, Decode};
 use sp_runtime::{
 	traits::SignedExtension,
@@ -24,9 +24,9 @@ use sp_runtime::{
 
 /// Ensure the transaction version registered in the transaction is the same as at present.
 #[derive(Encode, Decode, Clone, Eq, PartialEq)]
-pub struct CheckTxVersion<T: Trait + Send + Sync>(sp_std::marker::PhantomData<T>);
+pub struct CheckTxVersion<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
 
-impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckTxVersion<T> {
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckTxVersion<T> {
 	#[cfg(feature = "std")]
 	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
 		write!(f, "CheckTxVersion")
@@ -38,16 +38,16 @@ impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckTxVersion<T> {
 	}
 }
 
-impl<T: Trait + Send + Sync> CheckTxVersion<T> {
+impl<T: Config + Send + Sync> CheckTxVersion<T> {
 	/// Create new `SignedExtension` to check transaction version.
 	pub fn new() -> Self {
 		Self(sp_std::marker::PhantomData)
 	}
 }
 
-impl<T: Trait + Send + Sync> SignedExtension for CheckTxVersion<T> {
+impl<T: Config + Send + Sync> SignedExtension for CheckTxVersion<T> {
 	type AccountId = T::AccountId;
-	type Call = <T as Trait>::Call;
+	type Call = <T as Config>::Call;
 	type AdditionalSigned = u32;
 	type Pre = ();
 	const IDENTIFIER: &'static str = "CheckTxVersion";

substrate/frame/system/src/extensions/check_weight.rs

@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::{Trait, Module};
+use crate::{Config, Module};
 use codec::{Encode, Decode};
 use sp_runtime::{
 	traits::{SignedExtension, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Printable},
@@ -33,9 +33,9 @@ use frame_support::{
 
 /// Block resource (weight) limit check.
 #[derive(Encode, Decode, Clone, Eq, PartialEq, Default)]
-pub struct CheckWeight<T: Trait + Send + Sync>(sp_std::marker::PhantomData<T>);
+pub struct CheckWeight<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
 
-impl<T: Trait + Send + Sync> CheckWeight<T> where
+impl<T: Config + Send + Sync> CheckWeight<T> where
 	T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo>
 {
 	/// Get the quota ratio of each dispatch class type. This indicates that all operational and mandatory
@@ -213,7 +213,7 @@ impl<T: Trait + Send + Sync> CheckWeight<T> where
 	}
 }
 
-impl<T: Trait + Send + Sync> SignedExtension for CheckWeight<T> where
+impl<T: Config + Send + Sync> SignedExtension for CheckWeight<T> where
 	T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo>
 {
 	type AccountId = T::AccountId;
@@ -294,7 +294,7 @@ impl<T: Trait + Send + Sync> SignedExtension for CheckWeight<T> where
 	}
 }
 
-impl<T: Trait + Send + Sync> sp_std::fmt::Debug for CheckWeight<T> {
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckWeight<T> {
 	#[cfg(feature = "std")]
 	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
 		write!(f, "CheckWeight")
@@ -316,11 +316,11 @@ mod tests {
 	use frame_support::weights::{Weight, Pays};
 
 	fn normal_weight_limit() -> Weight {
-		<Test as Trait>::AvailableBlockRatio::get() * <Test as Trait>::MaximumBlockWeight::get()
+		<Test as Config>::AvailableBlockRatio::get() * <Test as Config>::MaximumBlockWeight::get()
 	}
 
 	fn normal_length_limit() -> u32 {
-		<Test as Trait>::AvailableBlockRatio::get() * <Test as Trait>::MaximumBlockLength::get()
+		<Test as Config>::AvailableBlockRatio::get() * <Test as Config>::MaximumBlockLength::get()
 	}
 
 	#[test]
@@ -341,7 +341,7 @@ mod tests {
 		check(|max, len| {
 			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(max, len));
 			assert_eq!(System::block_weight().total(), Weight::max_value());
-			assert!(System::block_weight().total() > <Test as Trait>::MaximumBlockWeight::get());
+			assert!(System::block_weight().total() > <Test as Config>::MaximumBlockWeight::get());
 		});
 		check(|max, len| {
 			assert_ok!(CheckWeight::<Test>::do_validate(max, len));
@@ -352,7 +352,7 @@ mod tests {
 	fn normal_extrinsic_limited_by_maximum_extrinsic_weight() {
 		new_test_ext().execute_with(|| {
 			let max = DispatchInfo {
-				weight: <Test as Trait>::MaximumExtrinsicWeight::get() + 1,
+				weight: <Test as Config>::MaximumExtrinsicWeight::get() + 1,
 				class: DispatchClass::Normal,
 				..Default::default()
 			};
@@ -370,9 +370,9 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			let operational_limit = CheckWeight::<Test>::get_dispatch_limit_ratio(
 				DispatchClass::Operational
-			) * <Test as Trait>::MaximumBlockWeight::get();
-			let base_weight = <Test as Trait>::ExtrinsicBaseWeight::get();
-			let block_base = <Test as Trait>::BlockExecutionWeight::get();
+			) * <Test as Config>::MaximumBlockWeight::get();
+			let base_weight = <Test as Config>::ExtrinsicBaseWeight::get();
+			let block_base = <Test as Config>::BlockExecutionWeight::get();
 
 			let weight = operational_limit - base_weight - block_base;
 			let okay = DispatchInfo {
@@ -406,7 +406,7 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			System::register_extra_weight_unchecked(Weight::max_value(), DispatchClass::Normal);
 			assert_eq!(System::block_weight().total(), Weight::max_value());
-			assert!(System::block_weight().total() > <Test as Trait>::MaximumBlockWeight::get());
+			assert!(System::block_weight().total() > <Test as Config>::MaximumBlockWeight::get());
 		});
 	}
 
@@ -426,8 +426,8 @@ mod tests {
 			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&max_normal, len));
 			assert_eq!(System::block_weight().total(), 768);
 			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&rest_operational, len));
-			assert_eq!(<Test as Trait>::MaximumBlockWeight::get(), 1024);
-			assert_eq!(System::block_weight().total(), <Test as Trait>::MaximumBlockWeight::get());
+			assert_eq!(<Test as Config>::MaximumBlockWeight::get(), 1024);
+			assert_eq!(System::block_weight().total(), <Test as Config>::MaximumBlockWeight::get());
 			// Checking single extrinsic should not take current block weight into account.
 			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&rest_operational), Ok(()));
 		});
@@ -446,8 +446,8 @@ mod tests {
 			// Extra 15 here from block execution + base extrinsic weight
 			assert_eq!(System::block_weight().total(), 266);
 			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&max_normal, len));
-			assert_eq!(<Test as Trait>::MaximumBlockWeight::get(), 1024);
-			assert_eq!(System::block_weight().total(), <Test as Trait>::MaximumBlockWeight::get());
+			assert_eq!(<Test as Config>::MaximumBlockWeight::get(), 1024);
+			assert_eq!(System::block_weight().total(), <Test as Config>::MaximumBlockWeight::get());
 		});
 	}
 
@@ -553,11 +553,11 @@ mod tests {
 			let normal_limit = normal_weight_limit();
 			let small = DispatchInfo { weight: 100, ..Default::default() };
 			let medium = DispatchInfo {
-				weight: normal_limit - <Test as Trait>::ExtrinsicBaseWeight::get(),
+				weight: normal_limit - <Test as Config>::ExtrinsicBaseWeight::get(),
 				..Default::default()
 			};
 			let big = DispatchInfo {
-				weight: normal_limit - <Test as Trait>::ExtrinsicBaseWeight::get() + 1,
+				weight: normal_limit - <Test as Config>::ExtrinsicBaseWeight::get() + 1,
 				..Default::default()
 			};
 			let len = 0_usize;
@@ -589,7 +589,7 @@ mod tests {
 
 			// We allow 75% for normal transaction, so we put 25% - extrinsic base weight
 			BlockWeight::mutate(|current_weight| {
-				current_weight.put(256 - <Test as Trait>::ExtrinsicBaseWeight::get(), DispatchClass::Normal)
+				current_weight.put(256 - <Test as Config>::ExtrinsicBaseWeight::get(), DispatchClass::Normal)
 			});
 
 			let pre = CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &info, len).unwrap();
@@ -623,7 +623,7 @@ mod tests {
 			let pre = CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &info, len).unwrap();
 			assert_eq!(
 				BlockWeight::get().total(),
-				info.weight + 128 + <Test as Trait>::ExtrinsicBaseWeight::get(),
+				info.weight + 128 + <Test as Config>::ExtrinsicBaseWeight::get(),
 			);
 
 			assert!(
@@ -632,7 +632,7 @@ mod tests {
 			);
 			assert_eq!(
 				BlockWeight::get().total(),
-				info.weight + 128 + <Test as Trait>::ExtrinsicBaseWeight::get(),
+				info.weight + 128 + <Test as Config>::ExtrinsicBaseWeight::get(),
 			);
 		})
 	}
@@ -644,12 +644,12 @@ mod tests {
 			let len = 0_usize;
 
 			// Initial weight from `BlockExecutionWeight`
-			assert_eq!(System::block_weight().total(), <Test as Trait>::BlockExecutionWeight::get());
+			assert_eq!(System::block_weight().total(), <Test as Config>::BlockExecutionWeight::get());
 			let r = CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &free, len);
 			assert!(r.is_ok());
 			assert_eq!(
 				System::block_weight().total(),
-				<Test as Trait>::ExtrinsicBaseWeight::get() + <Test as Trait>::BlockExecutionWeight::get()
+				<Test as Config>::ExtrinsicBaseWeight::get() + <Test as Config>::BlockExecutionWeight::get()
 			);
 		})
 	}