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;
 		}

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

@@ -25,21 +25,22 @@
 //!   This step will modify the ItemMod by adding some derive attributes or phantom data variants
 //!   to user defined types. And also crate new types and implement block.
 
-mod parse;
 mod expand;
+mod parse;
 
 pub use parse::Def;
 use syn::spanned::Spanned;
 
 pub fn pallet(
 	attr: proc_macro::TokenStream,
-	item: proc_macro::TokenStream
+	item: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
 	if !attr.is_empty() {
-		let msg = "Invalid pallet macro call: expected no attributes, e.g. macro call must be just \
+		let msg =
+			"Invalid pallet macro call: expected no attributes, e.g. macro call must be just \
 			`#[frame_support::pallet]` or `#[pallet]`";
 		let span = proc_macro2::TokenStream::from(attr).span();
-		return syn::Error::new(span, msg).to_compile_error().into();
+		return syn::Error::new(span, msg).to_compile_error().into()
 	}
 
 	let item = syn::parse_macro_input!(item as syn::ItemMod);

substrate/frame/support/procedural/src/pallet/parse/call.rs

@@ -75,9 +75,7 @@ impl syn::parse::Parse for FunctionAttr {
 
 		let weight_content;
 		syn::parenthesized!(weight_content in content);
-		Ok(FunctionAttr {
-			weight: weight_content.parse::<syn::Expr>()?,
-		})
+		Ok(FunctionAttr { weight: weight_content.parse::<syn::Expr>()? })
 	}
 }
 
@@ -100,7 +98,6 @@ impl syn::parse::Parse for ArgAttrIsCompact {
 
 /// Check the syntax is `OriginFor<T>`
 pub fn check_dispatchable_first_arg_type(ty: &syn::Type) -> syn::Result<()> {
-
 	pub struct CheckDispatchableFirstArg;
 	impl syn::parse::Parse for CheckDispatchableFirstArg {
 		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
@@ -113,13 +110,12 @@ pub fn check_dispatchable_first_arg_type(ty: &syn::Type) -> syn::Result<()> {
 		}
 	}
 
-	syn::parse2::<CheckDispatchableFirstArg>(ty.to_token_stream())
-		.map_err(|e| {
-			let msg = "Invalid type: expected `OriginFor<T>`";
-			let mut err = syn::Error::new(ty.span(), msg);
-			err.combine(e);
-			err
-		})?;
+	syn::parse2::<CheckDispatchableFirstArg>(ty.to_token_stream()).map_err(|e| {
+		let msg = "Invalid type: expected `OriginFor<T>`";
+		let mut err = syn::Error::new(ty.span(), msg);
+		err.combine(e);
+		err
+	})?;
 
 	Ok(())
 }
@@ -128,12 +124,12 @@ impl CallDef {
 	pub fn try_from(
 		attr_span: proc_macro2::Span,
 		index: usize,
-		item: &mut syn::Item
+		item: &mut syn::Item,
 	) -> syn::Result<Self> {
 		let item = if let syn::Item::Impl(item) = item {
 			item
 		} else {
-			return Err(syn::Error::new(item.span(), "Invalid pallet::call, expected item impl"));
+			return Err(syn::Error::new(item.span(), "Invalid pallet::call, expected item impl"))
 		};
 
 		let mut instances = vec![];
@@ -158,18 +154,18 @@ impl CallDef {
 						_ => method.vis.span(),
 					};
 
-					return Err(syn::Error::new(span, msg));
+					return Err(syn::Error::new(span, msg))
 				}
 
 				match method.sig.inputs.first() {
 					None => {
 						let msg = "Invalid pallet::call, must have at least origin arg";
-						return Err(syn::Error::new(method.sig.span(), msg));
+						return Err(syn::Error::new(method.sig.span(), msg))
 					},
 					Some(syn::FnArg::Receiver(_)) => {
 						let msg = "Invalid pallet::call, first argument must be a typed argument, \
 							e.g. `origin: OriginFor<T>`";
-						return Err(syn::Error::new(method.sig.span(), msg));
+						return Err(syn::Error::new(method.sig.span(), msg))
 					},
 					Some(syn::FnArg::Typed(arg)) => {
 						check_dispatchable_first_arg_type(&*arg.ty)?;
@@ -181,7 +177,7 @@ impl CallDef {
 				} else {
 					let msg = "Invalid pallet::call, require return type \
 						DispatchResultWithPostInfo";
-					return Err(syn::Error::new(method.sig.span(), msg));
+					return Err(syn::Error::new(method.sig.span(), msg))
 				}
 
 				let mut call_var_attrs: Vec<FunctionAttr> =
@@ -193,7 +189,7 @@ impl CallDef {
 					} else {
 						"Invalid pallet::call, too many weight attributes given"
 					};
-					return Err(syn::Error::new(method.sig.span(), msg));
+					return Err(syn::Error::new(method.sig.span(), msg))
 				}
 				let weight = call_var_attrs.pop().unwrap().weight;
 
@@ -210,14 +206,14 @@ impl CallDef {
 
 					if arg_attrs.len() > 1 {
 						let msg = "Invalid pallet::call, argument has too many attributes";
-						return Err(syn::Error::new(arg.span(), msg));
+						return Err(syn::Error::new(arg.span(), msg))
 					}
 
 					let arg_ident = if let syn::Pat::Ident(pat) = &*arg.pat {
 						pat.ident.clone()
 					} else {
 						let msg = "Invalid pallet::call, argument must be ident";
-						return Err(syn::Error::new(arg.pat.span(), msg));
+						return Err(syn::Error::new(arg.pat.span(), msg))
 					};
 
 					args.push((!arg_attrs.is_empty(), arg_ident, arg.ty.clone()));
@@ -225,15 +221,10 @@ impl CallDef {
 
 				let docs = helper::get_doc_literals(&method.attrs);
 
-				methods.push(CallVariantDef {
-					name: method.sig.ident.clone(),
-					weight,
-					args,
-					docs,
-				});
+				methods.push(CallVariantDef { name: method.sig.ident.clone(), weight, args, docs });
 			} else {
 				let msg = "Invalid pallet::call, only method accepted";
-				return Err(syn::Error::new(impl_item.span(), msg));
+				return Err(syn::Error::new(impl_item.span(), msg))
 			}
 		}
 

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

@@ -17,8 +17,8 @@
 
 use super::helper;
 use core::convert::TryFrom;
-use syn::spanned::Spanned;
 use quote::ToTokens;
+use syn::spanned::Spanned;
 
 /// List of additional token to be used for parsing.
 mod keyword {
@@ -66,23 +66,26 @@ impl TryFrom<&syn::TraitItemType> for ConstMetadataDef {
 	type Error = syn::Error;
 
 	fn try_from(trait_ty: &syn::TraitItemType) -> Result<Self, Self::Error> {
-		let err = |span, msg|
-			syn::Error::new(span, format!("Invalid usage of `#[pallet::constant]`: {}", msg));
+		let err = |span, msg| {
+			syn::Error::new(span, format!("Invalid usage of `#[pallet::constant]`: {}", msg))
+		};
 		let doc = helper::get_doc_literals(&trait_ty.attrs);
 		let ident = trait_ty.ident.clone();
-		let bound = trait_ty.bounds
+		let bound = trait_ty
+			.bounds
 			.iter()
-			.find_map(|b|
+			.find_map(|b| {
 				if let syn::TypeParamBound::Trait(tb) = b {
-					tb.path.segments
+					tb.path
+						.segments
 						.last()
-						.and_then(|s| if s.ident == "Get" { Some(s) } else { None } )
+						.and_then(|s| if s.ident == "Get" { Some(s) } else { None })
 				} else {
 					None
 				}
-			)
+			})
 			.ok_or_else(|| err(trait_ty.span(), "`Get<T>` trait bound not found"))?;
-		let type_arg = if let syn::PathArguments::AngleBracketed (ref ab) = bound.arguments {
+		let type_arg = if let syn::PathArguments::AngleBracketed(ref ab) = bound.arguments {
 			if ab.args.len() == 1 {
 				if let syn::GenericArgument::Type(ref ty) = ab.args[0] {
 					Ok(ty)
@@ -214,15 +217,15 @@ impl syn::parse::Parse for FromEventParse {
 fn check_event_type(
 	frame_system: &syn::Ident,
 	trait_item: &syn::TraitItem,
-	trait_has_instance: bool
-)  -> syn::Result<bool> {
+	trait_has_instance: bool,
+) -> syn::Result<bool> {
 	if let syn::TraitItem::Type(type_) = trait_item {
 		if type_.ident == "Event" {
 			// Check event has no generics
 			if !type_.generics.params.is_empty() || type_.generics.where_clause.is_some() {
 				let msg = "Invalid `type Event`, associated type `Event` is reserved and must have\
 					no generics nor where_clause";
-				return Err(syn::Error::new(trait_item.span(), msg));
+				return Err(syn::Error::new(trait_item.span(), msg))
 			}
 			// Check bound contains IsType and From
 
@@ -237,28 +240,28 @@ fn check_event_type(
 					bound: `IsType<<Self as {}::Config>::Event>`",
 					frame_system,
 				);
-				return Err(syn::Error::new(type_.span(), msg));
+				return Err(syn::Error::new(type_.span(), msg))
 			}
 
-			let from_event_bound = type_.bounds.iter().find_map(|s| {
-				syn::parse2::<FromEventParse>(s.to_token_stream()).ok()
-			});
+			let from_event_bound = type_
+				.bounds
+				.iter()
+				.find_map(|s| syn::parse2::<FromEventParse>(s.to_token_stream()).ok());
 
 			let from_event_bound = if let Some(b) = from_event_bound {
 				b
 			} else {
 				let msg = "Invalid `type Event`, associated type `Event` is reserved and must \
 					bound: `From<Event>` or `From<Event<Self>>` or `From<Event<Self, I>>`";
-				return Err(syn::Error::new(type_.span(), msg));
+				return Err(syn::Error::new(type_.span(), msg))
 			};
 
-			if from_event_bound.is_generic
-				&& (from_event_bound.has_instance != trait_has_instance)
+			if from_event_bound.is_generic && (from_event_bound.has_instance != trait_has_instance)
 			{
 				let msg = "Invalid `type Event`, associated type `Event` bounds inconsistent \
 					`From<Event..>`. Config and generic Event must be both with instance or \
 					without instance";
-				return Err(syn::Error::new(type_.span(), msg));
+				return Err(syn::Error::new(type_.span(), msg))
 			}
 
 			Ok(true)
@@ -272,16 +275,14 @@ fn check_event_type(
 
 /// Replace ident `Self` by `T`
 pub fn replace_self_by_t(input: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
-	input.into_iter()
+	input
+		.into_iter()
 		.map(|token_tree| match token_tree {
 			proc_macro2::TokenTree::Group(group) =>
-				proc_macro2::Group::new(
-					group.delimiter(),
-					replace_self_by_t(group.stream())
-				).into(),
+				proc_macro2::Group::new(group.delimiter(), replace_self_by_t(group.stream())).into(),
 			proc_macro2::TokenTree::Ident(ident) if ident == "Self" =>
 				proc_macro2::Ident::new("T", ident.span()).into(),
-			other => other
+			other => other,
 		})
 		.collect()
 }
@@ -297,27 +298,27 @@ impl ConfigDef {
 			item
 		} else {
 			let msg = "Invalid pallet::config, expected trait definition";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		};
 
 		if !matches!(item.vis, syn::Visibility::Public(_)) {
 			let msg = "Invalid pallet::config, trait must be public";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
 		syn::parse2::<keyword::Config>(item.ident.to_token_stream())?;
 
-
 		let where_clause = {
 			let stream = replace_self_by_t(item.generics.where_clause.to_token_stream());
-			syn::parse2::<Option<syn::WhereClause>>(stream)
-				.expect("Internal error: replacing `Self` by `T` should result in valid where
-					clause")
+			syn::parse2::<Option<syn::WhereClause>>(stream).expect(
+				"Internal error: replacing `Self` by `T` should result in valid where
+					clause",
+			)
 		};
 
 		if item.generics.params.len() > 1 {
 			let msg = "Invalid pallet::config, expected no more than one generic";
-			return Err(syn::Error::new(item.generics.params[2].span(), msg));
+			return Err(syn::Error::new(item.generics.params[2].span(), msg))
 		}
 
 		let has_instance = if item.generics.params.first().is_some() {
@@ -331,15 +332,15 @@ impl ConfigDef {
 		let mut consts_metadata = vec![];
 		for trait_item in &mut item.items {
 			// Parse for event
-			has_event_type = has_event_type
-				|| check_event_type(frame_system, trait_item, has_instance)?;
+			has_event_type =
+				has_event_type || check_event_type(frame_system, trait_item, has_instance)?;
 
 			// Parse for constant
 			let type_attrs_const: Vec<TypeAttrConst> = helper::take_item_pallet_attrs(trait_item)?;
 
 			if type_attrs_const.len() > 1 {
 				let msg = "Invalid attribute in pallet::config, only one attribute is expected";
-				return Err(syn::Error::new(type_attrs_const[1].span(), msg));
+				return Err(syn::Error::new(type_attrs_const[1].span(), msg))
 			}
 
 			if type_attrs_const.len() == 1 {
@@ -349,17 +350,17 @@ impl ConfigDef {
 						consts_metadata.push(constant);
 					},
 					_ => {
-						let msg = "Invalid pallet::constant in pallet::config, expected type trait \
+						let msg =
+							"Invalid pallet::constant in pallet::config, expected type trait \
 							item";
-						return Err(syn::Error::new(trait_item.span(), msg));
+						return Err(syn::Error::new(trait_item.span(), msg))
 					},
 				}
 			}
 		}
 
-		let attr: Option<DisableFrameSystemSupertraitCheck> = helper::take_first_item_pallet_attr(
-			&mut item.attrs
-		)?;
+		let attr: Option<DisableFrameSystemSupertraitCheck> =
+			helper::take_first_item_pallet_attr(&mut item.attrs)?;
 
 		let disable_system_supertrait_check = attr.is_some();
 
@@ -372,10 +373,9 @@ impl ConfigDef {
 			let found = if item.supertraits.is_empty() {
 				"none".to_string()
 			} else {
-				let mut found = item.supertraits.iter()
-					.fold(String::new(), |acc, s| {
-						format!("{}`{}`, ", acc, quote::quote!(#s).to_string())
-					});
+				let mut found = item.supertraits.iter().fold(String::new(), |acc, s| {
+					format!("{}`{}`, ", acc, quote::quote!(#s).to_string())
+				});
 				found.pop();
 				found.pop();
 				found
@@ -387,19 +387,11 @@ impl ConfigDef {
 				(try `pub trait Config: frame_system::Config {{ ...` or \
 				`pub trait Config<I: 'static>: frame_system::Config {{ ...`). \
 				To disable this check, use `#[pallet::disable_frame_system_supertrait_check]`",
-				frame_system,
-				found,
+				frame_system, found,
 			);
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
-		Ok(Self {
-			index,
-			has_instance,
-			consts_metadata,
-			has_event_type,
-			where_clause,
-			attr_span,
-		})
+		Ok(Self { index, has_instance, consts_metadata, has_event_type, where_clause, attr_span })
 	}
 }

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

@@ -16,8 +16,8 @@
 // limitations under the License.
 
 use super::helper;
-use syn::spanned::Spanned;
 use quote::ToTokens;
+use syn::spanned::Spanned;
 
 /// List of additional token to be used for parsing.
 mod keyword {
@@ -48,11 +48,11 @@ impl ErrorDef {
 		let item = if let syn::Item::Enum(item) = item {
 			item
 		} else {
-			return Err(syn::Error::new(item.span(), "Invalid pallet::error, expected item enum"));
+			return Err(syn::Error::new(item.span(), "Invalid pallet::error, expected item enum"))
 		};
 		if !matches!(item.vis, syn::Visibility::Public(_)) {
 			let msg = "Invalid pallet::error, `Error` must be public";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
 		let mut instances = vec![];
@@ -60,34 +60,30 @@ impl ErrorDef {
 
 		if item.generics.where_clause.is_some() {
 			let msg = "Invalid pallet::error, where clause is not allowed on pallet error item";
-			return Err(syn::Error::new(item.generics.where_clause.as_ref().unwrap().span(), msg));
+			return Err(syn::Error::new(item.generics.where_clause.as_ref().unwrap().span(), msg))
 		}
 
 		let error = syn::parse2::<keyword::Error>(item.ident.to_token_stream())?;
 
-		let variants = item.variants.iter()
+		let variants = item
+			.variants
+			.iter()
 			.map(|variant| {
 				if !matches!(variant.fields, syn::Fields::Unit) {
 					let msg = "Invalid pallet::error, unexpected fields, must be `Unit`";
-					return Err(syn::Error::new(variant.fields.span(), msg));
+					return Err(syn::Error::new(variant.fields.span(), msg))
 				}
 				if variant.discriminant.is_some() {
 					let msg = "Invalid pallet::error, unexpected discriminant, discriminant \
 						are not supported";
 					let span = variant.discriminant.as_ref().unwrap().0.span();
-					return Err(syn::Error::new(span, msg));
+					return Err(syn::Error::new(span, msg))
 				}
 
 				Ok((variant.ident.clone(), helper::get_doc_literals(&variant.attrs)))
 			})
 			.collect::<Result<_, _>>()?;
 
-		Ok(ErrorDef {
-			attr_span,
-			index,
-			variants,
-			instances,
-			error,
-		})
+		Ok(ErrorDef { attr_span, index, variants, instances, error })
 	}
 }

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

@@ -16,9 +16,9 @@
 // limitations under the License.
 
 use super::helper;
-use syn::spanned::Spanned;
-use quote::ToTokens;
 use frame_support_procedural_tools::clean_type_string;
+use quote::ToTokens;
+use syn::spanned::Spanned;
 
 /// List of additional token to be used for parsing.
 mod keyword {
@@ -80,7 +80,7 @@ impl PalletEventAttr {
 
 /// Parse for syntax `$Type = "$SomeString"`.
 fn parse_event_metadata_element(
-	input: syn::parse::ParseStream
+	input: syn::parse::ParseStream,
 ) -> syn::Result<(syn::Type, String)> {
 	let typ = input.parse::<syn::Type>()?;
 	input.parse::<syn::Token![=]>()?;
@@ -118,7 +118,6 @@ impl syn::parse::Parse for PalletEventAttr {
 			generate_content.parse::<syn::Token![fn]>()?;
 			let fn_span = generate_content.parse::<keyword::deposit_event>()?.span();
 
-
 			Ok(PalletEventAttr::DepositEvent { fn_vis, span, fn_span })
 		} else {
 			Err(lookahead.error())
@@ -139,11 +138,10 @@ impl PalletEventAttrInfo {
 			match attr {
 				PalletEventAttr::Metadata { metadata: m, .. } if metadata.is_none() =>
 					metadata = Some(m),
-				PalletEventAttr::DepositEvent { fn_vis, fn_span, .. } if deposit_event.is_none() =>
+				PalletEventAttr::DepositEvent { fn_vis, fn_span, .. }
+					if deposit_event.is_none() =>
 					deposit_event = Some((fn_vis, fn_span)),
-				attr => {
-					return Err(syn::Error::new(attr.span(), "Duplicate attribute"));
-				}
+				attr => return Err(syn::Error::new(attr.span(), "Duplicate attribute")),
 			}
 		}
 
@@ -170,7 +168,7 @@ impl EventDef {
 
 		if !matches!(item.vis, syn::Visibility::Public(_)) {
 			let msg = "Invalid pallet::event, `Error` must be public";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
 		let where_clause = item.generics.where_clause.clone();
@@ -182,10 +180,7 @@ impl EventDef {
 			instances.push(u);
 		} else {
 			// construct_runtime only allow non generic event for non instantiable pallet.
-			instances.push(helper::InstanceUsage {
-				has_instance: false,
-				span: item.ident.span(),
-			})
+			instances.push(helper::InstanceUsage { has_instance: false, span: item.ident.span() })
 		}
 
 		let has_instance = item.generics.type_params().any(|t| t.ident == "I");
@@ -195,13 +190,19 @@ impl EventDef {
 
 		let event = syn::parse2::<keyword::Event>(item.ident.to_token_stream())?;
 
-		let metadata = item.variants.iter()
+		let metadata = item
+			.variants
+			.iter()
 			.map(|variant| {
 				let name = variant.ident.clone();
 				let docs = helper::get_doc_literals(&variant.attrs);
-				let args = variant.fields.iter()
+				let args = variant
+					.fields
+					.iter()
 					.map(|field| {
-						metadata.iter().find(|m| m.0 == field.ty)
+						metadata
+							.iter()
+							.find(|m| m.0 == field.ty)
 							.map(|m| m.1.clone())
 							.unwrap_or_else(|| {
 								clean_type_string(&field.ty.to_token_stream().to_string())

substrate/frame/support/procedural/src/pallet/parse/extra_constants.rs

@@ -52,14 +52,11 @@ pub struct ExtraConstantDef {
 }
 
 impl ExtraConstantsDef {
-	pub fn try_from(
-		index: usize,
-		item: &mut syn::Item
-	) -> syn::Result<Self> {
+	pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
 		let item = if let syn::Item::Impl(item) = item {
 			item
 		} else {
-			return Err(syn::Error::new(item.span(), "Invalid pallet::call, expected item impl"));
+			return Err(syn::Error::new(item.span(), "Invalid pallet::call, expected item impl"))
 		};
 
 		let mut instances = vec![];
@@ -78,28 +75,28 @@ impl ExtraConstantsDef {
 				method
 			} else {
 				let msg = "Invalid pallet::call, only method accepted";
-				return Err(syn::Error::new(impl_item.span(), msg));
+				return Err(syn::Error::new(impl_item.span(), msg))
 			};
 
 			if !method.sig.inputs.is_empty() {
 				let msg = "Invalid pallet::extra_constants, method must have 0 args";
-				return Err(syn::Error::new(method.sig.span(), msg));
+				return Err(syn::Error::new(method.sig.span(), msg))
 			}
 
 			if !method.sig.generics.params.is_empty() {
 				let msg = "Invalid pallet::extra_constants, method must have 0 generics";
-				return Err(syn::Error::new(method.sig.generics.params[0].span(), msg));
+				return Err(syn::Error::new(method.sig.generics.params[0].span(), msg))
 			}
 
 			if method.sig.generics.where_clause.is_some() {
 				let msg = "Invalid pallet::extra_constants, method must have no where clause";
-				return Err(syn::Error::new(method.sig.generics.where_clause.span(), msg));
+				return Err(syn::Error::new(method.sig.generics.where_clause.span(), msg))
 			}
 
 			let type_ = match &method.sig.output {
 				syn::ReturnType::Default => {
 					let msg = "Invalid pallet::extra_constants, method must have a return type";
-					return Err(syn::Error::new(method.span(), msg));
+					return Err(syn::Error::new(method.span(), msg))
 				},
 				syn::ReturnType::Type(_, type_) => *type_.clone(),
 			};

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

@@ -15,8 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use syn::spanned::Spanned;
 use super::helper;
+use syn::spanned::Spanned;
 
 /// Definition for pallet genesis build implementation.
 pub struct GenesisBuildDef {
@@ -40,24 +40,22 @@ impl GenesisBuildDef {
 			item
 		} else {
 			let msg = "Invalid pallet::genesis_build, expected item impl";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		};
 
-		let item_trait = &item.trait_.as_ref()
+		let item_trait = &item
+			.trait_
+			.as_ref()
 			.ok_or_else(|| {
 				let msg = "Invalid pallet::genesis_build, expected impl<..> GenesisBuild<..> \
 					for GenesisConfig<..>";
 				syn::Error::new(item.span(), msg)
-			})?.1;
+			})?
+			.1;
 
 		let mut instances = vec![];
 		instances.push(helper::check_genesis_builder_usage(&item_trait)?);
 
-		Ok(Self {
-			attr_span,
-			index,
-			instances,
-			where_clause: item.generics.where_clause.clone(),
-		})
+		Ok(Self { attr_span, index, instances, where_clause: item.generics.where_clause.clone() })
 	}
 }

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

@@ -15,8 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use syn::spanned::Spanned;
 use super::helper;
+use syn::spanned::Spanned;
 
 /// Definition for pallet genesis config type.
 ///
@@ -42,7 +42,7 @@ impl GenesisConfigDef {
 			syn::Item::Struct(item) => (&item.vis, &item.ident, &item.generics),
 			_ => {
 				let msg = "Invalid pallet::genesis_config, expected enum or struct";
-				return Err(syn::Error::new(item.span(), msg));
+				return Err(syn::Error::new(item.span(), msg))
 			},
 		};
 
@@ -60,19 +60,14 @@ impl GenesisConfigDef {
 
 		if !matches!(vis, syn::Visibility::Public(_)) {
 			let msg = "Invalid pallet::genesis_config, GenesisConfig must be public";
-			return Err(syn::Error::new(item_span, msg));
+			return Err(syn::Error::new(item_span, msg))
 		}
 
 		if ident != "GenesisConfig" {
 			let msg = "Invalid pallet::genesis_config, ident must `GenesisConfig`";
-			return Err(syn::Error::new(ident.span(), msg));
+			return Err(syn::Error::new(ident.span(), msg))
 		}
 
-		Ok(GenesisConfigDef {
-			index,
-			genesis_config: ident.clone(),
-			instances,
-			gen_kind,
-		})
+		Ok(GenesisConfigDef { index, genesis_config: ident.clone(), instances, gen_kind })
 	}
 }

substrate/frame/support/procedural/src/pallet/parse/helper.rs

@@ -15,8 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use syn::spanned::Spanned;
 use quote::ToTokens;
+use syn::spanned::Spanned;
 
 /// List of additional token to be used for parsing.
 mod keyword {
@@ -47,20 +47,15 @@ pub trait MutItemAttrs {
 }
 
 /// Take the first pallet attribute (e.g. attribute like `#[pallet..]`) and decode it to `Attr`
-pub fn take_first_item_pallet_attr<Attr>(item: &mut impl MutItemAttrs) -> syn::Result<Option<Attr>> where
+pub fn take_first_item_pallet_attr<Attr>(item: &mut impl MutItemAttrs) -> syn::Result<Option<Attr>>
+where
 	Attr: syn::parse::Parse,
 {
-	let attrs = if let Some(attrs) = item.mut_item_attrs() {
-		attrs
-	} else {
-		return Ok(None)
-	};
+	let attrs = if let Some(attrs) = item.mut_item_attrs() { attrs } else { return Ok(None) };
 
-	if let Some(index) = attrs.iter()
-		.position(|attr|
-			attr.path.segments.first().map_or(false, |segment| segment.ident == "pallet")
-		)
-	{
+	if let Some(index) = attrs.iter().position(|attr| {
+		attr.path.segments.first().map_or(false, |segment| segment.ident == "pallet")
+	}) {
 		let pallet_attr = attrs.remove(index);
 		Ok(Some(syn::parse2(pallet_attr.into_token_stream())?))
 	} else {
@@ -69,7 +64,8 @@ pub fn take_first_item_pallet_attr<Attr>(item: &mut impl MutItemAttrs) -> syn::R
 }
 
 /// Take all the pallet attributes (e.g. attribute like `#[pallet..]`) and decode them to `Attr`
-pub fn take_item_pallet_attrs<Attr>(item: &mut impl MutItemAttrs) -> syn::Result<Vec<Attr>> where
+pub fn take_item_pallet_attrs<Attr>(item: &mut impl MutItemAttrs) -> syn::Result<Vec<Attr>>
+where
 	Attr: syn::parse::Parse,
 {
 	let mut pallet_attrs = Vec::new();
@@ -83,13 +79,16 @@ pub fn take_item_pallet_attrs<Attr>(item: &mut impl MutItemAttrs) -> syn::Result
 
 /// Get all the cfg attributes (e.g. attribute like `#[cfg..]`) and decode them to `Attr`
 pub fn get_item_cfg_attrs(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
-	attrs.iter().filter_map(|attr|  {
-		if attr.path.segments.first().map_or(false, |segment| segment.ident == "cfg") {
-			Some(attr.clone())
-		} else {
-			None
-		}
-	}).collect::<Vec<_>>()
+	attrs
+		.iter()
+		.filter_map(|attr| {
+			if attr.path.segments.first().map_or(false, |segment| segment.ident == "cfg") {
+				Some(attr.clone())
+			} else {
+				None
+			}
+		})
+		.collect::<Vec<_>>()
 }
 
 impl MutItemAttrs for syn::Item {
@@ -116,7 +115,6 @@ impl MutItemAttrs for syn::Item {
 	}
 }
 
-
 impl MutItemAttrs for syn::TraitItem {
 	fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
 		match self {
@@ -143,7 +141,8 @@ impl MutItemAttrs for syn::ItemMod {
 
 /// Return all doc attributes literals found.
 pub fn get_doc_literals(attrs: &Vec<syn::Attribute>) -> Vec<syn::Lit> {
-	attrs.iter()
+	attrs
+		.iter()
 		.filter_map(|attr| {
 			if let Ok(syn::Meta::NameValue(meta)) = attr.parse_meta() {
 				if meta.path.get_ident().map_or(false, |ident| ident == "doc") {
@@ -166,7 +165,7 @@ impl syn::parse::Parse for Unit {
 		syn::parenthesized!(content in input);
 		if !content.is_empty() {
 			let msg = "unexpected tokens, expected nothing inside parenthesis as `()`";
-			return Err(syn::Error::new(content.span(), msg));
+			return Err(syn::Error::new(content.span(), msg))
 		}
 		Ok(Self)
 	}
@@ -179,7 +178,7 @@ impl syn::parse::Parse for StaticLifetime {
 		let lifetime = input.parse::<syn::Lifetime>()?;
 		if lifetime.ident != "static" {
 			let msg = "unexpected tokens, expected `static`";
-			return Err(syn::Error::new(lifetime.ident.span(), msg));
+			return Err(syn::Error::new(lifetime.ident.span(), msg))
 		}
 		Ok(Self)
 	}
@@ -190,10 +189,7 @@ impl syn::parse::Parse for StaticLifetime {
 /// `span` is used in case generics is empty (empty generics has span == call_site).
 ///
 /// return the instance if found.
-pub fn check_config_def_gen(
-	gen: &syn::Generics,
-	span: proc_macro2::Span,
-) -> syn::Result<()> {
+pub fn check_config_def_gen(gen: &syn::Generics, span: proc_macro2::Span) -> syn::Result<()> {
 	let expected = "expected `I: 'static = ()`";
 	pub struct CheckTraitDefGenerics;
 	impl syn::parse::Parse for CheckTraitDefGenerics {
@@ -208,13 +204,12 @@ pub fn check_config_def_gen(
 		}
 	}
 
-	syn::parse2::<CheckTraitDefGenerics>(gen.params.to_token_stream())
-		.map_err(|e| {
-			let msg = format!("Invalid generics: {}", expected);
-			let mut err = syn::Error::new(span, msg);
-			err.combine(e);
-			err
-		})?;
+	syn::parse2::<CheckTraitDefGenerics>(gen.params.to_token_stream()).map_err(|e| {
+		let msg = format!("Invalid generics: {}", expected);
+		let mut err = syn::Error::new(span, msg);
+		err.combine(e);
+		err
+	})?;
 
 	Ok(())
 }
@@ -234,10 +229,7 @@ pub fn check_type_def_gen_no_bounds(
 	pub struct Checker(InstanceUsage);
 	impl syn::parse::Parse for Checker {
 		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-			let mut instance_usage = InstanceUsage {
-				has_instance: false,
-				span: input.span(),
-			};
+			let mut instance_usage = InstanceUsage { has_instance: false, span: input.span() };
 
 			input.parse::<keyword::T>()?;
 			if input.peek(syn::Token![,]) {
@@ -258,7 +250,8 @@ pub fn check_type_def_gen_no_bounds(
 			let mut err = syn::Error::new(span, msg);
 			err.combine(e);
 			err
-		})?.0;
+		})?
+		.0;
 
 	Ok(i)
 }
@@ -286,10 +279,7 @@ pub fn check_type_def_optional_gen(
 				return Ok(Self(None))
 			}
 
-			let mut instance_usage = InstanceUsage {
-				span: input.span(),
-				has_instance: false,
-			};
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
 
 			input.parse::<keyword::T>()?;
 
@@ -338,9 +328,13 @@ pub fn check_type_def_optional_gen(
 			let mut err = syn::Error::new(span, msg);
 			err.combine(e);
 			err
-		})?.0
+		})?
+		.0
 		// Span can be call_site if generic is empty. Thus we replace it.
-		.map(|mut i| { i.span = span; i });
+		.map(|mut i| {
+			i.span = span;
+			i
+		});
 
 	Ok(i)
 }
@@ -355,10 +349,7 @@ pub fn check_pallet_struct_usage(type_: &Box<syn::Type>) -> syn::Result<Instance
 	pub struct Checker(InstanceUsage);
 	impl syn::parse::Parse for Checker {
 		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-			let mut instance_usage = InstanceUsage {
-				span: input.span(),
-				has_instance: false,
-			};
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
 
 			input.parse::<keyword::Pallet>()?;
 			input.parse::<syn::Token![<]>()?;
@@ -380,7 +371,8 @@ pub fn check_pallet_struct_usage(type_: &Box<syn::Type>) -> syn::Result<Instance
 			let mut err = syn::Error::new(type_.span(), msg);
 			err.combine(e);
 			err
-		})?.0;
+		})?
+		.0;
 
 	Ok(i)
 }
@@ -392,18 +384,12 @@ pub fn check_pallet_struct_usage(type_: &Box<syn::Type>) -> syn::Result<Instance
 /// `span` is used in case generics is empty (empty generics has span == call_site).
 ///
 /// return whether it contains instance.
-pub fn check_impl_gen(
-	gen: &syn::Generics,
-	span: proc_macro2::Span
-) -> syn::Result<InstanceUsage> {
+pub fn check_impl_gen(gen: &syn::Generics, span: proc_macro2::Span) -> syn::Result<InstanceUsage> {
 	let expected = "expected `impl<T: Config>` or `impl<T: Config<I>, I: 'static>`";
 	pub struct Checker(InstanceUsage);
 	impl syn::parse::Parse for Checker {
 		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-			let mut instance_usage = InstanceUsage {
-				span: input.span(),
-				has_instance: false,
-			};
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
 
 			input.parse::<keyword::T>()?;
 			input.parse::<syn::Token![:]>()?;
@@ -428,7 +414,8 @@ pub fn check_impl_gen(
 			let mut err = syn::Error::new(span, format!("Invalid generics: {}", expected));
 			err.combine(e);
 			err
-		})?.0;
+		})?
+		.0;
 
 	Ok(i)
 }
@@ -451,10 +438,7 @@ pub fn check_type_def_gen(
 	pub struct Checker(InstanceUsage);
 	impl syn::parse::Parse for Checker {
 		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-			let mut instance_usage = InstanceUsage {
-				span: input.span(),
-				has_instance: false,
-			};
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
 
 			input.parse::<keyword::T>()?;
 
@@ -503,7 +487,8 @@ pub fn check_type_def_gen(
 			let mut err = syn::Error::new(span, msg);
 			err.combine(e);
 			err
-		})?.0;
+		})?
+		.0;
 
 	// Span can be call_site if generic is empty. Thus we replace it.
 	i.span = span;
@@ -521,10 +506,7 @@ pub fn check_genesis_builder_usage(type_: &syn::Path) -> syn::Result<InstanceUsa
 	pub struct Checker(InstanceUsage);
 	impl syn::parse::Parse for Checker {
 		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-			let mut instance_usage = InstanceUsage {
-				span: input.span(),
-				has_instance: false,
-			};
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
 
 			input.parse::<keyword::GenesisBuild>()?;
 			input.parse::<syn::Token![<]>()?;
@@ -546,7 +528,8 @@ pub fn check_genesis_builder_usage(type_: &syn::Path) -> syn::Result<InstanceUsa
 			let mut err = syn::Error::new(type_.span(), msg);
 			err.combine(e);
 			err
-		})?.0;
+		})?
+		.0;
 
 	Ok(i)
 }
@@ -575,10 +558,7 @@ pub fn check_type_value_gen(
 			input.parse::<syn::Token![:]>()?;
 			input.parse::<keyword::Config>()?;
 
-			let mut instance_usage = InstanceUsage {
-				span: input.span(),
-				has_instance: false,
-			};
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
 
 			if input.is_empty() {
 				return Ok(Self(Some(instance_usage)))
@@ -603,17 +583,19 @@ pub fn check_type_value_gen(
 			let mut err = syn::Error::new(span, msg);
 			err.combine(e);
 			err
-		})?.0
+		})?
+		.0
 		// Span can be call_site if generic is empty. Thus we replace it.
-		.map(|mut i| { i.span = span; i });
+		.map(|mut i| {
+			i.span = span;
+			i
+		});
 
 	Ok(i)
 }
 
 /// Check the keyword `DispatchResultWithPostInfo` or `DispatchResult`.
-pub fn check_pallet_call_return_type(
-	type_: &syn::Type,
-) -> syn::Result<()> {
+pub fn check_pallet_call_return_type(type_: &syn::Type) -> syn::Result<()> {
 	pub struct Checker;
 	impl syn::parse::Parse for Checker {
 		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {

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

@@ -15,8 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use syn::spanned::Spanned;
 use super::helper;
+use syn::spanned::Spanned;
 
 /// Implementation of the pallet hooks.
 pub struct HooksDef {
@@ -42,30 +42,31 @@ impl HooksDef {
 			item
 		} else {
 			let msg = "Invalid pallet::hooks, expected item impl";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		};
 
 		let mut instances = vec![];
 		instances.push(helper::check_pallet_struct_usage(&item.self_ty)?);
 		instances.push(helper::check_impl_gen(&item.generics, item.impl_token.span())?);
 
-		let item_trait = &item.trait_.as_ref()
+		let item_trait = &item
+			.trait_
+			.as_ref()
 			.ok_or_else(|| {
 				let msg = "Invalid pallet::hooks, expected impl<..> Hooks \
 					for Pallet<..>";
 				syn::Error::new(item.span(), msg)
-			})?.1;
+			})?
+			.1;
 
-		if item_trait.segments.len() != 1
-			|| item_trait.segments[0].ident != "Hooks"
-		{
+		if item_trait.segments.len() != 1 || item_trait.segments[0].ident != "Hooks" {
 			let msg = format!(
 				"Invalid pallet::hooks, expected trait to be `Hooks` found `{}`\
 				, you can import from `frame_support::pallet_prelude`",
 				quote::quote!(#item_trait)
 			);
 
-			return Err(syn::Error::new(item_trait.span(), msg));
+			return Err(syn::Error::new(item_trait.span(), msg))
 		}
 
 		let has_runtime_upgrade = item.items.iter().any(|i| match i {

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

@@ -15,8 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use syn::spanned::Spanned;
 use super::helper;
+use syn::spanned::Spanned;
 
 /// The definition of the pallet inherent implementation.
 pub struct InherentDef {
@@ -32,22 +32,22 @@ impl InherentDef {
 			item
 		} else {
 			let msg = "Invalid pallet::inherent, expected item impl";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		};
 
 		if item.trait_.is_none() {
 			let msg = "Invalid pallet::inherent, expected impl<..> ProvideInherent for Pallet<..>";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
 		if let Some(last) = item.trait_.as_ref().unwrap().1.segments.last() {
 			if last.ident != "ProvideInherent" {
 				let msg = "Invalid pallet::inherent, expected trait ProvideInherent";
-				return Err(syn::Error::new(last.span(), msg));
+				return Err(syn::Error::new(last.span(), msg))
 			}
 		} else {
 			let msg = "Invalid pallet::inherent, expected impl<..> ProvideInherent for Pallet<..>";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
 		let mut instances = vec![];

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

@@ -19,24 +19,24 @@
 //!
 //! Parse the module into `Def` struct through `Def::try_from` function.
 
-pub mod config;
-pub mod pallet_struct;
-pub mod hooks;
 pub mod call;
+pub mod config;
 pub mod error;
-pub mod origin;
-pub mod inherent;
-pub mod storage;
 pub mod event;
-pub mod helper;
-pub mod genesis_config;
-pub mod genesis_build;
-pub mod validate_unsigned;
-pub mod type_value;
 pub mod extra_constants;
+pub mod genesis_build;
+pub mod genesis_config;
+pub mod helper;
+pub mod hooks;
+pub mod inherent;
+pub mod origin;
+pub mod pallet_struct;
+pub mod storage;
+pub mod type_value;
+pub mod validate_unsigned;
 
-use syn::spanned::Spanned;
 use frame_support_procedural_tools::generate_crate_access_2018;
+use syn::spanned::Spanned;
 
 /// Parsed definition of a pallet.
 pub struct Def {
@@ -67,11 +67,14 @@ impl Def {
 		let frame_support = generate_crate_access_2018("frame-support")?;
 
 		let item_span = item.span();
-		let items = &mut item.content.as_mut()
+		let items = &mut item
+			.content
+			.as_mut()
 			.ok_or_else(|| {
 				let msg = "Invalid pallet definition, expected mod to be inlined.";
 				syn::Error::new(item_span, msg)
-			})?.1;
+			})?
+			.1;
 
 		let mut config = None;
 		let mut pallet_struct = None;
@@ -128,13 +131,12 @@ impl Def {
 				},
 				Some(PalletAttr::TypeValue(span)) =>
 					type_values.push(type_value::TypeValueDef::try_from(span, index, item)?),
-				Some(PalletAttr::ExtraConstants(_)) => {
+				Some(PalletAttr::ExtraConstants(_)) =>
 					extra_constants =
-						Some(extra_constants::ExtraConstantsDef::try_from(index, item)?)
-				},
+						Some(extra_constants::ExtraConstantsDef::try_from(index, item)?),
 				Some(attr) => {
 					let msg = "Invalid duplicated attribute";
-					return Err(syn::Error::new(attr.span(), msg));
+					return Err(syn::Error::new(attr.span(), msg))
 				},
 				None => (),
 			}
@@ -148,12 +150,13 @@ impl Def {
 				genesis_config.as_ref().map_or("unused", |_| "used"),
 				genesis_build.as_ref().map_or("unused", |_| "used"),
 			);
-			return Err(syn::Error::new(item_span, msg));
+			return Err(syn::Error::new(item_span, msg))
 		}
 
 		let def = Def {
 			item,
-			config: config.ok_or_else(|| syn::Error::new(item_span, "Missing `#[pallet::config]`"))?,
+			config: config
+				.ok_or_else(|| syn::Error::new(item_span, "Missing `#[pallet::config]`"))?,
 			pallet_struct: pallet_struct
 				.ok_or_else(|| syn::Error::new(item_span, "Missing `#[pallet::pallet]`"))?,
 			hooks,
@@ -181,10 +184,7 @@ impl Def {
 	/// Check that usage of trait `Event` is consistent with the definition, i.e. it is declared
 	/// and trait defines type Event, or not declared and no trait associated type.
 	fn check_event_usage(&self) -> syn::Result<()> {
-		match (
-			self.config.has_event_type,
-			self.event.is_some(),
-		) {
+		match (self.config.has_event_type, self.event.is_some()) {
 			(true, false) => {
 				let msg = "Invalid usage of Event, `Config` contains associated type `Event`, \
 					but enum `Event` is not declared (i.e. no use of `#[pallet::event]`). \
@@ -197,7 +197,7 @@ impl Def {
 					An Event associated type must be declare on trait `Config`.";
 				Err(syn::Error::new(proc_macro2::Span::call_site(), msg))
 			},
-			_ => Ok(())
+			_ => Ok(()),
 		}
 	}
 
@@ -235,19 +235,18 @@ impl Def {
 			instances.extend_from_slice(&extra_constants.instances[..]);
 		}
 
-		let mut errors = instances.into_iter()
-			.filter_map(|instances| {
-				if instances.has_instance == self.config.has_instance {
-					return None
-				}
-				let msg = if self.config.has_instance {
-					"Invalid generic declaration, trait is defined with instance but generic use none"
-				} else {
-					"Invalid generic declaration, trait is defined without instance but generic use \
+		let mut errors = instances.into_iter().filter_map(|instances| {
+			if instances.has_instance == self.config.has_instance {
+				return None
+			}
+			let msg = if self.config.has_instance {
+				"Invalid generic declaration, trait is defined with instance but generic use none"
+			} else {
+				"Invalid generic declaration, trait is defined without instance but generic use \
 						some"
-				};
-				Some(syn::Error::new(instances.span, msg))
-			});
+			};
+			Some(syn::Error::new(instances.span, msg))
+		});
 
 		if let Some(mut first_error) = errors.next() {
 			for error in errors {
@@ -351,7 +350,8 @@ impl GenericKind {
 		match self {
 			GenericKind::None => quote::quote!(),
 			GenericKind::Config => quote::quote_spanned!(span => T: Config),
-			GenericKind::ConfigAndInstance => quote::quote_spanned!(span => T: Config<I>, I: 'static),
+			GenericKind::ConfigAndInstance =>
+				quote::quote_spanned!(span => T: Config<I>, I: 'static),
 		}
 	}
 

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

@@ -15,8 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use syn::spanned::Spanned;
 use super::helper;
+use syn::spanned::Spanned;
 
 /// Definition of the pallet origin type.
 ///
@@ -42,7 +42,7 @@ impl OriginDef {
 			syn::Item::Type(item) => (&item.vis, &item.ident, &item.generics),
 			_ => {
 				let msg = "Invalid pallet::origin, expected enum or struct or type";
-				return Err(syn::Error::new(item.span(), msg));
+				return Err(syn::Error::new(item.span(), msg))
 			},
 		};
 
@@ -54,27 +54,19 @@ impl OriginDef {
 			instances.push(u);
 		} else {
 			// construct_runtime only allow generic event for instantiable pallet.
-			instances.push(helper::InstanceUsage {
-				has_instance: false,
-				span: ident.span(),
-			})
+			instances.push(helper::InstanceUsage { has_instance: false, span: ident.span() })
 		}
 
 		if !matches!(vis, syn::Visibility::Public(_)) {
 			let msg = "Invalid pallet::origin, Origin must be public";
-			return Err(syn::Error::new(item_span, msg));
+			return Err(syn::Error::new(item_span, msg))
 		}
 
 		if ident != "Origin" {
 			let msg = "Invalid pallet::origin, ident must `Origin`";
-			return Err(syn::Error::new(ident.span(), msg));
+			return Err(syn::Error::new(ident.span(), msg))
 		}
 
-		Ok(OriginDef {
-			index,
-			has_instance,
-			is_generic,
-			instances,
-		})
+		Ok(OriginDef { index, has_instance, is_generic, instances })
 	}
 }

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

@@ -16,8 +16,8 @@
 // limitations under the License.
 
 use super::helper;
-use syn::spanned::Spanned;
 use quote::ToTokens;
+use syn::spanned::Spanned;
 
 /// List of additional token to be used for parsing.
 mod keyword {
@@ -49,11 +49,7 @@ pub struct PalletStructDef {
 /// * `#[pallet::generate_store($vis trait Store)]`
 /// * `#[pallet::generate_storage_info]`
 pub enum PalletStructAttr {
-	GenerateStore {
-		span: proc_macro2::Span,
-		vis: syn::Visibility,
-		keyword: keyword::Store,
-	},
+	GenerateStore { span: proc_macro2::Span, vis: syn::Visibility, keyword: keyword::Store },
 	GenerateStorageInfoTrait(proc_macro2::Span),
 }
 
@@ -103,7 +99,7 @@ impl PalletStructDef {
 			item
 		} else {
 			let msg = "Invalid pallet::pallet, expected struct definition";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		};
 
 		let mut store = None;
@@ -115,12 +111,14 @@ impl PalletStructDef {
 				PalletStructAttr::GenerateStore { vis, keyword, .. } if store.is_none() => {
 					store = Some((vis, keyword));
 				},
-				PalletStructAttr::GenerateStorageInfoTrait(span) if generate_storage_info.is_none() => {
+				PalletStructAttr::GenerateStorageInfoTrait(span)
+					if generate_storage_info.is_none() =>
+				{
 					generate_storage_info = Some(span);
-				},
+				}
 				attr => {
 					let msg = "Unexpected duplicated attribute";
-					return Err(syn::Error::new(attr.span(), msg));
+					return Err(syn::Error::new(attr.span(), msg))
 				},
 			}
 		}
@@ -129,12 +127,12 @@ impl PalletStructDef {
 
 		if !matches!(item.vis, syn::Visibility::Public(_)) {
 			let msg = "Invalid pallet::pallet, Pallet must be public";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
 		if item.generics.where_clause.is_some() {
 			let msg = "Invalid pallet::pallet, where clause not supported on Pallet declaration";
-			return Err(syn::Error::new(item.generics.where_clause.span(), msg));
+			return Err(syn::Error::new(item.generics.where_clause.span(), msg))
 		}
 
 		let mut instances = vec![];

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

@@ -16,9 +16,9 @@
 // limitations under the License.
 
 use super::helper;
-use syn::spanned::Spanned;
 use quote::ToTokens;
 use std::collections::HashMap;
+use syn::spanned::Spanned;
 
 /// List of additional token to be used for parsing.
 mod keyword {
@@ -69,11 +69,10 @@ impl syn::parse::Parse for PalletStorageAttr {
 
 			let renamed_prefix = content.parse::<syn::LitStr>()?;
 			// Ensure the renamed prefix is a proper Rust identifier
-			syn::parse_str::<syn::Ident>(&renamed_prefix.value())
-				.map_err(|_| {
-					let msg = format!("`{}` is not a valid identifier", renamed_prefix.value());
-					syn::Error::new(renamed_prefix.span(), msg)
-				})?;
+			syn::parse_str::<syn::Ident>(&renamed_prefix.value()).map_err(|_| {
+				let msg = format!("`{}` is not a valid identifier", renamed_prefix.value());
+				syn::Error::new(renamed_prefix.span(), msg)
+			})?;
 
 			Ok(Self::StorageName(renamed_prefix, attr_span))
 		} else {
@@ -86,16 +85,8 @@ impl syn::parse::Parse for PalletStorageAttr {
 pub enum Metadata {
 	Value { value: syn::Type },
 	Map { value: syn::Type, key: syn::Type },
-	DoubleMap {
-		value: syn::Type,
-		key1: syn::Type,
-		key2: syn::Type
-	},
-	NMap {
-		keys: Vec<syn::Type>,
-		keygen: syn::Type,
-		value: syn::Type,
-	},
+	DoubleMap { value: syn::Type, key1: syn::Type, key2: syn::Type },
+	NMap { keys: Vec<syn::Type>, keygen: syn::Type, value: syn::Type },
 }
 
 pub enum QueryKind {
@@ -181,11 +172,8 @@ impl StorageGenerics {
 			Self::DoubleMap { value, key1, key2, .. } => Metadata::DoubleMap { value, key1, key2 },
 			Self::Map { value, key, .. } => Metadata::Map { value, key },
 			Self::Value { value, .. } => Metadata::Value { value },
-			Self::NMap { keygen, value, .. } => Metadata::NMap {
-				keys: collect_keys(&keygen)?,
-				keygen,
-				value,
-			},
+			Self::NMap { keygen, value, .. } =>
+				Metadata::NMap { keys: collect_keys(&keygen)?, keygen, value },
 		};
 
 		Ok(res)
@@ -194,11 +182,10 @@ impl StorageGenerics {
 	/// Return the query kind from the defined generics
 	fn query_kind(&self) -> Option<syn::Type> {
 		match &self {
-			Self::DoubleMap { query_kind, .. }
-			| Self::Map { query_kind, .. }
-			| Self::Value { query_kind, .. }
-			| Self::NMap { query_kind, .. }
-				=> query_kind.clone(),
+			Self::DoubleMap { query_kind, .. } |
+			Self::Map { query_kind, .. } |
+			Self::Value { query_kind, .. } |
+			Self::NMap { query_kind, .. } => query_kind.clone(),
 		}
 	}
 }
@@ -225,7 +212,10 @@ fn check_generics(
 		let mut e = format!(
 			"`{}` expect generics {}and optional generics {}",
 			storage_type_name,
-			mandatory_generics.iter().map(|name| format!("`{}`, ", name)).collect::<String>(),
+			mandatory_generics
+				.iter()
+				.map(|name| format!("`{}`, ", name))
+				.collect::<String>(),
 			&optional_generics.iter().map(|name| format!("`{}`, ", name)).collect::<String>(),
 		);
 		e.pop();
@@ -235,14 +225,12 @@ fn check_generics(
 	};
 
 	for (gen_name, gen_binding) in map {
-		if !mandatory_generics.contains(&gen_name.as_str())
-			&& !optional_generics.contains(&gen_name.as_str())
+		if !mandatory_generics.contains(&gen_name.as_str()) &&
+			!optional_generics.contains(&gen_name.as_str())
 		{
 			let msg = format!(
 				"Invalid pallet::storage, Unexpected generic `{}` for `{}`. {}",
-				gen_name,
-				storage_type_name,
-				expectation,
+				gen_name, storage_type_name, expectation,
 			);
 			errors.push(syn::Error::new(gen_binding.span(), msg));
 		}
@@ -252,8 +240,7 @@ fn check_generics(
 		if !map.contains_key(&mandatory_generic.to_string()) {
 			let msg = format!(
 				"Invalid pallet::storage, cannot find `{}` generic, required for `{}`.",
-				mandatory_generic,
-				storage_type_name
+				mandatory_generic, storage_type_name
 			);
 			errors.push(syn::Error::new(args_span, msg));
 		}
@@ -284,7 +271,7 @@ fn process_named_generics(
 			let msg = "Invalid pallet::storage, Duplicated named generic";
 			let mut err = syn::Error::new(arg.ident.span(), msg);
 			err.combine(syn::Error::new(other.ident.span(), msg));
-			return Err(err);
+			return Err(err)
 		}
 		parsed.insert(arg.ident.to_string(), arg.clone());
 	}
@@ -300,15 +287,14 @@ fn process_named_generics(
 			)?;
 
 			StorageGenerics::Value {
-				value: parsed.remove("Value")
+				value: parsed
+					.remove("Value")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
-				query_kind: parsed.remove("QueryKind")
-					.map(|binding| binding.ty),
-				on_empty: parsed.remove("OnEmpty")
-					.map(|binding| binding.ty),
+				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
+				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
 			}
-		}
+		},
 		StorageKind::Map => {
 			check_generics(
 				&parsed,
@@ -319,20 +305,23 @@ fn process_named_generics(
 			)?;
 
 			StorageGenerics::Map {
-				hasher: parsed.remove("Hasher")
+				hasher: parsed
+					.remove("Hasher")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
-				key: parsed.remove("Key")
+				key: parsed
+					.remove("Key")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
-				value: parsed.remove("Value")
+				value: parsed
+					.remove("Value")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
 				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
 				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
 				max_values: parsed.remove("MaxValues").map(|binding| binding.ty),
 			}
-		}
+		},
 		StorageKind::DoubleMap => {
 			check_generics(
 				&parsed,
@@ -343,26 +332,31 @@ fn process_named_generics(
 			)?;
 
 			StorageGenerics::DoubleMap {
-				hasher1: parsed.remove("Hasher1")
+				hasher1: parsed
+					.remove("Hasher1")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
-				key1: parsed.remove("Key1")
+				key1: parsed
+					.remove("Key1")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
-				hasher2: parsed.remove("Hasher2")
+				hasher2: parsed
+					.remove("Hasher2")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
-				key2: parsed.remove("Key2")
+				key2: parsed
+					.remove("Key2")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
-				value: parsed.remove("Value")
+				value: parsed
+					.remove("Value")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
 				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
 				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
 				max_values: parsed.remove("MaxValues").map(|binding| binding.ty),
 			}
-		}
+		},
 		StorageKind::NMap => {
 			check_generics(
 				&parsed,
@@ -373,17 +367,19 @@ fn process_named_generics(
 			)?;
 
 			StorageGenerics::NMap {
-				keygen: parsed.remove("Key")
+				keygen: parsed
+					.remove("Key")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
-				value: parsed.remove("Value")
+				value: parsed
+					.remove("Value")
 					.map(|binding| binding.ty)
 					.expect("checked above as mandatory generic"),
 				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
 				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
 				max_values: parsed.remove("MaxValues").map(|binding| binding.ty),
 			}
-		}
+		},
 	};
 
 	let metadata = generics.metadata()?;
@@ -399,41 +395,32 @@ fn process_unnamed_generics(
 	args: &[syn::Type],
 ) -> syn::Result<(Option<StorageGenerics>, Metadata, Option<syn::Type>)> {
 	let retrieve_arg = |arg_pos| {
-		args.get(arg_pos)
-			.cloned()
-			.ok_or_else(|| {
-				let msg = format!(
-					"Invalid pallet::storage, unexpected number of generic argument, \
+		args.get(arg_pos).cloned().ok_or_else(|| {
+			let msg = format!(
+				"Invalid pallet::storage, unexpected number of generic argument, \
 						expect at least {} args, found {}.",
-					arg_pos + 1,
-					args.len(),
-				);
-				syn::Error::new(args_span, msg)
-			})
+				arg_pos + 1,
+				args.len(),
+			);
+			syn::Error::new(args_span, msg)
+		})
 	};
 
 	let prefix_arg = retrieve_arg(0)?;
-	syn::parse2::<syn::Token![_]>(prefix_arg.to_token_stream())
-		.map_err(|e| {
-			let msg = "Invalid pallet::storage, for unnamed generic arguments the type \
+	syn::parse2::<syn::Token![_]>(prefix_arg.to_token_stream()).map_err(|e| {
+		let msg = "Invalid pallet::storage, for unnamed generic arguments the type \
 				first generic argument must be `_`, the argument is then replaced by macro.";
-			let mut err = syn::Error::new(prefix_arg.span(), msg);
-			err.combine(e);
-			err
-		})?;
+		let mut err = syn::Error::new(prefix_arg.span(), msg);
+		err.combine(e);
+		err
+	})?;
 
 	let res = match storage {
-		StorageKind::Value => (
-			None,
-			Metadata::Value { value: retrieve_arg(1)? },
-			retrieve_arg(2).ok(),
-		),
+		StorageKind::Value =>
+			(None, Metadata::Value { value: retrieve_arg(1)? }, retrieve_arg(2).ok()),
 		StorageKind::Map => (
 			None,
-			Metadata::Map {
-				key: retrieve_arg(2)?,
-				value: retrieve_arg(3)?,
-			},
+			Metadata::Map { key: retrieve_arg(2)?, value: retrieve_arg(3)? },
 			retrieve_arg(4).ok(),
 		),
 		StorageKind::DoubleMap => (
@@ -448,15 +435,7 @@ fn process_unnamed_generics(
 		StorageKind::NMap => {
 			let keygen = retrieve_arg(1)?;
 			let keys = collect_keys(&keygen)?;
-			(
-				None,
-				Metadata::NMap {
-					keys,
-					keygen,
-					value: retrieve_arg(2)?,
-				},
-				retrieve_arg(3).ok(),
-			)
+			(None, Metadata::NMap { keys, keygen, value: retrieve_arg(2)? }, retrieve_arg(3).ok())
 		},
 	};
 
@@ -479,8 +458,8 @@ fn process_generics(
 				found `{}`.",
 				found,
 			);
-			return Err(syn::Error::new(segment.ident.span(), msg));
-		}
+			return Err(syn::Error::new(segment.ident.span(), msg))
+		},
 	};
 
 	let args_span = segment.arguments.span();
@@ -490,12 +469,14 @@ fn process_generics(
 		_ => {
 			let msg = "Invalid pallet::storage, invalid number of generic generic arguments, \
 				expect more that 0 generic arguments.";
-			return Err(syn::Error::new(segment.span(), msg));
-		}
+			return Err(syn::Error::new(segment.span(), msg))
+		},
 	};
 
 	if args.args.iter().all(|gen| matches!(gen, syn::GenericArgument::Type(_))) {
-		let args = args.args.iter()
+		let args = args
+			.args
+			.iter()
 			.map(|gen| match gen {
 				syn::GenericArgument::Type(gen) => gen.clone(),
 				_ => unreachable!("It is asserted above that all generics are types"),
@@ -503,7 +484,9 @@ fn process_generics(
 			.collect::<Vec<_>>();
 		process_unnamed_generics(&storage_kind, args_span, &args)
 	} else if args.args.iter().all(|gen| matches!(gen, syn::GenericArgument::Binding(_))) {
-		let args = args.args.iter()
+		let args = args
+			.args
+			.iter()
 			.map(|gen| match gen {
 				syn::GenericArgument::Binding(gen) => gen.clone(),
 				_ => unreachable!("It is asserted above that all generics are bindings"),
@@ -521,11 +504,7 @@ fn process_generics(
 /// Parse the 2nd type argument to `StorageNMap` and return its keys.
 fn collect_keys(keygen: &syn::Type) -> syn::Result<Vec<syn::Type>> {
 	if let syn::Type::Tuple(tup) = keygen {
-		tup
-			.elems
-			.iter()
-			.map(extract_key)
-			.collect::<syn::Result<Vec<_>>>()
+		tup.elems.iter().map(extract_key).collect::<syn::Result<Vec<_>>>()
 	} else {
 		Ok(vec![extract_key(keygen)?])
 	}
@@ -537,7 +516,7 @@ fn extract_key(ty: &syn::Type) -> syn::Result<syn::Type> {
 		typ
 	} else {
 		let msg = "Invalid pallet::storage, expected type path";
-		return Err(syn::Error::new(ty.span(), msg));
+		return Err(syn::Error::new(ty.span(), msg))
 	};
 
 	let key_struct = typ.path.segments.last().ok_or_else(|| {
@@ -546,28 +525,31 @@ fn extract_key(ty: &syn::Type) -> syn::Result<syn::Type> {
 	})?;
 	if key_struct.ident != "Key" && key_struct.ident != "NMapKey" {
 		let msg = "Invalid pallet::storage, expected Key or NMapKey struct";
-		return Err(syn::Error::new(key_struct.ident.span(), msg));
+		return Err(syn::Error::new(key_struct.ident.span(), msg))
 	}
 
 	let ty_params = if let syn::PathArguments::AngleBracketed(args) = &key_struct.arguments {
 		args
 	} else {
 		let msg = "Invalid pallet::storage, expected angle bracketed arguments";
-		return Err(syn::Error::new(key_struct.arguments.span(), msg));
+		return Err(syn::Error::new(key_struct.arguments.span(), msg))
 	};
 
 	if ty_params.args.len() != 2 {
-		let msg = format!("Invalid pallet::storage, unexpected number of generic arguments \
-			for Key struct, expected 2 args, found {}", ty_params.args.len());
-		return Err(syn::Error::new(ty_params.span(), msg));
+		let msg = format!(
+			"Invalid pallet::storage, unexpected number of generic arguments \
+			for Key struct, expected 2 args, found {}",
+			ty_params.args.len()
+		);
+		return Err(syn::Error::new(ty_params.span(), msg))
 	}
 
 	let key = match &ty_params.args[1] {
 		syn::GenericArgument::Type(key_ty) => key_ty.clone(),
 		_ => {
 			let msg = "Invalid pallet::storage, expected type";
-			return Err(syn::Error::new(ty_params.args[1].span(), msg));
-		}
+			return Err(syn::Error::new(ty_params.args[1].span(), msg))
+		},
 	};
 
 	Ok(key)
@@ -576,8 +558,7 @@ fn extract_key(ty: &syn::Type) -> syn::Result<syn::Type> {
 impl StorageDef {
 	/// Return the storage prefix for this storage item
 	pub fn prefix(&self) -> String {
-		self
-			.rename_as
+		self.rename_as
 			.as_ref()
 			.map(syn::LitStr::value)
 			.unwrap_or(self.ident.to_string())
@@ -586,11 +567,7 @@ impl StorageDef {
 	/// Return either the span of the ident or the span of the literal in the
 	/// #[storage_prefix] attribute
 	pub fn prefix_span(&self) -> proc_macro2::Span {
-		self
-			.rename_as
-			.as_ref()
-			.map(syn::LitStr::span)
-			.unwrap_or(self.ident.span())
+		self.rename_as.as_ref().map(syn::LitStr::span).unwrap_or(self.ident.span())
 	}
 
 	pub fn try_from(
@@ -601,7 +578,7 @@ impl StorageDef {
 		let item = if let syn::Item::Type(item) = item {
 			item
 		} else {
-			return Err(syn::Error::new(item.span(), "Invalid pallet::storage, expect item type."));
+			return Err(syn::Error::new(item.span(), "Invalid pallet::storage, expect item type."))
 		};
 
 		let attrs: Vec<PalletStorageAttr> = helper::take_item_pallet_attrs(&mut item.attrs)?;
@@ -610,23 +587,19 @@ impl StorageDef {
 			.partition::<Vec<_>, _>(|attr| matches!(attr, PalletStorageAttr::Getter(..)));
 		if getters.len() > 1 {
 			let msg = "Invalid pallet::storage, multiple argument pallet::getter found";
-			return Err(syn::Error::new(getters[1].attr_span(), msg));
+			return Err(syn::Error::new(getters[1].attr_span(), msg))
 		}
 		if names.len() > 1 {
 			let msg = "Invalid pallet::storage, multiple argument pallet::storage_prefix found";
-			return Err(syn::Error::new(names[1].attr_span(), msg));
+			return Err(syn::Error::new(names[1].attr_span(), msg))
 		}
-		let getter = getters.pop().map(|attr| {
-			match attr {
-				PalletStorageAttr::Getter(ident, _) => ident,
-				_ => unreachable!(),
-			}
+		let getter = getters.pop().map(|attr| match attr {
+			PalletStorageAttr::Getter(ident, _) => ident,
+			_ => unreachable!(),
 		});
-		let rename_as = names.pop().map(|attr| {
-			match attr {
-				PalletStorageAttr::StorageName(lit, _) => lit,
-				_ => unreachable!(),
-			}
+		let rename_as = names.pop().map(|attr| match attr {
+			PalletStorageAttr::StorageName(lit, _) => lit,
+			_ => unreachable!(),
 		});
 
 		let cfg_attrs = helper::get_item_cfg_attrs(&item.attrs);
@@ -641,12 +614,12 @@ impl StorageDef {
 			typ
 		} else {
 			let msg = "Invalid pallet::storage, expected type path";
-			return Err(syn::Error::new(item.ty.span(), msg));
+			return Err(syn::Error::new(item.ty.span(), msg))
 		};
 
 		if typ.path.segments.len() != 1 {
 			let msg = "Invalid pallet::storage, expected type path with one segment";
-			return Err(syn::Error::new(item.ty.span(), msg));
+			return Err(syn::Error::new(item.ty.span(), msg))
 		}
 
 		let (named_generics, metadata, query_kind) = process_generics(&typ.path.segments[0])?;
@@ -654,11 +627,11 @@ impl StorageDef {
 		let query_kind = query_kind
 			.map(|query_kind| match query_kind {
 				syn::Type::Path(path)
-					if path.path.segments.last().map_or(false, |s| s.ident == "OptionQuery")
-				=> Some(QueryKind::OptionQuery),
+					if path.path.segments.last().map_or(false, |s| s.ident == "OptionQuery") =>
+					Some(QueryKind::OptionQuery),
 				syn::Type::Path(path)
-					if path.path.segments.last().map_or(false, |s| s.ident == "ValueQuery")
-				=> Some(QueryKind::ValueQuery),
+					if path.path.segments.last().map_or(false, |s| s.ident == "ValueQuery") =>
+					Some(QueryKind::ValueQuery),
 				_ => None,
 			})
 			.unwrap_or(Some(QueryKind::OptionQuery)); // This value must match the default generic.
@@ -667,7 +640,7 @@ impl StorageDef {
 			let msg = "Invalid pallet::storage, cannot generate getter because QueryKind is not \
 				identifiable. QueryKind must be `OptionQuery`, `ValueQuery`, or default one to be \
 				identifiable.";
-			return Err(syn::Error::new(getter.unwrap().span(), msg));
+			return Err(syn::Error::new(getter.unwrap().span(), msg))
 		}
 
 		Ok(StorageDef {

substrate/frame/support/procedural/src/pallet/parse/type_value.rs

@@ -50,28 +50,31 @@ impl TypeValueDef {
 			item
 		} else {
 			let msg = "Invalid pallet::type_value, expected item fn";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		};
 
-
 		if !item.attrs.is_empty() {
 			let msg = "Invalid pallet::type_value, unexpected attribute";
-			return Err(syn::Error::new(item.attrs[0].span(), msg));
+			return Err(syn::Error::new(item.attrs[0].span(), msg))
 		}
 
-		if let Some(span) = item.sig.constness.as_ref().map(|t| t.span())
+		if let Some(span) = item
+			.sig
+			.constness
+			.as_ref()
+			.map(|t| t.span())
 			.or_else(|| item.sig.asyncness.as_ref().map(|t| t.span()))
 			.or_else(|| item.sig.unsafety.as_ref().map(|t| t.span()))
 			.or_else(|| item.sig.abi.as_ref().map(|t| t.span()))
 			.or_else(|| item.sig.variadic.as_ref().map(|t| t.span()))
 		{
 			let msg = "Invalid pallet::type_value, unexpected token";
-			return Err(syn::Error::new(span, msg));
+			return Err(syn::Error::new(span, msg))
 		}
 
 		if !item.sig.inputs.is_empty() {
 			let msg = "Invalid pallet::type_value, unexpected argument";
-			return Err(syn::Error::new(item.sig.inputs[0].span(), msg));
+			return Err(syn::Error::new(item.sig.inputs[0].span(), msg))
 		}
 
 		let vis = item.vis.clone();
@@ -81,7 +84,7 @@ impl TypeValueDef {
 			syn::ReturnType::Type(_, type_) => type_,
 			syn::ReturnType::Default => {
 				let msg = "Invalid pallet::type_value, expected return type";
-				return Err(syn::Error::new(item.sig.span(), msg));
+				return Err(syn::Error::new(item.sig.span(), msg))
 			},
 		};
 

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

@@ -15,8 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use syn::spanned::Spanned;
 use super::helper;
+use syn::spanned::Spanned;
 
 /// The definition of the pallet validate unsigned implementation.
 pub struct ValidateUnsignedDef {
@@ -32,24 +32,24 @@ impl ValidateUnsignedDef {
 			item
 		} else {
 			let msg = "Invalid pallet::validate_unsigned, expected item impl";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		};
 
 		if item.trait_.is_none() {
 			let msg = "Invalid pallet::validate_unsigned, expected impl<..> ValidateUnsigned for \
 				Pallet<..>";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
 		if let Some(last) = item.trait_.as_ref().unwrap().1.segments.last() {
 			if last.ident != "ValidateUnsigned" {
 				let msg = "Invalid pallet::validate_unsigned, expected trait ValidateUnsigned";
-				return Err(syn::Error::new(last.span(), msg));
+				return Err(syn::Error::new(last.span(), msg))
 			}
 		} else {
 			let msg = "Invalid pallet::validate_unsigned, expected impl<..> ValidateUnsigned for \
 				Pallet<..>";
-			return Err(syn::Error::new(item.span(), msg));
+			return Err(syn::Error::new(item.span(), msg))
 		}
 
 		let mut instances = vec![];