Use pallet names to name enum variants

frame/support/procedural/src/construct_runtime/expand/config.rs

@@ -16,6 +16,7 @@
 // limitations under the License
 
 use crate::construct_runtime::Pallet;
+use inflector::Inflector;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::Ident;
@@ -32,11 +33,11 @@ pub fn expand_outer_config(
 	for decl in pallet_decls {
 		if let Some(pallet_entry) = decl.find_part("Config") {
 			let config = format_ident!("{}Config", decl.name);
-			let mod_name = decl.pallet.mod_name();
+			let pallet_name = &decl.name.to_string().to_snake_case();
 			let field_name = if let Some(inst) = decl.instance.as_ref() {
-				format_ident!("{}_{}", mod_name, inst)
+				format_ident!("{}_{}", pallet_name, inst.to_string().to_snake_case())
 			} else {
-				mod_name
+				Ident::new(pallet_name, decl.name.span())
 			};
 			let part_is_generic = !pallet_entry.generics.params.is_empty();
 
@@ -56,7 +57,6 @@ pub fn expand_outer_config(
 		#[serde(rename_all = "camelCase")]
 		#[serde(deny_unknown_fields)]
 		#[serde(crate = "__genesis_config_serde_import__")]
-		#[allow(non_snake_case)]
 		pub struct GenesisConfig {
 			#fields
 		}
@@ -85,7 +85,7 @@ fn expand_config_types(
 	config: &Ident,
 	part_is_generic: bool,
 ) -> TokenStream {
-	let path = &decl.pallet;
+	let path = &decl.path;
 
 	match (decl.instance.as_ref(), part_is_generic) {
 		(Some(inst), true) => quote!{
@@ -109,7 +109,7 @@ fn expand_config_build_storage_call(
 	decl: &Pallet,
 	field_name: &Ident,
 ) -> TokenStream {
-	let path = &decl.pallet;
+	let path = &decl.path;
 	let instance = if let Some(inst) = decl.instance.as_ref() {
 		quote!(#path::#inst)
 	} else {

frame/support/procedural/src/construct_runtime/expand/event.rs

@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License
 
-use crate::construct_runtime::{Pallet, parse::PalletPath};
+use crate::construct_runtime::Pallet;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::{Generics, Ident};
@@ -27,11 +27,10 @@ pub fn expand_outer_event(
 ) -> syn::Result<TokenStream> {
 	let mut event_variants = TokenStream::new();
 	let mut event_conversions = TokenStream::new();
-	let mut events_metadata = TokenStream::new();
 
 	for pallet_decl in pallet_decls {
 		if let Some(pallet_entry) = pallet_decl.find_part("Event") {
-			let path = &pallet_decl.pallet;
+			let path = &pallet_decl.path;
 			let index = pallet_decl.index;
 			let instance = pallet_decl.instance.as_ref();
 			let generics = &pallet_entry.generics;
@@ -53,9 +52,8 @@ pub fn expand_outer_event(
 				(None, false) => quote!(#path::Event),
 			};
 
-			event_variants.extend(expand_event_variant(runtime, path, index, instance, generics));
-			event_conversions.extend(expand_event_conversion(scrate, path, instance, &pallet_event));
-			events_metadata.extend(expand_event_metadata(scrate, path, &pallet_event));
+			event_variants.extend(expand_event_variant(runtime, pallet_decl, index, instance, generics));
+			event_conversions.extend(expand_event_conversion(scrate, pallet_decl, instance, &pallet_event));
 		}
 	}
 
@@ -77,43 +75,45 @@ pub fn expand_outer_event(
 
 fn expand_event_variant(
 	runtime: &Ident,
-	path: &PalletPath,
+	pallet: &Pallet,
 	index: u8,
 	instance: Option<&Ident>,
 	generics: &Generics,
 ) -> TokenStream {
+	let path = &pallet.path;
+	let pallet_name = &pallet.name;
 	let part_is_generic = !generics.params.is_empty();
-	let mod_name = &path.mod_name();
 
-	match (instance, part_is_generic) {
-		(Some(inst), true) => {
-			let variant = format_ident!("{}_{}", mod_name, inst);
-			quote!(#[codec(index = #index)] #variant(#path::Event<#runtime, #path::#inst>),)
-		}
-		(Some(inst), false) => {
-			let variant = format_ident!("{}_{}", mod_name, inst);
-			quote!(#[codec(index = #index)] #variant(#path::Event<#path::#inst>),)
+	match instance {
+		Some(inst) => {
+			let variant = format_ident!("{}_{}", pallet_name, inst);
+
+			if part_is_generic {
+				quote!(#[codec(index = #index)] #variant(#path::Event<#runtime, #path::#inst>),)
+			} else {
+				quote!(#[codec(index = #index)] #variant(#path::Event<#path::#inst>),)
+			}
 		}
-		(None, true) => {
-			quote!(#[codec(index = #index)] #mod_name(#path::Event<#runtime>),)
+		None if part_is_generic => {
+			quote!(#[codec(index = #index)] #pallet_name(#path::Event<#runtime>),)
 		}
-		(None, false) => {
-			quote!(#[codec(index = #index)] #mod_name(#path::Event),)
+		None => {
+			quote!(#[codec(index = #index)] #pallet_name(#path::Event),)
 		}
 	}
 }
 
 fn expand_event_conversion(
 	scrate: &TokenStream,
-	path: &PalletPath,
+	pallet: &Pallet,
 	instance: Option<&Ident>,
 	pallet_event: &TokenStream,
 ) -> TokenStream {
-	let mod_name = path.mod_name();
+	let pallet_name = &pallet.name;
 	let variant = if let Some(inst) = instance {
-		format_ident!("{}_{}", mod_name, inst)
+		format_ident!("{}_{}", pallet_name, inst)
 	} else {
-		mod_name
+		pallet_name.clone()
 	};
 
 	quote!{
@@ -134,13 +134,3 @@ fn expand_event_conversion(
 		}
 	}
 }
-
-fn expand_event_metadata(
-	scrate: &TokenStream,
-	path: &PalletPath,
-	pallet_event: &TokenStream,
-) -> TokenStream {
-	let mod_name = path.mod_name();
-
-	quote!{(stringify!(#mod_name), #scrate::event::FnEncode(#pallet_event::metadata)),}
-}

frame/support/procedural/src/construct_runtime/expand/metadata.rs

@@ -92,7 +92,7 @@ fn expand_pallet_metadata_storage(
 ) -> TokenStream {
 	if filtered_names.contains(&"Storage") {
 		let instance = decl.instance.as_ref().into_iter();
-		let path = &decl.pallet;
+		let path = &decl.path;
 
 		quote!{
 			Some(#scrate::metadata::DecodeDifferent::Encode(
@@ -114,7 +114,7 @@ fn expand_pallet_metadata_calls(
 ) -> TokenStream {
 	if filtered_names.contains(&"Call") {
 		let instance = decl.instance.as_ref().into_iter();
-		let path = &decl.pallet;
+		let path = &decl.path;
 
 		quote!{
 			Some(#scrate::metadata::DecodeDifferent::Encode(
@@ -135,7 +135,7 @@ fn expand_pallet_metadata_events(
 	decl: &Pallet,
 ) -> TokenStream {
 	if filtered_names.contains(&"Event") {
-		let path = &decl.pallet;
+		let path = &decl.path;
 		let part_is_generic =
 			!decl.find_part("Event").expect("Event part exists; qed").generics.params.is_empty();
 		let pallet_event = match (decl.instance.as_ref(), part_is_generic) {
@@ -160,7 +160,7 @@ fn expand_pallet_metadata_constants(
 	scrate: &TokenStream,
 	decl: &Pallet,
 ) -> TokenStream {
-	let path = &decl.pallet;
+	let path = &decl.path;
 	let instance = decl.instance.as_ref().into_iter();
 
 	quote!{
@@ -177,7 +177,7 @@ fn expand_pallet_metadata_errors(
 	scrate: &TokenStream,
 	decl: &Pallet,
 ) -> TokenStream {
-	let path = &decl.pallet;
+	let path = &decl.path;
 	let instance = decl.instance.as_ref().into_iter();
 
 	quote!{

frame/support/procedural/src/construct_runtime/expand/origin.rs

@@ -15,9 +15,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License
 
-use crate::construct_runtime::{parse::PalletPath, Pallet, SYSTEM_PALLET_NAME};
+use crate::construct_runtime::{Pallet, SYSTEM_PALLET_NAME};
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
+use quote::quote;
 use syn::{token, Ident, Generics};
 
 pub fn expand_outer_origin(
@@ -39,7 +39,6 @@ pub fn expand_outer_origin(
 
 	for pallet_decl in pallets.iter().filter(|pallet| pallet.name != SYSTEM_PALLET_NAME) {
 		if let Some(pallet_entry) = pallet_decl.find_part("Origin") {
-			let path = &pallet_decl.pallet;
 			let instance = pallet_decl.instance.as_ref();
 			let index = pallet_decl.index;
 			let generics = &pallet_entry.generics;
@@ -54,15 +53,15 @@ pub fn expand_outer_origin(
 			}
 
 			caller_variants.extend(
-				expand_origin_caller_variant(runtime, path, index, instance, generics),
+				expand_origin_caller_variant(runtime, pallet_decl, index, instance, generics),
 			);
 			pallet_conversions.extend(
-				expand_origin_pallet_conversions(scrate, runtime, path, instance, generics),
+				expand_origin_pallet_conversions(scrate, runtime, pallet_decl, instance, generics),
 			);
 		}
 	}
 
-	let system_path = &system_pallet.pallet;
+	let system_path = &system_pallet.path;
 	let system_index = system_pallet.index;
 
 	Ok(quote!{
@@ -251,58 +250,53 @@ pub fn expand_outer_origin(
 
 fn expand_origin_caller_variant(
 	runtime: &Ident,
-	path: &PalletPath,
+	pallet: &Pallet,
 	index: u8,
 	instance: Option<&Ident>,
 	generics: &Generics,
 ) -> TokenStream {
 	let part_is_generic = !generics.params.is_empty();
-	let mod_name = &path.mod_name();
+	let variant_name = &pallet.name;
+	let path = &pallet.path;
 
-	match (instance, part_is_generic) {
-		(Some(inst), true) => {
-			let variant = format_ident!("{}_{}", mod_name, inst);
-			quote!(#[codec(index = #index)] #variant(#path::Origin<#runtime, #path::#inst>),)
+	match instance {
+		Some(inst) if part_is_generic => {
+			quote!(#[codec(index = #index)] #variant_name(#path::Origin<#runtime, #path::#inst>),)
 		}
-		(Some(inst), false) => {
-			let variant = format_ident!("{}_{}", mod_name, inst);
-			quote!(#[codec(index = #index)] #variant(#path::Origin<#path::#inst>),)
+		Some(inst) => {
+			quote!(#[codec(index = #index)] #variant_name(#path::Origin<#path::#inst>),)
 		}
-		(None, true) => {
-			quote!(#[codec(index = #index)] #mod_name(#path::Origin<#runtime>),)
+		None if part_is_generic => {
+			quote!(#[codec(index = #index)] #variant_name(#path::Origin<#runtime>),)
 		}
-		(None, false) => {
-			quote!(#[codec(index = #index)] #mod_name(#path::Origin),)
+		None => {
+			quote!(#[codec(index = #index)] #variant_name(#path::Origin),)
 		}
 	}
 }
 
 fn expand_origin_pallet_conversions(
 	scrate: &TokenStream,
 	runtime: &Ident,
-	path: &PalletPath,
+	pallet: &Pallet,
 	instance: Option<&Ident>,
 	generics: &Generics,
 ) -> TokenStream {
-	let mod_name = path.mod_name();
-	let variant = if let Some(inst) = instance {
-		format_ident!("{}_{}", mod_name, inst)
-	} else {
-		mod_name
-	};
+	let path = &pallet.path;
+	let variant_name = &pallet.name;
 
 	let part_is_generic = !generics.params.is_empty();
-	let pallet_origin = match (instance, part_is_generic) {
-		(Some(inst), true) => quote!(#path::Origin<#runtime, #path::#inst>),
-		(Some(inst), false) => quote!(#path::Origin<#path::#inst>),
-		(None, true) => quote!(#path::Origin<#runtime>),
-		(None, false) => quote!(#path::Origin),
+	let pallet_origin = match instance {
+		Some(inst) if part_is_generic => quote!(#path::Origin<#runtime, #path::#inst>),
+		Some(inst) => quote!(#path::Origin<#path::#inst>),
+		None if part_is_generic => quote!(#path::Origin<#runtime>),
+		None => quote!(#path::Origin),
 	};
 
 	quote!{
 		impl From<#pallet_origin> for OriginCaller {
 			fn from(x: #pallet_origin) -> Self {
-				OriginCaller::#variant(x)
+				OriginCaller::#variant_name(x)
 			}
 		}
 
@@ -317,7 +311,7 @@ fn expand_origin_pallet_conversions(
 		impl From<Origin> for #scrate::sp_std::result::Result<#pallet_origin, Origin> {
 			/// NOTE: converting to pallet origin loses the origin filter information.
 			fn from(val: Origin) -> Self {
-				if let OriginCaller::#variant(l) = val.caller {
+				if let OriginCaller::#variant_name(l) = val.caller {
 					Ok(l)
 				} else {
 					Err(val)
@@ -330,7 +324,7 @@ fn expand_origin_pallet_conversions(
 			fn try_from(
 				x: OriginCaller,
 			) -> #scrate::sp_std::result::Result<#pallet_origin, OriginCaller> {
-				if let OriginCaller::#variant(l) = x {
+				if let OriginCaller::#variant_name(l) = x {
 					Ok(l)
 				} else {
 					Err(x)

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

@@ -35,7 +35,7 @@ const SYSTEM_PALLET_NAME: &str = "System";
 pub struct Pallet {
 	pub name: Ident,
 	pub index: u8,
-	pub pallet: PalletPath,
+	pub path: PalletPath,
 	pub instance: Option<Ident>,
 	pub pallet_parts: Vec<PalletPart>,
 }
@@ -101,7 +101,7 @@ fn complete_pallets(decl: impl Iterator<Item = PalletDeclaration>) -> syn::Resul
 			Ok(Pallet {
 				name: pallet.name,
 				index: final_index,
-				pallet: pallet.pallet,
+				path: pallet.path,
 				instance: pallet.instance,
 				pallet_parts: pallet.pallet_parts,
 			})
@@ -252,7 +252,7 @@ fn decl_outer_dispatch<'a>(
 	let pallets_tokens = pallet_declarations
 		.filter(|pallet_declaration| pallet_declaration.exists_part("Call"))
 		.map(|pallet_declaration| {
-			let pallet = &pallet_declaration.pallet.inner.segments.last().unwrap();
+			let pallet = &pallet_declaration.path.inner.segments.last().unwrap();
 			let name = &pallet_declaration.name;
 			let index = pallet_declaration.index;
 			quote!(#[codec(index = #index)] #pallet::#name)
@@ -275,7 +275,7 @@ fn decl_all_pallets<'a>(
 	let mut names = Vec::new();
 	for pallet_declaration in pallet_declarations {
 		let type_name = &pallet_declaration.name;
-		let pallet = &pallet_declaration.pallet;
+		let pallet = &pallet_declaration.path;
 		let mut generics = vec![quote!(#runtime)];
 		generics.extend(
 			pallet_declaration