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/storage/genesis_config/builder_def.rs

@@ -17,11 +17,11 @@
 
 //! Builder logic definition used to build genesis storage.
 
+use super::super::{DeclStorageDefExt, StorageLineTypeDef};
 use frame_support_procedural_tools::syn_ext as ext;
 use proc_macro2::TokenStream;
-use syn::spanned::Spanned;
 use quote::{quote, quote_spanned};
-use super::super::{DeclStorageDefExt, StorageLineTypeDef};
+use syn::spanned::Spanned;
 
 /// Definition of builder blocks, each block insert some value in the storage.
 /// They must be called inside externalities, and with `self` being the genesis config.
@@ -79,7 +79,7 @@ impl BuilderDef {
 			if let Some(data) = data {
 				blocks.push(match &line.storage_type {
 					StorageLineTypeDef::Simple(_) if line.is_option => {
-						quote!{{
+						quote! {{
 							#data
 							let v: Option<&#value_type>= data;
 							if let Some(v) = v {
@@ -88,7 +88,7 @@ impl BuilderDef {
 						}}
 					},
 					StorageLineTypeDef::Simple(_) if !line.is_option => {
-						quote!{{
+						quote! {{
 							#data
 							let v: &#value_type = data;
 							<#storage_struct as #scrate::#storage_trait>::put::<&#value_type>(v);
@@ -97,7 +97,7 @@ impl BuilderDef {
 					StorageLineTypeDef::Simple(_) => unreachable!(),
 					StorageLineTypeDef::Map(map) => {
 						let key = &map.key;
-						quote!{{
+						quote! {{
 							#data
 							let data: &#scrate::sp_std::vec::Vec<(#key, #value_type)> = data;
 							data.iter().for_each(|(k, v)| {
@@ -110,7 +110,7 @@ impl BuilderDef {
 					StorageLineTypeDef::DoubleMap(map) => {
 						let key1 = &map.key1;
 						let key2 = &map.key2;
-						quote!{{
+						quote! {{
 							#data
 							let data: &#scrate::sp_std::vec::Vec<(#key1, #key2, #value_type)> = data;
 							data.iter().for_each(|(k1, k2, v)| {
@@ -122,12 +122,8 @@ impl BuilderDef {
 					},
 					StorageLineTypeDef::NMap(map) => {
 						let key_tuple = map.to_key_tuple();
-						let key_arg = if map.keys.len() == 1 {
-							quote!((k,))
-						} else {
-							quote!(k)
-						};
-						quote!{{
+						let key_arg = if map.keys.len() == 1 { quote!((k,)) } else { quote!(k) };
+						quote! {{
 							#data
 							let data: &#scrate::sp_std::vec::Vec<(#key_tuple, #value_type)> = data;
 							data.iter().for_each(|(k, v)| {
@@ -148,10 +144,6 @@ impl BuilderDef {
 			});
 		}
 
-
-		Self {
-			blocks,
-			is_generic,
-		}
+		Self { blocks, is_generic }
 	}
 }

substrate/frame/support/procedural/src/storage/genesis_config/genesis_config_def.rs

@@ -17,11 +17,11 @@
 
 //! Genesis config definition.
 
+use super::super::{DeclStorageDefExt, StorageLineTypeDef};
 use frame_support_procedural_tools::syn_ext as ext;
 use proc_macro2::TokenStream;
-use syn::{spanned::Spanned, parse_quote};
 use quote::quote;
-use super::super::{DeclStorageDefExt, StorageLineTypeDef};
+use syn::{parse_quote, spanned::Spanned};
 
 pub struct GenesisConfigFieldDef {
 	pub name: syn::Ident,
@@ -47,30 +47,28 @@ impl GenesisConfigDef {
 	pub fn from_def(def: &DeclStorageDefExt) -> syn::Result<Self> {
 		let fields = Self::get_genesis_config_field_defs(def)?;
 
-		let is_generic = fields.iter()
+		let is_generic = fields
+			.iter()
 			.any(|field| ext::type_contains_ident(&field.typ, &def.module_runtime_generic));
 
-		let (
-			genesis_struct_decl,
-			genesis_impl,
-			genesis_struct,
-			genesis_where_clause
-		) = if is_generic {
-			let runtime_generic = &def.module_runtime_generic;
-			let runtime_trait = &def.module_runtime_trait;
-			let optional_instance = &def.optional_instance;
-			let optional_instance_bound = &def.optional_instance_bound;
-			let optional_instance_bound_optional_default = &def.optional_instance_bound_optional_default;
-			let where_clause = &def.where_clause;
-			(
-				quote!(<#runtime_generic: #runtime_trait, #optional_instance_bound_optional_default>),
-				quote!(<#runtime_generic: #runtime_trait, #optional_instance_bound>),
-				quote!(<#runtime_generic, #optional_instance>),
-				where_clause.clone(),
-			)
-		} else {
-			(quote!(), quote!(), quote!(), None)
-		};
+		let (genesis_struct_decl, genesis_impl, genesis_struct, genesis_where_clause) =
+			if is_generic {
+				let runtime_generic = &def.module_runtime_generic;
+				let runtime_trait = &def.module_runtime_trait;
+				let optional_instance = &def.optional_instance;
+				let optional_instance_bound = &def.optional_instance_bound;
+				let optional_instance_bound_optional_default =
+					&def.optional_instance_bound_optional_default;
+				let where_clause = &def.where_clause;
+				(
+					quote!(<#runtime_generic: #runtime_trait, #optional_instance_bound_optional_default>),
+					quote!(<#runtime_generic: #runtime_trait, #optional_instance_bound>),
+					quote!(<#runtime_generic, #optional_instance>),
+					where_clause.clone(),
+				)
+			} else {
+				(quote!(), quote!(), quote!(), None)
+			};
 
 		Ok(Self {
 			is_generic,
@@ -82,14 +80,14 @@ impl GenesisConfigDef {
 		})
 	}
 
-	fn get_genesis_config_field_defs(def: &DeclStorageDefExt)
-		-> syn::Result<Vec<GenesisConfigFieldDef>>
-	{
+	fn get_genesis_config_field_defs(
+		def: &DeclStorageDefExt,
+	) -> syn::Result<Vec<GenesisConfigFieldDef>> {
 		let mut config_field_defs = Vec::new();
 
-		for (config_field, line) in def.storage_lines.iter()
-			.filter_map(|line| line.config.as_ref().map(|config_field| (config_field.clone(), line)))
-		{
+		for (config_field, line) in def.storage_lines.iter().filter_map(|line| {
+			line.config.as_ref().map(|config_field| (config_field.clone(), line))
+		}) {
 			let value_type = &line.value_type;
 
 			let typ = match &line.storage_type {
@@ -107,18 +105,20 @@ impl GenesisConfigDef {
 				StorageLineTypeDef::NMap(map) => {
 					let key_tuple = map.to_key_tuple();
 					parse_quote!( Vec<(#key_tuple, #value_type)> )
-				}
+				},
 			};
 
-			let default = line.default_value.as_ref()
-				.map(|d| {
-					if line.is_option {
-						quote!( #d.unwrap_or_default() )
-					} else {
-						quote!( #d )
-					}
-				})
-				.unwrap_or_else(|| quote!( Default::default() ));
+			let default =
+				line.default_value
+					.as_ref()
+					.map(|d| {
+						if line.is_option {
+							quote!( #d.unwrap_or_default() )
+						} else {
+							quote!( #d )
+						}
+					})
+					.unwrap_or_else(|| quote!(Default::default()));
 
 			config_field_defs.push(GenesisConfigFieldDef {
 				name: config_field,
@@ -129,22 +129,26 @@ impl GenesisConfigDef {
 		}
 
 		for line in &def.extra_genesis_config_lines {
-			let attrs = line.attrs.iter()
+			let attrs = line
+				.attrs
+				.iter()
 				.map(|attr| {
 					let meta = attr.parse_meta()?;
 					if meta.path().is_ident("cfg") {
 						return Err(syn::Error::new(
 							meta.span(),
-							"extra genesis config items do not support `cfg` attribute"
-						));
+							"extra genesis config items do not support `cfg` attribute",
+						))
 					}
 					Ok(meta)
 				})
 				.collect::<syn::Result<_>>()?;
 
-			let default = line.default.as_ref().map(|e| quote!( #e ))
-				.unwrap_or_else(|| quote!( Default::default() ));
-
+			let default = line
+				.default
+				.as_ref()
+				.map(|e| quote!( #e ))
+				.unwrap_or_else(|| quote!(Default::default()));
 
 			config_field_defs.push(GenesisConfigFieldDef {
 				name: line.name.clone(),

substrate/frame/support/procedural/src/storage/genesis_config/mod.rs

@@ -18,14 +18,14 @@
 //! Declaration of genesis config structure and implementation of build storage trait and
 //! functions.
 
-use proc_macro2::{TokenStream, Span};
-use quote::quote;
 use super::DeclStorageDefExt;
-pub use genesis_config_def::GenesisConfigDef;
 pub use builder_def::BuilderDef;
+pub use genesis_config_def::GenesisConfigDef;
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
 
-mod genesis_config_def;
 mod builder_def;
+mod genesis_config_def;
 
 const DEFAULT_INSTANCE_NAME: &str = "__GeneratedInstance";
 
@@ -118,19 +118,16 @@ fn impl_build_storage(
 	let genesis_impl = &genesis_config.genesis_impl;
 	let genesis_where_clause = &genesis_config.genesis_where_clause;
 
-	let (
-		fn_generic,
-		fn_traitinstance,
-		fn_where_clause
-	) = if !genesis_config.is_generic && builders.is_generic {
-		(
-			quote!( <#runtime_generic: #runtime_trait, #optional_instance_bound> ),
-			quote!( #runtime_generic, #optional_instance ),
-			Some(&def.where_clause),
-		)
-	} else {
-		(quote!(), quote!(), None)
-	};
+	let (fn_generic, fn_traitinstance, fn_where_clause) =
+		if !genesis_config.is_generic && builders.is_generic {
+			(
+				quote!( <#runtime_generic: #runtime_trait, #optional_instance_bound> ),
+				quote!( #runtime_generic, #optional_instance ),
+				Some(&def.where_clause),
+			)
+		} else {
+			(quote!(), quote!(), None)
+		};
 
 	let builder_blocks = &builders.blocks;
 
@@ -138,7 +135,7 @@ fn impl_build_storage(
 		#scrate::sp_runtime::BuildModuleGenesisStorage<#runtime_generic, #inherent_instance>
 	);
 
-	quote!{
+	quote! {
 		#[cfg(feature = "std")]
 		impl#genesis_impl GenesisConfig#genesis_struct #genesis_where_clause {
 			/// Build the storage for this module.
@@ -189,7 +186,7 @@ pub fn genesis_config_and_build_storage(def: &DeclStorageDefExt) -> TokenStream
 			decl_genesis_config_and_impl_default(scrate, &genesis_config);
 		let impl_build_storage = impl_build_storage(scrate, def, &genesis_config, &builders);
 
-		quote!{
+		quote! {
 			#decl_genesis_config_and_impl_default
 			#impl_build_storage
 		}

substrate/frame/support/procedural/src/storage/getters.rs

@@ -17,15 +17,17 @@
 
 //! Implementation of getters on module structure.
 
+use super::{DeclStorageDefExt, StorageLineTypeDef};
 use proc_macro2::TokenStream;
 use quote::quote;
-use super::{DeclStorageDefExt, StorageLineTypeDef};
 
 pub fn impl_getters(def: &DeclStorageDefExt) -> TokenStream {
 	let scrate = &def.hidden_crate;
 	let mut getters = TokenStream::new();
 
-	for (get_fn, line) in def.storage_lines.iter()
+	for (get_fn, line) in def
+		.storage_lines
+		.iter()
 		.filter_map(|line| line.getter.as_ref().map(|get_fn| (get_fn, line)))
 	{
 		let attrs = &line.doc_attrs;
@@ -35,7 +37,7 @@ pub fn impl_getters(def: &DeclStorageDefExt) -> TokenStream {
 
 		let getter = match &line.storage_type {
 			StorageLineTypeDef::Simple(value) => {
-				quote!{
+				quote! {
 					#( #[ #attrs ] )*
 					pub fn #get_fn() -> #value {
 						<#storage_struct as #scrate::#storage_trait>::get()
@@ -45,7 +47,7 @@ pub fn impl_getters(def: &DeclStorageDefExt) -> TokenStream {
 			StorageLineTypeDef::Map(map) => {
 				let key = &map.key;
 				let value = &map.value;
-				quote!{
+				quote! {
 					#( #[ #attrs ] )*
 					pub fn #get_fn<K: #scrate::codec::EncodeLike<#key>>(key: K) -> #value {
 						<#storage_struct as #scrate::#storage_trait>::get(key)
@@ -56,7 +58,7 @@ pub fn impl_getters(def: &DeclStorageDefExt) -> TokenStream {
 				let key1 = &map.key1;
 				let key2 = &map.key2;
 				let value = &map.value;
-				quote!{
+				quote! {
 					pub fn #get_fn<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> #value
 					where
 						KArg1: #scrate::codec::EncodeLike<#key1>,
@@ -69,7 +71,7 @@ pub fn impl_getters(def: &DeclStorageDefExt) -> TokenStream {
 			StorageLineTypeDef::NMap(map) => {
 				let keygen = map.to_keygen_struct(&def.hidden_crate);
 				let value = &map.value;
-				quote!{
+				quote! {
 					pub fn #get_fn<KArg>(key: KArg) -> #value
 					where
 						KArg: #scrate::storage::types::EncodeLikeTuple<
@@ -80,7 +82,7 @@ pub fn impl_getters(def: &DeclStorageDefExt) -> TokenStream {
 						<#storage_struct as #scrate::#storage_trait>::get(key)
 					}
 				}
-			}
+			},
 		};
 		getters.extend(getter);
 	}

substrate/frame/support/procedural/src/storage/instance_trait.rs

@@ -18,10 +18,10 @@
 //! Implementation of the trait instance and the instance structures implementing it.
 //! (For not instantiable traits there is still the inherent instance implemented).
 
-use proc_macro2::{TokenStream, Span};
-use quote::quote;
 use super::DeclStorageDefExt;
 use crate::NUMBER_OF_INSTANCE;
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
 
 pub(crate) const INHERENT_INSTANCE_NAME: &str = "__InherentHiddenInstance";
 
@@ -52,14 +52,12 @@ pub fn decl_and_impl(def: &DeclStorageDefExt) -> TokenStream {
 					index: i,
 				}
 			})
-			.chain(
-				module_instance.instance_default.as_ref().map(|ident| InstanceDef {
-					prefix: String::new(),
-					instance_struct: ident.clone(),
-					doc: quote!(#[doc=r"Default module instance"]),
-					index: 0,
-				})
-			);
+			.chain(module_instance.instance_default.as_ref().map(|ident| InstanceDef {
+				prefix: String::new(),
+				instance_struct: ident.clone(),
+				doc: quote!(#[doc=r"Default module instance"]),
+				index: 0,
+			}));
 
 		for instance_def in instance_defs {
 			impls.extend(create_and_impl_instance_struct(scrate, &instance_def, def));
@@ -70,8 +68,8 @@ pub fn decl_and_impl(def: &DeclStorageDefExt) -> TokenStream {
 	let inherent_instance = syn::Ident::new(INHERENT_INSTANCE_NAME, Span::call_site());
 
 	// Implementation of inherent instance.
-	if let Some(default_instance) = def.module_instance.as_ref()
-		.and_then(|i| i.instance_default.as_ref())
+	if let Some(default_instance) =
+		def.module_instance.as_ref().and_then(|i| i.instance_default.as_ref())
 	{
 		impls.extend(quote! {
 			/// Hidden instance generated to be internally used when module is used without
@@ -97,10 +95,7 @@ pub fn decl_and_impl(def: &DeclStorageDefExt) -> TokenStream {
 	impls
 }
 
-fn reexport_instance_trait(
-	scrate: &TokenStream,
-	def: &DeclStorageDefExt,
-) -> TokenStream {
+fn reexport_instance_trait(scrate: &TokenStream, def: &DeclStorageDefExt) -> TokenStream {
 	if let Some(i) = def.module_instance.as_ref() {
 		let instance_trait = &i.instance_trait;
 		quote!(

substrate/frame/support/procedural/src/storage/metadata.rs

@@ -17,17 +17,17 @@
 
 //! Implementation of `storage_metadata` on module structure, used by construct_runtime.
 
+use super::{DeclStorageDefExt, StorageLineDefExt, StorageLineTypeDef};
 use frame_support_procedural_tools::clean_type_string;
 use proc_macro2::TokenStream;
 use quote::quote;
-use super::{DeclStorageDefExt, StorageLineDefExt, StorageLineTypeDef};
 
 fn storage_line_metadata_type(scrate: &TokenStream, line: &StorageLineDefExt) -> TokenStream {
 	let value_type = &line.value_type;
 	let value_type = clean_type_string(&quote!( #value_type ).to_string());
 	match &line.storage_type {
 		StorageLineTypeDef::Simple(_) => {
-			quote!{
+			quote! {
 				#scrate::metadata::StorageEntryType::Plain(
 					#scrate::metadata::DecodeDifferent::Encode(#value_type),
 				)
@@ -37,7 +37,7 @@ fn storage_line_metadata_type(scrate: &TokenStream, line: &StorageLineDefExt) ->
 			let hasher = map.hasher.into_metadata();
 			let key = &map.key;
 			let key = clean_type_string(&quote!(#key).to_string());
-			quote!{
+			quote! {
 				#scrate::metadata::StorageEntryType::Map {
 					hasher: #scrate::metadata::#hasher,
 					key: #scrate::metadata::DecodeDifferent::Encode(#key),
@@ -53,7 +53,7 @@ fn storage_line_metadata_type(scrate: &TokenStream, line: &StorageLineDefExt) ->
 			let key1 = clean_type_string(&quote!(#key1).to_string());
 			let key2 = &map.key2;
 			let key2 = clean_type_string(&quote!(#key2).to_string());
-			quote!{
+			quote! {
 				#scrate::metadata::StorageEntryType::DoubleMap {
 					hasher: #scrate::metadata::#hasher1,
 					key1: #scrate::metadata::DecodeDifferent::Encode(#key1),
@@ -64,15 +64,17 @@ fn storage_line_metadata_type(scrate: &TokenStream, line: &StorageLineDefExt) ->
 			}
 		},
 		StorageLineTypeDef::NMap(map) => {
-			let keys = map.keys
+			let keys = map
+				.keys
 				.iter()
 				.map(|key| clean_type_string(&quote!(#key).to_string()))
 				.collect::<Vec<_>>();
-			let hashers = map.hashers
+			let hashers = map
+				.hashers
 				.iter()
 				.map(|hasher| hasher.to_storage_hasher_struct())
 				.collect::<Vec<_>>();
-			quote!{
+			quote! {
 				#scrate::metadata::StorageEntryType::NMap {
 					keys: #scrate::metadata::DecodeDifferent::Encode(&[
 						#( #keys, )*
@@ -83,7 +85,7 @@ fn storage_line_metadata_type(scrate: &TokenStream, line: &StorageLineDefExt) ->
 					value: #scrate::metadata::DecodeDifferent::Encode(#value_type),
 				}
 			}
-		}
+		},
 	}
 }
 
@@ -92,12 +94,17 @@ fn default_byte_getter(
 	line: &StorageLineDefExt,
 	def: &DeclStorageDefExt,
 ) -> (TokenStream, TokenStream) {
-	let default = line.default_value.as_ref().map(|d| quote!( #d ))
-		.unwrap_or_else(|| quote!( Default::default() ));
+	let default = line
+		.default_value
+		.as_ref()
+		.map(|d| quote!( #d ))
+		.unwrap_or_else(|| quote!(Default::default()));
 
 	let str_name = line.name.to_string();
-	let struct_name = syn::Ident::new(&("__GetByteStruct".to_string() + &str_name), line.name.span());
-	let cache_name = syn::Ident::new(&("__CACHE_GET_BYTE_STRUCT_".to_string() + &str_name), line.name.span());
+	let struct_name =
+		syn::Ident::new(&("__GetByteStruct".to_string() + &str_name), line.name.span());
+	let cache_name =
+		syn::Ident::new(&("__CACHE_GET_BYTE_STRUCT_".to_string() + &str_name), line.name.span());
 
 	let runtime_generic = &def.module_runtime_generic;
 	let runtime_trait = &def.module_runtime_trait;
@@ -177,10 +184,8 @@ pub fn impl_metadata(def: &DeclStorageDefExt) -> TokenStream {
 
 		let ty = storage_line_metadata_type(scrate, line);
 
-		let (
-			default_byte_getter_struct_def,
-			default_byte_getter_struct_instance,
-		) = default_byte_getter(scrate, line, def);
+		let (default_byte_getter_struct_def, default_byte_getter_struct_instance) =
+			default_byte_getter(scrate, line, def);
 
 		let mut docs = TokenStream::new();
 		for attr in line.attrs.iter().filter_map(|v| v.parse_meta().ok()) {

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

@@ -17,22 +17,22 @@
 
 //! `decl_storage` input definition and expansion.
 
-mod storage_struct;
-mod storage_info;
-mod parse;
-mod store_trait;
-mod getters;
-mod metadata;
-mod instance_trait;
 mod genesis_config;
+mod getters;
+mod instance_trait;
+mod metadata;
+mod parse;
 mod print_pallet_upgrade;
+mod storage_info;
+mod storage_struct;
+mod store_trait;
 
 pub(crate) use instance_trait::INHERENT_INSTANCE_NAME;
 
-use quote::quote;
 use frame_support_procedural_tools::{
-	generate_crate_access, generate_hidden_includes, syn_ext as ext
+	generate_crate_access, generate_hidden_includes, syn_ext as ext,
 };
+use quote::quote;
 
 /// All information contained in input of decl_storage
 pub struct DeclStorageDef {
@@ -115,34 +115,37 @@ pub struct DeclStorageDefExt {
 
 impl From<DeclStorageDef> for DeclStorageDefExt {
 	fn from(mut def: DeclStorageDef) -> Self {
-		let hidden_crate_name = def.hidden_crate.as_ref().map(|i| i.to_string())
+		let hidden_crate_name = def
+			.hidden_crate
+			.as_ref()
+			.map(|i| i.to_string())
 			.unwrap_or_else(|| "decl_storage".to_string());
 
 		let hidden_crate = generate_crate_access(&hidden_crate_name, "frame-support");
 		let hidden_imports = generate_hidden_includes(&hidden_crate_name, "frame-support");
 
 		let storage_lines = def.storage_lines.drain(..).collect::<Vec<_>>();
-		let storage_lines = storage_lines.into_iter()
+		let storage_lines = storage_lines
+			.into_iter()
 			.map(|line| StorageLineDefExt::from_def(line, &def, &hidden_crate))
 			.collect();
 
-		let (
-			optional_instance,
-			optional_instance_bound,
-			optional_instance_bound_optional_default,
-		) = if let Some(instance) = def.module_instance.as_ref() {
-			let instance_generic = &instance.instance_generic;
-			let instance_trait= &instance.instance_trait;
-			let optional_equal_instance_default = instance.instance_default.as_ref()
-				.map(|d| quote!( = #d ));
-			(
-				Some(quote!(#instance_generic)),
-				Some(quote!(#instance_generic: #instance_trait)),
-				Some(quote!(#instance_generic: #instance_trait #optional_equal_instance_default)),
-			)
-		} else {
-			(None, None, None)
-		};
+		let (optional_instance, optional_instance_bound, optional_instance_bound_optional_default) =
+			if let Some(instance) = def.module_instance.as_ref() {
+				let instance_generic = &instance.instance_generic;
+				let instance_trait = &instance.instance_trait;
+				let optional_equal_instance_default =
+					instance.instance_default.as_ref().map(|d| quote!( = #d ));
+				(
+					Some(quote!(#instance_generic)),
+					Some(quote!(#instance_generic: #instance_trait)),
+					Some(
+						quote!(#instance_generic: #instance_trait #optional_equal_instance_default),
+					),
+				)
+			} else {
+				(None, None, None)
+			};
 
 		let module_runtime_generic = &def.module_runtime_generic;
 		let module_runtime_trait = &def.module_runtime_trait;
@@ -255,22 +258,20 @@ impl StorageLineDefExt {
 		hidden_crate: &proc_macro2::TokenStream,
 	) -> Self {
 		let is_generic = match &storage_def.storage_type {
-			StorageLineTypeDef::Simple(value) => {
-				ext::type_contains_ident(&value, &def.module_runtime_generic)
-			},
-			StorageLineTypeDef::Map(map) => {
-				ext::type_contains_ident(&map.key, &def.module_runtime_generic)
-					|| ext::type_contains_ident(&map.value, &def.module_runtime_generic)
-			}
-			StorageLineTypeDef::DoubleMap(map) => {
-				ext::type_contains_ident(&map.key1, &def.module_runtime_generic)
-					|| ext::type_contains_ident(&map.key2, &def.module_runtime_generic)
-					|| ext::type_contains_ident(&map.value, &def.module_runtime_generic)
-			}
-			StorageLineTypeDef::NMap(map) => {
-				map.keys.iter().any(|key| ext::type_contains_ident(key, &def.module_runtime_generic))
-					|| ext::type_contains_ident(&map.value, &def.module_runtime_generic)
-			}
+			StorageLineTypeDef::Simple(value) =>
+				ext::type_contains_ident(&value, &def.module_runtime_generic),
+			StorageLineTypeDef::Map(map) =>
+				ext::type_contains_ident(&map.key, &def.module_runtime_generic) ||
+					ext::type_contains_ident(&map.value, &def.module_runtime_generic),
+			StorageLineTypeDef::DoubleMap(map) =>
+				ext::type_contains_ident(&map.key1, &def.module_runtime_generic) ||
+					ext::type_contains_ident(&map.key2, &def.module_runtime_generic) ||
+					ext::type_contains_ident(&map.value, &def.module_runtime_generic),
+			StorageLineTypeDef::NMap(map) =>
+				map.keys
+					.iter()
+					.any(|key| ext::type_contains_ident(key, &def.module_runtime_generic)) ||
+					ext::type_contains_ident(&map.value, &def.module_runtime_generic),
 		};
 
 		let query_type = match &storage_def.storage_type {
@@ -280,15 +281,13 @@ impl StorageLineDefExt {
 			StorageLineTypeDef::NMap(map) => map.value.clone(),
 		};
 		let is_option = ext::extract_type_option(&query_type).is_some();
-		let value_type = ext::extract_type_option(&query_type).unwrap_or_else(|| query_type.clone());
+		let value_type =
+			ext::extract_type_option(&query_type).unwrap_or_else(|| query_type.clone());
 
 		let module_runtime_generic = &def.module_runtime_generic;
 		let module_runtime_trait = &def.module_runtime_trait;
-		let optional_storage_runtime_comma = if is_generic {
-			Some(quote!( #module_runtime_generic, ))
-		} else {
-			None
-		};
+		let optional_storage_runtime_comma =
+			if is_generic { Some(quote!( #module_runtime_generic, )) } else { None };
 		let optional_storage_runtime_bound_comma = if is_generic {
 			Some(quote!( #module_runtime_generic: #module_runtime_trait, ))
 		} else {
@@ -304,11 +303,8 @@ impl StorageLineDefExt {
 			#storage_name<#optional_storage_runtime_comma #optional_instance_generic>
 		);
 
-		let optional_storage_where_clause = if is_generic {
-			def.where_clause.as_ref().map(|w| quote!( #w ))
-		} else {
-			None
-		};
+		let optional_storage_where_clause =
+			if is_generic { def.where_clause.as_ref().map(|w| quote!( #w )) } else { None };
 
 		let storage_trait_truncated = match &storage_def.storage_type {
 			StorageLineTypeDef::Simple(_) => {
@@ -326,13 +322,15 @@ impl StorageLineDefExt {
 			StorageLineTypeDef::NMap(map) => {
 				let keygen = map.to_keygen_struct(hidden_crate);
 				quote!( StorageNMap<#keygen, #value_type> )
-			}
+			},
 		};
 
 		let storage_trait = quote!( storage::#storage_trait_truncated );
 		let storage_generator_trait = quote!( storage::generator::#storage_trait_truncated );
 
-		let doc_attrs = storage_def.attrs.iter()
+		let doc_attrs = storage_def
+			.attrs
+			.iter()
 			.filter_map(|a| a.parse_meta().ok())
 			.filter(|m| m.path().is_ident("doc"))
 			.collect();
@@ -396,27 +394,28 @@ impl NMapDef {
 		if self.keys.len() == 1 {
 			let hasher = &self.hashers[0].to_storage_hasher_struct();
 			let key = &self.keys[0];
-			return quote!( #scrate::storage::types::Key<#scrate::#hasher, #key> );
+			return quote!( #scrate::storage::types::Key<#scrate::#hasher, #key> )
 		}
 
-		let key_hasher = self.keys.iter().zip(&self.hashers).map(|(key, hasher)| {
-			let hasher = hasher.to_storage_hasher_struct();
-			quote!( #scrate::storage::types::Key<#scrate::#hasher, #key> )
-		})
-		.collect::<Vec<_>>();
+		let key_hasher = self
+			.keys
+			.iter()
+			.zip(&self.hashers)
+			.map(|(key, hasher)| {
+				let hasher = hasher.to_storage_hasher_struct();
+				quote!( #scrate::storage::types::Key<#scrate::#hasher, #key> )
+			})
+			.collect::<Vec<_>>();
 		quote!(( #(#key_hasher,)* ))
 	}
 
 	fn to_key_tuple(&self) -> proc_macro2::TokenStream {
 		if self.keys.len() == 1 {
 			let key = &self.keys[0];
-			return quote!(#key);
+			return quote!(#key)
 		}
 
-		let tuple = self.keys.iter().map(|key| {
-			quote!(#key)
-		})
-		.collect::<Vec<_>>();
+		let tuple = self.keys.iter().map(|key| quote!(#key)).collect::<Vec<_>>();
 		quote!(( #(#tuple,)* ))
 	}
 }
@@ -442,25 +441,25 @@ pub enum HasherKind {
 impl HasherKind {
 	fn to_storage_hasher_struct(&self) -> proc_macro2::TokenStream {
 		match self {
-			HasherKind::Blake2_256 => quote!( Blake2_256 ),
-			HasherKind::Blake2_128 => quote!( Blake2_128 ),
-			HasherKind::Blake2_128Concat => quote!( Blake2_128Concat ),
-			HasherKind::Twox256 => quote!( Twox256 ),
-			HasherKind::Twox128 => quote!( Twox128 ),
-			HasherKind::Twox64Concat => quote!( Twox64Concat ),
-			HasherKind::Identity => quote!( Identity ),
+			HasherKind::Blake2_256 => quote!(Blake2_256),
+			HasherKind::Blake2_128 => quote!(Blake2_128),
+			HasherKind::Blake2_128Concat => quote!(Blake2_128Concat),
+			HasherKind::Twox256 => quote!(Twox256),
+			HasherKind::Twox128 => quote!(Twox128),
+			HasherKind::Twox64Concat => quote!(Twox64Concat),
+			HasherKind::Identity => quote!(Identity),
 		}
 	}
 
 	fn into_metadata(&self) -> proc_macro2::TokenStream {
 		match self {
-			HasherKind::Blake2_256 => quote!( StorageHasher::Blake2_256 ),
-			HasherKind::Blake2_128 => quote!( StorageHasher::Blake2_128 ),
-			HasherKind::Blake2_128Concat => quote!( StorageHasher::Blake2_128Concat ),
-			HasherKind::Twox256 => quote!( StorageHasher::Twox256 ),
-			HasherKind::Twox128 => quote!( StorageHasher::Twox128 ),
-			HasherKind::Twox64Concat => quote!( StorageHasher::Twox64Concat ),
-			HasherKind::Identity => quote!( StorageHasher::Identity ),
+			HasherKind::Blake2_256 => quote!(StorageHasher::Blake2_256),
+			HasherKind::Blake2_128 => quote!(StorageHasher::Blake2_128),
+			HasherKind::Blake2_128Concat => quote!(StorageHasher::Blake2_128Concat),
+			HasherKind::Twox256 => quote!(StorageHasher::Twox256),
+			HasherKind::Twox128 => quote!(StorageHasher::Twox128),
+			HasherKind::Twox64Concat => quote!(StorageHasher::Twox64Concat),
+			HasherKind::Identity => quote!(StorageHasher::Identity),
 		}
 	}
 }
@@ -502,5 +501,6 @@ pub fn decl_storage_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStr
 		#genesis_config
 		#storage_struct
 		#storage_info
-	).into()
+	)
+	.into()
 }

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

@@ -17,8 +17,8 @@
 
 //! Parsing of decl_storage input.
 
-use frame_support_procedural_tools::{ToTokens, Parse, syn_ext as ext};
-use syn::{Ident, Token, spanned::Spanned};
+use frame_support_procedural_tools::{syn_ext as ext, Parse, ToTokens};
+use syn::{spanned::Spanned, Ident, Token};
 
 mod keyword {
 	syn::custom_keyword!(generate_storage_info);
@@ -367,48 +367,35 @@ fn get_module_instance(
 			it is now defined at frame_support::traits::Instance. Expect `Instance` found `{}`",
 			instantiable.as_ref().unwrap(),
 		);
-		return Err(syn::Error::new(instantiable.span(), msg));
+		return Err(syn::Error::new(instantiable.span(), msg))
 	}
 
 	match (instance, instantiable, default_instance) {
-		(Some(instance), Some(instantiable), default_instance) => {
+		(Some(instance), Some(instantiable), default_instance) =>
 			Ok(Some(super::ModuleInstanceDef {
 				instance_generic: instance,
 				instance_trait: instantiable,
 				instance_default: default_instance,
-			}))
-		},
+			})),
 		(None, None, None) => Ok(None),
-		(Some(instance), None, _) => Err(
-			syn::Error::new(
-				instance.span(),
-				format!(
-					"Expect instantiable trait bound for instance: {}. {}",
-					instance,
-					right_syntax,
-				)
-			)
-		),
-		(None, Some(instantiable), _) => Err(
-			syn::Error::new(
-				instantiable.span(),
-				format!(
-					"Expect instance generic for bound instantiable: {}. {}",
-					instantiable,
-					right_syntax,
-				)
-			)
-		),
-		(None, _, Some(default_instance)) => Err(
-			syn::Error::new(
-				default_instance.span(),
-				format!(
-					"Expect instance generic for default instance: {}. {}",
-					default_instance,
-					right_syntax,
-				)
-			)
-		),
+		(Some(instance), None, _) => Err(syn::Error::new(
+			instance.span(),
+			format!("Expect instantiable trait bound for instance: {}. {}", instance, right_syntax,),
+		)),
+		(None, Some(instantiable), _) => Err(syn::Error::new(
+			instantiable.span(),
+			format!(
+				"Expect instance generic for bound instantiable: {}. {}",
+				instantiable, right_syntax,
+			),
+		)),
+		(None, _, Some(default_instance)) => Err(syn::Error::new(
+			default_instance.span(),
+			format!(
+				"Expect instance generic for default instance: {}. {}",
+				default_instance, right_syntax,
+			),
+		)),
 	}
 }
 
@@ -417,37 +404,37 @@ pub fn parse(input: syn::parse::ParseStream) -> syn::Result<super::DeclStorageDe
 
 	let def = StorageDefinition::parse(input)?;
 
-	let module_instance = get_module_instance(
-		def.mod_instance,
-		def.mod_instantiable,
-		def.mod_default_instance,
-	)?;
+	let module_instance =
+		get_module_instance(def.mod_instance, def.mod_instantiable, def.mod_default_instance)?;
 
 	let mut extra_genesis_config_lines = vec![];
 	let mut extra_genesis_build = None;
 
-	for line in def.extra_genesis.inner.into_iter()
+	for line in def
+		.extra_genesis
+		.inner
+		.into_iter()
 		.flat_map(|o| o.content.content.lines.inner.into_iter())
 	{
 		match line {
 			AddExtraGenesisLineEnum::AddExtraGenesisLine(def) => {
-				extra_genesis_config_lines.push(super::ExtraGenesisLineDef{
+				extra_genesis_config_lines.push(super::ExtraGenesisLineDef {
 					attrs: def.attrs.inner,
 					name: def.extra_field.content,
 					typ: def.extra_type,
 					default: def.default_value.inner.map(|o| o.expr),
 				});
-			}
+			},
 			AddExtraGenesisLineEnum::AddExtraGenesisBuild(def) => {
 				if extra_genesis_build.is_some() {
 					return Err(syn::Error::new(
 						def.span(),
-						"Only one build expression allowed for extra genesis"
+						"Only one build expression allowed for extra genesis",
 					))
 				}
 
 				extra_genesis_build = Some(def.expr.content);
-			}
+			},
 		}
 	}
 
@@ -496,68 +483,65 @@ fn parse_storage_line_defs(
 		};
 
 		if let Some(ref config) = config {
-			storage_lines.iter().filter_map(|sl| sl.config.as_ref()).try_for_each(|other_config| {
-				if other_config == config {
-					Err(syn::Error::new(
-						config.span(),
-						"`config()`/`get()` with the same name already defined.",
-					))
-				} else {
-					Ok(())
-				}
-			})?;
+			storage_lines.iter().filter_map(|sl| sl.config.as_ref()).try_for_each(
+				|other_config| {
+					if other_config == config {
+						Err(syn::Error::new(
+							config.span(),
+							"`config()`/`get()` with the same name already defined.",
+						))
+					} else {
+						Ok(())
+					}
+				},
+			)?;
 		}
 
 		let max_values = match &line.storage_type {
-			DeclStorageType::Map(_) | DeclStorageType::DoubleMap(_) | DeclStorageType::NMap(_) => {
-				line.max_values.inner.map(|i| i.expr.content)
-			},
-			DeclStorageType::Simple(_) => {
+			DeclStorageType::Map(_) | DeclStorageType::DoubleMap(_) | DeclStorageType::NMap(_) =>
+				line.max_values.inner.map(|i| i.expr.content),
+			DeclStorageType::Simple(_) =>
 				if let Some(max_values) = line.max_values.inner {
 					let msg = "unexpected max_values attribute for storage value.";
 					let span = max_values.max_values_keyword.span();
-					return Err(syn::Error::new(span, msg));
+					return Err(syn::Error::new(span, msg))
 				} else {
 					Some(syn::parse_quote!(1u32))
-				}
-			},
+				},
 		};
 
 		let span = line.storage_type.span();
-		let no_hasher_error = || syn::Error::new(
-			span,
-			"Default hasher has been removed, use explicit hasher(blake2_128_concat) instead."
-		);
+		let no_hasher_error = || {
+			syn::Error::new(
+				span,
+				"Default hasher has been removed, use explicit hasher(blake2_128_concat) instead.",
+			)
+		};
 
 		let storage_type = match line.storage_type {
-			DeclStorageType::Map(map) => super::StorageLineTypeDef::Map(
-				super::MapDef {
-					hasher: map.hasher.inner.ok_or_else(no_hasher_error)?.into(),
-					key: map.key,
-					value: map.value,
-				}
-			),
-			DeclStorageType::DoubleMap(map) => super::StorageLineTypeDef::DoubleMap(
-				Box::new(super::DoubleMapDef {
+			DeclStorageType::Map(map) => super::StorageLineTypeDef::Map(super::MapDef {
+				hasher: map.hasher.inner.ok_or_else(no_hasher_error)?.into(),
+				key: map.key,
+				value: map.value,
+			}),
+			DeclStorageType::DoubleMap(map) =>
+				super::StorageLineTypeDef::DoubleMap(Box::new(super::DoubleMapDef {
 					hasher1: map.hasher1.inner.ok_or_else(no_hasher_error)?.into(),
 					hasher2: map.hasher2.inner.ok_or_else(no_hasher_error)?.into(),
 					key1: map.key1,
 					key2: map.key2,
 					value: map.value,
-				})
-			),
-			DeclStorageType::NMap(map) => super::StorageLineTypeDef::NMap(
-				super::NMapDef {
-					hashers: map
-						.storage_keys
-						.inner
-						.iter()
-						.map(|pair| Ok(pair.hasher.inner.clone().ok_or_else(no_hasher_error)?.into()))
-						.collect::<Result<Vec<_>, syn::Error>>()?,
-					keys: map.storage_keys.inner.iter().map(|pair| pair.key.clone()).collect(),
-					value: map.value,
-				}
-			),
+				})),
+			DeclStorageType::NMap(map) => super::StorageLineTypeDef::NMap(super::NMapDef {
+				hashers: map
+					.storage_keys
+					.inner
+					.iter()
+					.map(|pair| Ok(pair.hasher.inner.clone().ok_or_else(no_hasher_error)?.into()))
+					.collect::<Result<Vec<_>, syn::Error>>()?,
+				keys: map.storage_keys.inner.iter().map(|pair| pair.key.clone()).collect(),
+				value: map.value,
+			}),
 			DeclStorageType::Simple(expr) => super::StorageLineTypeDef::Simple(expr),
 		};
 

substrate/frame/support/procedural/src/storage/print_pallet_upgrade.rs

@@ -1,6 +1,6 @@
 use super::StorageLineTypeDef;
-use quote::ToTokens;
 use frame_support_procedural_tools::clean_type_string;
+use quote::ToTokens;
 
 /// Environment variable that tells us to print pallet upgrade helper.
 const PRINT_PALLET_UPGRADE: &str = "PRINT_PALLET_UPGRADE";
@@ -10,7 +10,7 @@ fn check_print_pallet_upgrade() -> bool {
 }
 
 /// Convert visibilty as now objects are defined in a module.
-fn convert_vis(vis: &syn::Visibility) -> &'static str{
+fn convert_vis(vis: &syn::Visibility) -> &'static str {
 	match vis {
 		syn::Visibility::Inherited => "pub(super)",
 		syn::Visibility::Public(_) => "pub",
@@ -31,23 +31,13 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 
 	let scrate = &quote::quote!(frame_support);
 
-	let config_gen = if def.optional_instance.is_some() {
-		"<I: 'static = ()>"
-	} else {
-		Default::default()
-	};
+	let config_gen =
+		if def.optional_instance.is_some() { "<I: 'static = ()>" } else { Default::default() };
 
-	let impl_gen = if def.optional_instance.is_some() {
-		"<T: Config<I>, I: 'static>"
-	} else {
-		"<T: Config>"
-	};
+	let impl_gen =
+		if def.optional_instance.is_some() { "<T: Config<I>, I: 'static>" } else { "<T: Config>" };
 
-	let decl_gen = if def.optional_instance.is_some() {
-		"<T, I=()>"
-	} else {
-		"<T>"
-	};
+	let decl_gen = if def.optional_instance.is_some() { "<T, I=()>" } else { "<T>" };
 
 	let full_decl_gen = if def.optional_instance.is_some() {
 		"<T: Config<I>, I: 'static = ()>"
@@ -55,17 +45,9 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 		"<T: Config>"
 	};
 
-	let use_gen = if def.optional_instance.is_some() {
-		"<T, I>"
-	} else {
-		"<T>"
-	};
+	let use_gen = if def.optional_instance.is_some() { "<T, I>" } else { "<T>" };
 
-	let use_gen_tuple = if def.optional_instance.is_some() {
-		"<(T, I)>"
-	} else {
-		"<T>"
-	};
+	let use_gen_tuple = if def.optional_instance.is_some() { "<(T, I)>" } else { "<T>" };
 
 	let mut genesis_config = String::new();
 	let mut genesis_build = String::new();
@@ -80,17 +62,11 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 			},
 		};
 
-		let genesis_config_impl_gen = if genesis_config_def.is_generic {
-			impl_gen
-		} else {
-			Default::default()
-		};
+		let genesis_config_impl_gen =
+			if genesis_config_def.is_generic { impl_gen } else { Default::default() };
 
-		let genesis_config_use_gen = if genesis_config_def.is_generic {
-			use_gen
-		} else {
-			Default::default()
-		};
+		let genesis_config_use_gen =
+			if genesis_config_def.is_generic { use_gen } else { Default::default() };
 
 		let genesis_config_decl_gen = if genesis_config_def.is_generic {
 			if def.optional_instance.is_some() {
@@ -105,26 +81,31 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 		let mut genesis_config_decl_fields = String::new();
 		let mut genesis_config_default_fields = String::new();
 		for field in &genesis_config_def.fields {
-			genesis_config_decl_fields.push_str(&format!("
+			genesis_config_decl_fields.push_str(&format!(
+				"
 		{attrs}pub {name}: {typ},",
-				attrs = field.attrs.iter()
-					.fold(String::new(), |res, attr| {
-						format!("{}#[{}]
+				attrs = field.attrs.iter().fold(String::new(), |res, attr| {
+					format!(
+						"{}#[{}]
 		",
-						res, attr.to_token_stream())
-					}),
+						res,
+						attr.to_token_stream()
+					)
+				}),
 				name = field.name,
 				typ = to_cleaned_string(&field.typ),
 			));
 
-			genesis_config_default_fields.push_str(&format!("
+			genesis_config_default_fields.push_str(&format!(
+				"
 				{name}: {default},",
 				name = field.name,
 				default = to_cleaned_string(&field.default),
 			));
 		}
 
-		genesis_config = format!("
+		genesis_config = format!(
+			"
 	#[pallet::genesis_config]
 	pub struct GenesisConfig{genesis_config_decl_gen}
 		// TODO_MAYBE_WHERE_CLAUSE
@@ -147,16 +128,18 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 			genesis_config_use_gen = genesis_config_use_gen,
 		);
 
-		let genesis_config_build = genesis_config_builder_def.blocks.iter()
-			.fold(String::new(), |res, block| {
-				format!("{}
+		let genesis_config_build =
+			genesis_config_builder_def.blocks.iter().fold(String::new(), |res, block| {
+				format!(
+					"{}
 					{}",
 					res,
 					to_cleaned_string(block),
 				)
 			});
 
-		genesis_build = format!("
+		genesis_build = format!(
+			"
 	#[pallet::genesis_build]
 	impl{impl_gen} GenesisBuild{use_gen} for GenesisConfig{genesis_config_use_gen}
 		// TODO_MAYBE_WHERE_CLAUSE
@@ -176,7 +159,8 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 		let storage_vis = convert_vis(&line.visibility);
 
 		let getter = if let Some(getter) = &line.getter {
-			format!("
+			format!(
+				"
 	#[pallet::getter(fn {getter})]",
 				getter = getter
 			)
@@ -186,9 +170,12 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 
 		let value_type = &line.value_type;
 
-		let default_value_type_value = line.default_value.as_ref()
+		let default_value_type_value = line
+			.default_value
+			.as_ref()
 			.map(|default_expr| {
-				format!("
+				format!(
+					"
 	#[pallet::type_value]
 	{storage_vis} fn DefaultFor{name} /* TODO_MAYBE_GENERICS */ () -> {value_type} {{
 		{default_expr}
@@ -212,13 +199,16 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 			", ValueQuery"
 		};
 
-		let comma_default_value_getter_name = line.default_value.as_ref()
+		let comma_default_value_getter_name = line
+			.default_value
+			.as_ref()
 			.map(|_| format!(", DefaultFor{}", line.name))
 			.unwrap_or_else(String::new);
 
 		let typ = match &line.storage_type {
 			StorageLineTypeDef::Map(map) => {
-				format!("StorageMap<_, {hasher}, {key}, {value_type}{comma_query_kind}\
+				format!(
+					"StorageMap<_, {hasher}, {key}, {value_type}{comma_query_kind}\
 					{comma_default_value_getter_name}>",
 					hasher = &map.hasher.to_storage_hasher_struct(),
 					key = to_cleaned_string(&map.key),
@@ -228,7 +218,8 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 				)
 			},
 			StorageLineTypeDef::DoubleMap(double_map) => {
-				format!("StorageDoubleMap<_, {hasher1}, {key1}, {hasher2}, {key2}, {value_type}\
+				format!(
+					"StorageDoubleMap<_, {hasher1}, {key1}, {hasher2}, {key2}, {value_type}\
 					{comma_query_kind}{comma_default_value_getter_name}>",
 					hasher1 = double_map.hasher1.to_storage_hasher_struct(),
 					key1 = to_cleaned_string(&double_map.key1),
@@ -240,16 +231,18 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 				)
 			},
 			StorageLineTypeDef::NMap(map) => {
-				format!("StorageNMap<_, {keygen}, {value_type}{comma_query_kind}\
+				format!(
+					"StorageNMap<_, {keygen}, {value_type}{comma_query_kind}\
 					{comma_default_value_getter_name}>",
 					keygen = map.to_keygen_struct(&def.hidden_crate),
 					value_type = to_cleaned_string(&value_type),
 					comma_query_kind = comma_query_kind,
 					comma_default_value_getter_name = comma_default_value_getter_name,
 				)
-			}
+			},
 			StorageLineTypeDef::Simple(_) => {
-				format!("StorageValue<_, {value_type}{comma_query_kind}\
+				format!(
+					"StorageValue<_, {value_type}{comma_query_kind}\
 					{comma_default_value_getter_name}>",
 					value_type = to_cleaned_string(&value_type),
 					comma_query_kind = comma_query_kind,
@@ -265,7 +258,8 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 			""
 		};
 
-		storages.push_str(&format!("
+		storages.push_str(&format!(
+			"
 {default_value_type_value}{doc}
 	#[pallet::storage]{getter}
 	{storage_vis} type {name}{full_decl_gen} = {typ};{additional_comment}",
@@ -276,21 +270,21 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 			full_decl_gen = full_decl_gen,
 			typ = typ,
 			additional_comment = additional_comment,
-			doc = line.doc_attrs.iter()
-				.fold(String::new(), |mut res, attr| {
-					if let syn::Meta::NameValue(name_value) = attr {
-						if name_value.path.is_ident("doc") {
-							if let syn::Lit::Str(string) = &name_value.lit {
-								res = format!("{}
+			doc = line.doc_attrs.iter().fold(String::new(), |mut res, attr| {
+				if let syn::Meta::NameValue(name_value) = attr {
+					if name_value.path.is_ident("doc") {
+						if let syn::Lit::Str(string) = &name_value.lit {
+							res = format!(
+								"{}
 	///{}",
-									res,
-									string.value(),
-								);
-							}
+								res,
+								string.value(),
+							);
 						}
 					}
-					res
-				}),
+				}
+				res
+			}),
 		));
 	}
 
@@ -308,7 +302,8 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 		""
 	};
 
-	println!("
+	println!(
+		"
 // Template for pallet upgrade for {pallet_name}
 
 pub use pallet::*;

substrate/frame/support/procedural/src/storage/storage_info.rs

@@ -17,9 +17,9 @@
 
 //! Implementation of trait `StorageInfoTrait` on module structure.
 
+use super::DeclStorageDefExt;
 use proc_macro2::TokenStream;
 use quote::quote;
-use super::DeclStorageDefExt;
 
 pub fn impl_storage_info(def: &DeclStorageDefExt) -> TokenStream {
 	let scrate = &def.hidden_crate;

substrate/frame/support/procedural/src/storage/storage_struct.rs

@@ -17,16 +17,15 @@
 
 //! Implementation of storage structures and implementation of storage traits on them.
 
-use proc_macro2::{TokenStream, Ident, Span};
+use super::{instance_trait::INHERENT_INSTANCE_NAME, DeclStorageDefExt, StorageLineTypeDef};
+use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
-use super::{
-	DeclStorageDefExt, StorageLineTypeDef,
-	instance_trait::INHERENT_INSTANCE_NAME,
-};
 
 fn from_optional_value_to_query(is_option: bool, default: &Option<syn::Expr>) -> TokenStream {
-	let default = default.as_ref().map(|d| quote!( #d ))
-		.unwrap_or_else(|| quote!( Default::default() ));
+	let default = default
+		.as_ref()
+		.map(|d| quote!( #d ))
+		.unwrap_or_else(|| quote!(Default::default()));
 
 	if !is_option {
 		// raw type case
@@ -40,10 +39,10 @@ fn from_optional_value_to_query(is_option: bool, default: &Option<syn::Expr>) ->
 fn from_query_to_optional_value(is_option: bool) -> TokenStream {
 	if !is_option {
 		// raw type case
-		quote!( Some(v) )
+		quote!(Some(v))
 	} else {
 		// Option<> type case
-		quote!( v )
+		quote!(v)
 	}
 }
 
@@ -52,7 +51,6 @@ pub fn decl_and_impl(def: &DeclStorageDefExt) -> TokenStream {
 	let mut impls = TokenStream::new();
 
 	for line in &def.storage_lines {
-
 		// Propagate doc attributes.
 		let attrs = &line.doc_attrs;
 
@@ -60,7 +58,8 @@ pub fn decl_and_impl(def: &DeclStorageDefExt) -> TokenStream {
 		let optional_storage_runtime_comma = &line.optional_storage_runtime_comma;
 		let optional_storage_runtime_bound_comma = &line.optional_storage_runtime_bound_comma;
 		let optional_storage_where_clause = &line.optional_storage_where_clause;
-		let optional_instance_bound_optional_default = &def.optional_instance_bound_optional_default;
+		let optional_instance_bound_optional_default =
+			&def.optional_instance_bound_optional_default;
 		let optional_instance_bound = &def.optional_instance_bound;
 		let optional_instance = &def.optional_instance;
 		let name = &line.name;
@@ -87,10 +86,8 @@ pub fn decl_and_impl(def: &DeclStorageDefExt) -> TokenStream {
 			Ident::new(INHERENT_INSTANCE_NAME, Span::call_site())
 		};
 
-		let storage_name_bstr = syn::LitByteStr::new(
-			line.name.to_string().as_ref(),
-			line.name.span()
-		);
+		let storage_name_bstr =
+			syn::LitByteStr::new(line.name.to_string().as_ref(), line.name.span());
 
 		let storage_generator_trait = &line.storage_generator_trait;
 		let storage_struct = &line.storage_struct;
@@ -242,7 +239,7 @@ pub fn decl_and_impl(def: &DeclStorageDefExt) -> TokenStream {
 						}
 					}
 				)
-			}
+			},
 		};
 
 		let max_values = if let Some(max_values) = &line.max_values {

substrate/frame/support/procedural/src/storage/store_trait.rs

@@ -17,26 +17,26 @@
 
 //! Declaration of store trait and implementation on module structure.
 
+use super::DeclStorageDefExt;
 use proc_macro2::TokenStream;
 use quote::quote;
-use super::DeclStorageDefExt;
 
 pub fn decl_and_impl(def: &DeclStorageDefExt) -> TokenStream {
-	let decl_store_items = def.storage_lines.iter()
-		.map(|sline| &sline.name)
-		.fold(TokenStream::new(), |mut items, name| {
+	let decl_store_items = def.storage_lines.iter().map(|sline| &sline.name).fold(
+		TokenStream::new(),
+		|mut items, name| {
 			items.extend(quote!(type #name;));
 			items
-		});
+		},
+	);
 
-	let impl_store_items = def.storage_lines.iter()
-		.fold(TokenStream::new(), |mut items, line| {
-			let name = &line.name;
-			let storage_struct = &line.storage_struct;
+	let impl_store_items = def.storage_lines.iter().fold(TokenStream::new(), |mut items, line| {
+		let name = &line.name;
+		let storage_struct = &line.storage_struct;
 
-			items.extend(quote!(type #name = #storage_struct;));
-			items
-		});
+		items.extend(quote!(type #name = #storage_struct;));
+		items
+	});
 
 	let visibility = &def.visibility;
 	let store_trait = &def.store_trait;