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/tracing/src/logging/directives.rs

@@ -63,12 +63,7 @@ pub fn reload_filter() -> Result<(), String> {
 	let mut env_filter = EnvFilter::default();
 	if let Some(current_directives) = CURRENT_DIRECTIVES.get() {
 		// Use join and then split in case any directives added together
-		for directive in current_directives
-			.lock()
-			.join(",")
-			.split(',')
-			.map(|d| d.parse())
-		{
+		for directive in current_directives.lock().join(",").split(',').map(|d| d.parse()) {
 			match directive {
 				Ok(dir) => env_filter = env_filter.add_directive(dir),
 				Err(invalid_directive) => {
@@ -77,7 +72,7 @@ pub fn reload_filter() -> Result<(), String> {
 						"Unable to parse directive while setting log filter: {:?}",
 						invalid_directive,
 					);
-				}
+				},
 			}
 		}
 	}
@@ -99,14 +94,9 @@ pub fn reload_filter() -> Result<(), String> {
 ///
 /// Includes substrate defaults and CLI supplied directives.
 pub fn reset_log_filter() -> Result<(), String> {
-	let directive = DEFAULT_DIRECTIVES
-		.get_or_init(|| Mutex::new(Vec::new()))
-		.lock()
-		.clone();
+	let directive = DEFAULT_DIRECTIVES.get_or_init(|| Mutex::new(Vec::new())).lock().clone();
 
-	*CURRENT_DIRECTIVES
-		.get_or_init(|| Mutex::new(Vec::new()))
-		.lock() = directive;
+	*CURRENT_DIRECTIVES.get_or_init(|| Mutex::new(Vec::new())).lock() = directive;
 	reload_filter()
 }
 

substrate/client/tracing/src/logging/event_format.rs

@@ -79,11 +79,11 @@ where
 			match current_thread.name() {
 				Some(name) => {
 					write!(writer, "{} ", FmtThreadName::new(name))?;
-				}
+				},
 				// fall-back to thread id when name is absent and ids are not enabled
 				None => {
 					write!(writer, "{:0>2?} ", current_thread.id())?;
-				}
+				},
 			}
 		}
 
@@ -98,7 +98,7 @@ where
 				let exts = span.extensions();
 				if let Some(prefix) = exts.get::<super::layers::Prefix>() {
 					write!(writer, "{}", prefix.as_str())?;
-					break;
+					break
 				}
 			}
 		}
@@ -125,11 +125,11 @@ where
 		writer: &mut dyn fmt::Write,
 		event: &Event,
 	) -> fmt::Result {
-		if self.dup_to_stdout && (
-			event.metadata().level() == &Level::INFO ||
-			event.metadata().level() == &Level::WARN ||
-			event.metadata().level() == &Level::ERROR
-		) {
+		if self.dup_to_stdout &&
+			(event.metadata().level() == &Level::INFO ||
+				event.metadata().level() == &Level::WARN ||
+				event.metadata().level() == &Level::ERROR)
+		{
 			let mut out = String::new();
 			self.format_event_custom(CustomFmtContext::FmtContext(ctx), &mut out, event)?;
 			writer.write_str(&out)?;
@@ -271,9 +271,8 @@ where
 	) -> fmt::Result {
 		match self {
 			CustomFmtContext::FmtContext(fmt_ctx) => fmt_ctx.format_fields(writer, fields),
-			CustomFmtContext::ContextWithFormatFields(_ctx, fmt_fields) => {
-				fmt_fields.format_fields(writer, fields)
-			}
+			CustomFmtContext::ContextWithFormatFields(_ctx, fmt_fields) =>
+				fmt_fields.format_fields(writer, fields),
 		}
 	}
 }
@@ -321,11 +320,7 @@ impl<'a> fmt::Write for MaybeColorWriter<'a> {
 impl<'a> MaybeColorWriter<'a> {
 	/// Creates a new instance.
 	fn new(enable_color: bool, inner_writer: &'a mut dyn fmt::Write) -> Self {
-		Self {
-			enable_color,
-			inner_writer,
-			buffer: String::new(),
-		}
+		Self { enable_color, inner_writer, buffer: String::new() }
 	}
 
 	/// Write the buffered content to the `inner_writer`.

substrate/client/tracing/src/logging/layers/console_log.rs

@@ -40,11 +40,7 @@ pub struct ConsoleLogLayer<S, N = tracing_subscriber::fmt::format::DefaultFields
 impl<S, T> ConsoleLogLayer<S, tracing_subscriber::fmt::format::DefaultFields, T> {
 	/// Create a new [`ConsoleLogLayer`] using the `EventFormat` provided in argument.
 	pub fn new(event_format: EventFormat<T>) -> Self {
-		Self {
-			event_format,
-			fmt_fields: Default::default(),
-			_inner: std::marker::PhantomData,
-		}
+		Self { event_format, fmt_fields: Default::default(), _inner: std::marker::PhantomData }
 	}
 }
 
@@ -90,11 +86,11 @@ where
 				Ok(buf) => {
 					a = buf;
 					&mut *a
-				}
+				},
 				_ => {
 					b = String::new();
 					&mut b
-				}
+				},
 			};
 
 			if self.format_event(&ctx, &mut buf, event).is_ok() {

substrate/client/tracing/src/logging/layers/prefix_layer.rs

@@ -42,12 +42,12 @@ where
 					"newly created span with ID {:?} did not exist in the registry; this is a bug!",
 					id
 				);
-				return;
-			}
+				return
+			},
 		};
 
 		if span.name() != PREFIX_LOG_SPAN {
-			return;
+			return
 		}
 
 		let mut extensions = span.extensions_mut();

substrate/client/tracing/src/logging/mod.rs

@@ -33,10 +33,9 @@ use std::io;
 use tracing::Subscriber;
 use tracing_subscriber::{
 	filter::LevelFilter,
-	fmt::time::ChronoLocal,
 	fmt::{
-		format, FormatEvent, FormatFields, Formatter, Layer as FmtLayer, MakeWriter,
-		SubscriberBuilder,
+		format, time::ChronoLocal, FormatEvent, FormatFields, Formatter, Layer as FmtLayer,
+		MakeWriter, SubscriberBuilder,
 	},
 	layer::{self, SubscriberExt},
 	registry::LookupSpan,
@@ -153,9 +152,7 @@ where
 	let max_level_hint = Layer::<FmtSubscriber>::max_level_hint(&env_filter);
 	let max_level = to_log_level_filter(max_level_hint);
 
-	tracing_log::LogTracer::builder()
-		.with_max_level(max_level)
-		.init()?;
+	tracing_log::LogTracer::builder().with_max_level(max_level).init()?;
 
 	// If we're only logging `INFO` entries then we'll use a simplified logging format.
 	let simple = match max_level_hint {
@@ -276,23 +273,19 @@ impl LoggerBuilder {
 			}
 		} else {
 			if self.log_reloading {
-				let subscriber = prepare_subscriber(
-					&self.directives,
-					None,
-					self.force_colors,
-					|builder| enable_log_reloading!(builder),
-				)?;
+				let subscriber =
+					prepare_subscriber(&self.directives, None, self.force_colors, |builder| {
+						enable_log_reloading!(builder)
+					})?;
 
 				tracing::subscriber::set_global_default(subscriber)?;
 
 				Ok(())
 			} else {
-				let subscriber = prepare_subscriber(
-					&self.directives,
-					None,
-					self.force_colors,
-					|builder| builder,
-				)?;
+				let subscriber =
+					prepare_subscriber(&self.directives, None, self.force_colors, |builder| {
+						builder
+					})?;
 
 				tracing::subscriber::set_global_default(subscriber)?;
 
@@ -410,12 +403,7 @@ mod tests {
 			.unwrap();
 
 		let output = String::from_utf8(output.stderr).unwrap();
-		assert!(
-			re.is_match(output.trim()),
-			"Expected:\n{}\nGot:\n{}",
-			re,
-			output,
-		);
+		assert!(re.is_match(output.trim()), "Expected:\n{}\nGot:\n{}", re, output,);
 	}
 
 	/// This is not an actual test, it is used by the `prefix_in_log_lines` test.
@@ -460,12 +448,7 @@ mod tests {
 			.unwrap();
 
 		let output = String::from_utf8(output.stderr).unwrap();
-		assert!(
-			re.is_match(output.trim()),
-			"Expected:\n{}\nGot:\n{}",
-			re,
-			output,
-		);
+		assert!(re.is_match(output.trim()), "Expected:\n{}\nGot:\n{}", re, output,);
 	}
 
 	#[test]
@@ -503,18 +486,9 @@ mod tests {
 			eprint!("MAX_LOG_LEVEL={:?}", log::max_level());
 		} else {
 			assert_eq!("MAX_LOG_LEVEL=Info", run_test(None, None));
-			assert_eq!(
-				"MAX_LOG_LEVEL=Trace",
-				run_test(Some("test=trace".into()), None)
-			);
-			assert_eq!(
-				"MAX_LOG_LEVEL=Debug",
-				run_test(Some("test=debug".into()), None)
-			);
-			assert_eq!(
-				"MAX_LOG_LEVEL=Trace",
-				run_test(None, Some("test=info".into()))
-			);
+			assert_eq!("MAX_LOG_LEVEL=Trace", run_test(Some("test=trace".into()), None));
+			assert_eq!("MAX_LOG_LEVEL=Debug", run_test(Some("test=debug".into()), None));
+			assert_eq!("MAX_LOG_LEVEL=Trace", run_test(None, Some("test=info".into())));
 		}
 	}
 }