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/executor/src/integration_tests/mod.rs

@@ -20,20 +20,22 @@
 mod linux;
 mod sandbox;
 
-use std::sync::Arc;
-use codec::{Encode, Decode};
+use codec::{Decode, Encode};
 use hex_literal::hex;
-use sp_core::{
-	blake2_128, blake2_256, ed25519, sr25519, map, Pair,
-	offchain::{OffchainWorkerExt, OffchainDbExt, testing},
-	traits::Externalities,
-};
+use sc_executor_common::{runtime_blob::RuntimeBlob, wasm_runtime::WasmModule};
 use sc_runtime_test::wasm_binary_unwrap;
-use sp_state_machine::TestExternalities as CoreTestExternalities;
-use sp_trie::{TrieConfiguration, trie_types::Layout};
-use sp_wasm_interface::HostFunctions as _;
+use sp_core::{
+	blake2_128, blake2_256, ed25519, map,
+	offchain::{testing, OffchainDbExt, OffchainWorkerExt},
+	sr25519,
+	traits::Externalities,
+	Pair,
+};
 use sp_runtime::traits::BlakeTwo256;
-use sc_executor_common::{wasm_runtime::WasmModule, runtime_blob::RuntimeBlob};
+use sp_state_machine::TestExternalities as CoreTestExternalities;
+use sp_trie::{trie_types::Layout, TrieConfiguration};
+use sp_wasm_interface::HostFunctions as _;
+use std::sync::Arc;
 use tracing_subscriber::layer::SubscriberExt;
 
 use crate::WasmExecutionMethod;
@@ -96,12 +98,7 @@ fn returning_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 
-	let output = call_in_wasm(
-		"test_empty_return",
-		&[],
-		wasm_method,
-		&mut ext,
-	).unwrap();
+	let output = call_in_wasm("test_empty_return", &[], wasm_method, &mut ext).unwrap();
 	assert_eq!(output, vec![0u8; 0]);
 }
 
@@ -164,28 +161,13 @@ fn panicking_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 
-	let output = call_in_wasm(
-		"test_panic",
-		&[],
-		wasm_method,
-		&mut ext,
-	);
+	let output = call_in_wasm("test_panic", &[], wasm_method, &mut ext);
 	assert!(output.is_err());
 
-	let output = call_in_wasm(
-		"test_conditional_panic",
-		&[0],
-		wasm_method,
-		&mut ext,
-	);
+	let output = call_in_wasm("test_conditional_panic", &[0], wasm_method, &mut ext);
 	assert_eq!(Decode::decode(&mut &output.unwrap()[..]), Ok(Vec::<u8>::new()));
 
-	let output = call_in_wasm(
-		"test_conditional_panic",
-		&vec![2].encode(),
-		wasm_method,
-		&mut ext,
-	);
+	let output = call_in_wasm("test_conditional_panic", &vec![2].encode(), wasm_method, &mut ext);
 	assert!(output.is_err());
 }
 
@@ -197,12 +179,9 @@ fn storage_should_work(wasm_method: WasmExecutionMethod) {
 		let mut ext = ext.ext();
 		ext.set_storage(b"foo".to_vec(), b"bar".to_vec());
 
-		let output = call_in_wasm(
-			"test_data_in",
-			&b"Hello world".to_vec().encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap();
+		let output =
+			call_in_wasm("test_data_in", &b"Hello world".to_vec().encode(), wasm_method, &mut ext)
+				.unwrap();
 
 		assert_eq!(output, b"all ok!".to_vec().encode());
 	}
@@ -230,12 +209,9 @@ fn clear_prefix_should_work(wasm_method: WasmExecutionMethod) {
 		ext.set_storage(b"bbb".to_vec(), b"5".to_vec());
 
 		// This will clear all entries which prefix is "ab".
-		let output = call_in_wasm(
-			"test_clear_prefix",
-			&b"ab".to_vec().encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap();
+		let output =
+			call_in_wasm("test_clear_prefix", &b"ab".to_vec().encode(), wasm_method, &mut ext)
+				.unwrap();
 
 		assert_eq!(output, b"all ok!".to_vec().encode());
 	}
@@ -256,21 +232,12 @@ fn blake2_256_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 	assert_eq!(
-		call_in_wasm(
-			"test_blake2_256",
-			&[0],
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_blake2_256", &[0], wasm_method, &mut ext,).unwrap(),
 		blake2_256(&b""[..]).to_vec().encode(),
 	);
 	assert_eq!(
-		call_in_wasm(
-			"test_blake2_256",
-			&b"Hello world!".to_vec().encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_blake2_256", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
 		blake2_256(&b"Hello world!"[..]).to_vec().encode(),
 	);
 }
@@ -280,21 +247,12 @@ fn blake2_128_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 	assert_eq!(
-		call_in_wasm(
-			"test_blake2_128",
-			&[0],
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_blake2_128", &[0], wasm_method, &mut ext,).unwrap(),
 		blake2_128(&b""[..]).to_vec().encode(),
 	);
 	assert_eq!(
-		call_in_wasm(
-			"test_blake2_128",
-			&b"Hello world!".to_vec().encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_blake2_128", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
 		blake2_128(&b"Hello world!"[..]).to_vec().encode(),
 	);
 }
@@ -304,25 +262,14 @@ fn sha2_256_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 	assert_eq!(
-		call_in_wasm(
-			"test_sha2_256",
-			&[0],
-			wasm_method,
-			&mut ext,
-		)
-		.unwrap(),
+		call_in_wasm("test_sha2_256", &[0], wasm_method, &mut ext,).unwrap(),
 		hex!("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
 			.to_vec()
 			.encode(),
 	);
 	assert_eq!(
-		call_in_wasm(
-			"test_sha2_256",
-			&b"Hello world!".to_vec().encode(),
-			wasm_method,
-			&mut ext,
-		)
-		.unwrap(),
+		call_in_wasm("test_sha2_256", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
 		hex!("c0535e4be2b79ffd93291305436bf889314e4a3faec05ecffcbb7df31ad9e51a")
 			.to_vec()
 			.encode(),
@@ -334,26 +281,17 @@ fn twox_256_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 	assert_eq!(
-		call_in_wasm(
-			"test_twox_256",
-			&[0],
-			wasm_method,
-			&mut ext,
-		).unwrap(),
-		hex!(
-				"99e9d85137db46ef4bbea33613baafd56f963c64b1f3685a4eb4abd67ff6203a"
-			).to_vec().encode(),
+		call_in_wasm("test_twox_256", &[0], wasm_method, &mut ext,).unwrap(),
+		hex!("99e9d85137db46ef4bbea33613baafd56f963c64b1f3685a4eb4abd67ff6203a")
+			.to_vec()
+			.encode(),
 	);
 	assert_eq!(
-		call_in_wasm(
-			"test_twox_256",
-			&b"Hello world!".to_vec().encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap(),
-		hex!(
-				"b27dfd7f223f177f2a13647b533599af0c07f68bda23d96d059da2b451a35a74"
-			).to_vec().encode(),
+		call_in_wasm("test_twox_256", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
+		hex!("b27dfd7f223f177f2a13647b533599af0c07f68bda23d96d059da2b451a35a74")
+			.to_vec()
+			.encode(),
 	);
 }
 
@@ -362,21 +300,12 @@ fn twox_128_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 	assert_eq!(
-		call_in_wasm(
-			"test_twox_128",
-			&[0],
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_twox_128", &[0], wasm_method, &mut ext,).unwrap(),
 		hex!("99e9d85137db46ef4bbea33613baafd5").to_vec().encode(),
 	);
 	assert_eq!(
-		call_in_wasm(
-			"test_twox_128",
-			&b"Hello world!".to_vec().encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_twox_128", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
 		hex!("b27dfd7f223f177f2a13647b533599af").to_vec().encode(),
 	);
 }
@@ -392,12 +321,7 @@ fn ed25519_verify_should_work(wasm_method: WasmExecutionMethod) {
 	calldata.extend_from_slice(sig.as_ref());
 
 	assert_eq!(
-		call_in_wasm(
-			"test_ed25519_verify",
-			&calldata.encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_ed25519_verify", &calldata.encode(), wasm_method, &mut ext,).unwrap(),
 		true.encode(),
 	);
 
@@ -407,12 +331,7 @@ fn ed25519_verify_should_work(wasm_method: WasmExecutionMethod) {
 	calldata.extend_from_slice(other_sig.as_ref());
 
 	assert_eq!(
-		call_in_wasm(
-			"test_ed25519_verify",
-			&calldata.encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_ed25519_verify", &calldata.encode(), wasm_method, &mut ext,).unwrap(),
 		false.encode(),
 	);
 }
@@ -428,12 +347,7 @@ fn sr25519_verify_should_work(wasm_method: WasmExecutionMethod) {
 	calldata.extend_from_slice(sig.as_ref());
 
 	assert_eq!(
-		call_in_wasm(
-			"test_sr25519_verify",
-			&calldata.encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_sr25519_verify", &calldata.encode(), wasm_method, &mut ext,).unwrap(),
 		true.encode(),
 	);
 
@@ -443,12 +357,7 @@ fn sr25519_verify_should_work(wasm_method: WasmExecutionMethod) {
 	calldata.extend_from_slice(other_sig.as_ref());
 
 	assert_eq!(
-		call_in_wasm(
-			"test_sr25519_verify",
-			&calldata.encode(),
-			wasm_method,
-			&mut ext,
-		).unwrap(),
+		call_in_wasm("test_sr25519_verify", &calldata.encode(), wasm_method, &mut ext,).unwrap(),
 		false.encode(),
 	);
 }
@@ -458,12 +367,7 @@ fn ordered_trie_root_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let trie_input = vec![b"zero".to_vec(), b"one".to_vec(), b"two".to_vec()];
 	assert_eq!(
-		call_in_wasm(
-			"test_ordered_trie_root",
-			&[0],
-			wasm_method,
-			&mut ext.ext(),
-		).unwrap(),
+		call_in_wasm("test_ordered_trie_root", &[0], wasm_method, &mut ext.ext(),).unwrap(),
 		Layout::<BlakeTwo256>::ordered_trie_root(trie_input.iter()).as_bytes().encode(),
 	);
 }
@@ -473,17 +377,14 @@ fn offchain_index(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let (offchain, _state) = testing::TestOffchainExt::new();
 	ext.register_extension(OffchainWorkerExt::new(offchain));
-	call_in_wasm(
-		"test_offchain_index_set",
-		&[0],
-		wasm_method,
-		&mut ext.ext(),
-	).unwrap();
+	call_in_wasm("test_offchain_index_set", &[0], wasm_method, &mut ext.ext()).unwrap();
 
 	use sp_core::offchain::OffchainOverlayedChange;
-	let data = ext.overlayed_changes().clone().offchain_drain_committed().find(|(k, _v)| {
-		k == &(sp_core::offchain::STORAGE_PREFIX.to_vec(), b"k".to_vec())
-	});
+	let data = ext
+		.overlayed_changes()
+		.clone()
+		.offchain_drain_committed()
+		.find(|(k, _v)| k == &(sp_core::offchain::STORAGE_PREFIX.to_vec(), b"k".to_vec()));
 	assert_eq!(data.map(|data| data.1), Some(OffchainOverlayedChange::SetValue(b"v".to_vec())));
 }
 
@@ -494,12 +395,7 @@ fn offchain_local_storage_should_work(wasm_method: WasmExecutionMethod) {
 	ext.register_extension(OffchainDbExt::new(offchain.clone()));
 	ext.register_extension(OffchainWorkerExt::new(offchain));
 	assert_eq!(
-		call_in_wasm(
-			"test_offchain_local_storage",
-			&[0],
-			wasm_method,
-			&mut ext.ext(),
-		).unwrap(),
+		call_in_wasm("test_offchain_local_storage", &[0], wasm_method, &mut ext.ext(),).unwrap(),
 		true.encode(),
 	);
 	assert_eq!(state.read().persistent_storage.get(b"test"), Some(vec![]));
@@ -511,24 +407,18 @@ fn offchain_http_should_work(wasm_method: WasmExecutionMethod) {
 	let (offchain, state) = testing::TestOffchainExt::new();
 	ext.register_extension(OffchainWorkerExt::new(offchain));
 	state.write().expect_request(testing::PendingRequest {
-			method: "POST".into(),
-			uri: "http://localhost:12345".into(),
-			body: vec![1, 2, 3, 4],
-			headers: vec![("X-Auth".to_owned(), "test".to_owned())],
-			sent: true,
-			response: Some(vec![1, 2, 3]),
-			response_headers: vec![("X-Auth".to_owned(), "hello".to_owned())],
-			..Default::default()
-		},
-	);
+		method: "POST".into(),
+		uri: "http://localhost:12345".into(),
+		body: vec![1, 2, 3, 4],
+		headers: vec![("X-Auth".to_owned(), "test".to_owned())],
+		sent: true,
+		response: Some(vec![1, 2, 3]),
+		response_headers: vec![("X-Auth".to_owned(), "hello".to_owned())],
+		..Default::default()
+	});
 
 	assert_eq!(
-		call_in_wasm(
-			"test_offchain_http",
-			&[0],
-			wasm_method,
-			&mut ext.ext(),
-		).unwrap(),
+		call_in_wasm("test_offchain_http", &[0], wasm_method, &mut ext.ext(),).unwrap(),
 		true.encode(),
 	);
 }
@@ -539,7 +429,7 @@ fn should_trap_when_heap_exhausted(wasm_method: WasmExecutionMethod) {
 
 	let executor = crate::WasmExecutor::new(
 		wasm_method,
-		Some(17),  // `17` is the initial number of pages compiled into the binary.
+		Some(17), // `17` is the initial number of pages compiled into the binary.
 		HostFunctions::host_functions(),
 		8,
 		None,
@@ -593,17 +483,13 @@ fn returns_mutable_static_bss(wasm_method: WasmExecutionMethod) {
 	let runtime = mk_test_runtime(wasm_method, 1024);
 
 	let instance = runtime.new_instance().unwrap();
-	let res = instance
-		.call_export("returns_mutable_static_bss", &[0])
-		.unwrap();
+	let res = instance.call_export("returns_mutable_static_bss", &[0]).unwrap();
 	assert_eq!(1, u64::decode(&mut &res[..]).unwrap());
 
 	// We expect that every invocation will need to return the initial
 	// value plus one. If the value increases more than that then it is
 	// a sign that the wasm runtime preserves the memory content.
-	let res = instance
-		.call_export("returns_mutable_static_bss", &[0])
-		.unwrap();
+	let res = instance.call_export("returns_mutable_static_bss", &[0]).unwrap();
 	assert_eq!(1, u64::decode(&mut &res[..]).unwrap());
 }
 
@@ -638,7 +524,8 @@ fn heap_is_reset_between_calls(wasm_method: WasmExecutionMethod) {
 	let runtime = mk_test_runtime(wasm_method, 1024);
 	let instance = runtime.new_instance().unwrap();
 
-	let heap_base = instance.get_global_const("__heap_base")
+	let heap_base = instance
+		.get_global_const("__heap_base")
 		.expect("`__heap_base` is valid")
 		.expect("`__heap_base` exists")
 		.as_i32()
@@ -689,8 +576,8 @@ fn parallel_execution(wasm_method: WasmExecutionMethod) {
 
 test_wasm_execution!(wasm_tracing_should_work);
 fn wasm_tracing_should_work(wasm_method: WasmExecutionMethod) {
-	use std::sync::Mutex;
 	use sc_tracing::{SpanDatum, TraceEvent};
+	use std::sync::Mutex;
 
 	struct TestTraceHandler(Arc<Mutex<Vec<SpanDatum>>>);
 
@@ -706,36 +593,23 @@ fn wasm_tracing_should_work(wasm_method: WasmExecutionMethod) {
 	let handler = TestTraceHandler(traces.clone());
 
 	// Create subscriber with wasm_tracing disabled
-	let test_subscriber = tracing_subscriber::fmt().finish().with(
-		sc_tracing::ProfilingLayer::new_with_handler(
-			Box::new(handler), "default"
-		)
-	);
+	let test_subscriber = tracing_subscriber::fmt()
+		.finish()
+		.with(sc_tracing::ProfilingLayer::new_with_handler(Box::new(handler), "default"));
 
 	let _guard = tracing::subscriber::set_default(test_subscriber);
 
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 
-	let span_id = call_in_wasm(
-		"test_enter_span",
-		Default::default(),
-		wasm_method,
-		&mut ext,
-	).unwrap();
+	let span_id =
+		call_in_wasm("test_enter_span", Default::default(), wasm_method, &mut ext).unwrap();
 
 	let span_id = u64::decode(&mut &span_id[..]).unwrap();
 
-	assert!(
-		span_id > 0
-	);
+	assert!(span_id > 0);
 
-	call_in_wasm(
-		"test_exit_span",
-		&span_id.encode(),
-		wasm_method,
-		&mut ext,
-	).unwrap();
+	call_in_wasm("test_exit_span", &span_id.encode(), wasm_method, &mut ext).unwrap();
 
 	// Check there is only the single trace
 	let len = traces.lock().unwrap().len();
@@ -747,12 +621,7 @@ fn wasm_tracing_should_work(wasm_method: WasmExecutionMethod) {
 	assert_eq!(span_datum.name, "");
 	assert_eq!(values.bool_values.get("wasm").unwrap(), &true);
 
-	call_in_wasm(
-		"test_nested_spans",
-		Default::default(),
-		wasm_method,
-		&mut ext,
-	).unwrap();
+	call_in_wasm("test_nested_spans", Default::default(), wasm_method, &mut ext).unwrap();
 	let len = traces.lock().unwrap().len();
 	assert_eq!(len, 2);
 }
@@ -762,12 +631,7 @@ fn spawning_runtime_instance_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 
-	call_in_wasm(
-		"test_spawn",
-		&[],
-		wasm_method,
-		&mut ext,
-	).unwrap();
+	call_in_wasm("test_spawn", &[], wasm_method, &mut ext).unwrap();
 }
 
 test_wasm_execution!(spawning_runtime_instance_nested_should_work);
@@ -775,12 +639,7 @@ fn spawning_runtime_instance_nested_should_work(wasm_method: WasmExecutionMethod
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 
-	call_in_wasm(
-		"test_nested_spawn",
-		&[],
-		wasm_method,
-		&mut ext,
-	).unwrap();
+	call_in_wasm("test_nested_spawn", &[], wasm_method, &mut ext).unwrap();
 }
 
 test_wasm_execution!(panic_in_spawned_instance_panics_on_joining_its_result);
@@ -788,12 +647,8 @@ fn panic_in_spawned_instance_panics_on_joining_its_result(wasm_method: WasmExecu
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
 
-	let error_result = call_in_wasm(
-		"test_panic_in_spawned",
-		&[],
-		wasm_method,
-		&mut ext,
-	).unwrap_err();
+	let error_result =
+		call_in_wasm("test_panic_in_spawned", &[], wasm_method, &mut ext).unwrap_err();
 
 	assert!(format!("{}", error_result).contains("Spawned task"));
 }