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/bin/node/inspect/src/cli.rs

@@ -18,8 +18,8 @@
 
 //! Structs to easily compose inspect sub-command for CLI.
 
-use std::fmt::Debug;
 use sc_cli::{ImportParams, SharedParams};
+use std::fmt::Debug;
 use structopt::StructOpt;
 
 /// The `inspect` command used to print decoded chain data.

substrate/bin/node/inspect/src/command.rs

@@ -18,8 +18,10 @@
 
 //! Command ran by the CLI
 
-use crate::cli::{InspectCmd, InspectSubCmd};
-use crate::Inspector;
+use crate::{
+	cli::{InspectCmd, InspectSubCmd},
+	Inspector,
+};
 use sc_cli::{CliConfiguration, ImportParams, Result, SharedParams};
 use sc_service::{new_full_client, Configuration, NativeExecutionDispatch};
 use sp_runtime::traits::Block;
@@ -43,13 +45,13 @@ impl InspectCmd {
 				let res = inspect.block(input).map_err(|e| format!("{}", e))?;
 				println!("{}", res);
 				Ok(())
-			}
+			},
 			InspectSubCmd::Extrinsic { input } => {
 				let input = input.parse()?;
 				let res = inspect.extrinsic(input).map_err(|e| format!("{}", e))?;
 				println!("{}", res);
 				Ok(())
-			}
+			},
 		}
 	}
 }

substrate/bin/node/inspect/src/lib.rs

@@ -27,33 +27,27 @@
 pub mod cli;
 pub mod command;
 
-use std::{
-	fmt,
-	fmt::Debug,
-	marker::PhantomData,
-	str::FromStr,
-};
-use codec::{Encode, Decode};
+use codec::{Decode, Encode};
 use sc_client_api::BlockBackend;
 use sp_blockchain::HeaderBackend;
 use sp_core::hexdisplay::HexDisplay;
 use sp_runtime::{
 	generic::BlockId,
-	traits::{Block, HashFor, NumberFor, Hash}
+	traits::{Block, Hash, HashFor, NumberFor},
 };
+use std::{fmt, fmt::Debug, marker::PhantomData, str::FromStr};
 
 /// A helper type for a generic block input.
-pub type BlockAddressFor<TBlock> = BlockAddress<
-	<HashFor<TBlock> as Hash>::Output,
-	NumberFor<TBlock>
->;
+pub type BlockAddressFor<TBlock> =
+	BlockAddress<<HashFor<TBlock> as Hash>::Output, NumberFor<TBlock>>;
 
 /// A Pretty formatter implementation.
 pub trait PrettyPrinter<TBlock: Block> {
 	/// Nicely format block.
 	fn fmt_block(&self, fmt: &mut fmt::Formatter, block: &TBlock) -> fmt::Result;
 	/// Nicely format extrinsic.
-	fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic) -> fmt::Result;
+	fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic)
+		-> fmt::Result;
 }
 
 /// Default dummy debug printer.
@@ -72,7 +66,11 @@ impl<TBlock: Block> PrettyPrinter<TBlock> for DebugPrinter {
 		Ok(())
 	}
 
-	fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic) -> fmt::Result {
+	fn fmt_extrinsic(
+		&self,
+		fmt: &mut fmt::Formatter,
+		extrinsic: &TBlock::Extrinsic,
+	) -> fmt::Result {
 		writeln!(fmt, " {:#?}", extrinsic)?;
 		writeln!(fmt, " Bytes: {:?}", HexDisplay::from(&extrinsic.encode()))?;
 		Ok(())
@@ -101,15 +99,14 @@ impl std::error::Error for Error {
 }
 
 /// A helper trait to access block headers and bodies.
-pub trait ChainAccess<TBlock: Block>:
-	HeaderBackend<TBlock> +
-	BlockBackend<TBlock>
-{}
+pub trait ChainAccess<TBlock: Block>: HeaderBackend<TBlock> + BlockBackend<TBlock> {}
 
-impl<T, TBlock> ChainAccess<TBlock> for T where
+impl<T, TBlock> ChainAccess<TBlock> for T
+where
 	TBlock: Block,
 	T: sp_blockchain::HeaderBackend<TBlock> + sc_client_api::BlockBackend<TBlock>,
-{}
+{
+}
 
 /// Blockchain inspector.
 pub struct Inspector<TBlock: Block, TPrinter: PrettyPrinter<TBlock> = DebugPrinter> {
@@ -120,22 +117,16 @@ pub struct Inspector<TBlock: Block, TPrinter: PrettyPrinter<TBlock> = DebugPrint
 
 impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter> {
 	/// Create new instance of the inspector with default printer.
-	pub fn new(
-		chain: impl ChainAccess<TBlock> + 'static,
-	) -> Self where TPrinter: Default {
+	pub fn new(chain: impl ChainAccess<TBlock> + 'static) -> Self
+	where
+		TPrinter: Default,
+	{
 		Self::with_printer(chain, Default::default())
 	}
 
 	/// Customize pretty-printing of the data.
-	pub fn with_printer(
-		chain: impl ChainAccess<TBlock> + 'static,
-		printer: TPrinter,
-	) -> Self {
-		Inspector {
-			chain: Box::new(chain) as _,
-			printer,
-			_block: Default::default(),
-		}
+	pub fn with_printer(chain: impl ChainAccess<TBlock> + 'static, printer: TPrinter) -> Self {
+		Inspector { chain: Box::new(chain) as _, printer, _block: Default::default() }
 	}
 
 	/// Get a pretty-printed block.
@@ -153,25 +144,27 @@ impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter>
 
 	fn get_block(&self, input: BlockAddressFor<TBlock>) -> Result<TBlock, Error> {
 		Ok(match input {
-			BlockAddress::Bytes(bytes) => {
-				TBlock::decode(&mut &*bytes)?
-			},
+			BlockAddress::Bytes(bytes) => TBlock::decode(&mut &*bytes)?,
 			BlockAddress::Number(number) => {
 				let id = BlockId::number(number);
 				let not_found = format!("Could not find block {:?}", id);
-				let body = self.chain.block_body(&id)?
-					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
-				let header = self.chain.header(id)?
+				let body = self
+					.chain
+					.block_body(&id)?
 					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
+				let header =
+					self.chain.header(id)?.ok_or_else(|| Error::NotFound(not_found.clone()))?;
 				TBlock::new(header, body)
 			},
 			BlockAddress::Hash(hash) => {
 				let id = BlockId::hash(hash);
 				let not_found = format!("Could not find block {:?}", id);
-				let body = self.chain.block_body(&id)?
-					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
-				let header = self.chain.header(id)?
+				let body = self
+					.chain
+					.block_body(&id)?
 					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
+				let header =
+					self.chain.header(id)?.ok_or_else(|| Error::NotFound(not_found.clone()))?;
 				TBlock::new(header, body)
 			},
 		})
@@ -192,16 +185,14 @@ impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter>
 		let ext = match input {
 			ExtrinsicAddress::Block(block, index) => {
 				let block = self.get_block(block)?;
-				block.extrinsics()
-					.get(index)
-					.cloned()
-					.ok_or_else(|| Error::NotFound(format!(
-						"Could not find extrinsic {} in block {:?}", index, block
-					)))?
+				block.extrinsics().get(index).cloned().ok_or_else(|| {
+					Error::NotFound(format!(
+						"Could not find extrinsic {} in block {:?}",
+						index, block
+					))
+				})?
 			},
-			ExtrinsicAddress::Bytes(bytes) => {
-				TBlock::Extrinsic::decode(&mut &*bytes)?
-			}
+			ExtrinsicAddress::Bytes(bytes) => TBlock::Extrinsic::decode(&mut &*bytes)?,
 		};
 
 		Ok(format!("{}", ExtrinsicPrinter(ext, &self.printer)))
@@ -234,12 +225,12 @@ impl<Hash: FromStr, Number: FromStr> FromStr for BlockAddress<Hash, Number> {
 		}
 
 		// then assume it's bytes (hex-encoded)
-		sp_core::bytes::from_hex(s)
-			.map(Self::Bytes)
-			.map_err(|e| format!(
+		sp_core::bytes::from_hex(s).map(Self::Bytes).map_err(|e| {
+			format!(
 				"Given string does not look like hash or number. It could not be parsed as bytes either: {}",
 				e
-			))
+			)
+		})
 	}
 }
 
@@ -263,11 +254,13 @@ impl<Hash: FromStr + Debug, Number: FromStr + Debug> FromStr for ExtrinsicAddres
 
 		// split by a bunch of different characters
 		let mut it = s.split(|c| c == '.' || c == ':' || c == ' ');
-		let block = it.next()
+		let block = it
+			.next()
 			.expect("First element of split iterator is never empty; qed")
 			.parse()?;
 
-		let index = it.next()
+		let index = it
+			.next()
 			.ok_or_else(|| format!("Extrinsic index missing: example \"5:0\""))?
 			.parse()
 			.map_err(|e| format!("Invalid index format: {}", e))?;
@@ -290,10 +283,10 @@ mod tests {
 		let b2 = BlockAddress::from_str("0");
 		let b3 = BlockAddress::from_str("0x0012345f");
 
-
-		assert_eq!(b0, Ok(BlockAddress::Hash(
-			"3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()
-		)));
+		assert_eq!(
+			b0,
+			Ok(BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()))
+		);
 		assert_eq!(b1, Ok(BlockAddress::Number(1234)));
 		assert_eq!(b2, Ok(BlockAddress::Number(0)));
 		assert_eq!(b3, Ok(BlockAddress::Bytes(vec![0, 0x12, 0x34, 0x5f])));
@@ -310,20 +303,16 @@ mod tests {
 		let b2 = ExtrinsicAddress::from_str("0 0");
 		let b3 = ExtrinsicAddress::from_str("0x0012345f");
 
-
 		assert_eq!(e0, Err("Extrinsic index missing: example \"5:0\"".into()));
-		assert_eq!(b0, Ok(ExtrinsicAddress::Block(
-			BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()),
-			5
-		)));
-		assert_eq!(b1, Ok(ExtrinsicAddress::Block(
-			BlockAddress::Number(1234),
-			0
-		)));
-		assert_eq!(b2, Ok(ExtrinsicAddress::Block(
-			BlockAddress::Number(0),
-			0
-		)));
+		assert_eq!(
+			b0,
+			Ok(ExtrinsicAddress::Block(
+				BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()),
+				5
+			))
+		);
+		assert_eq!(b1, Ok(ExtrinsicAddress::Block(BlockAddress::Number(1234), 0)));
+		assert_eq!(b2, Ok(ExtrinsicAddress::Block(BlockAddress::Number(0), 0)));
 		assert_eq!(b3, Ok(ExtrinsicAddress::Bytes(vec![0, 0x12, 0x34, 0x5f])));
 	}
 }