Improve spans of pallet macro (#7830)

* fix spans

* convert name to snake case

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

@@ -24,9 +24,9 @@ use syn::spanned::Spanned;
 pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
 	let frame_system = &def.frame_system;
-	let type_impl_gen = &def.type_impl_generics();
-	let type_decl_bounded_gen = &def.type_decl_bounded_generics();
-	let type_use_gen = &def.type_use_generics();
+	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 pallet_ident = &def.pallet_struct.pallet;
 	let where_clause = &def.call.where_clause;
@@ -61,7 +61,7 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 		method.args.iter()
 			.map(|(is_compact, _, type_)| {
 				let final_type = if *is_compact {
-					quote::quote!(Compact<#type_>)
+					quote::quote_spanned!(type_.span() => Compact<#type_>)
 				} else {
 					quote::quote!(#type_)
 				};

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

@@ -33,9 +33,9 @@ struct ConstDef {
 /// * Impl fn module_constant_metadata for pallet.
 pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
-	let type_impl_gen = &def.type_impl_generics();
-	let type_decl_gen = &def.type_decl_generics();
-	let type_use_gen = &def.type_use_generics();
+	let type_impl_gen = &def.type_impl_generics(proc_macro2::Span::call_site());
+	let type_decl_gen = &def.type_decl_generics(proc_macro2::Span::call_site());
+	let type_use_gen = &def.type_use_generics(proc_macro2::Span::call_site());
 	let pallet_ident = &def.pallet_struct.pallet;
 
 	let mut where_clauses = vec![&def.config.where_clause];

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

@@ -16,7 +16,6 @@
 // limitations under the License.
 
 use crate::pallet::Def;
-use syn::spanned::Spanned;
 
 /// * impl various trait on Error
 /// * impl ModuleErrorMetadata for Error
@@ -27,13 +26,11 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
 		return Default::default()
 	};
 
-	let error_item_span =
-		def.item.content.as_mut().expect("Checked by def parser").1[error.index].span();
 	let error_ident = &error.error;
 	let frame_support = &def.frame_support;
 	let frame_system = &def.frame_system;
-	let type_impl_gen = &def.type_impl_generics();
-	let type_use_gen = &def.type_use_generics();
+	let type_impl_gen = &def.type_impl_generics(error.attr_span);
+	let type_use_gen = &def.type_use_generics(error.attr_span);
 	let config_where_clause = &def.config.where_clause;
 
 	let phantom_variant: syn::Variant = syn::parse_quote!(
@@ -45,18 +42,20 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
 	);
 
 	let as_u8_matches = error.variants.iter().enumerate()
-		.map(|(i, (variant, _))| quote::quote!(Self::#variant => #i as u8,));
+		.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!(Self::#variant => #variant_str,)
+			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!(
+			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, )* ]),
@@ -69,13 +68,13 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
 		if let syn::Item::Enum(item) = item {
 			item
 		} else {
-			unreachable!("Checked by event parser")
+			unreachable!("Checked by error parser")
 		}
 	};
 
 	error_item.variants.insert(0, phantom_variant);
 
-	quote::quote_spanned!(error_item_span =>
+	quote::quote_spanned!(error.attr_span =>
 		impl<#type_impl_gen> #frame_support::sp_std::fmt::Debug for #error_ident<#type_use_gen>
 			#config_where_clause
 		{

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

@@ -16,7 +16,6 @@
 // limitations under the License.
 
 use crate::pallet::Def;
-use syn::spanned::Spanned;
 
 /// * Add __Ignore variant on Event
 /// * Impl various trait on Event including metadata
@@ -40,12 +39,12 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 	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();
-	let event_impl_gen= &event.gen_kind.type_impl_gen();
+	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!(
+			quote::quote_spanned!(event.attr_span =>
 				#frame_support::event::EventMetadata {
 					name: #frame_support::event::DecodeDifferent::Encode(#name),
 					arguments: #frame_support::event::DecodeDifferent::Encode(&[
@@ -58,9 +57,6 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 			)
 		});
 
-	let event_item_span =
-		def.item.content.as_mut().expect("Checked by def parser").1[event.index].span();
-
 	let event_item = {
 		let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[event.index];
 		if let syn::Item::Enum(item) = item {
@@ -99,10 +95,10 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 
 
 	let deposit_event = if let Some((fn_vis, fn_span)) = &event.deposit_event {
-		let event_use_gen = &event.gen_kind.type_use_gen();
-		let trait_use_gen = &def.trait_use_generics();
-		let type_impl_gen = &def.type_impl_generics();
-		let type_use_gen = &def.type_use_generics();
+		let event_use_gen = &event.gen_kind.type_use_gen(event.attr_span);
+		let trait_use_gen = &def.trait_use_generics(event.attr_span);
+		let type_impl_gen = &def.type_impl_generics(event.attr_span);
+		let type_use_gen = &def.type_use_generics(event.attr_span);
 
 		quote::quote_spanned!(*fn_span =>
 			impl<#type_impl_gen> Pallet<#type_use_gen> #completed_where_clause {
@@ -125,7 +121,7 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 		Default::default()
 	};
 
-	quote::quote_spanned!(event_item_span =>
+	quote::quote_spanned!(event.attr_span =>
 		#deposit_event
 
 		impl<#event_impl_gen> From<#event_ident<#event_use_gen>> for () #event_where_clause {

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

@@ -16,7 +16,6 @@
 // limitations under the License.
 
 use crate::pallet::Def;
-use syn::spanned::Spanned;
 
 /// * implement the trait `sp_runtime::BuildModuleGenesisStorage`
 /// * add #[cfg(features = "std")] to GenesisBuild implementation.
@@ -26,21 +25,21 @@ pub fn expand_genesis_build(def: &mut Def) -> proc_macro2::TokenStream {
 	} else {
 		return Default::default()
 	};
+	let genesis_build = def.genesis_build.as_ref().expect("Checked by def parser");
 
 	let frame_support = &def.frame_support;
-	let type_impl_gen = &def.type_impl_generics();
-	let type_use_gen = &def.type_use_generics();
+	let type_impl_gen = &def.type_impl_generics(genesis_build.attr_span);
+	let type_use_gen = &def.type_use_generics(genesis_build.attr_span);
 	let trait_use_gen = if def.config.has_instance {
-		quote::quote!(T, I)
+		quote::quote_spanned!(genesis_build.attr_span => T, I)
 	} else {
 		// `__InherentHiddenInstance` used by construct_runtime here is alias for `()`
-		quote::quote!(T, ())
+		quote::quote_spanned!(genesis_build.attr_span => T, ())
 	};
 	let gen_cfg_ident = &genesis_config.genesis_config;
 
-	let gen_cfg_use_gen = genesis_config.gen_kind.type_use_gen();
+	let gen_cfg_use_gen = genesis_config.gen_kind.type_use_gen(genesis_build.attr_span);
 
-	let genesis_build = def.genesis_build.as_ref().expect("Checked by def parser");
 	let genesis_build_item = &mut def.item.content.as_mut()
 		.expect("Checked by def parser").1[genesis_build.index];
 
@@ -53,7 +52,7 @@ pub fn expand_genesis_build(def: &mut Def) -> proc_macro2::TokenStream {
 	genesis_build_item_impl.attrs.push(syn::parse_quote!( #[cfg(feature = "std")] ));
 	let where_clause = &genesis_build.where_clause;
 
-	quote::quote_spanned!(genesis_build_item.span() =>
+	quote::quote_spanned!(genesis_build.attr_span =>
 		#[cfg(feature = "std")]
 		impl<#type_impl_gen> #frame_support::sp_runtime::BuildModuleGenesisStorage<#trait_use_gen>
 			for #gen_cfg_ident<#gen_cfg_use_gen> #where_clause

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

@@ -16,21 +16,17 @@
 // limitations under the License.
 
 use crate::pallet::Def;
-use syn::spanned::Spanned;
 
 /// * implement the individual traits using the Hooks trait
 pub fn expand_hooks(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
-	let type_impl_gen = &def.type_impl_generics();
-	let type_use_gen = &def.type_use_generics();
+	let type_impl_gen = &def.type_impl_generics(def.hooks.attr_span);
+	let type_use_gen = &def.type_use_generics(def.hooks.attr_span);
 	let pallet_ident = &def.pallet_struct.pallet;
 	let where_clause = &def.hooks.where_clause;
 	let frame_system = &def.frame_system;
 
-	let hooks_item_span = def.item.content.as_mut()
-		.expect("Checked by def parser").1[def.hooks.index].span();
-
-	quote::quote_spanned!(hooks_item_span =>
+	quote::quote_spanned!(def.hooks.attr_span =>
 		impl<#type_impl_gen>
 			#frame_support::traits::OnFinalize<<T as #frame_system::Config>::BlockNumber>
 			for #pallet_ident<#type_use_gen> #where_clause

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

@@ -25,9 +25,9 @@ use crate::pallet::Def;
 pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
 	let frame_system = &def.frame_system;
-	let type_impl_gen = &def.type_impl_generics();
-	let type_use_gen = &def.type_use_generics();
-	let type_decl_gen = &def.type_decl_generics();
+	let type_impl_gen = &def.type_impl_generics(def.pallet_struct.attr_span);
+	let type_use_gen = &def.type_use_generics(def.pallet_struct.attr_span);
+	let type_decl_gen = &def.type_decl_generics(def.pallet_struct.attr_span);
 	let pallet_ident = &def.pallet_struct.pallet;
 	let config_where_clause = &def.config.where_clause;
 
@@ -52,7 +52,7 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
 
 	let module_error_metadata = if let Some(error_def) = &def.error {
 		let error_ident = &error_def.error;
-		quote::quote!(
+		quote::quote_spanned!(def.pallet_struct.attr_span =>
 			impl<#type_impl_gen> #frame_support::error::ModuleErrorMetadata
 				for #pallet_ident<#type_use_gen>
 				#config_where_clause
@@ -65,7 +65,7 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
 			}
 		)
 	} else {
-		quote::quote!(
+		quote::quote_spanned!(def.pallet_struct.attr_span =>
 			impl<#type_impl_gen> #frame_support::error::ModuleErrorMetadata
 				for #pallet_ident<#type_use_gen>
 				#config_where_clause
@@ -77,7 +77,7 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
 		)
 	};
 
-	quote::quote!(
+	quote::quote_spanned!(def.pallet_struct.attr_span =>
 		#module_error_metadata
 
 		/// Type alias to `Pallet`, to be used by `construct_runtime`.

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

@@ -32,8 +32,6 @@ fn prefix_ident(storage_ident: &syn::Ident) -> syn::Ident {
 pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
 	let frame_system = &def.frame_system;
-	let type_impl_gen = &def.type_impl_generics();
-	let type_use_gen = &def.type_use_generics();
 	let pallet_ident = &def.pallet_struct.pallet;
 
 	// Replace first arg `_` by the generated prefix structure.
@@ -63,6 +61,11 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 			unreachable!("Checked by def");
 		};
 
+		let type_use_gen = if def.config.has_instance {
+			quote::quote_spanned!(storage_def.attr_span => T, I)
+		} else {
+			quote::quote_spanned!(storage_def.attr_span => T)
+		};
 		let prefix_ident = prefix_ident(&storage_def.ident);
 		args.args[0] = syn::parse_quote!( #prefix_ident<#type_use_gen> );
 	}
@@ -72,22 +75,25 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 			let docs = &storage.docs;
 
 			let ident = &storage.ident;
-			let gen = &def.type_use_generics();
-			let full_ident = quote::quote!( #ident<#gen> );
+			let gen = &def.type_use_generics(storage.attr_span);
+			let full_ident = quote::quote_spanned!(storage.attr_span => #ident<#gen> );
 
 			let metadata_trait = match &storage.metadata {
-				Metadata::Value { .. } =>
-					quote::quote!(#frame_support::storage::types::StorageValueMetadata),
-				Metadata::Map { .. } =>
-					quote::quote!(#frame_support::storage::types::StorageMapMetadata),
-				Metadata::DoubleMap { .. } =>
-					quote::quote!(#frame_support::storage::types::StorageDoubleMapMetadata),
+				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
+				),
 			};
 
 			let ty = match &storage.metadata {
 				Metadata::Value { value } => {
 					let value = clean_type_string(&quote::quote!(#value).to_string());
-					quote::quote!(
+					quote::quote_spanned!(storage.attr_span =>
 						#frame_support::metadata::StorageEntryType::Plain(
 							#frame_support::metadata::DecodeDifferent::Encode(#value)
 						)
@@ -96,7 +102,7 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 				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!(
+					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),
@@ -109,7 +115,7 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 					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!(
+					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,
@@ -121,7 +127,7 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 				}
 			};
 
-			quote::quote_spanned!(storage.ident.span() =>
+			quote::quote_spanned!(storage.attr_span =>
 				#frame_support::metadata::StorageEntryMetadata {
 					name: #frame_support::metadata::DecodeDifferent::Encode(
 						<#full_ident as #metadata_trait>::NAME
@@ -144,19 +150,24 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 				&storage.where_clause,
 				&def.config.where_clause,
 			]);
-			let docs = storage.docs.iter().map(|d| quote::quote!(#[doc = #d]));
+			let docs = storage.docs.iter()
+				.map(|d| quote::quote_spanned!(storage.attr_span => #[doc = #d]));
 
 			let ident = &storage.ident;
-			let gen = &def.type_use_generics();
-			let full_ident = quote::quote!( #ident<#gen> );
+			let gen = &def.type_use_generics(storage.attr_span);
+			let type_impl_gen = &def.type_impl_generics(storage.attr_span);
+			let type_use_gen = &def.type_use_generics(storage.attr_span);
+			let full_ident = quote::quote_spanned!(storage.attr_span => #ident<#gen> );
 
 			match &storage.metadata {
 				Metadata::Value { value } => {
 					let query = match storage.query_kind.as_ref().expect("Checked by def") {
-						QueryKind::OptionQuery => quote::quote!(Option<#value>),
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
 						QueryKind::ValueQuery => quote::quote!(#value),
 					};
-					quote::quote_spanned!(getter.span() =>
+					quote::quote_spanned!(storage.attr_span =>
 						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
 							#( #docs )*
 							pub fn #getter() -> #query {
@@ -169,10 +180,12 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 				},
 				Metadata::Map { key, value } => {
 					let query = match storage.query_kind.as_ref().expect("Checked by def") {
-						QueryKind::OptionQuery => quote::quote!(Option<#value>),
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
 						QueryKind::ValueQuery => quote::quote!(#value),
 					};
-					quote::quote_spanned!(getter.span() =>
+					quote::quote_spanned!(storage.attr_span =>
 						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
 							#( #docs )*
 							pub fn #getter<KArg>(k: KArg) -> #query where
@@ -187,10 +200,12 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 				},
 				Metadata::DoubleMap { key1, key2, value } => {
 					let query = match storage.query_kind.as_ref().expect("Checked by def") {
-						QueryKind::OptionQuery => quote::quote!(Option<#value>),
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
 						QueryKind::ValueQuery => quote::quote!(#value),
 					};
-					quote::quote_spanned!(getter.span() =>
+					quote::quote_spanned!(storage.attr_span =>
 						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
 							#( #docs )*
 							pub fn #getter<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> #query where
@@ -211,12 +226,14 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 		});
 
 	let prefix_structs = def.storages.iter().map(|storage_def| {
+		let type_impl_gen = &def.type_impl_generics(storage_def.attr_span);
+		let type_use_gen = &def.type_use_generics(storage_def.attr_span);
 		let prefix_struct_ident = prefix_ident(&storage_def.ident);
 		let prefix_struct_vis = &storage_def.vis;
 		let prefix_struct_const = storage_def.ident.to_string();
 		let config_where_clause = &def.config.where_clause;
 
-		quote::quote_spanned!(storage_def.ident.span() =>
+		quote::quote_spanned!(storage_def.attr_span =>
 			#prefix_struct_vis struct #prefix_struct_ident<#type_use_gen>(
 				core::marker::PhantomData<(#type_use_gen,)>
 			);
@@ -239,6 +256,8 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 	let mut where_clauses = vec![&def.config.where_clause];
 	where_clauses.extend(def.storages.iter().map(|storage| &storage.where_clause));
 	let completed_where_clause = super::merge_where_clauses(&where_clauses);
+	let type_impl_gen = &def.type_impl_generics(proc_macro2::Span::call_site());
+	let type_use_gen = &def.type_use_generics(proc_macro2::Span::call_site());
 
 	quote::quote!(
 		impl<#type_impl_gen> #pallet_ident<#type_use_gen>

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

@@ -28,8 +28,8 @@ pub fn expand_store_trait(def: &mut Def) -> proc_macro2::TokenStream {
 		return Default::default()
 	};
 
-	let type_impl_gen = &def.type_impl_generics();
-	let type_use_gen = &def.type_use_generics();
+	let type_impl_gen = &def.type_impl_generics(trait_store.span());
+	let type_use_gen = &def.type_use_generics(trait_store.span());
 	let pallet_ident = &def.pallet_struct.pallet;
 
 	let mut where_clauses = vec![&def.config.where_clause];

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

@@ -16,38 +16,56 @@
 // limitations under the License.
 
 use crate::pallet::Def;
-use syn::spanned::Spanned;
 
 /// * Generate the struct
 /// * implement the `Get<..>` on it
+/// * Rename the name of the function to internal name
 pub fn expand_type_values(def: &mut Def) -> proc_macro2::TokenStream {
 	let mut expand = quote::quote!();
 	let frame_support = &def.frame_support;
 
 	for type_value in &def.type_values {
-		// Remove item from module content
-		let item = &mut def.item.content.as_mut().expect("Checked by def").1[type_value.index];
-		let span = item.span();
-		*item = syn::Item::Verbatim(Default::default());
+		let fn_name_str = &type_value.ident.to_string();
+		let fn_name_snakecase = inflector::cases::snakecase::to_snake_case(fn_name_str);
+		let fn_ident_renamed = syn::Ident::new(
+			&format!("__type_value_for_{}", fn_name_snakecase),
+			type_value.ident.span(),
+		);
+
+		let type_value_item = {
+			let item = &mut def.item.content.as_mut().expect("Checked by def").1[type_value.index];
+			if let syn::Item::Fn(item) = item {
+				item
+			} else {
+				unreachable!("Checked by error parser")
+			}
+		};
+
+		// Rename the type_value function name
+		type_value_item.sig.ident = fn_ident_renamed.clone();
 
 		let vis = &type_value.vis;
 		let ident = &type_value.ident;
-		let block = &type_value.block;
 		let type_ = &type_value.type_;
 		let where_clause = &type_value.where_clause;
 
 		let (struct_impl_gen, struct_use_gen) = if type_value.is_generic {
-			(def.type_impl_generics(), def.type_use_generics())
+			(
+				def.type_impl_generics(type_value.attr_span),
+				def.type_use_generics(type_value.attr_span),
+			)
 		} else {
 			(Default::default(), Default::default())
 		};
 
-		expand.extend(quote::quote_spanned!(span =>
+		expand.extend(quote::quote_spanned!(type_value.attr_span =>
 			#vis struct #ident<#struct_use_gen>(core::marker::PhantomData<((), #struct_use_gen)>);
 			impl<#struct_impl_gen> #frame_support::traits::Get<#type_> for #ident<#struct_use_gen>
 			#where_clause
 			{
-				fn get() -> #type_ #block
+				fn get() -> #type_ {
+					#fn_ident_renamed::<#struct_use_gen>()
+				}
 			}
 		));
 	}