Partially backport #7381

client/cli/src/commands/export_blocks_cmd.rs

@@ -85,7 +85,7 @@ impl ExportBlocksCmd {
 			info!("DB path: {}", path.display());
 		}
 
-		let from = self.from.as_ref().and_then(|f| f.parse().ok()).unwrap_or(1);
+		let from = self.from.as_ref().and_then(|f| f.parse().ok()).unwrap_or(1u32);
 		let to = self.to.as_ref().and_then(|t| t.parse().ok());
 
 		let binary = self.binary;

client/finality-grandpa/src/voting_rule.rs

@@ -241,7 +241,7 @@ impl<Block, B> Default for VotingRulesBuilder<Block, B> where
 {
 	fn default() -> Self {
 		VotingRulesBuilder::new()
-			.add(BeforeBestBlockBy(2.into()))
+			.add(BeforeBestBlockBy(2u32.into()))
 			.add(ThreeQuartersOfTheUnfinalizedChain)
 	}
 }

client/informant/src/display.rs

@@ -168,7 +168,7 @@ fn speed<B: BlockT>(
 	} else {
 		// If the number of blocks can't be converted to a regular integer, then we need a more
 		// algebraic approach and we stay within the realm of integers.
-		let one_thousand = NumberFor::<B>::from(1_000);
+		let one_thousand = NumberFor::<B>::from(1_000u32);
 		let elapsed = NumberFor::<B>::from(
 			<u32 as TryFrom<_>>::try_from(elapsed_ms).unwrap_or(u32::max_value())
 		);

client/network/src/light_client_handler.rs

@@ -1429,7 +1429,7 @@ mod tests {
 			_: ChangesProof<B::Header>
 		) -> Result<Vec<(NumberFor<B>, u32)>, ClientError> {
 			match self.ok {
-				true => Ok(vec![(100.into(), 2)]),
+				true => Ok(vec![(100u32.into(), 2)]),
 				false => Err(ClientError::Backend("Test error".into())),
 			}
 		}

client/service/src/chain_ops/export_blocks.rs

@@ -87,7 +87,7 @@ where
 			// Reached end of the chain.
 			None => return Poll::Ready(Ok(())),
 		}
-		if (block % 10000.into()).is_zero() {
+		if (block % 10000u32.into()).is_zero() {
 			info!("#{}", block);
 		}
 		if block == last {

client/service/src/chain_ops/import_blocks.rs

@@ -200,7 +200,7 @@ impl<B: BlockT> Speedometer<B> {
 	/// Creates a fresh Speedometer.
 	fn new() -> Self {
 		Self {
-			best_number: NumberFor::<B>::from(0),
+			best_number: NumberFor::<B>::from(0u32),
 			last_number: None,
 			last_update: Instant::now(),
 		}
@@ -232,7 +232,7 @@ impl<B: BlockT> Speedometer<B> {
 		} else {
 			// If the number of blocks can't be converted to a regular integer, then we need a more
 			// algebraic approach and we stay within the realm of integers.
-			let one_thousand = NumberFor::<B>::from(1_000);
+			let one_thousand = NumberFor::<B>::from(1_000u32);
 			let elapsed = NumberFor::<B>::from(
 				<u32 as TryFrom<_>>::try_from(elapsed_ms).unwrap_or(u32::max_value())
 			);

client/service/src/client/client.rs

@@ -38,7 +38,7 @@ use sp_runtime::{
 	generic::{BlockId, SignedBlock, DigestItem},
 	traits::{
 		Block as BlockT, Header as HeaderT, Zero, NumberFor,
-		HashFor, SaturatedConversion, One, DigestFor,
+		HashFor, SaturatedConversion, One, DigestFor, UniqueSaturatedInto,
 	},
 };
 use sp_state_machine::{
@@ -1139,7 +1139,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		let mut ancestor = load_header(ancestor_hash)?;
 		let mut uncles = Vec::new();
 
-		for _generation in 0..max_generation.saturated_into() {
+		for _generation in 0u32..UniqueSaturatedInto::<u32>::unique_saturated_into(max_generation) {
 			let children = self.backend.blockchain().children(ancestor_hash)?;
 			uncles.extend(children.into_iter().filter(|h| h != &current_hash));
 			current_hash = ancestor_hash;

client/service/src/metrics.rs

@@ -316,9 +316,9 @@ impl MetricsService {
 			);
 
 			if let Some(metrics) = self.metrics.as_ref() {
-				let best_seen_block = net_status
+				let best_seen_block: Option<u64> = net_status
 					.best_seen_block
-					.map(|num: NumberFor<T>| num.unique_saturated_into() as u64);
+					.map(|num: NumberFor<T>| UniqueSaturatedInto::<u64>::unique_saturated_into(num));
 
 				if let Some(best_seen_block) = best_seen_block {
 					metrics.block_height.with_label_values(&["sync_target"]).set(best_seen_block);

client/transaction-pool/src/lib.rs

@@ -569,7 +569,7 @@ impl<PoolApi, Block> MaintainedTransactionPool for BasicPool<PoolApi, Block>
 				let next_action = self.revalidation_strategy.lock().next(
 					block_number,
 					Some(std::time::Duration::from_secs(60)),
-					Some(20.into()),
+					Some(20u32.into()),
 				);
 				let revalidation_strategy = self.revalidation_strategy.clone();
 				let revalidation_queue = self.revalidation_queue.clone();

frame/aura/src/lib.rs

@@ -74,7 +74,7 @@ pub trait Trait: pallet_timestamp::Trait {
 decl_storage! {
 	trait Store for Module<T: Trait> as Aura {
 		/// The last timestamp.
-		LastTimestamp get(fn last) build(|_| 0.into()): T::Moment;
+		LastTimestamp get(fn last): T::Moment;
 
 		/// The current authorities
 		pub Authorities get(fn authorities): Vec<T::AuthorityId>;
@@ -196,7 +196,7 @@ impl<T: Trait> Module<T> {
 	pub fn slot_duration() -> T::Moment {
 		// we double the minimum block-period so each author can always propose within
 		// the majority of its slot.
-		<T as pallet_timestamp::Trait>::MinimumPeriod::get().saturating_mul(2.into())
+		<T as pallet_timestamp::Trait>::MinimumPeriod::get().saturating_mul(2u32.into())
 	}
 
 	fn on_timestamp_set(now: T::Moment, slot_duration: T::Moment) {

frame/babe/src/lib.rs

@@ -371,7 +371,7 @@ impl<T: Trait> Module<T> {
 	pub fn slot_duration() -> T::Moment {
 		// we double the minimum block-period so each author can always propose within
 		// the majority of their slot.
-		<T as pallet_timestamp::Trait>::MinimumPeriod::get().saturating_mul(2.into())
+		<T as pallet_timestamp::Trait>::MinimumPeriod::get().saturating_mul(2u32.into())
 	}
 
 	/// Determine whether an epoch change should take place at this block.

frame/benchmarking/src/lib.rs

@@ -820,7 +820,7 @@ macro_rules! impl_benchmark {
 
 						// Set the block number to at least 1 so events are deposited.
 						if $crate::Zero::is_zero(&frame_system::Module::<T>::block_number()) {
-							frame_system::Module::<T>::set_block_number(1.into());
+							frame_system::Module::<T>::set_block_number(1u32.into());
 						}
 
 						// Commit the externalities to the database, flushing the DB cache.
@@ -966,7 +966,7 @@ macro_rules! impl_benchmark_test {
 
 					// Set the block number to at least 1 so events are deposited.
 					if $crate::Zero::is_zero(&frame_system::Module::<T>::block_number()) {
-						frame_system::Module::<T>::set_block_number(1.into());
+						frame_system::Module::<T>::set_block_number(1u32.into());
 					}
 
 					// Run execution + verification

frame/example-offchain-worker/src/lib.rs

@@ -269,7 +269,7 @@ decl_module! {
 			// to the storage and other included pallets.
 			//
 			// We can easily import `frame_system` and retrieve a block hash of the parent block.
-			let parent_hash = <system::Module<T>>::block_hash(block_number - 1.into());
+			let parent_hash = <system::Module<T>>::block_hash(block_number - 1u32.into());
 			debug::debug!("Current block: {:?} (parent hash: {:?})", block_number, parent_hash);
 
 			// It's a good practice to keep `fn offchain_worker()` function minimal, and move most
@@ -364,10 +364,10 @@ impl<T: Trait> Module<T> {
 				// transactions in a row. If a strict order is desired, it's better to use
 				// the storage entry for that. (for instance store both block number and a flag
 				// indicating the type of next transaction to send).
-				let transaction_type = block_number % 3.into();
+				let transaction_type = block_number % 3u32.into();
 				if transaction_type == Zero::zero() { TransactionType::Signed }
-				else if transaction_type == T::BlockNumber::from(1) { TransactionType::UnsignedForAny }
-				else if transaction_type == T::BlockNumber::from(2) { TransactionType::UnsignedForAll }
+				else if transaction_type == T::BlockNumber::from(1u32) { TransactionType::UnsignedForAny }
+				else if transaction_type == T::BlockNumber::from(2u32) { TransactionType::UnsignedForAll }
 				else { TransactionType::Raw }
 			},
 			// We are in the grace period, we should not send a transaction this time.

frame/executive/src/lib.rs

@@ -468,7 +468,7 @@ where
 		<AllModules as OffchainWorker<System::BlockNumber>>::offchain_worker(
 			// to maintain backward compatibility we call module offchain workers
 			// with parent block number.
-			header.number().saturating_sub(1.into())
+			header.number().saturating_sub(1u32.into())
 		)
 	}
 }

frame/grandpa/src/benchmarking.rs

@@ -65,8 +65,8 @@ benchmarks! {
 	}
 
 	note_stalled {
-		let delay = 1000.into();
-		let best_finalized_block_number = 1.into();
+		let delay = 1000u32.into();
+		let best_finalized_block_number = 1u32.into();
 
 	}: _(RawOrigin::Root, delay, best_finalized_block_number)
 	verify {

frame/grandpa/src/lib.rs

@@ -447,7 +447,7 @@ impl<T: Trait> Module<T> {
 
 				// only allow the next forced change when twice the window has passed since
 				// this one.
-				<NextForced<T>>::put(scheduled_at + in_blocks * 2.into());
+				<NextForced<T>>::put(scheduled_at + in_blocks * 2u32.into());
 			}
 
 			<PendingChange<T>>::put(StoredPendingChange {

frame/im-online/src/lib.rs

@@ -594,7 +594,7 @@ impl<T: Trait> Module<T> {
 
 		// clear the lock in case we have failed to send transaction.
 		if res.is_err() {
-			new_status.sent_at = 0.into();
+			new_status.sent_at = 0u32.into();
 			storage.set(&new_status);
 		}
 
@@ -635,7 +635,7 @@ impl<T: Trait> pallet_session::OneSessionHandler<T::AccountId> for Module<T> {
 		// Since we consider producing blocks as being online,
 		// the heartbeat is deferred a bit to prevent spamming.
 		let block_number = <frame_system::Module<T>>::block_number();
-		let half_session = T::SessionDuration::get() / 2.into();
+		let half_session = T::SessionDuration::get() / 2u32.into();
 		<HeartbeatAfter<T>>::put(block_number + half_session);
 
 		// Remember who the authorities are for the new session.
@@ -723,7 +723,7 @@ impl<T: Trait> frame_support::unsigned::ValidateUnsigned for Module<T> {
 				.priority(T::UnsignedPriority::get())
 				.and_provides((current_session, authority_id))
 				.longevity(TryInto::<u64>::try_into(
-					T::SessionDuration::get() / 2.into()
+					T::SessionDuration::get() / 2u32.into()
 				).unwrap_or(64_u64))
 				.propagate(true)
 				.build()

frame/offences/benchmarking/src/lib.rs

@@ -87,7 +87,7 @@ struct Offender<T: Trait> {
 }
 
 fn bond_amount<T: Trait>() -> BalanceOf<T> {
-	T::Currency::minimum_balance().saturating_mul(10_000.into())
+	T::Currency::minimum_balance().saturating_mul(10_000u32.into())
 }
 
 fn create_offender<T: Trait>(n: u32, nominators: u32) -> Result<Offender<T>, &'static str> {
@@ -97,7 +97,7 @@ fn create_offender<T: Trait>(n: u32, nominators: u32) -> Result<Offender<T>, &'s
 	let reward_destination = RewardDestination::Staked;
 	let raw_amount = bond_amount::<T>();
 	// add twice as much balance to prevent the account from being killed.
-	let free_amount = raw_amount.saturating_mul(2.into());
+	let free_amount = raw_amount.saturating_mul(2u32.into());
 	T::Currency::make_free_balance_be(&stash, free_amount);
 	let amount: BalanceOf<T> = raw_amount.into();
 	Staking::<T>::bond(
@@ -243,7 +243,8 @@ benchmarks! {
 	verify {
 		// make sure the report was not deferred
 		assert!(Offences::<T>::deferred_offences().is_empty());
-		let slash_amount = slash_fraction * bond_amount::<T>().unique_saturated_into() as u32;
+		let bond_amount: u32 = UniqueSaturatedInto::<u32>::unique_saturated_into(bond_amount::<T>());
+		let slash_amount = slash_fraction * bond_amount;
 		let reward_amount = slash_amount * (1 + n) / 2;
 		let mut slash_events = raw_offenders.into_iter()
 			.flat_map(|offender| {
@@ -379,7 +380,7 @@ benchmarks! {
 		Offences::<T>::set_deferred_offences(deferred_offences);
 		assert!(!Offences::<T>::deferred_offences().is_empty());
 	}: {
-		Offences::<T>::on_initialize(0.into());
+		Offences::<T>::on_initialize(0u32.into());
 	}
 	verify {
 		// make sure that all deferred offences were reported with Ok status.

frame/randomness-collective-flip/src/lib.rs

@@ -69,7 +69,7 @@ const RANDOM_MATERIAL_LEN: u32 = 81;
 
 fn block_number_to_index<T: Trait>(block_number: T::BlockNumber) -> usize {
 	// on_initialize is called on the first block after genesis
-	let index = (block_number - 1.into()) % RANDOM_MATERIAL_LEN.into();
+	let index = (block_number - 1u32.into()) % RANDOM_MATERIAL_LEN.into();
 	index.try_into().ok().expect("Something % 81 is always smaller than usize; qed")
 }
 

frame/staking/src/benchmarking.rs

@@ -103,7 +103,7 @@ pub fn create_validator_with_nominators<T: Trait>(
 	ErasRewardPoints::<T>::insert(current_era, reward);
 
 	// Create reward pool
-	let total_payout = T::Currency::minimum_balance() * 1000.into();
+	let total_payout = T::Currency::minimum_balance() * 1000u32.into();
 	<ErasValidatorReward<T>>::insert(current_era, total_payout);
 
 	Ok(v_stash)
@@ -119,7 +119,7 @@ benchmarks! {
 		let controller = create_funded_user::<T>("controller", USER_SEED, 100);
 		let controller_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(controller.clone());
 		let reward_destination = RewardDestination::Staked;
-		let amount = T::Currency::minimum_balance() * 10.into();
+		let amount = T::Currency::minimum_balance() * 10u32.into();
 		do_whitelist!(stash);
 	}: _(RawOrigin::Signed(stash.clone()), controller_lookup, amount, reward_destination)
 	verify {
@@ -129,7 +129,7 @@ benchmarks! {
 
 	bond_extra {
 		let (stash, controller) = create_stash_controller::<T>(USER_SEED, 100, Default::default())?;
-		let max_additional = T::Currency::minimum_balance() * 10.into();
+		let max_additional = T::Currency::minimum_balance() * 10u32.into();
 		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created before")?;
 		let original_bonded: BalanceOf<T> = ledger.active;
 		do_whitelist!(stash);
@@ -142,7 +142,7 @@ benchmarks! {
 
 	unbond {
 		let (_, controller) = create_stash_controller::<T>(USER_SEED, 100, Default::default())?;
-		let amount = T::Currency::minimum_balance() * 10.into();
+		let amount = T::Currency::minimum_balance() * 10u32.into();
 		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created before")?;
 		let original_bonded: BalanceOf<T> = ledger.active;
 		do_whitelist!(controller);
@@ -159,7 +159,7 @@ benchmarks! {
 		let s in 0 .. MAX_SPANS;
 		let (stash, controller) = create_stash_controller::<T>(0, 100, Default::default())?;
 		add_slashing_spans::<T>(&stash, s);
-		let amount = T::Currency::minimum_balance() * 5.into(); // Half of total
+		let amount = T::Currency::minimum_balance() * 5u32.into(); // Half of total
 		Staking::<T>::unbond(RawOrigin::Signed(controller.clone()).into(), amount)?;
 		CurrentEra::put(EraIndex::max_value());
 		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created before")?;
@@ -178,7 +178,7 @@ benchmarks! {
 		let s in 0 .. MAX_SPANS;
 		let (stash, controller) = create_stash_controller::<T>(0, 100, Default::default())?;
 		add_slashing_spans::<T>(&stash, s);
-		let amount = T::Currency::minimum_balance() * 10.into();
+		let amount = T::Currency::minimum_balance() * 10u32.into();
 		Staking::<T>::unbond(RawOrigin::Signed(controller.clone()).into(), amount)?;
 		CurrentEra::put(EraIndex::max_value());
 		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created before")?;
@@ -342,7 +342,7 @@ benchmarks! {
 		let (_, controller) = create_stash_controller::<T>(USER_SEED, 100, Default::default())?;
 		let mut staking_ledger = Ledger::<T>::get(controller.clone()).unwrap();
 		let unlock_chunk = UnlockChunk::<BalanceOf<T>> {
-			value: 1.into(),
+			value: 1u32.into(),
 			era: EraIndex::zero(),
 		};
 		for _ in 0 .. l {
@@ -380,7 +380,7 @@ benchmarks! {
 		let s in 1 .. MAX_SPANS;
 		let (stash, controller) = create_stash_controller::<T>(0, 100, Default::default())?;
 		add_slashing_spans::<T>(&stash, s);
-		T::Currency::make_free_balance_be(&stash, 0.into());
+		T::Currency::make_free_balance_be(&stash, 0u32.into());
 		do_whitelist!(controller);
 	}: _(RawOrigin::Signed(controller), stash.clone(), s)
 	verify {
@@ -427,7 +427,7 @@ benchmarks! {
 		ErasRewardPoints::<T>::insert(current_era, reward);
 
 		// Create reward pool
-		let total_payout = T::Currency::minimum_balance() * 1000.into();
+		let total_payout = T::Currency::minimum_balance() * 1000u32.into();
 		<ErasValidatorReward<T>>::insert(current_era, total_payout);
 
 		let caller: T::AccountId = whitelisted_caller();
@@ -443,14 +443,14 @@ benchmarks! {
 		let (stash, controller) = create_stash_controller::<T>(0, 100, Default::default())?;
 		let mut staking_ledger = Ledger::<T>::get(controller.clone()).unwrap();
 		let unlock_chunk = UnlockChunk::<BalanceOf<T>> {
-			value: 1.into(),
+			value: 1u32.into(),
 			era: EraIndex::zero(),
 		};
 		for _ in 0 .. l {
 			staking_ledger.unlocking.push(unlock_chunk.clone())
 		}
 		Ledger::<T>::insert(controller, staking_ledger);
-		let slash_amount = T::Currency::minimum_balance() * 10.into();
+		let slash_amount = T::Currency::minimum_balance() * 10u32.into();
 		let balance_before = T::Currency::free_balance(&stash);
 	}: {
 		crate::slashing::do_slash::<T>(

frame/system/benchmarking/src/lib.rs

@@ -139,17 +139,17 @@ benchmarks! {
 	suicide {
 		let caller: T::AccountId = whitelisted_caller();
 		let account_info = AccountInfo::<T::Index, T::AccountData> {
-			nonce: 1337.into(),
+			nonce: 1337u32.into(),
 			refcount: 0,
 			data: T::AccountData::default()
 		};
 		frame_system::Account::<T>::insert(&caller, account_info);
 		let new_account_info = System::<T>::account(caller.clone());
-		assert_eq!(new_account_info.nonce, 1337.into());
+		assert_eq!(new_account_info.nonce, 1337u32.into());
 	}: _(RawOrigin::Signed(caller.clone()))
 	verify {
 		let account_info = System::<T>::account(&caller);
-		assert_eq!(account_info.nonce, 0.into());
+		assert_eq!(account_info.nonce, 0u32.into());
 	}
 }
 

frame/system/src/offchain.rs

@@ -183,7 +183,7 @@ impl<T: SigningTypes, C: AppCrypto<T::Public, T::Signature>, X> Signer<T, C, X>
 			.enumerate()
 			.map(|(index, key)| {
 				let generic_public = C::GenericPublic::from(key);
-				let public = generic_public.into();
+				let public: T::Public = generic_public.into();
 				let account_id = public.clone().into_account();
 				Account::new(index, account_id, public)
 			})