Fix compilation with latest nightly (#162)

jordy25519 · bkchr · web-flow · commit 5da1a8c8c31d · 2020-11-19T09:46:12.000+13:00
* Make Substrate compile with latest nightly (#7381)

* Try to get it compiling

* One more

* Make stable happy

* Make stable even more happy ;)

* Update shell.nix

* CI use latest nightly

Co-authored-by: Bastian Köcher &lt;bkchr@users.noreply.github.com&gt;
diff --git a/.circleci/config.yml b/.circleci/config.yml
@@ -13,8 +13,8 @@ commands:
             source ~/.cargo/env
             rustup install $RUST_VERSION
             rustup default $RUST_VERSION
-            rustup install nightly-2020-04-17
-            rustup target add wasm32-unknown-unknown --toolchain=nightly-2020-04-17
+            rustup install nightly
+            rustup target add wasm32-unknown-unknown --toolchain=nightly
             rustup target add x86_64-unknown-linux-musl --toolchain=$RUST_VERSION
             export RUSTC_WRAPPER="" # sccache is uninstalled at this point so it must be unset here for `wasm-gc` install
             command -v wasm-gc || cargo install --git https://github.com/alexcrichton/wasm-gc --force
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/client/cli/src/commands/export_blocks_cmd.rs b/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;
diff --git a/client/finality-grandpa/src/voting_rule.rs b/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)
 	}
 }
diff --git a/client/informant/src/display.rs b/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())
 		);
diff --git a/client/network/src/light_client_handler.rs b/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())),
 			}
 		}
diff --git a/client/service/src/chain_ops/export_blocks.rs b/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 {
diff --git a/client/service/src/chain_ops/import_blocks.rs b/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())
 			);
diff --git a/client/service/src/client/client.rs b/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;
diff --git a/client/service/src/metrics.rs b/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);
diff --git a/client/transaction-pool/src/lib.rs b/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();
diff --git a/frame/aura/src/lib.rs b/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) {
diff --git a/frame/babe/src/lib.rs b/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.
diff --git a/frame/benchmarking/src/lib.rs b/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
diff --git a/frame/benchmarking/src/utils.rs b/frame/benchmarking/src/utils.rs
@@ -219,3 +219,12 @@ pub fn account<AccountId: Decode + Default>(name: &'static str, index: u32, seed
 pub fn whitelisted_caller<AccountId: Decode + Default>() -> AccountId {
 	account::<AccountId>("whitelisted_caller", 0, 0)
 }
+
+#[macro_export]
+macro_rules! whitelist_account {
+	($acc:ident) => {
+		frame_benchmarking::benchmarking::add_to_whitelist(
+			frame_system::Account::<T>::hashed_key_for(&$acc).into()
+		);
+	}
+}
diff --git a/frame/example-offchain-worker/src/lib.rs b/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.
diff --git a/frame/executive/src/lib.rs b/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())
 		)
 	}
 }
diff --git a/frame/grandpa/src/benchmarking.rs b/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 {
diff --git a/frame/grandpa/src/lib.rs b/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 {
diff --git a/frame/im-online/src/lib.rs b/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()
diff --git a/frame/offences/benchmarking/src/lib.rs b/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.
diff --git a/frame/randomness-collective-flip/src/lib.rs b/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")
 }
 
diff --git a/frame/staking/src/benchmarking.rs b/frame/staking/src/benchmarking.rs
diff --git a/frame/system/benchmarking/src/lib.rs b/frame/system/benchmarking/src/lib.rs
diff --git a/frame/system/src/offchain.rs b/frame/system/src/offchain.rs
diff --git a/frame/timestamp/src/lib.rs b/frame/timestamp/src/lib.rs
diff --git a/frame/treasury/src/lib.rs b/frame/treasury/src/lib.rs
diff --git a/primitives/arithmetic/src/fixed_point.rs b/primitives/arithmetic/src/fixed_point.rs
diff --git a/primitives/npos-elections/src/mock.rs b/primitives/npos-elections/src/mock.rs
diff --git a/shell.nix b/shell.nix
diff --git a/test-utils/client/src/client_ext.rs b/test-utils/client/src/client_ext.rs

Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ impl ExportBlocksCmd {`
`85`	`85`	`info!("DB path: {}", path.display());`
`86`	`86`	`}`
`87`	`87`
`88`		`- let from = self.from.as_ref().and_then(\|f\| f.parse().ok()).unwrap_or(1);`
	`88`	`+ let from = self.from.as_ref().and_then(\|f\| f.parse().ok()).unwrap_or(1u32);`
`89`	`89`	`let to = self.to.as_ref().and_then(\|t\| t.parse().ok());`
`90`	`90`
`91`	`91`	`let binary = self.binary;`
Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ impl<Block, B> Default for VotingRulesBuilder<Block, B> where`
`241`	`241`	`{`
`242`	`242`	`fn default() -> Self {`
`243`	`243`	`VotingRulesBuilder::new()`
`244`		`- .add(BeforeBestBlockBy(2.into()))`
	`244`	`+ .add(BeforeBestBlockBy(2u32.into()))`
`245`	`245`	`.add(ThreeQuartersOfTheUnfinalizedChain)`
`246`	`246`	`}`
`247`	`247`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1429,7 +1429,7 @@ mod tests {`
`1429`	`1429`	`_: ChangesProof<B::Header>`
`1430`	`1430`	`) -> Result<Vec<(NumberFor<B>, u32)>, ClientError> {`
`1431`	`1431`	`match self.ok {`
`1432`		`- true => Ok(vec![(100.into(), 2)]),`
	`1432`	`+ true => Ok(vec![(100u32.into(), 2)]),`
`1433`	`1433`	`false => Err(ClientError::Backend("Test error".into())),`
`1434`	`1434`	`}`
`1435`	`1435`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ where`
`87`	`87`	`// Reached end of the chain.`
`88`	`88`	`None => return Poll::Ready(Ok(())),`
`89`	`89`	`}`
`90`		`- if (block % 10000.into()).is_zero() {`
	`90`	`+ if (block % 10000u32.into()).is_zero() {`
`91`	`91`	`info!("#{}", block);`
`92`	`92`	`}`
`93`	`93`	`if block == last {`