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/api/src/cht.rs

@@ -25,15 +25,15 @@
 //! root hash. A correct proof implies that the claimed block is identical to the one
 //! we discarded.
 
-use hash_db;
 use codec::Encode;
+use hash_db;
 use sp_trie;
 
-use sp_core::{H256, convert_hash};
-use sp_runtime::traits::{Header as HeaderT, AtLeast32Bit, Zero, One};
+use sp_core::{convert_hash, H256};
+use sp_runtime::traits::{AtLeast32Bit, Header as HeaderT, One, Zero};
 use sp_state_machine::{
-	MemoryDB, TrieBackend, Backend as StateBackend, StorageProof, InMemoryBackend,
-	prove_read_on_trie_backend, read_proof_check, read_proof_check_on_proving_backend
+	prove_read_on_trie_backend, read_proof_check, read_proof_check_on_proving_backend,
+	Backend as StateBackend, InMemoryBackend, MemoryDB, StorageProof, TrieBackend,
 };
 
 use sp_blockchain::{Error as ClientError, Result as ClientResult};
@@ -49,17 +49,17 @@ pub fn size<N: From<u32>>() -> N {
 
 /// Returns Some(cht_number) if CHT is need to be built when the block with given number is canonized.
 pub fn is_build_required<N>(cht_size: N, block_num: N) -> Option<N>
-	where
-		N: Clone + AtLeast32Bit,
+where
+	N: Clone + AtLeast32Bit,
 {
 	let block_cht_num = block_to_cht_number(cht_size.clone(), block_num.clone())?;
 	let two = N::one() + N::one();
 	if block_cht_num < two {
-		return None;
+		return None
 	}
 	let cht_start = start_number(cht_size, block_cht_num.clone());
 	if cht_start != block_num {
-		return None;
+		return None
 	}
 
 	Some(block_cht_num - two)
@@ -67,13 +67,13 @@ pub fn is_build_required<N>(cht_size: N, block_num: N) -> Option<N>
 
 /// Returns Some(max_cht_number) if CHT has ever been built given maximal canonical block number.
 pub fn max_cht_number<N>(cht_size: N, max_canonical_block: N) -> Option<N>
-	where
-		N: Clone + AtLeast32Bit,
+where
+	N: Clone + AtLeast32Bit,
 {
 	let max_cht_number = block_to_cht_number(cht_size, max_canonical_block)?;
 	let two = N::one() + N::one();
 	if max_cht_number < two {
-		return None;
+		return None
 	}
 	Some(max_cht_number - two)
 }
@@ -86,16 +86,16 @@ pub fn compute_root<Header, Hasher, I>(
 	cht_num: Header::Number,
 	hashes: I,
 ) -> ClientResult<Hasher::Out>
-	where
-		Header: HeaderT,
-		Hasher: hash_db::Hasher,
-		Hasher::Out: Ord,
-		I: IntoIterator<Item=ClientResult<Option<Header::Hash>>>,
+where
+	Header: HeaderT,
+	Hasher: hash_db::Hasher,
+	Hasher::Out: Ord,
+	I: IntoIterator<Item = ClientResult<Option<Header::Hash>>>,
 {
 	use sp_trie::TrieConfiguration;
-	Ok(sp_trie::trie_types::Layout::<Hasher>::trie_root(
-		build_pairs::<Header, I>(cht_size, cht_num, hashes)?
-	))
+	Ok(sp_trie::trie_types::Layout::<Hasher>::trie_root(build_pairs::<Header, I>(
+		cht_size, cht_num, hashes,
+	)?))
 }
 
 /// Build CHT-based header proof.
@@ -103,26 +103,28 @@ pub fn build_proof<Header, Hasher, BlocksI, HashesI>(
 	cht_size: Header::Number,
 	cht_num: Header::Number,
 	blocks: BlocksI,
-	hashes: HashesI
+	hashes: HashesI,
 ) -> ClientResult<StorageProof>
-	where
-		Header: HeaderT,
-		Hasher: hash_db::Hasher,
-		Hasher::Out: Ord + codec::Codec,
-		BlocksI: IntoIterator<Item=Header::Number>,
-		HashesI: IntoIterator<Item=ClientResult<Option<Header::Hash>>>,
+where
+	Header: HeaderT,
+	Hasher: hash_db::Hasher,
+	Hasher::Out: Ord + codec::Codec,
+	BlocksI: IntoIterator<Item = Header::Number>,
+	HashesI: IntoIterator<Item = ClientResult<Option<Header::Hash>>>,
 {
 	let transaction = build_pairs::<Header, _>(cht_size, cht_num, hashes)?
 		.into_iter()
 		.map(|(k, v)| (k, Some(v)))
 		.collect::<Vec<_>>();
 	let mut storage = InMemoryBackend::<Hasher>::default().update(vec![(None, transaction)]);
-	let trie_storage = storage.as_trie_backend()
+	let trie_storage = storage
+		.as_trie_backend()
 		.expect("InMemoryState::as_trie_backend always returns Some; qed");
 	prove_read_on_trie_backend(
 		trie_storage,
 		blocks.into_iter().map(|number| encode_cht_key(number)),
-	).map_err(ClientError::from_state)
+	)
+	.map_err(ClientError::from_state)
 }
 
 /// Check CHT-based header proof.
@@ -132,25 +134,24 @@ pub fn check_proof<Header, Hasher>(
 	remote_hash: Header::Hash,
 	remote_proof: StorageProof,
 ) -> ClientResult<()>
-	where
-		Header: HeaderT,
-		Hasher: hash_db::Hasher,
-		Hasher::Out: Ord + codec::Codec,
+where
+	Header: HeaderT,
+	Hasher: hash_db::Hasher,
+	Hasher::Out: Ord + codec::Codec,
 {
 	do_check_proof::<Header, Hasher, _>(
 		local_root,
 		local_number,
 		remote_hash,
-		move |local_root, local_cht_key|
+		move |local_root, local_cht_key| {
 			read_proof_check::<Hasher, _>(
 				local_root,
 				remote_proof,
 				::std::iter::once(local_cht_key),
 			)
-			.map(|mut map| map
-				.remove(local_cht_key)
-				.expect("checked proof of local_cht_key; qed"))
-			.map_err(ClientError::from_state),
+			.map(|mut map| map.remove(local_cht_key).expect("checked proof of local_cht_key; qed"))
+			.map_err(ClientError::from_state)
+		},
 	)
 }
 
@@ -161,20 +162,19 @@ pub fn check_proof_on_proving_backend<Header, Hasher>(
 	remote_hash: Header::Hash,
 	proving_backend: &TrieBackend<MemoryDB<Hasher>, Hasher>,
 ) -> ClientResult<()>
-	where
-		Header: HeaderT,
-		Hasher: hash_db::Hasher,
-		Hasher::Out: Ord + codec::Codec,
+where
+	Header: HeaderT,
+	Hasher: hash_db::Hasher,
+	Hasher::Out: Ord + codec::Codec,
 {
 	do_check_proof::<Header, Hasher, _>(
 		local_root,
 		local_number,
 		remote_hash,
-		|_, local_cht_key|
-			read_proof_check_on_proving_backend::<Hasher>(
-				proving_backend,
-				local_cht_key,
-			).map_err(ClientError::from_state),
+		|_, local_cht_key| {
+			read_proof_check_on_proving_backend::<Hasher>(proving_backend, local_cht_key)
+				.map_err(ClientError::from_state)
+		},
 	)
 }
 
@@ -185,22 +185,22 @@ fn do_check_proof<Header, Hasher, F>(
 	remote_hash: Header::Hash,
 	checker: F,
 ) -> ClientResult<()>
-	where
-		Header: HeaderT,
-		Hasher: hash_db::Hasher,
-		Hasher::Out: Ord,
-		F: FnOnce(Hasher::Out, &[u8]) -> ClientResult<Option<Vec<u8>>>,
+where
+	Header: HeaderT,
+	Hasher: hash_db::Hasher,
+	Hasher::Out: Ord,
+	F: FnOnce(Hasher::Out, &[u8]) -> ClientResult<Option<Vec<u8>>>,
 {
 	let root: Hasher::Out = convert_hash(&local_root);
 	let local_cht_key = encode_cht_key(local_number);
 	let local_cht_value = checker(root, &local_cht_key)?;
 	let local_cht_value = local_cht_value.ok_or_else(|| ClientError::InvalidCHTProof)?;
-	let local_hash = decode_cht_value(&local_cht_value).ok_or_else(|| ClientError::InvalidCHTProof)?;
+	let local_hash =
+		decode_cht_value(&local_cht_value).ok_or_else(|| ClientError::InvalidCHTProof)?;
 	match &local_hash[..] == remote_hash.as_ref() {
 		true => Ok(()),
 		false => Err(ClientError::InvalidCHTProof.into()),
 	}
-
 }
 
 /// Group ordered blocks by CHT number and call functor with blocks of each group.
@@ -210,29 +210,31 @@ pub fn for_each_cht_group<Header, I, F, P>(
 	mut functor: F,
 	mut functor_param: P,
 ) -> ClientResult<()>
-	where
-		Header: HeaderT,
-		I: IntoIterator<Item=Header::Number>,
-		F: FnMut(P, Header::Number, Vec<Header::Number>) -> ClientResult<P>,
+where
+	Header: HeaderT,
+	I: IntoIterator<Item = Header::Number>,
+	F: FnMut(P, Header::Number, Vec<Header::Number>) -> ClientResult<P>,
 {
 	let mut current_cht_num = None;
 	let mut current_cht_blocks = Vec::new();
 	for block in blocks {
-		let new_cht_num = block_to_cht_number(cht_size, block).ok_or_else(|| ClientError::Backend(format!(
-				"Cannot compute CHT root for the block #{}", block))
-			)?;
+		let new_cht_num = block_to_cht_number(cht_size, block).ok_or_else(|| {
+			ClientError::Backend(format!("Cannot compute CHT root for the block #{}", block))
+		})?;
 
 		let advance_to_next_cht = current_cht_num.is_some() && current_cht_num != Some(new_cht_num);
 		if advance_to_next_cht {
-			let current_cht_num = current_cht_num.expect("advance_to_next_cht is true;
-				it is true only when current_cht_num is Some; qed");
-			assert!(new_cht_num > current_cht_num, "for_each_cht_group only supports ordered iterators");
+			let current_cht_num = current_cht_num.expect(
+				"advance_to_next_cht is true;
+				it is true only when current_cht_num is Some; qed",
+			);
+			assert!(
+				new_cht_num > current_cht_num,
+				"for_each_cht_group only supports ordered iterators"
+			);
 
-			functor_param = functor(
-				functor_param,
-				current_cht_num,
-				std::mem::take(&mut current_cht_blocks),
-			)?;
+			functor_param =
+				functor(functor_param, current_cht_num, std::mem::take(&mut current_cht_blocks))?;
 		}
 
 		current_cht_blocks.push(block);
@@ -240,11 +242,7 @@ pub fn for_each_cht_group<Header, I, F, P>(
 	}
 
 	if let Some(current_cht_num) = current_cht_num {
-		functor(
-			functor_param,
-			current_cht_num,
-			std::mem::take(&mut current_cht_blocks),
-		)?;
+		functor(functor_param, current_cht_num, std::mem::take(&mut current_cht_blocks))?;
 	}
 
 	Ok(())
@@ -254,26 +252,22 @@ pub fn for_each_cht_group<Header, I, F, P>(
 fn build_pairs<Header, I>(
 	cht_size: Header::Number,
 	cht_num: Header::Number,
-	hashes: I
+	hashes: I,
 ) -> ClientResult<Vec<(Vec<u8>, Vec<u8>)>>
-	where
-		Header: HeaderT,
-		I: IntoIterator<Item=ClientResult<Option<Header::Hash>>>,
+where
+	Header: HeaderT,
+	I: IntoIterator<Item = ClientResult<Option<Header::Hash>>>,
 {
 	let start_num = start_number(cht_size, cht_num);
 	let mut pairs = Vec::new();
 	let mut hash_index = Header::Number::zero();
 	for hash in hashes.into_iter() {
-		let hash = hash?.ok_or_else(|| ClientError::from(
-			ClientError::MissingHashRequiredForCHT
-		))?;
-		pairs.push((
-			encode_cht_key(start_num + hash_index).to_vec(),
-			encode_cht_value(hash)
-		));
+		let hash =
+			hash?.ok_or_else(|| ClientError::from(ClientError::MissingHashRequiredForCHT))?;
+		pairs.push((encode_cht_key(start_num + hash_index).to_vec(), encode_cht_value(hash)));
 		hash_index += Header::Number::one();
 		if hash_index == cht_size {
-			break;
+			break
 		}
 	}
 
@@ -325,7 +319,6 @@ pub fn decode_cht_value(value: &[u8]) -> Option<H256> {
 		32 => Some(H256::from_slice(&value[0..32])),
 		_ => None,
 	}
-
 }
 
 #[cfg(test)]
@@ -379,8 +372,12 @@ mod tests {
 
 	#[test]
 	fn build_pairs_fails_when_no_enough_blocks() {
-		assert!(build_pairs::<Header, _>(SIZE as _, 0,
-			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1)))).take(SIZE as usize / 2)).is_err());
+		assert!(build_pairs::<Header, _>(
+			SIZE as _,
+			0,
+			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1)))).take(SIZE as usize / 2)
+		)
+		.is_err());
 	}
 
 	#[test]
@@ -391,9 +388,12 @@ mod tests {
 			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1))))
 				.take(SIZE as usize / 2)
 				.chain(::std::iter::once(Ok(None)))
-				.chain(::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(2))))
-					.take(SIZE as usize / 2 - 1))
-		).is_err());
+				.chain(
+					::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(2))))
+						.take(SIZE as usize / 2 - 1)
+				)
+		)
+		.is_err());
 	}
 
 	#[test]
@@ -401,9 +401,9 @@ mod tests {
 		assert!(compute_root::<Header, BlakeTwo256, _>(
 			SIZE as _,
 			42,
-			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1))))
-				.take(SIZE as usize)
-		).is_ok());
+			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1)))).take(SIZE as usize)
+		)
+		.is_ok());
 	}
 
 	#[test]
@@ -413,9 +413,9 @@ mod tests {
 			SIZE as _,
 			0,
 			vec![(SIZE * 1000) as u64],
-			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1))))
-				.take(SIZE as usize)
-		).is_err());
+			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1)))).take(SIZE as usize)
+		)
+		.is_err());
 	}
 
 	#[test]
@@ -424,9 +424,9 @@ mod tests {
 			SIZE as _,
 			0,
 			vec![(SIZE / 2) as u64],
-			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1))))
-				.take(SIZE as usize)
-		).is_ok());
+			::std::iter::repeat_with(|| Ok(Some(H256::from_low_u64_be(1)))).take(SIZE as usize)
+		)
+		.is_ok());
 	}
 
 	#[test]
@@ -447,19 +447,27 @@ mod tests {
 		let _ = for_each_cht_group::<Header, _, _, _>(
 			cht_size,
 			vec![
-				cht_size * 2 + 1, cht_size * 2 + 2, cht_size * 2 + 5,
-				cht_size * 4 + 1, cht_size * 4 + 7,
-				cht_size * 6 + 1
-			], |_, cht_num, blocks| {
+				cht_size * 2 + 1,
+				cht_size * 2 + 2,
+				cht_size * 2 + 5,
+				cht_size * 4 + 1,
+				cht_size * 4 + 7,
+				cht_size * 6 + 1,
+			],
+			|_, cht_num, blocks| {
 				match cht_num {
-					2 => assert_eq!(blocks, vec![cht_size * 2 + 1, cht_size * 2 + 2, cht_size * 2 + 5]),
+					2 => assert_eq!(
+						blocks,
+						vec![cht_size * 2 + 1, cht_size * 2 + 2, cht_size * 2 + 5]
+					),
 					4 => assert_eq!(blocks, vec![cht_size * 4 + 1, cht_size * 4 + 7]),
 					6 => assert_eq!(blocks, vec![cht_size * 6 + 1]),
 					_ => unreachable!(),
 				}
 
 				Ok(())
-			}, ()
+			},
+			(),
 		);
 	}
 }