Feat suppert procedural (#7913)

* fix clippy replace clone with copy

* fix clippy warning pattern

* fix clippy warning replace into_iter with iter

* replace match with if let

* replace =0 with is_empty

* replace or with or_else

* replace vec! with Vec::new

frame/support/procedural/src/construct_runtime/mod.rs

@@ -205,7 +205,7 @@ fn construct_runtime_parsed(definition: RuntimeDefinition) -> Result<TokenStream
 		#integrity_test
 	);
 
-	Ok(res.into())
+	Ok(res)
 }
 
 fn decl_validate_unsigned<'a>(
@@ -299,7 +299,7 @@ fn decl_runtime_metadata<'a>(
 			module_declaration.find_part("Module").map(|_| {
 				let filtered_names: Vec<_> = module_declaration
 					.module_parts()
-					.into_iter()
+					.iter()
 					.filter(|part| part.name() != "Module")
 					.map(|part| part.ident())
 					.collect();
@@ -360,24 +360,21 @@ fn decl_outer_origin<'a>(
 ) -> syn::Result<TokenStream2> {
 	let mut modules_tokens = TokenStream2::new();
 	for module_declaration in modules_except_system {
-		match module_declaration.find_part("Origin") {
-			Some(module_entry) => {
-				let module = &module_declaration.module;
-				let instance = module_declaration.instance.as_ref();
-				let generics = &module_entry.generics;
-				if instance.is_some() && generics.params.len() == 0 {
-					let msg = format!(
-						"Instantiable module with no generic `Origin` cannot \
-						 be constructed: module `{}` must have generic `Origin`",
-						module_declaration.name
-					);
-					return Err(syn::Error::new(module_declaration.name.span(), msg));
-				}
-				let index = module_declaration.index.to_string();
-				let tokens = quote!(#[codec(index = #index)] #module #instance #generics,);
-				modules_tokens.extend(tokens);
+		if let Some(module_entry) = module_declaration.find_part("Origin") {
+			let module = &module_declaration.module;
+			let instance = module_declaration.instance.as_ref();
+			let generics = &module_entry.generics;
+			if instance.is_some() && generics.params.is_empty() {
+				let msg = format!(
+					"Instantiable module with no generic `Origin` cannot \
+					 be constructed: module `{}` must have generic `Origin`",
+					module_declaration.name
+				);
+				return Err(syn::Error::new(module_declaration.name.span(), msg));
 			}
-			None => {}
+			let index = module_declaration.index.to_string();
+			let tokens = quote!(#[codec(index = #index)] #module #instance #generics,);
+			modules_tokens.extend(tokens);
 		}
 	}
 
@@ -403,25 +400,22 @@ fn decl_outer_event<'a>(
 ) -> syn::Result<TokenStream2> {
 	let mut modules_tokens = TokenStream2::new();
 	for module_declaration in module_declarations {
-		match module_declaration.find_part("Event") {
-			Some(module_entry) => {
-				let module = &module_declaration.module;
-				let instance = module_declaration.instance.as_ref();
-				let generics = &module_entry.generics;
-				if instance.is_some() && generics.params.len() == 0 {
-					let msg = format!(
-						"Instantiable module with no generic `Event` cannot \
-						 be constructed: module `{}` must have generic `Event`",
-						module_declaration.name,
-					);
-					return Err(syn::Error::new(module_declaration.name.span(), msg));
-				}
-
-				let index = module_declaration.index.to_string();
-				let tokens = quote!(#[codec(index = #index)] #module #instance #generics,);
-				modules_tokens.extend(tokens);
+		if let Some(module_entry) = module_declaration.find_part("Event") {
+			let module = &module_declaration.module;
+			let instance = module_declaration.instance.as_ref();
+			let generics = &module_entry.generics;
+			if instance.is_some() && generics.params.is_empty() {
+				let msg = format!(
+					"Instantiable module with no generic `Event` cannot \
+					 be constructed: module `{}` must have generic `Event`",
+					module_declaration.name,
+				);
+				return Err(syn::Error::new(module_declaration.name.span(), msg));
 			}
-			None => {}
+
+			let index = module_declaration.index.to_string();
+			let tokens = quote!(#[codec(index = #index)] #module #instance #generics,);
+			modules_tokens.extend(tokens);
 		}
 	}
 

frame/support/procedural/src/construct_runtime/parse.rs

@@ -333,7 +333,7 @@ impl Parse for ModulePart {
 
 impl ModulePart {
 	pub fn format_names(names: &[&'static str]) -> String {
-		let res: Vec<_> = names.into_iter().map(|s| format!("`{}`", s)).collect();
+		let res: Vec<_> = names.iter().map(|s| format!("`{}`", s)).collect();
 		res.join(", ")
 	}
 

frame/support/procedural/src/pallet/expand/call.rs

@@ -27,7 +27,7 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 	let type_impl_gen = &def.type_impl_generics(def.call.attr_span);
 	let type_decl_bounded_gen = &def.type_decl_bounded_generics(def.call.attr_span);
 	let type_use_gen = &def.type_use_generics(def.call.attr_span);
-	let call_ident = syn::Ident::new("Call", def.call.attr_span.clone());
+	let call_ident = syn::Ident::new("Call", def.call.attr_span);
 	let pallet_ident = &def.pallet_struct.pallet;
 	let where_clause = &def.call.where_clause;
 

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

@@ -174,7 +174,7 @@ impl CallDef {
 					helper::take_item_attrs(&mut method.attrs)?;
 
 				if call_var_attrs.len() != 1 {
-					let msg = if call_var_attrs.len() == 0 {
+					let msg = if call_var_attrs.is_empty() {
 						"Invalid pallet::call, require weight attribute i.e. `#[pallet::weight = $expr]`"
 					} else {
 						"Invalid pallet::call, too many weight attributes given"

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

@@ -255,7 +255,7 @@ pub fn replace_self_by_t(input: proc_macro2::TokenStream) -> proc_macro2::TokenS
 				).into(),
 			proc_macro2::TokenTree::Ident(ident) if ident == "Self" =>
 				proc_macro2::Ident::new("T", ident.span()).into(),
-			other @ _ => other
+			other => other
 		})
 		.collect()
 }
@@ -294,7 +294,7 @@ impl ConfigDef {
 			return Err(syn::Error::new(item.generics.params[2].span(), msg));
 		}
 
-		let has_instance = if let Some(_) = item.generics.params.first() {
+		let has_instance = if item.generics.params.first().is_some() {
 			helper::check_config_def_gen(&item.generics, item.ident.span())?;
 			true
 		} else {

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

@@ -72,8 +72,8 @@ enum PalletEventAttr {
 impl PalletEventAttr {
 	fn span(&self) -> proc_macro2::Span {
 		match self {
-			Self::Metadata { span, .. } => span.clone(),
-			Self::DepositEvent { span, .. } => span.clone(),
+			Self::Metadata { span, .. } => *span,
+			Self::DepositEvent { span, .. } => *span,
 		}
 	}
 }
@@ -165,7 +165,7 @@ impl EventDef {
 
 		let event_attrs: Vec<PalletEventAttr> = helper::take_item_attrs(&mut item.attrs)?;
 		let attr_info = PalletEventAttrInfo::from_attrs(event_attrs)?;
-		let metadata = attr_info.metadata.unwrap_or_else(|| vec![]);
+		let metadata = attr_info.metadata.unwrap_or_else(Vec::new);
 		let deposit_event = attr_info.deposit_event;
 
 		if !matches!(item.vis, syn::Visibility::Public(_)) {

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

@@ -81,12 +81,12 @@ impl ExtraConstantsDef {
 				return Err(syn::Error::new(impl_item.span(), msg));
 			};
 
-			if method.sig.inputs.len() != 0 {
+			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));
 			}
 
-			if method.sig.generics.params.len() != 0 {
+			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));
 			}

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

@@ -136,7 +136,7 @@ pub fn get_doc_literals(attrs: &Vec<syn::Attribute>) -> Vec<syn::Lit> {
 		.filter_map(|attr| {
 			if let Ok(syn::Meta::NameValue(meta)) = attr.parse_meta() {
 				if meta.path.get_ident().map_or(false, |ident| ident == "doc") {
-					Some(meta.lit.clone())
+					Some(meta.lit)
 				} else {
 					None
 				}

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

@@ -66,7 +66,7 @@ impl Def {
 		let frame_system = generate_crate_access_2018("frame-system")?;
 		let frame_support = generate_crate_access_2018("frame-support")?;
 
-		let item_span = item.span().clone();
+		let item_span = item.span();
 		let items = &mut item.content.as_mut()
 			.ok_or_else(|| {
 				let msg = "Invalid pallet definition, expected mod to be inlined.";
@@ -152,7 +152,7 @@ impl Def {
 		}
 
 		let def = Def {
-			item: item,
+			item,
 			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]`"))?,
@@ -403,20 +403,20 @@ enum PalletAttr {
 impl PalletAttr {
 	fn span(&self) -> proc_macro2::Span {
 		match self {
-			Self::Config(span) => span.clone(),
-			Self::Pallet(span) => span.clone(),
-			Self::Hooks(span) => span.clone(),
-			Self::Call(span) => span.clone(),
-			Self::Error(span) => span.clone(),
-			Self::Event(span) => span.clone(),
-			Self::Origin(span) => span.clone(),
-			Self::Inherent(span) => span.clone(),
-			Self::Storage(span) => span.clone(),
-			Self::GenesisConfig(span) => span.clone(),
-			Self::GenesisBuild(span) => span.clone(),
-			Self::ValidateUnsigned(span) => span.clone(),
-			Self::TypeValue(span) => span.clone(),
-			Self::ExtraConstants(span) => span.clone(),
+			Self::Config(span) => *span,
+			Self::Pallet(span) => *span,
+			Self::Hooks(span) => *span,
+			Self::Call(span) => *span,
+			Self::Error(span) => *span,
+			Self::Event(span) => *span,
+			Self::Origin(span) => *span,
+			Self::Inherent(span) => *span,
+			Self::Storage(span) => *span,
+			Self::GenesisConfig(span) => *span,
+			Self::GenesisBuild(span) => *span,
+			Self::ValidateUnsigned(span) => *span,
+			Self::TypeValue(span) => *span,
+			Self::ExtraConstants(span) => *span,
 		}
 	}
 }

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

@@ -47,7 +47,7 @@ impl OriginDef {
 		};
 
 		let has_instance = generics.params.len() == 2;
-		let is_generic = generics.params.len() > 0;
+		let is_generic = !generics.params.is_empty();
 
 		let mut instances = vec![];
 		if let Some(u) = helper::check_type_def_optional_gen(&generics, item.span())? {

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

@@ -173,7 +173,7 @@ impl StorageDef {
 					value: retrieve_arg(&typ.path.segments[0], 5)?,
 				}
 			}
-			found @ _ => {
+			found => {
 				let msg = format!(
 					"Invalid pallet::storage, expected ident: `StorageValue` or \
 					`StorageMap` or `StorageDoubleMap` in order to expand metadata, found \

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

@@ -60,10 +60,10 @@ impl TypeValueDef {
 		}
 
 		if let Some(span) = item.sig.constness.as_ref().map(|t| t.span())
-			.or(item.sig.asyncness.as_ref().map(|t| t.span()))
-			.or(item.sig.unsafety.as_ref().map(|t| t.span()))
-			.or(item.sig.abi.as_ref().map(|t| t.span()))
-			.or(item.sig.variadic.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));

frame/support/procedural/src/pallet_version.rs

@@ -27,7 +27,7 @@ use frame_support_procedural_tools::generate_crate_access_2018;
 /// The version is parsed into the requested destination type.
 fn get_version<T: FromStr>(version_env: &str) -> std::result::Result<T, ()> {
 	let version = env::var(version_env)
-		.expect(&format!("`{}` is always set by cargo; qed", version_env));
+		.unwrap_or_else(|_| panic!("`{}` is always set by cargo; qed", version_env));
 
 	T::from_str(&version).map_err(drop)
 }

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

@@ -200,7 +200,7 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 					default_expr = to_cleaned_string(&default_expr),
 				)
 			})
-			.unwrap_or_else(|| String::new());
+			.unwrap_or_else(String::new);
 
 		let comma_query_kind = if line.is_option {
 			if line.default_value.is_some() {
@@ -214,7 +214,7 @@ pub fn maybe_print_pallet_upgrade(def: &super::DeclStorageDefExt) {
 
 		let comma_default_value_getter_name = line.default_value.as_ref()
 			.map(|_| format!(", DefaultFor{}", line.name))
-			.unwrap_or_else(|| String::new());
+			.unwrap_or_else(String::new);
 
 		let typ = match &line.storage_type {
 			StorageLineTypeDef::Map(map) => {