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/frame/merkle-mountain-range/src/mmr/mmr.rs

@@ -16,13 +16,13 @@
 // limitations under the License.
 
 use crate::{
-	Config, HashingOf,
 	mmr::{
-		Node, NodeOf, Hasher,
-		storage::{Storage, OffchainStorage, RuntimeStorage},
+		storage::{OffchainStorage, RuntimeStorage, Storage},
 		utils::NodesUtils,
+		Hasher, Node, NodeOf,
 	},
 	primitives::{self, Error},
+	Config, HashingOf,
 };
 #[cfg(not(feature = "std"))]
 use sp_std::vec;
@@ -32,45 +32,39 @@ pub fn verify_leaf_proof<H, L>(
 	root: H::Output,
 	leaf: Node<H, L>,
 	proof: primitives::Proof<H::Output>,
-) -> Result<bool, Error> where
+) -> Result<bool, Error>
+where
 	H: sp_runtime::traits::Hash,
 	L: primitives::FullLeaf,
 {
 	let size = NodesUtils::new(proof.leaf_count).size();
 	let leaf_position = mmr_lib::leaf_index_to_pos(proof.leaf_index);
 
-	let p = mmr_lib::MerkleProof::<
-		Node<H, L>,
-		Hasher<H, L>,
-	>::new(
+	let p = mmr_lib::MerkleProof::<Node<H, L>, Hasher<H, L>>::new(
 		size,
 		proof.items.into_iter().map(Node::Hash).collect(),
 	);
-	p.verify(
-		Node::Hash(root),
-		vec![(leaf_position, leaf)],
-	).map_err(|e| Error::Verify.log_debug(e))
+	p.verify(Node::Hash(root), vec![(leaf_position, leaf)])
+		.map_err(|e| Error::Verify.log_debug(e))
 }
 
 /// A wrapper around a MMR library to expose limited functionality.
 ///
 /// Available functions depend on the storage kind ([Runtime](crate::mmr::storage::RuntimeStorage)
 /// vs [Off-chain](crate::mmr::storage::OffchainStorage)).
-pub struct Mmr<StorageType, T, I, L> where
+pub struct Mmr<StorageType, T, I, L>
+where
 	T: Config<I>,
 	I: 'static,
 	L: primitives::FullLeaf,
 	Storage<StorageType, T, I, L>: mmr_lib::MMRStore<NodeOf<T, I, L>>,
 {
-	mmr: mmr_lib::MMR<
-		NodeOf<T, I, L>,
-		Hasher<HashingOf<T, I>, L>,
-		Storage<StorageType, T, I, L>
-	>,
+	mmr: mmr_lib::MMR<NodeOf<T, I, L>, Hasher<HashingOf<T, I>, L>, Storage<StorageType, T, I, L>>,
 	leaves: u64,
 }
 
-impl<StorageType, T, I, L> Mmr<StorageType, T, I, L> where
+impl<StorageType, T, I, L> Mmr<StorageType, T, I, L>
+where
 	T: Config<I>,
 	I: 'static,
 	L: primitives::FullLeaf,
@@ -79,10 +73,7 @@ impl<StorageType, T, I, L> Mmr<StorageType, T, I, L> where
 	/// Create a pointer to an existing MMR with given number of leaves.
 	pub fn new(leaves: u64) -> Self {
 		let size = NodesUtils::new(leaves).size();
-		Self {
-			mmr: mmr_lib::MMR::new(size, Default::default()),
-			leaves,
-		}
+		Self { mmr: mmr_lib::MMR::new(size, Default::default()), leaves }
 	}
 
 	/// Verify proof of a single leaf.
@@ -91,19 +82,14 @@ impl<StorageType, T, I, L> Mmr<StorageType, T, I, L> where
 		leaf: L,
 		proof: primitives::Proof<<T as Config<I>>::Hash>,
 	) -> Result<bool, Error> {
-		let p = mmr_lib::MerkleProof::<
-			NodeOf<T, I, L>,
-			Hasher<HashingOf<T, I>, L>,
-		>::new(
+		let p = mmr_lib::MerkleProof::<NodeOf<T, I, L>, Hasher<HashingOf<T, I>, L>>::new(
 			self.mmr.mmr_size(),
 			proof.items.into_iter().map(Node::Hash).collect(),
 		);
 		let position = mmr_lib::leaf_index_to_pos(proof.leaf_index);
 		let root = self.mmr.get_root().map_err(|e| Error::GetRoot.log_error(e))?;
-		p.verify(
-			root,
-			vec![(position, Node::Data(leaf))],
-		).map_err(|e| Error::Verify.log_debug(e))
+		p.verify(root, vec![(position, Node::Data(leaf))])
+			.map_err(|e| Error::Verify.log_debug(e))
 	}
 
 	/// Return the internal size of the MMR (number of nodes).
@@ -114,19 +100,18 @@ impl<StorageType, T, I, L> Mmr<StorageType, T, I, L> where
 }
 
 /// Runtime specific MMR functions.
-impl<T, I, L> Mmr<RuntimeStorage, T, I, L> where
+impl<T, I, L> Mmr<RuntimeStorage, T, I, L>
+where
 	T: Config<I>,
 	I: 'static,
 	L: primitives::FullLeaf,
 {
-
 	/// Push another item to the MMR.
 	///
 	/// Returns element position (index) in the MMR.
 	pub fn push(&mut self, leaf: L) -> Option<u64> {
-		let position = self.mmr.push(Node::Data(leaf))
-			.map_err(|e| Error::Push.log_error(e))
-			.ok()?;
+		let position =
+			self.mmr.push(Node::Data(leaf)).map_err(|e| Error::Push.log_error(e)).ok()?;
 
 		self.leaves += 1;
 
@@ -143,7 +128,8 @@ impl<T, I, L> Mmr<RuntimeStorage, T, I, L> where
 }
 
 /// Off-chain specific MMR functions.
-impl<T, I, L> Mmr<OffchainStorage, T, I, L> where
+impl<T, I, L> Mmr<OffchainStorage, T, I, L>
+where
 	T: Config<I>,
 	I: 'static,
 	L: primitives::FullLeaf + codec::Decode,
@@ -152,10 +138,10 @@ impl<T, I, L> Mmr<OffchainStorage, T, I, L> where
 	///
 	/// Proof generation requires all the nodes (or their hashes) to be available in the storage.
 	/// (i.e. you can't run the function in the pruned storage).
-	pub fn generate_proof(&self, leaf_index: u64) -> Result<
-		(L, primitives::Proof<<T as Config<I>>::Hash>),
-		Error
-	> {
+	pub fn generate_proof(
+		&self,
+		leaf_index: u64,
+	) -> Result<(L, primitives::Proof<<T as Config<I>>::Hash>), Error> {
 		let position = mmr_lib::leaf_index_to_pos(leaf_index);
 		let store = <Storage<OffchainStorage, T, I, L>>::default();
 		let leaf = match mmr_lib::MMRStore::get_elem(&store, position) {
@@ -163,7 +149,8 @@ impl<T, I, L> Mmr<OffchainStorage, T, I, L> where
 			e => return Err(Error::LeafNotFound.log_debug(e)),
 		};
 		let leaf_count = self.leaves;
-		self.mmr.gen_proof(vec![position])
+		self.mmr
+			.gen_proof(vec![position])
 			.map_err(|e| Error::GenerateProof.log_error(e))
 			.map(|p| primitives::Proof {
 				leaf_index,
@@ -173,4 +160,3 @@ impl<T, I, L> Mmr<OffchainStorage, T, I, L> where
 			.map(|p| (leaf, p))
 	}
 }
-

substrate/frame/merkle-mountain-range/src/mmr/mod.rs

@@ -15,14 +15,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+mod mmr;
 pub mod storage;
 pub mod utils;
-mod mmr;
 
 use crate::primitives::FullLeaf;
 use sp_runtime::traits;
 
-pub use self::mmr::{Mmr, verify_leaf_proof};
+pub use self::mmr::{verify_leaf_proof, Mmr};
 
 /// Node type for runtime `T`.
 pub type NodeOf<T, I, L> = Node<<T as crate::Config<I>>::Hashing, L>;

substrate/frame/merkle-mountain-range/src/mmr/storage.rs

@@ -21,8 +21,10 @@ use codec::Encode;
 #[cfg(not(feature = "std"))]
 use sp_std::prelude::Vec;
 
-use crate::mmr::{NodeOf, Node};
-use crate::{NumberOfLeaves, Nodes, Pallet, Config, primitives};
+use crate::{
+	mmr::{Node, NodeOf},
+	primitives, Config, Nodes, NumberOfLeaves, Pallet,
+};
 
 /// A marker type for runtime-specific storage implementation.
 ///
@@ -44,9 +46,7 @@ pub struct OffchainStorage;
 ///
 /// There are two different implementations depending on the use case.
 /// See docs for [RuntimeStorage] and [OffchainStorage].
-pub struct Storage<StorageType, T, I, L>(
-	sp_std::marker::PhantomData<(StorageType, T, I, L)>
-);
+pub struct Storage<StorageType, T, I, L>(sp_std::marker::PhantomData<(StorageType, T, I, L)>);
 
 impl<StorageType, T, I, L> Default for Storage<StorageType, T, I, L> {
 	fn default() -> Self {
@@ -54,7 +54,8 @@ impl<StorageType, T, I, L> Default for Storage<StorageType, T, I, L> {
 	}
 }
 
-impl<T, I, L> mmr_lib::MMRStore<NodeOf<T, I, L>> for Storage<OffchainStorage, T, I, L> where
+impl<T, I, L> mmr_lib::MMRStore<NodeOf<T, I, L>> for Storage<OffchainStorage, T, I, L>
+where
 	T: Config<I>,
 	I: 'static,
 	L: primitives::FullLeaf + codec::Decode,
@@ -62,32 +63,30 @@ impl<T, I, L> mmr_lib::MMRStore<NodeOf<T, I, L>> for Storage<OffchainStorage, T,
 	fn get_elem(&self, pos: u64) -> mmr_lib::Result<Option<NodeOf<T, I, L>>> {
 		let key = Pallet::<T, I>::offchain_key(pos);
 		// Retrieve the element from Off-chain DB.
-		Ok(sp_io::offchain
-			::local_storage_get(sp_core::offchain::StorageKind::PERSISTENT, &key)
+		Ok(sp_io::offchain::local_storage_get(sp_core::offchain::StorageKind::PERSISTENT, &key)
 			.and_then(|v| codec::Decode::decode(&mut &*v).ok()))
 	}
 
 	fn append(&mut self, _: u64, _: Vec<NodeOf<T, I, L>>) -> mmr_lib::Result<()> {
 		panic!("MMR must not be altered in the off-chain context.")
- 	}
+	}
 }
 
-impl<T, I, L> mmr_lib::MMRStore<NodeOf<T, I, L>> for Storage<RuntimeStorage, T, I, L> where
+impl<T, I, L> mmr_lib::MMRStore<NodeOf<T, I, L>> for Storage<RuntimeStorage, T, I, L>
+where
 	T: Config<I>,
 	I: 'static,
 	L: primitives::FullLeaf,
 {
 	fn get_elem(&self, pos: u64) -> mmr_lib::Result<Option<NodeOf<T, I, L>>> {
-		Ok(<Nodes<T, I>>::get(pos)
-			.map(Node::Hash)
-		)
+		Ok(<Nodes<T, I>>::get(pos).map(Node::Hash))
 	}
 
 	fn append(&mut self, pos: u64, elems: Vec<NodeOf<T, I, L>>) -> mmr_lib::Result<()> {
 		let mut leaves = crate::NumberOfLeaves::<T, I>::get();
 		let mut size = crate::mmr::utils::NodesUtils::new(leaves).size();
 		if pos != size {
-			return Err(mmr_lib::Error::InconsistentStore);
+			return Err(mmr_lib::Error::InconsistentStore)
 		}
 
 		for elem in elems {

substrate/frame/merkle-mountain-range/src/mmr/utils.rs

@@ -49,9 +49,7 @@ impl NodesUtils {
 			return 0
 		}
 
-		64 - self.no_of_leaves
-				.next_power_of_two()
-				.leading_zeros()
+		64 - self.no_of_leaves.next_power_of_two().leading_zeros()
 	}
 }
 
@@ -123,9 +121,6 @@ mod tests {
 				actual_sizes.push(mmr.size());
 			})
 		}
-		assert_eq!(
-			sizes[1..],
-			actual_sizes[..],
-		);
+		assert_eq!(sizes[1..], actual_sizes[..],);
 	}
 }