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>
2026-07-03 11:07:25 +00:00 · 2021-07-21 16:32:32 +02:00
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
@@ -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),
 		};