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/primitives/state-machine/src/proving_backend.rs

@@ -17,20 +17,28 @@
 
 //! Proving state machine backend.
 
-use std::{sync::Arc, collections::{HashMap, hash_map::Entry}};
-use parking_lot::RwLock;
-use codec::{Decode, Codec, Encode};
-use log::debug;
-use hash_db::{Hasher, HashDB, EMPTY_PREFIX, Prefix};
-use sp_trie::{
-	MemoryDB, empty_child_trie_root, read_trie_value_with, read_child_trie_value_with,
-	record_all_keys, StorageProof,
+use crate::{
+	trie_backend::TrieBackend,
+	trie_backend_essence::{Ephemeral, TrieBackendEssence, TrieBackendStorage},
+	Backend, DBValue, Error, ExecutionError,
 };
-pub use sp_trie::{Recorder, trie_types::{Layout, TrieError}};
-use crate::trie_backend::TrieBackend;
-use crate::trie_backend_essence::{Ephemeral, TrieBackendEssence, TrieBackendStorage};
-use crate::{Error, ExecutionError, Backend, DBValue};
+use codec::{Codec, Decode, Encode};
+use hash_db::{HashDB, Hasher, Prefix, EMPTY_PREFIX};
+use log::debug;
+use parking_lot::RwLock;
 use sp_core::storage::ChildInfo;
+use sp_trie::{
+	empty_child_trie_root, read_child_trie_value_with, read_trie_value_with, record_all_keys,
+	MemoryDB, StorageProof,
+};
+pub use sp_trie::{
+	trie_types::{Layout, TrieError},
+	Recorder,
+};
+use std::{
+	collections::{hash_map::Entry, HashMap},
+	sync::Arc,
+};
 
 /// Patricia trie-based backend specialized in get value proofs.
 pub struct ProvingBackendRecorder<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher> {
@@ -39,18 +47,15 @@ pub struct ProvingBackendRecorder<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Has
 }
 
 impl<'a, S, H> ProvingBackendRecorder<'a, S, H>
-	where
-		S: TrieBackendStorage<H>,
-		H: Hasher,
-		H::Out: Codec,
+where
+	S: TrieBackendStorage<H>,
+	H: Hasher,
+	H::Out: Codec,
 {
 	/// Produce proof for a key query.
 	pub fn storage(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>, String> {
 		let mut read_overlay = S::Overlay::default();
-		let eph = Ephemeral::new(
-			self.backend.backend_storage(),
-			&mut read_overlay,
-		);
+		let eph = Ephemeral::new(self.backend.backend_storage(), &mut read_overlay);
 
 		let map_e = |e| format!("Trie lookup error: {}", e);
 
@@ -59,25 +64,24 @@ impl<'a, S, H> ProvingBackendRecorder<'a, S, H>
 			self.backend.root(),
 			key,
 			&mut *self.proof_recorder,
-		).map_err(map_e)
+		)
+		.map_err(map_e)
 	}
 
 	/// Produce proof for a child key query.
 	pub fn child_storage(
 		&mut self,
 		child_info: &ChildInfo,
-		key: &[u8]
+		key: &[u8],
 	) -> Result<Option<Vec<u8>>, String> {
 		let storage_key = child_info.storage_key();
-		let root = self.storage(storage_key)?
+		let root = self
+			.storage(storage_key)?
 			.and_then(|r| Decode::decode(&mut &r[..]).ok())
 			.unwrap_or_else(|| empty_child_trie_root::<Layout<H>>());
 
 		let mut read_overlay = S::Overlay::default();
-		let eph = Ephemeral::new(
-			self.backend.backend_storage(),
-			&mut read_overlay,
-		);
+		let eph = Ephemeral::new(self.backend.backend_storage(), &mut read_overlay);
 
 		let map_e = |e| format!("Trie lookup error: {}", e);
 
@@ -86,17 +90,15 @@ impl<'a, S, H> ProvingBackendRecorder<'a, S, H>
 			&eph,
 			&root.as_ref(),
 			key,
-			&mut *self.proof_recorder
-		).map_err(map_e)
+			&mut *self.proof_recorder,
+		)
+		.map_err(map_e)
 	}
 
 	/// Produce proof for the whole backend.
 	pub fn record_all_keys(&mut self) {
 		let mut read_overlay = S::Overlay::default();
-		let eph = Ephemeral::new(
-			self.backend.backend_storage(),
-			&mut read_overlay,
-		);
+		let eph = Ephemeral::new(self.backend.backend_storage(), &mut read_overlay);
 
 		let mut iter = move || -> Result<(), Box<TrieError<H::Out>>> {
 			let root = self.backend.root();
@@ -150,13 +152,14 @@ impl<Hash: std::hash::Hash + Eq> ProofRecorder<Hash> {
 	/// encoded proof.
 	pub fn estimate_encoded_size(&self) -> usize {
 		let inner = self.inner.read();
-		inner.encoded_size
-			+ codec::Compact(inner.records.len() as u32).encoded_size()
+		inner.encoded_size + codec::Compact(inner.records.len() as u32).encoded_size()
 	}
 
 	/// Convert into a [`StorageProof`].
 	pub fn to_storage_proof(&self) -> StorageProof {
-		let trie_nodes = self.inner.read()
+		let trie_nodes = self
+			.inner
+			.read()
 			.records
 			.iter()
 			.filter_map(|(_k, v)| v.as_ref().map(|v| v.to_vec()))
@@ -175,7 +178,7 @@ impl<Hash: std::hash::Hash + Eq> ProofRecorder<Hash> {
 
 /// Patricia trie-based backend which also tracks all touched storage trie values.
 /// These can be sent to remote node and used as a proof of execution.
-pub struct ProvingBackend<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher> (
+pub struct ProvingBackend<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher>(
 	TrieBackend<ProofRecorderBackend<'a, S, H>, H>,
 );
 
@@ -186,7 +189,8 @@ pub struct ProofRecorderBackend<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hashe
 }
 
 impl<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher> ProvingBackend<'a, S, H>
-	where H::Out: Codec
+where
+	H::Out: Codec,
 {
 	/// Create new proving backend.
 	pub fn new(backend: &'a TrieBackend<S, H>) -> Self {
@@ -201,10 +205,7 @@ impl<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher> ProvingBackend<'a, S, H>
 	) -> Self {
 		let essence = backend.essence();
 		let root = essence.root().clone();
-		let recorder = ProofRecorderBackend {
-			backend: essence.backend_storage(),
-			proof_recorder,
-		};
+		let recorder = ProofRecorderBackend { backend: essence.backend_storage(), proof_recorder };
 		ProvingBackend(TrieBackend::new(recorder, root))
 	}
 
@@ -229,7 +230,7 @@ impl<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher> TrieBackendStorage<H>
 
 	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>, String> {
 		if let Some(v) = self.proof_recorder.get(key) {
-			return Ok(v);
+			return Ok(v)
 		}
 
 		let backend_value = self.backend.get(key, prefix)?;
@@ -247,10 +248,10 @@ impl<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher> std::fmt::Debug
 }
 
 impl<'a, S, H> Backend<H> for ProvingBackend<'a, S, H>
-	where
-		S: 'a + TrieBackendStorage<H>,
-		H: 'a + Hasher,
-		H::Out: Ord + Codec,
+where
+	S: 'a + TrieBackendStorage<H>,
+	H: 'a + Hasher,
+	H::Out: Ord + Codec,
 {
 	type Error = String;
 	type Transaction = S::Overlay;
@@ -314,7 +315,7 @@ impl<'a, S, H> Backend<H> for ProvingBackend<'a, S, H>
 		prefix: &[u8],
 		f: F,
 	) {
-		self.0.for_child_keys_with_prefix( child_info, prefix, f)
+		self.0.for_child_keys_with_prefix(child_info, prefix, f)
 	}
 
 	fn pairs(&self) -> Vec<(Vec<u8>, Vec<u8>)> {
@@ -325,30 +326,32 @@ impl<'a, S, H> Backend<H> for ProvingBackend<'a, S, H>
 		self.0.keys(prefix)
 	}
 
-	fn child_keys(
-		&self,
-		child_info: &ChildInfo,
-		prefix: &[u8],
-	) -> Vec<Vec<u8>> {
+	fn child_keys(&self, child_info: &ChildInfo, prefix: &[u8]) -> Vec<Vec<u8>> {
 		self.0.child_keys(child_info, prefix)
 	}
 
 	fn storage_root<'b>(
 		&self,
-		delta: impl Iterator<Item=(&'b [u8], Option<&'b [u8]>)>,
-	) -> (H::Out, Self::Transaction) where H::Out: Ord {
+		delta: impl Iterator<Item = (&'b [u8], Option<&'b [u8]>)>,
+	) -> (H::Out, Self::Transaction)
+	where
+		H::Out: Ord,
+	{
 		self.0.storage_root(delta)
 	}
 
 	fn child_storage_root<'b>(
 		&self,
 		child_info: &ChildInfo,
-		delta: impl Iterator<Item=(&'b [u8], Option<&'b [u8]>)>,
-	) -> (H::Out, bool, Self::Transaction) where H::Out: Ord {
+		delta: impl Iterator<Item = (&'b [u8], Option<&'b [u8]>)>,
+	) -> (H::Out, bool, Self::Transaction)
+	where
+		H::Out: Ord,
+	{
 		self.0.child_storage_root(child_info, delta)
 	}
 
-	fn register_overlay_stats(&self, _stats: &crate::stats::StateMachineStats) { }
+	fn register_overlay_stats(&self, _stats: &crate::stats::StateMachineStats) {}
 
 	fn usage_info(&self) -> crate::stats::UsageInfo {
 		self.0.usage_info()
@@ -375,15 +378,16 @@ where
 
 #[cfg(test)]
 mod tests {
-	use crate::InMemoryBackend;
-	use crate::trie_backend::tests::test_trie;
 	use super::*;
-	use crate::proving_backend::create_proof_check_backend;
-	use sp_trie::PrefixedMemoryDB;
+	use crate::{
+		proving_backend::create_proof_check_backend, trie_backend::tests::test_trie,
+		InMemoryBackend,
+	};
 	use sp_runtime::traits::BlakeTwo256;
+	use sp_trie::PrefixedMemoryDB;
 
 	fn test_proving<'a>(
-		trie_backend: &'a TrieBackend<PrefixedMemoryDB<BlakeTwo256>,BlakeTwo256>,
+		trie_backend: &'a TrieBackend<PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256>,
 	) -> ProvingBackend<'a, PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256> {
 		ProvingBackend::new(trie_backend)
 	}
@@ -407,7 +411,7 @@ mod tests {
 		use sp_core::H256;
 		let result = create_proof_check_backend::<BlakeTwo256>(
 			H256::from_low_u64_be(1),
-			StorageProof::empty()
+			StorageProof::empty(),
 		);
 		assert!(result.is_err());
 	}
@@ -443,7 +447,8 @@ mod tests {
 
 		let proof = proving.extract_proof();
 
-		let proof_check = create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof).unwrap();
+		let proof_check =
+			create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof).unwrap();
 		assert_eq!(proof_check.storage(&[42]).unwrap().unwrap(), vec![42]);
 	}
 
@@ -455,48 +460,38 @@ mod tests {
 		let child_info_2 = &child_info_2;
 		let contents = vec![
 			(None, (0..64).map(|i| (vec![i], Some(vec![i]))).collect()),
-			(Some(child_info_1.clone()),
-				(28..65).map(|i| (vec![i], Some(vec![i]))).collect()),
-			(Some(child_info_2.clone()),
-				(10..15).map(|i| (vec![i], Some(vec![i]))).collect()),
+			(Some(child_info_1.clone()), (28..65).map(|i| (vec![i], Some(vec![i]))).collect()),
+			(Some(child_info_2.clone()), (10..15).map(|i| (vec![i], Some(vec![i]))).collect()),
 		];
 		let in_memory = InMemoryBackend::<BlakeTwo256>::default();
 		let mut in_memory = in_memory.update(contents);
 		let child_storage_keys = vec![child_info_1.to_owned(), child_info_2.to_owned()];
-		let in_memory_root = in_memory.full_storage_root(
-			std::iter::empty(),
-			child_storage_keys.iter().map(|k|(k, std::iter::empty()))
-		).0;
-		(0..64).for_each(|i| assert_eq!(
-			in_memory.storage(&[i]).unwrap().unwrap(),
-			vec![i]
-		));
-		(28..65).for_each(|i| assert_eq!(
-			in_memory.child_storage(child_info_1, &[i]).unwrap().unwrap(),
-			vec![i]
-		));
-		(10..15).for_each(|i| assert_eq!(
-			in_memory.child_storage(child_info_2, &[i]).unwrap().unwrap(),
-			vec![i]
-		));
+		let in_memory_root = in_memory
+			.full_storage_root(
+				std::iter::empty(),
+				child_storage_keys.iter().map(|k| (k, std::iter::empty())),
+			)
+			.0;
+		(0..64).for_each(|i| assert_eq!(in_memory.storage(&[i]).unwrap().unwrap(), vec![i]));
+		(28..65).for_each(|i| {
+			assert_eq!(in_memory.child_storage(child_info_1, &[i]).unwrap().unwrap(), vec![i])
+		});
+		(10..15).for_each(|i| {
+			assert_eq!(in_memory.child_storage(child_info_2, &[i]).unwrap().unwrap(), vec![i])
+		});
 
 		let trie = in_memory.as_trie_backend().unwrap();
 		let trie_root = trie.storage_root(std::iter::empty()).0;
 		assert_eq!(in_memory_root, trie_root);
-		(0..64).for_each(|i| assert_eq!(
-			trie.storage(&[i]).unwrap().unwrap(),
-			vec![i]
-		));
+		(0..64).for_each(|i| assert_eq!(trie.storage(&[i]).unwrap().unwrap(), vec![i]));
 
 		let proving = ProvingBackend::new(trie);
 		assert_eq!(proving.storage(&[42]).unwrap().unwrap(), vec![42]);
 
 		let proof = proving.extract_proof();
 
-		let proof_check = create_proof_check_backend::<BlakeTwo256>(
-			in_memory_root.into(),
-			proof
-		).unwrap();
+		let proof_check =
+			create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof).unwrap();
 		assert!(proof_check.storage(&[0]).is_err());
 		assert_eq!(proof_check.storage(&[42]).unwrap().unwrap(), vec![42]);
 		// note that it is include in root because proof close
@@ -507,14 +502,9 @@ mod tests {
 		assert_eq!(proving.child_storage(child_info_1, &[64]), Ok(Some(vec![64])));
 
 		let proof = proving.extract_proof();
-		let proof_check = create_proof_check_backend::<BlakeTwo256>(
-			in_memory_root.into(),
-			proof
-		).unwrap();
-		assert_eq!(
-			proof_check.child_storage(child_info_1, &[64]).unwrap().unwrap(),
-			vec![64]
-		);
+		let proof_check =
+			create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof).unwrap();
+		assert_eq!(proof_check.child_storage(child_info_1, &[64]).unwrap().unwrap(), vec![64]);
 	}
 
 	#[test]
@@ -522,15 +512,14 @@ mod tests {
 		let trie_backend = test_trie();
 		let backend = test_proving(&trie_backend);
 
-		let check_estimation = |backend: &ProvingBackend<'_, PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256>| {
-			let storage_proof = backend.extract_proof();
-			let estimation = backend.0.essence()
-				.backend_storage()
-				.proof_recorder
-				.estimate_encoded_size();
+		let check_estimation =
+			|backend: &ProvingBackend<'_, PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256>| {
+				let storage_proof = backend.extract_proof();
+				let estimation =
+					backend.0.essence().backend_storage().proof_recorder.estimate_encoded_size();
 
-			assert_eq!(storage_proof.encoded_size(), estimation);
-		};
+				assert_eq!(storage_proof.encoded_size(), estimation);
+			};
 
 		assert_eq!(backend.storage(b"key").unwrap(), Some(b"value".to_vec()));
 		check_estimation(&backend);