Run cargo fmt on the whole code base (#9394)

* Run cargo fmt on the whole code base

* Second run

* Add CI check

* Fix compilation

* More unnecessary braces

* Handle weights

* Use --all

* Use correct attributes...

* Fix UI tests

* AHHHHHHHHH

* 🤦

* Docs

* Fix compilation

* 🤷

* Please stop

* 🤦 x 2

* More

* make rustfmt.toml consistent with polkadot

Co-authored-by: André Silva <andrerfosilva@gmail.com>

substrate/client/consensus/babe/src/authorship.rs

@@ -18,23 +18,17 @@
 
 //! BABE authority selection and slot claiming.
 
+use super::Epoch;
+use codec::Encode;
+use schnorrkel::{keys::PublicKey, vrf::VRFInOut};
 use sp_application_crypto::AppKey;
 use sp_consensus_babe::{
-	BABE_VRF_PREFIX, AuthorityId, BabeAuthorityWeight, make_transcript, make_transcript_data,
-	Slot,
-};
-use sp_consensus_babe::digests::{
-	PreDigest, PrimaryPreDigest, SecondaryPlainPreDigest, SecondaryVRFPreDigest,
+	digests::{PreDigest, PrimaryPreDigest, SecondaryPlainPreDigest, SecondaryVRFPreDigest},
+	make_transcript, make_transcript_data, AuthorityId, BabeAuthorityWeight, Slot, BABE_VRF_PREFIX,
 };
 use sp_consensus_vrf::schnorrkel::{VRFOutput, VRFProof};
-use sp_core::{U256, blake2_256, crypto::Public};
-use sp_keystore::{SyncCryptoStorePtr, SyncCryptoStore};
-use codec::Encode;
-use schnorrkel::{
-	keys::PublicKey,
-	vrf::VRFInOut,
-};
-use super::Epoch;
+use sp_core::{blake2_256, crypto::Public, U256};
+use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 
 /// Calculates the primary selection threshold for a given authority, taking
 /// into account `c` (`1 - c` represents the probability of a slot being empty).
@@ -49,8 +43,7 @@ pub(super) fn calculate_primary_threshold(
 
 	let c = c.0 as f64 / c.1 as f64;
 
-	let theta =
-		authorities[authority_index].1 as f64 /
+	let theta = authorities[authority_index].1 as f64 /
 		authorities.iter().map(|(_, weight)| weight).sum::<u64>() as f64;
 
 	assert!(theta > 0.0, "authority with weight 0.");
@@ -74,14 +67,14 @@ pub(super) fn calculate_primary_threshold(
 		"returns None when the given value is negative; \
 		 p is defined as `1 - n` where n is defined in (0, 1]; \
 		 p must be a value in [0, 1); \
-		 qed."
+		 qed.",
 	);
 
 	let denom = p.denom().to_biguint().expect(
 		"returns None when the given value is negative; \
 		 p is defined as `1 - n` where n is defined in (0, 1]; \
 		 p must be a value in [0, 1); \
-		 qed."
+		 qed.",
 	);
 
 	((BigUint::one() << 128) * numer / denom).to_u128().expect(
@@ -108,7 +101,7 @@ pub(super) fn secondary_slot_author(
 	randomness: [u8; 32],
 ) -> Option<&AuthorityId> {
 	if authorities.is_empty() {
-		return None;
+		return None
 	}
 
 	let rand = U256::from((randomness, slot).using_encoded(blake2_256));
@@ -116,9 +109,10 @@ pub(super) fn secondary_slot_author(
 	let authorities_len = U256::from(authorities.len());
 	let idx = rand % authorities_len;
 
-	let expected_author = authorities.get(idx.as_u32() as usize)
-		.expect("authorities not empty; index constrained to list length; \
-				this is a valid index; qed");
+	let expected_author = authorities.get(idx.as_u32() as usize).expect(
+		"authorities not empty; index constrained to list length; \
+				this is a valid index; qed",
+	);
 
 	Some(&expected_author.0)
 }
@@ -136,23 +130,15 @@ fn claim_secondary_slot(
 	let Epoch { authorities, randomness, epoch_index, .. } = epoch;
 
 	if authorities.is_empty() {
-		return None;
+		return None
 	}
 
-	let expected_author = secondary_slot_author(
-		slot,
-		authorities,
-		*randomness,
-	)?;
+	let expected_author = secondary_slot_author(slot, authorities, *randomness)?;
 
 	for (authority_id, authority_index) in keys {
 		if authority_id == expected_author {
 			let pre_digest = if author_secondary_vrf {
-				let transcript_data = make_transcript_data(
-					randomness,
-					slot,
-					*epoch_index,
-				);
+				let transcript_data = make_transcript_data(randomness, slot, *epoch_index);
 				let result = SyncCryptoStore::sr25519_vrf_sign(
 					&**keystore,
 					AuthorityId::ID,
@@ -169,7 +155,10 @@ fn claim_secondary_slot(
 				} else {
 					None
 				}
-			} else if SyncCryptoStore::has_keys(&**keystore, &[(authority_id.to_raw_vec(), AuthorityId::ID)]) {
+			} else if SyncCryptoStore::has_keys(
+				&**keystore,
+				&[(authority_id.to_raw_vec(), AuthorityId::ID)],
+			) {
 				Some(PreDigest::SecondaryPlain(SecondaryPlainPreDigest {
 					slot,
 					authority_index: *authority_index as u32,
@@ -179,7 +168,7 @@ fn claim_secondary_slot(
 			};
 
 			if let Some(pre_digest) = pre_digest {
-				return Some((pre_digest, authority_id.clone()));
+				return Some((pre_digest, authority_id.clone()))
 			}
 		}
 	}
@@ -196,7 +185,9 @@ pub fn claim_slot(
 	epoch: &Epoch,
 	keystore: &SyncCryptoStorePtr,
 ) -> Option<(PreDigest, AuthorityId)> {
-	let authorities = epoch.authorities.iter()
+	let authorities = epoch
+		.authorities
+		.iter()
 		.enumerate()
 		.map(|(index, a)| (a.0.clone(), index))
 		.collect::<Vec<_>>();
@@ -211,22 +202,21 @@ pub fn claim_slot_using_keys(
 	keystore: &SyncCryptoStorePtr,
 	keys: &[(AuthorityId, usize)],
 ) -> Option<(PreDigest, AuthorityId)> {
-	claim_primary_slot(slot, epoch, epoch.config.c, keystore, &keys)
-		.or_else(|| {
-			if epoch.config.allowed_slots.is_secondary_plain_slots_allowed() ||
-				epoch.config.allowed_slots.is_secondary_vrf_slots_allowed()
-			{
-				claim_secondary_slot(
-					slot,
-					&epoch,
-					keys,
-					&keystore,
-					epoch.config.allowed_slots.is_secondary_vrf_slots_allowed(),
-				)
-			} else {
-				None
-			}
-		})
+	claim_primary_slot(slot, epoch, epoch.config.c, keystore, &keys).or_else(|| {
+		if epoch.config.allowed_slots.is_secondary_plain_slots_allowed() ||
+			epoch.config.allowed_slots.is_secondary_vrf_slots_allowed()
+		{
+			claim_secondary_slot(
+				slot,
+				&epoch,
+				keys,
+				&keystore,
+				epoch.config.allowed_slots.is_secondary_vrf_slots_allowed(),
+			)
+		} else {
+			None
+		}
+	})
 }
 
 /// Claim a primary slot if it is our turn.  Returns `None` if it is not our turn.
@@ -243,16 +233,8 @@ fn claim_primary_slot(
 	let Epoch { authorities, randomness, epoch_index, .. } = epoch;
 
 	for (authority_id, authority_index) in keys {
-		let transcript = make_transcript(
-			randomness,
-			slot,
-			*epoch_index
-		);
-		let transcript_data = make_transcript_data(
-			randomness,
-			slot,
-			*epoch_index
-		);
+		let transcript = make_transcript(randomness, slot, *epoch_index);
+		let transcript_data = make_transcript_data(randomness, slot, *epoch_index);
 		// Compute the threshold we will use.
 		//
 		// We already checked that authorities contains `key.public()`, so it can't
@@ -279,7 +261,7 @@ fn claim_primary_slot(
 					authority_index: *authority_index as u32,
 				});
 
-				return Some((pre_digest, authority_id.clone()));
+				return Some((pre_digest, authority_id.clone()))
 			}
 		}
 	}
@@ -290,10 +272,10 @@ fn claim_primary_slot(
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use std::sync::Arc;
-	use sp_core::{sr25519::Pair, crypto::Pair as _};
-	use sp_consensus_babe::{AuthorityId, BabeEpochConfiguration, AllowedSlots};
 	use sc_keystore::LocalKeystore;
+	use sp_consensus_babe::{AllowedSlots, AuthorityId, BabeEpochConfiguration};
+	use sp_core::{crypto::Pair as _, sr25519::Pair};
+	use std::sync::Arc;
 
 	#[test]
 	fn claim_secondary_plain_slot_works() {
@@ -302,7 +284,8 @@ mod tests {
 			&*keystore,
 			AuthorityId::ID,
 			Some(sp_core::crypto::DEV_PHRASE),
-		).unwrap();
+		)
+		.unwrap();
 
 		let authorities = vec![
 			(AuthorityId::from(Pair::generate().0.public()), 5),