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/support/procedural/src/pallet/expand/call.rs

@@ -15,9 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::Def;
+use crate::{pallet::Def, COUNTER};
 use frame_support_procedural_tools::clean_type_string;
-use crate::COUNTER;
 use syn::spanned::Spanned;
 
 /// * Generate enum call and implement various trait on it.
@@ -31,7 +30,7 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 			let docs = call.docs.clone();
 
 			(span, where_clause, methods, docs)
-		}
+		},
 		None => (def.item.span(), None, Vec::new(), Vec::new()),
 	};
 	let frame_support = &def.frame_support;
@@ -48,16 +47,20 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 
 	let fn_doc = methods.iter().map(|method| &method.docs).collect::<Vec<_>>();
 
-	let args_name = methods.iter()
+	let args_name = methods
+		.iter()
 		.map(|method| method.args.iter().map(|(_, name, _)| name.clone()).collect::<Vec<_>>())
 		.collect::<Vec<_>>();
 
-	let args_type = methods.iter()
+	let args_type = methods
+		.iter()
 		.map(|method| method.args.iter().map(|(_, _, type_)| type_.clone()).collect::<Vec<_>>())
 		.collect::<Vec<_>>();
 
 	let args_compact_attr = methods.iter().map(|method| {
-		method.args.iter()
+		method
+			.args
+			.iter()
 			.map(|(is_compact, _, type_)| {
 				if *is_compact {
 					quote::quote_spanned!(type_.span() => #[codec(compact)] )
@@ -69,7 +72,9 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 	});
 
 	let args_metadata_type = methods.iter().map(|method| {
-		method.args.iter()
+		method
+			.args
+			.iter()
 			.map(|(is_compact, _, type_)| {
 				let final_type = if *is_compact {
 					quote::quote_spanned!(type_.span() => Compact<#type_>)
@@ -84,14 +89,10 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 	let default_docs = [syn::parse_quote!(
 		r"Contains one variant per dispatchable that can be called by an extrinsic."
 	)];
-	let docs = if docs.is_empty() {
-		&default_docs[..]
-	} else {
-		&docs[..]
-	};
+	let docs = if docs.is_empty() { &default_docs[..] } else { &docs[..] };
 
 	let maybe_compile_error = if def.call.is_none() {
-		quote::quote!{
+		quote::quote! {
 			compile_error!(concat!(
 				"`",
 				stringify!($pallet_name),

substrate/frame/support/procedural/src/pallet/expand/config.rs

@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::{Def, parse::helper::get_doc_literals};
+use crate::pallet::{parse::helper::get_doc_literals, Def};
 
 /// * Generate default rust doc
 pub fn expand_config(def: &mut Def) -> proc_macro2::TokenStream {

substrate/frame/support/procedural/src/pallet/expand/constants.rs

@@ -71,58 +71,55 @@ pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {
 		}
 	});
 
-	let consts = config_consts.chain(extra_consts)
-		.map(|const_| {
-			let const_type = &const_.type_;
-			let const_type_str = clean_type_string(&const_type.to_token_stream().to_string());
-			let ident = &const_.ident;
-			let ident_str = format!("{}", ident);
-			let doc = const_.doc.clone().into_iter();
-			let default_byte_impl = &const_.default_byte_impl;
-			let default_byte_getter = syn::Ident::new(
-				&format!("{}DefaultByteGetter", ident),
-				ident.span()
+	let consts = config_consts.chain(extra_consts).map(|const_| {
+		let const_type = &const_.type_;
+		let const_type_str = clean_type_string(&const_type.to_token_stream().to_string());
+		let ident = &const_.ident;
+		let ident_str = format!("{}", ident);
+		let doc = const_.doc.clone().into_iter();
+		let default_byte_impl = &const_.default_byte_impl;
+		let default_byte_getter =
+			syn::Ident::new(&format!("{}DefaultByteGetter", ident), ident.span());
+
+		quote::quote!({
+			#[allow(non_upper_case_types)]
+			#[allow(non_camel_case_types)]
+			struct #default_byte_getter<#type_decl_gen>(
+				#frame_support::sp_std::marker::PhantomData<(#type_use_gen)>
 			);
 
-			quote::quote!({
-				#[allow(non_upper_case_types)]
-				#[allow(non_camel_case_types)]
-				struct #default_byte_getter<#type_decl_gen>(
-					#frame_support::sp_std::marker::PhantomData<(#type_use_gen)>
-				);
-
-				impl<#type_impl_gen> #frame_support::dispatch::DefaultByte for
-					#default_byte_getter<#type_use_gen>
-					#completed_where_clause
-				{
-					fn default_byte(&self) -> #frame_support::sp_std::vec::Vec<u8> {
-						#default_byte_impl
-					}
+			impl<#type_impl_gen> #frame_support::dispatch::DefaultByte for
+				#default_byte_getter<#type_use_gen>
+				#completed_where_clause
+			{
+				fn default_byte(&self) -> #frame_support::sp_std::vec::Vec<u8> {
+					#default_byte_impl
 				}
+			}
 
-				unsafe impl<#type_impl_gen> Send for #default_byte_getter<#type_use_gen>
-					#completed_where_clause
-				{}
-				unsafe impl<#type_impl_gen> Sync for #default_byte_getter<#type_use_gen>
-					#completed_where_clause
-				{}
+			unsafe impl<#type_impl_gen> Send for #default_byte_getter<#type_use_gen>
+				#completed_where_clause
+			{}
+			unsafe impl<#type_impl_gen> Sync for #default_byte_getter<#type_use_gen>
+				#completed_where_clause
+			{}
 
-				#frame_support::dispatch::ModuleConstantMetadata {
-					name: #frame_support::dispatch::DecodeDifferent::Encode(#ident_str),
-					ty: #frame_support::dispatch::DecodeDifferent::Encode(#const_type_str),
-					value: #frame_support::dispatch::DecodeDifferent::Encode(
-						#frame_support::dispatch::DefaultByteGetter(
-							&#default_byte_getter::<#type_use_gen>(
-								#frame_support::sp_std::marker::PhantomData
-							)
+			#frame_support::dispatch::ModuleConstantMetadata {
+				name: #frame_support::dispatch::DecodeDifferent::Encode(#ident_str),
+				ty: #frame_support::dispatch::DecodeDifferent::Encode(#const_type_str),
+				value: #frame_support::dispatch::DecodeDifferent::Encode(
+					#frame_support::dispatch::DefaultByteGetter(
+						&#default_byte_getter::<#type_use_gen>(
+							#frame_support::sp_std::marker::PhantomData
 						)
-					),
-					documentation: #frame_support::dispatch::DecodeDifferent::Encode(
-						&[ #( #doc ),* ]
-					),
-				}
-			})
-		});
+					)
+				),
+				documentation: #frame_support::dispatch::DecodeDifferent::Encode(
+					&[ #( #doc ),* ]
+				),
+			}
+		})
+	});
 
 	quote::quote!(
 		impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause{

substrate/frame/support/procedural/src/pallet/expand/error.rs

@@ -15,16 +15,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::{Def, parse::helper::get_doc_literals};
+use crate::pallet::{parse::helper::get_doc_literals, Def};
 
 /// * impl various trait on Error
 /// * impl ModuleErrorMetadata for Error
 pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
-	let error = if let Some(error) = &def.error {
-		error
-	} else {
-		return Default::default()
-	};
+	let error = if let Some(error) = &def.error { error } else { return Default::default() };
 
 	let error_ident = &error.error;
 	let frame_support = &def.frame_support;
@@ -41,27 +37,24 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
 		)
 	);
 
-	let as_u8_matches = error.variants.iter().enumerate()
-		.map(|(i, (variant, _))| {
-			quote::quote_spanned!(error.attr_span => Self::#variant => #i as u8,)
-		});
+	let as_u8_matches = error.variants.iter().enumerate().map(
+		|(i, (variant, _))| quote::quote_spanned!(error.attr_span => Self::#variant => #i as u8,),
+	);
 
-	let as_str_matches = error.variants.iter()
-		.map(|(variant, _)| {
-			let variant_str = format!("{}", variant);
-			quote::quote_spanned!(error.attr_span => Self::#variant => #variant_str,)
-		});
+	let as_str_matches = error.variants.iter().map(|(variant, _)| {
+		let variant_str = format!("{}", variant);
+		quote::quote_spanned!(error.attr_span => Self::#variant => #variant_str,)
+	});
 
-	let metadata = error.variants.iter()
-		.map(|(variant, doc)| {
-			let variant_str = format!("{}", variant);
-			quote::quote_spanned!(error.attr_span =>
-				#frame_support::error::ErrorMetadata {
-					name: #frame_support::error::DecodeDifferent::Encode(#variant_str),
-					documentation: #frame_support::error::DecodeDifferent::Encode(&[ #( #doc, )* ]),
-				},
-			)
-		});
+	let metadata = error.variants.iter().map(|(variant, doc)| {
+		let variant_str = format!("{}", variant);
+		quote::quote_spanned!(error.attr_span =>
+			#frame_support::error::ErrorMetadata {
+				name: #frame_support::error::DecodeDifferent::Encode(#variant_str),
+				documentation: #frame_support::error::DecodeDifferent::Encode(&[ #( #doc, )* ]),
+			},
+		)
+	});
 
 	let error_item = {
 		let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[error.index];

substrate/frame/support/procedural/src/pallet/expand/event.rs

@@ -15,8 +15,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::{Def, parse::helper::get_doc_literals};
-use crate::COUNTER;
+use crate::{
+	pallet::{parse::helper::get_doc_literals, Def},
+	COUNTER,
+};
 use syn::{spanned::Spanned, Ident};
 
 /// * Add __Ignore variant on Event
@@ -29,10 +31,8 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 		let ident = Ident::new(&format!("__is_event_part_defined_{}", count), event.attr_span);
 		(event, ident)
 	} else {
-		let macro_ident = Ident::new(
-			&format!("__is_event_part_defined_{}", count),
-			def.item.span(),
-		);
+		let macro_ident =
+			Ident::new(&format!("__is_event_part_defined_{}", count), def.item.span());
 
 		return quote::quote! {
 			#[doc(hidden)]
@@ -49,42 +49,39 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 						));
 					}
 				}
-	
+
 				#[doc(hidden)]
 				pub use #macro_ident as is_event_part_defined;
 			}
-		};
+		}
 	};
 
 	let event_where_clause = &event.where_clause;
 
 	// NOTE: actually event where clause must be a subset of config where clause because of
 	// `type Event: From<Event<Self>>`. But we merge either way for potential better error message
-	let completed_where_clause = super::merge_where_clauses(&[
-		&event.where_clause,
-		&def.config.where_clause,
-	]);
+	let completed_where_clause =
+		super::merge_where_clauses(&[&event.where_clause, &def.config.where_clause]);
 
 	let event_ident = &event.event;
 	let frame_system = &def.frame_system;
 	let frame_support = &def.frame_support;
 	let event_use_gen = &event.gen_kind.type_use_gen(event.attr_span);
-	let event_impl_gen= &event.gen_kind.type_impl_gen(event.attr_span);
-	let metadata = event.metadata.iter()
-		.map(|(ident, args, docs)| {
-			let name = format!("{}", ident);
-			quote::quote_spanned!(event.attr_span =>
-				#frame_support::event::EventMetadata {
-					name: #frame_support::event::DecodeDifferent::Encode(#name),
-					arguments: #frame_support::event::DecodeDifferent::Encode(&[
-						#( #args, )*
-					]),
-					documentation: #frame_support::event::DecodeDifferent::Encode(&[
-						#( #docs, )*
-					]),
-				},
-			)
-		});
+	let event_impl_gen = &event.gen_kind.type_impl_gen(event.attr_span);
+	let metadata = event.metadata.iter().map(|(ident, args, docs)| {
+		let name = format!("{}", ident);
+		quote::quote_spanned!(event.attr_span =>
+			#frame_support::event::EventMetadata {
+				name: #frame_support::event::DecodeDifferent::Encode(#name),
+				arguments: #frame_support::event::DecodeDifferent::Encode(&[
+					#( #args, )*
+				]),
+				documentation: #frame_support::event::DecodeDifferent::Encode(&[
+					#( #docs, )*
+				]),
+			},
+		)
+	});
 
 	let event_item = {
 		let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[event.index];
@@ -166,7 +163,7 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 			macro_rules! #macro_ident {
 				($pallet_name:ident) => {};
 			}
-	
+
 			#[doc(hidden)]
 			pub use #macro_ident as is_event_part_defined;
 		}

substrate/frame/support/procedural/src/pallet/expand/genesis_build.rs

@@ -40,8 +40,8 @@ pub fn expand_genesis_build(def: &mut Def) -> proc_macro2::TokenStream {
 
 	let gen_cfg_use_gen = genesis_config.gen_kind.type_use_gen(genesis_build.attr_span);
 
-	let genesis_build_item = &mut def.item.content.as_mut()
-		.expect("Checked by def parser").1[genesis_build.index];
+	let genesis_build_item =
+		&mut def.item.content.as_mut().expect("Checked by def parser").1[genesis_build.index];
 
 	let genesis_build_item_impl = if let syn::Item::Impl(impl_) = genesis_build_item {
 		impl_

substrate/frame/support/procedural/src/pallet/expand/genesis_config.rs

@@ -15,9 +15,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::{Def, parse::helper::get_doc_literals};
-use crate::COUNTER;
-use syn::{Ident, spanned::Spanned};
+use crate::{
+	pallet::{parse::helper::get_doc_literals, Def},
+	COUNTER,
+};
+use syn::{spanned::Spanned, Ident};
 
 /// * add various derive trait on GenesisConfig struct.
 pub fn expand_genesis_config(def: &mut Def) -> proc_macro2::TokenStream {
@@ -37,15 +39,11 @@ pub fn expand_genesis_config(def: &mut Def) -> proc_macro2::TokenStream {
 
 			(genesis_config, def_macro_ident, std_macro_ident)
 		} else {
-			let def_macro_ident = Ident::new(
-				&format!("__is_genesis_config_defined_{}", count),
-				def.item.span(),
-			);
+			let def_macro_ident =
+				Ident::new(&format!("__is_genesis_config_defined_{}", count), def.item.span());
 
-			let std_macro_ident = Ident::new(
-				&format!("__is_std_enabled_for_genesis_{}", count),
-				def.item.span(),
-			);
+			let std_macro_ident =
+				Ident::new(&format!("__is_std_enabled_for_genesis_{}", count), def.item.span());
 
 			return quote::quote! {
 				#[doc(hidden)]
@@ -74,18 +72,18 @@ pub fn expand_genesis_config(def: &mut Def) -> proc_macro2::TokenStream {
 					#[doc(hidden)]
 					pub use #std_macro_ident as is_std_enabled_for_genesis;
 				}
-			};
+			}
 		};
 
 	let frame_support = &def.frame_support;
 
-	let genesis_config_item = &mut def.item.content.as_mut()
-		.expect("Checked by def parser").1[genesis_config.index];
+	let genesis_config_item =
+		&mut def.item.content.as_mut().expect("Checked by def parser").1[genesis_config.index];
 
 	let serde_crate = format!("{}::serde", frame_support);
 
 	match genesis_config_item {
-		syn::Item::Enum(syn::ItemEnum { attrs, ..}) |
+		syn::Item::Enum(syn::ItemEnum { attrs, .. }) |
 		syn::Item::Struct(syn::ItemStruct { attrs, .. }) |
 		syn::Item::Type(syn::ItemType { attrs, .. }) => {
 			if get_doc_literals(&attrs).is_empty() {

substrate/frame/support/procedural/src/pallet/expand/hooks.rs

@@ -59,7 +59,7 @@ pub fn expand_hooks(def: &mut Def) -> proc_macro2::TokenStream {
 
 	let hooks_impl = if def.hooks.is_none() {
 		let frame_system = &def.frame_system;
-		quote::quote!{
+		quote::quote! {
 			impl<#type_impl_gen>
 				#frame_support::traits::Hooks<<T as #frame_system::Config>::BlockNumber>
 				for Pallet<#type_use_gen> {}

substrate/frame/support/procedural/src/pallet/expand/inherent.rs

@@ -15,11 +15,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::Def;
+use crate::{pallet::Def, COUNTER};
 use proc_macro2::TokenStream;
 use quote::quote;
-use crate::COUNTER;
-use syn::{Ident, spanned::Spanned};
+use syn::{spanned::Spanned, Ident};
 
 pub fn expand_inherents(def: &mut Def) -> TokenStream {
 	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
@@ -48,7 +47,7 @@ pub fn expand_inherents(def: &mut Def) -> TokenStream {
 					#maybe_compile_error
 				}
 			}
-	
+
 			#[doc(hidden)]
 			pub use #macro_ident as is_inherent_part_defined;
 		}

substrate/frame/support/procedural/src/pallet/expand/instances.rs

@@ -15,9 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use crate::{pallet::Def, NUMBER_OF_INSTANCE};
 use proc_macro2::Span;
-use crate::pallet::Def;
-use crate::NUMBER_OF_INSTANCE;
 
 /// * Provide inherent instance to be used by construct_runtime
 /// * Provide Instance1 ..= Instance16 for instantiable pallet
@@ -25,7 +24,9 @@ pub fn expand_instances(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
 	let inherent_ident = syn::Ident::new(crate::INHERENT_INSTANCE_NAME, Span::call_site());
 	let instances = if def.config.has_instance {
-		(1..=NUMBER_OF_INSTANCE).map(|i| syn::Ident::new(&format!("Instance{}", i), Span::call_site())).collect()
+		(1..=NUMBER_OF_INSTANCE)
+			.map(|i| syn::Ident::new(&format!("Instance{}", i), Span::call_site()))
+			.collect()
 	} else {
 		vec![]
 	};

substrate/frame/support/procedural/src/pallet/expand/mod.rs

@@ -15,24 +15,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod constants;
-mod pallet_struct;
 mod call;
 mod config;
+mod constants;
 mod error;
 mod event;
-mod storage;
-mod hooks;
-mod store_trait;
-mod inherent;
-mod instances;
 mod genesis_build;
 mod genesis_config;
-mod type_value;
+mod hooks;
+mod inherent;
+mod instances;
 mod origin;
+mod pallet_struct;
+mod storage;
+mod store_trait;
+mod type_value;
 mod validate_unsigned;
 
-use crate::pallet::{Def, parse::helper::get_doc_literals};
+use crate::pallet::{parse::helper::get_doc_literals, Def};
 use quote::ToTokens;
 
 /// Merge where clause together, `where` token span is taken from the first not none one.
@@ -97,7 +97,11 @@ pub fn expand(mut def: Def) -> proc_macro2::TokenStream {
 		#validate_unsigned
 	);
 
-	def.item.content.as_mut().expect("This is checked by parsing").1
+	def.item
+		.content
+		.as_mut()
+		.expect("This is checked by parsing")
+		.1
 		.push(syn::Item::Verbatim(new_items));
 
 	def.item.into_token_stream()

substrate/frame/support/procedural/src/pallet/expand/origin.rs

@@ -18,7 +18,7 @@
 use crate::{pallet::Def, COUNTER};
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{Ident, spanned::Spanned};
+use syn::{spanned::Spanned, Ident};
 
 pub fn expand_origins(def: &mut Def) -> TokenStream {
 	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
@@ -47,7 +47,7 @@ pub fn expand_origins(def: &mut Def) -> TokenStream {
 					#maybe_compile_error
 				}
 			}
-	
+
 			#[doc(hidden)]
 			pub use #macro_ident as is_origin_part_defined;
 		}

substrate/frame/support/procedural/src/pallet/expand/pallet_struct.rs

@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::{Def, expand::merge_where_clauses, parse::helper::get_doc_literals};
+use crate::pallet::{expand::merge_where_clauses, parse::helper::get_doc_literals, Def};
 
 /// * Add derive trait on Pallet
 /// * Implement GetPalletVersion on Pallet
@@ -104,29 +104,25 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
 
 	// Depending on the flag `generate_storage_info` we use partial or full storage info from
 	// storage.
-	let (
-		storage_info_span,
-		storage_info_trait,
-		storage_info_method,
-	) = if let Some(span) = def.pallet_struct.generate_storage_info {
-		(
-			span,
-			quote::quote_spanned!(span => StorageInfoTrait),
-			quote::quote_spanned!(span => storage_info),
-		)
-	} else {
-		let span = def.pallet_struct.attr_span;
-		(
-			span,
-			quote::quote_spanned!(span => PartialStorageInfoTrait),
-			quote::quote_spanned!(span => partial_storage_info),
-		)
-	};
+	let (storage_info_span, storage_info_trait, storage_info_method) =
+		if let Some(span) = def.pallet_struct.generate_storage_info {
+			(
+				span,
+				quote::quote_spanned!(span => StorageInfoTrait),
+				quote::quote_spanned!(span => storage_info),
+			)
+		} else {
+			let span = def.pallet_struct.attr_span;
+			(
+				span,
+				quote::quote_spanned!(span => PartialStorageInfoTrait),
+				quote::quote_spanned!(span => partial_storage_info),
+			)
+		};
 
 	let storage_names = &def.storages.iter().map(|storage| &storage.ident).collect::<Vec<_>>();
-	let storage_cfg_attrs = &def.storages.iter()
-		.map(|storage| &storage.cfg_attrs)
-		.collect::<Vec<_>>();
+	let storage_cfg_attrs =
+		&def.storages.iter().map(|storage| &storage.cfg_attrs).collect::<Vec<_>>();
 
 	let storage_info = quote::quote_spanned!(storage_info_span =>
 		impl<#type_impl_gen> #frame_support::traits::StorageInfoTrait

substrate/frame/support/procedural/src/pallet/expand/storage.rs

@@ -15,8 +15,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::{Def, parse::storage::StorageDef};
-use crate::pallet::parse::storage::{Metadata, QueryKind, StorageGenerics};
+use crate::pallet::{
+	parse::storage::{Metadata, QueryKind, StorageDef, StorageGenerics},
+	Def,
+};
 use frame_support_procedural_tools::clean_type_string;
 use std::collections::HashSet;
 
@@ -30,10 +32,7 @@ fn prefix_ident(storage: &StorageDef) -> syn::Ident {
 /// Check for duplicated storage prefixes. This step is necessary since users can specify an
 /// alternative storage prefix using the #[pallet::storage_prefix] syntax, and we need to ensure
 /// that the prefix specified by the user is not a duplicate of an existing one.
-fn check_prefix_duplicates(
-	storage_def: &StorageDef,
-	set: &mut HashSet<String>,
-) -> syn::Result<()> {
+fn check_prefix_duplicates(storage_def: &StorageDef, set: &mut HashSet<String>) -> syn::Result<()> {
 	let prefix = storage_def.prefix();
 
 	if !set.insert(prefix.clone()) {
@@ -41,7 +40,7 @@ fn check_prefix_duplicates(
 			storage_def.prefix_span(),
 			format!("Duplicate storage prefixes found for `{}`", prefix),
 		);
-		return Err(err);
+		return Err(err)
 	}
 
 	Ok(())
@@ -85,10 +84,8 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
 
 		let default_query_kind: syn::Type =
 			syn::parse_quote!(#frame_support::storage::types::OptionQuery);
-		let default_on_empty: syn::Type =
-			syn::parse_quote!(#frame_support::traits::GetDefault);
-		let default_max_values: syn::Type =
-			syn::parse_quote!(#frame_support::traits::GetDefault);
+		let default_on_empty: syn::Type = syn::parse_quote!(#frame_support::traits::GetDefault);
+		let default_max_values: syn::Type = syn::parse_quote!(#frame_support::traits::GetDefault);
 
 		if let Some(named_generics) = storage_def.named_generics.clone() {
 			args.args.clear();
@@ -100,7 +97,7 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
 					args.args.push(syn::GenericArgument::Type(query_kind));
 					let on_empty = on_empty.unwrap_or_else(|| default_on_empty.clone());
 					args.args.push(syn::GenericArgument::Type(on_empty));
-				}
+				},
 				StorageGenerics::Map { hasher, key, value, query_kind, on_empty, max_values } => {
 					args.args.push(syn::GenericArgument::Type(hasher));
 					args.args.push(syn::GenericArgument::Type(key));
@@ -111,9 +108,16 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
 					args.args.push(syn::GenericArgument::Type(on_empty));
 					let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
 					args.args.push(syn::GenericArgument::Type(max_values));
-				}
+				},
 				StorageGenerics::DoubleMap {
-					hasher1, key1, hasher2, key2, value, query_kind, on_empty, max_values,
+					hasher1,
+					key1,
+					hasher2,
+					key2,
+					value,
+					query_kind,
+					on_empty,
+					max_values,
 				} => {
 					args.args.push(syn::GenericArgument::Type(hasher1));
 					args.args.push(syn::GenericArgument::Type(key1));
@@ -126,8 +130,8 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
 					args.args.push(syn::GenericArgument::Type(on_empty));
 					let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
 					args.args.push(syn::GenericArgument::Type(max_values));
-				}
-				StorageGenerics::NMap { keygen, value, query_kind, on_empty, max_values, } => {
+				},
+				StorageGenerics::NMap { keygen, value, query_kind, on_empty, max_values } => {
 					args.args.push(syn::GenericArgument::Type(keygen));
 					args.args.push(syn::GenericArgument::Type(value));
 					let query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
@@ -136,7 +140,7 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
 					args.args.push(syn::GenericArgument::Type(on_empty));
 					let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
 					args.args.push(syn::GenericArgument::Type(max_values));
-				}
+				},
 			}
 		} else {
 			args.args[0] = syn::parse_quote!( #prefix_ident<#type_use_gen> );
@@ -154,118 +158,116 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
 /// * generate metadatas
 pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 	if let Err(e) = process_generics(def) {
-		return e.into_compile_error().into();
+		return e.into_compile_error().into()
 	}
 
 	let frame_support = &def.frame_support;
 	let frame_system = &def.frame_system;
 	let pallet_ident = &def.pallet_struct.pallet;
 
+	let entries = def.storages.iter().map(|storage| {
+		let docs = &storage.docs;
 
-	let entries = def.storages.iter()
-		.map(|storage| {
-			let docs = &storage.docs;
+		let ident = &storage.ident;
+		let gen = &def.type_use_generics(storage.attr_span);
+		let full_ident = quote::quote_spanned!(storage.attr_span => #ident<#gen> );
 
-			let ident = &storage.ident;
-			let gen = &def.type_use_generics(storage.attr_span);
-			let full_ident = quote::quote_spanned!(storage.attr_span => #ident<#gen> );
+		let cfg_attrs = &storage.cfg_attrs;
 
-			let cfg_attrs = &storage.cfg_attrs;
+		let metadata_trait = match &storage.metadata {
+			Metadata::Value { .. } => quote::quote_spanned!(storage.attr_span =>
+				#frame_support::storage::types::StorageValueMetadata
+			),
+			Metadata::Map { .. } => quote::quote_spanned!(storage.attr_span =>
+				#frame_support::storage::types::StorageMapMetadata
+			),
+			Metadata::DoubleMap { .. } => quote::quote_spanned!(storage.attr_span =>
+				#frame_support::storage::types::StorageDoubleMapMetadata
+			),
+			Metadata::NMap { .. } => quote::quote_spanned!(storage.attr_span =>
+				#frame_support::storage::types::StorageNMapMetadata
+			),
+		};
 
-			let metadata_trait = match &storage.metadata {
-				Metadata::Value { .. } => quote::quote_spanned!(storage.attr_span =>
-					#frame_support::storage::types::StorageValueMetadata
-				),
-				Metadata::Map { .. } => quote::quote_spanned!(storage.attr_span =>
-					#frame_support::storage::types::StorageMapMetadata
-				),
-				Metadata::DoubleMap { .. } => quote::quote_spanned!(storage.attr_span =>
-					#frame_support::storage::types::StorageDoubleMapMetadata
-				),
-				Metadata::NMap { .. } => quote::quote_spanned!(storage.attr_span =>
-					#frame_support::storage::types::StorageNMapMetadata
-				),
-			};
-
-			let ty = match &storage.metadata {
-				Metadata::Value { value } => {
-					let value = clean_type_string(&quote::quote!(#value).to_string());
-					quote::quote_spanned!(storage.attr_span =>
-						#frame_support::metadata::StorageEntryType::Plain(
-							#frame_support::metadata::DecodeDifferent::Encode(#value)
-						)
+		let ty = match &storage.metadata {
+			Metadata::Value { value } => {
+				let value = clean_type_string(&quote::quote!(#value).to_string());
+				quote::quote_spanned!(storage.attr_span =>
+					#frame_support::metadata::StorageEntryType::Plain(
+						#frame_support::metadata::DecodeDifferent::Encode(#value)
 					)
-				},
-				Metadata::Map { key, value } => {
-					let value = clean_type_string(&quote::quote!(#value).to_string());
-					let key = clean_type_string(&quote::quote!(#key).to_string());
-					quote::quote_spanned!(storage.attr_span =>
-						#frame_support::metadata::StorageEntryType::Map {
-							hasher: <#full_ident as #metadata_trait>::HASHER,
-							key: #frame_support::metadata::DecodeDifferent::Encode(#key),
-							value: #frame_support::metadata::DecodeDifferent::Encode(#value),
-							unused: false,
-						}
-					)
-				},
-				Metadata::DoubleMap { key1, key2, value } => {
-					let value = clean_type_string(&quote::quote!(#value).to_string());
-					let key1 = clean_type_string(&quote::quote!(#key1).to_string());
-					let key2 = clean_type_string(&quote::quote!(#key2).to_string());
-					quote::quote_spanned!(storage.attr_span =>
-						#frame_support::metadata::StorageEntryType::DoubleMap {
-							hasher: <#full_ident as #metadata_trait>::HASHER1,
-							key2_hasher: <#full_ident as #metadata_trait>::HASHER2,
-							key1: #frame_support::metadata::DecodeDifferent::Encode(#key1),
-							key2: #frame_support::metadata::DecodeDifferent::Encode(#key2),
-							value: #frame_support::metadata::DecodeDifferent::Encode(#value),
-						}
-					)
-				},
-				Metadata::NMap { keys, value, .. } => {
-					let keys = keys
-						.iter()
-						.map(|key| clean_type_string(&quote::quote!(#key).to_string()))
-						.collect::<Vec<_>>();
-					let value = clean_type_string(&quote::quote!(#value).to_string());
-					quote::quote_spanned!(storage.attr_span =>
-						#frame_support::metadata::StorageEntryType::NMap {
-							keys: #frame_support::metadata::DecodeDifferent::Encode(&[
-								#( #keys, )*
-							]),
-							hashers: #frame_support::metadata::DecodeDifferent::Encode(
-								<#full_ident as #metadata_trait>::HASHERS,
-							),
-							value: #frame_support::metadata::DecodeDifferent::Encode(#value),
-						}
-					)
-				}
-			};
+				)
+			},
+			Metadata::Map { key, value } => {
+				let value = clean_type_string(&quote::quote!(#value).to_string());
+				let key = clean_type_string(&quote::quote!(#key).to_string());
+				quote::quote_spanned!(storage.attr_span =>
+					#frame_support::metadata::StorageEntryType::Map {
+						hasher: <#full_ident as #metadata_trait>::HASHER,
+						key: #frame_support::metadata::DecodeDifferent::Encode(#key),
+						value: #frame_support::metadata::DecodeDifferent::Encode(#value),
+						unused: false,
+					}
+				)
+			},
+			Metadata::DoubleMap { key1, key2, value } => {
+				let value = clean_type_string(&quote::quote!(#value).to_string());
+				let key1 = clean_type_string(&quote::quote!(#key1).to_string());
+				let key2 = clean_type_string(&quote::quote!(#key2).to_string());
+				quote::quote_spanned!(storage.attr_span =>
+					#frame_support::metadata::StorageEntryType::DoubleMap {
+						hasher: <#full_ident as #metadata_trait>::HASHER1,
+						key2_hasher: <#full_ident as #metadata_trait>::HASHER2,
+						key1: #frame_support::metadata::DecodeDifferent::Encode(#key1),
+						key2: #frame_support::metadata::DecodeDifferent::Encode(#key2),
+						value: #frame_support::metadata::DecodeDifferent::Encode(#value),
+					}
+				)
+			},
+			Metadata::NMap { keys, value, .. } => {
+				let keys = keys
+					.iter()
+					.map(|key| clean_type_string(&quote::quote!(#key).to_string()))
+					.collect::<Vec<_>>();
+				let value = clean_type_string(&quote::quote!(#value).to_string());
+				quote::quote_spanned!(storage.attr_span =>
+					#frame_support::metadata::StorageEntryType::NMap {
+						keys: #frame_support::metadata::DecodeDifferent::Encode(&[
+							#( #keys, )*
+						]),
+						hashers: #frame_support::metadata::DecodeDifferent::Encode(
+							<#full_ident as #metadata_trait>::HASHERS,
+						),
+						value: #frame_support::metadata::DecodeDifferent::Encode(#value),
+					}
+				)
+			},
+		};
 
-			quote::quote_spanned!(storage.attr_span =>
-				#(#cfg_attrs)* #frame_support::metadata::StorageEntryMetadata {
-					name: #frame_support::metadata::DecodeDifferent::Encode(
-						<#full_ident as #metadata_trait>::NAME
-					),
-					modifier: <#full_ident as #metadata_trait>::MODIFIER,
-					ty: #ty,
-					default: #frame_support::metadata::DecodeDifferent::Encode(
-						<#full_ident as #metadata_trait>::DEFAULT
-					),
-					documentation: #frame_support::metadata::DecodeDifferent::Encode(&[
-						#( #docs, )*
-					]),
-				}
-			)
-		});
+		quote::quote_spanned!(storage.attr_span =>
+			#(#cfg_attrs)* #frame_support::metadata::StorageEntryMetadata {
+				name: #frame_support::metadata::DecodeDifferent::Encode(
+					<#full_ident as #metadata_trait>::NAME
+				),
+				modifier: <#full_ident as #metadata_trait>::MODIFIER,
+				ty: #ty,
+				default: #frame_support::metadata::DecodeDifferent::Encode(
+					<#full_ident as #metadata_trait>::DEFAULT
+				),
+				documentation: #frame_support::metadata::DecodeDifferent::Encode(&[
+					#( #docs, )*
+				]),
+			}
+		)
+	});
 
-	let getters = def.storages.iter()
-		.map(|storage| if let Some(getter) = &storage.getter {
-			let completed_where_clause = super::merge_where_clauses(&[
-				&storage.where_clause,
-				&def.config.where_clause,
-			]);
-			let docs = storage.docs.iter()
+	let getters = def.storages.iter().map(|storage| {
+		if let Some(getter) = &storage.getter {
+			let completed_where_clause =
+				super::merge_where_clauses(&[&storage.where_clause, &def.config.where_clause]);
+			let docs = storage
+				.docs
+				.iter()
 				.map(|d| quote::quote_spanned!(storage.attr_span => #[doc = #d]));
 
 			let ident = &storage.ident;
@@ -365,11 +367,12 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 							}
 						}
 					)
-				}
+				},
 			}
 		} else {
 			Default::default()
-		});
+		}
+	});
 
 	let prefix_structs = def.storages.iter().map(|storage_def| {
 		let type_impl_gen = &def.type_impl_generics(storage_def.attr_span);

substrate/frame/support/procedural/src/pallet/expand/store_trait.rs

@@ -22,11 +22,8 @@ use syn::spanned::Spanned;
 /// * generate Store trait with all storages,
 /// * implement Store trait for Pallet.
 pub fn expand_store_trait(def: &mut Def) -> proc_macro2::TokenStream {
-	let (trait_vis, trait_store) = if let Some(store) = &def.pallet_struct.store {
-		store
-	} else {
-		return Default::default()
-	};
+	let (trait_vis, trait_store) =
+		if let Some(store) = &def.pallet_struct.store { store } else { return Default::default() };
 
 	let type_impl_gen = &def.type_impl_generics(trait_store.span());
 	let type_use_gen = &def.type_use_generics(trait_store.span());
@@ -37,7 +34,8 @@ pub fn expand_store_trait(def: &mut Def) -> proc_macro2::TokenStream {
 	let completed_where_clause = super::merge_where_clauses(&where_clauses);
 
 	let storage_names = &def.storages.iter().map(|storage| &storage.ident).collect::<Vec<_>>();
-	let storage_cfg_attrs = &def.storages.iter().map(|storage| &storage.cfg_attrs).collect::<Vec<_>>();
+	let storage_cfg_attrs =
+		&def.storages.iter().map(|storage| &storage.cfg_attrs).collect::<Vec<_>>();
 
 	quote::quote_spanned!(trait_store.span() =>
 		#trait_vis trait #trait_store {

substrate/frame/support/procedural/src/pallet/expand/validate_unsigned.rs

@@ -15,15 +15,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::pallet::Def;
+use crate::{pallet::Def, COUNTER};
 use proc_macro2::TokenStream;
 use quote::quote;
-use crate::COUNTER;
-use syn::{Ident, spanned::Spanned};
+use syn::{spanned::Spanned, Ident};
 
 pub fn expand_validate_unsigned(def: &mut Def) -> TokenStream {
 	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
-	let macro_ident = Ident::new(&format!("__is_validate_unsigned_part_defined_{}", count), def.item.span());
+	let macro_ident =
+		Ident::new(&format!("__is_validate_unsigned_part_defined_{}", count), def.item.span());
 
 	let maybe_compile_error = if def.validate_unsigned.is_none() {
 		quote! {
@@ -48,7 +48,7 @@ pub fn expand_validate_unsigned(def: &mut Def) -> TokenStream {
 					#maybe_compile_error
 				}
 			}
-	
+
 			#[doc(hidden)]
 			pub use #macro_ident as is_validate_unsigned_part_defined;
 		}