Replace 'Module' with 'Pallet' in construct_runtime macro (#8372)

* Use 'Pallet' struct in construct_runtime.

* Fix genesis and metadata macro.

* Fix 'Pallet' type alias.

* Replace 'Module' with 'Pallet' for all construct_runtime use cases.

* Replace more deprecated 'Module' struct.

* Bring back AllModules and AllPalletsWithSystem type, but deprecate them.

* Replace deprecated 'Module' struct from merge master.

* Minor fix.

* Fix UI tests.

* Revert UI override in derive_no_bound.

* Fix more deprecated 'Module' use from master branch.

* Fix more deprecated 'Module' use from master branch.

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

@@ -19,90 +19,90 @@ mod parse;
 
 use frame_support_procedural_tools::syn_ext as ext;
 use frame_support_procedural_tools::{generate_crate_access, generate_hidden_includes};
-use parse::{ModuleDeclaration, RuntimeDefinition, WhereSection, ModulePart};
+use parse::{PalletDeclaration, RuntimeDefinition, WhereSection, PalletPart};
 use proc_macro::TokenStream;
 use proc_macro2::{TokenStream as TokenStream2};
 use quote::quote;
 use syn::{Ident, Result, TypePath};
 use std::collections::HashMap;
 
-/// The fixed name of the system module.
-const SYSTEM_MODULE_NAME: &str = "System";
+/// The fixed name of the system pallet.
+const SYSTEM_PALLET_NAME: &str = "System";
 
-/// The complete definition of a module with the resulting fixed index.
+/// The complete definition of a pallet with the resulting fixed index.
 #[derive(Debug, Clone)]
-pub struct Module {
+pub struct Pallet {
 	pub name: Ident,
 	pub index: u8,
-	pub module: Ident,
+	pub pallet: Ident,
 	pub instance: Option<Ident>,
-	pub module_parts: Vec<ModulePart>,
+	pub pallet_parts: Vec<PalletPart>,
 }
 
-impl Module {
-	/// Get resolved module parts
-	fn module_parts(&self) -> &[ModulePart] {
-		&self.module_parts
+impl Pallet {
+	/// Get resolved pallet parts
+	fn pallet_parts(&self) -> &[PalletPart] {
+		&self.pallet_parts
 	}
 
 	/// Find matching parts
-	fn find_part(&self, name: &str) -> Option<&ModulePart> {
-		self.module_parts.iter().find(|part| part.name() == name)
+	fn find_part(&self, name: &str) -> Option<&PalletPart> {
+		self.pallet_parts.iter().find(|part| part.name() == name)
 	}
 
-	/// Return whether module contains part
+	/// Return whether pallet contains part
 	fn exists_part(&self, name: &str) -> bool {
 		self.find_part(name).is_some()
 	}
 }
 
-/// Convert from the parsed module to their final information.
-/// Assign index to each modules using same rules as rust for fieldless enum.
+/// Convert from the parsed pallet to their final information.
+/// Assign index to each pallet using same rules as rust for fieldless enum.
 /// I.e. implicit are assigned number incrementedly from last explicit or 0.
-fn complete_modules(decl: impl Iterator<Item = ModuleDeclaration>) -> syn::Result<Vec<Module>> {
+fn complete_pallets(decl: impl Iterator<Item = PalletDeclaration>) -> syn::Result<Vec<Pallet>> {
 	let mut indices = HashMap::new();
 	let mut last_index: Option<u8> = None;
 	let mut names = HashMap::new();
 
 	decl
-		.map(|module| {
-			let final_index = match module.index {
+		.map(|pallet| {
+			let final_index = match pallet.index {
 				Some(i) => i,
 				None => last_index.map_or(Some(0), |i| i.checked_add(1))
 					.ok_or_else(|| {
-						let msg = "Module index doesn't fit into u8, index is 256";
-						syn::Error::new(module.name.span(), msg)
+						let msg = "Pallet index doesn't fit into u8, index is 256";
+						syn::Error::new(pallet.name.span(), msg)
 					})?,
 			};
 
 			last_index = Some(final_index);
 
-			if let Some(used_module) = indices.insert(final_index, module.name.clone()) {
+			if let Some(used_pallet) = indices.insert(final_index, pallet.name.clone()) {
 				let msg = format!(
-					"Module indices are conflicting: Both modules {} and {} are at index {}",
-					used_module,
-					module.name,
+					"Pallet indices are conflicting: Both pallets {} and {} are at index {}",
+					used_pallet,
+					pallet.name,
 					final_index,
 				);
-				let mut err = syn::Error::new(used_module.span(), &msg);
-				err.combine(syn::Error::new(module.name.span(), msg));
+				let mut err = syn::Error::new(used_pallet.span(), &msg);
+				err.combine(syn::Error::new(pallet.name.span(), msg));
 				return Err(err);
 			}
 
-			if let Some(used_module) = names.insert(module.name.clone(), module.name.span()) {
-				let msg = "Two modules with the same name!";
+			if let Some(used_pallet) = names.insert(pallet.name.clone(), pallet.name.span()) {
+				let msg = "Two pallets with the same name!";
 
-				let mut err = syn::Error::new(used_module, &msg);
-				err.combine(syn::Error::new(module.name.span(), &msg));
+				let mut err = syn::Error::new(used_pallet, &msg);
+				err.combine(syn::Error::new(pallet.name.span(), &msg));
 				return Err(err);
 			}
 
-			Ok(Module {
-				name: module.name,
+			Ok(Pallet {
+				name: pallet.name,
 				index: final_index,
-				module: module.module,
-				instance: module.instance,
-				module_parts: module.module_parts,
+				pallet: pallet.pallet,
+				instance: pallet.instance,
+				pallet_parts: pallet.pallet_parts,
 			})
 		})
 		.collect()
@@ -124,55 +124,55 @@ fn construct_runtime_parsed(definition: RuntimeDefinition) -> Result<TokenStream
 			unchecked_extrinsic,
 			..
 		},
-		modules:
+		pallets:
 			ext::Braces {
-				content: ext::Punctuated { inner: modules, .. },
-				token: modules_token,
+				content: ext::Punctuated { inner: pallets, .. },
+				token: pallets_token,
 			},
 		..
 	} = definition;
 
-	let modules = complete_modules(modules.into_iter())?;
+	let pallets = complete_pallets(pallets.into_iter())?;
 
-	let system_module = modules.iter()
-		.find(|decl| decl.name == SYSTEM_MODULE_NAME)
+	let system_pallet = pallets.iter()
+		.find(|decl| decl.name == SYSTEM_PALLET_NAME)
 		.ok_or_else(|| syn::Error::new(
-			modules_token.span,
-			"`System` module declaration is missing. \
-			 Please add this line: `System: frame_system::{Module, Call, Storage, Config, Event<T>},`",
+			pallets_token.span,
+			"`System` pallet declaration is missing. \
+			 Please add this line: `System: frame_system::{Pallet, Call, Storage, Config, Event<T>},`",
 		))?;
 
 	let hidden_crate_name = "construct_runtime";
 	let scrate = generate_crate_access(&hidden_crate_name, "frame-support");
 	let scrate_decl = generate_hidden_includes(&hidden_crate_name, "frame-support");
 
-	let all_but_system_modules = modules.iter().filter(|module| module.name != SYSTEM_MODULE_NAME);
+	let all_but_system_pallets = pallets.iter().filter(|pallet| pallet.name != SYSTEM_PALLET_NAME);
 
 	let outer_event = decl_outer_event(
 		&name,
-		modules.iter(),
+		pallets.iter(),
 		&scrate,
 	)?;
 
 	let outer_origin = decl_outer_origin(
 		&name,
-		all_but_system_modules,
-		&system_module,
+		all_but_system_pallets,
+		&system_pallet,
 		&scrate,
 	)?;
-	let all_modules = decl_all_modules(&name, modules.iter());
-	let module_to_index = decl_pallet_runtime_setup(&modules, &scrate);
+	let all_pallets = decl_all_pallets(&name, pallets.iter());
+	let pallet_to_index = decl_pallet_runtime_setup(&pallets, &scrate);
 
-	let dispatch = decl_outer_dispatch(&name, modules.iter(), &scrate);
-	let metadata = decl_runtime_metadata(&name, modules.iter(), &scrate, &unchecked_extrinsic);
-	let outer_config = decl_outer_config(&name, modules.iter(), &scrate);
+	let dispatch = decl_outer_dispatch(&name, pallets.iter(), &scrate);
+	let metadata = decl_runtime_metadata(&name, pallets.iter(), &scrate, &unchecked_extrinsic);
+	let outer_config = decl_outer_config(&name, pallets.iter(), &scrate);
 	let inherent = decl_outer_inherent(
 		&block,
 		&unchecked_extrinsic,
-		modules.iter(),
+		pallets.iter(),
 		&scrate,
 	);
-	let validate_unsigned = decl_validate_unsigned(&name, modules.iter(), &scrate);
+	let validate_unsigned = decl_validate_unsigned(&name, pallets.iter(), &scrate);
 	let integrity_test = decl_integrity_test(&scrate);
 
 	let res = quote!(
@@ -197,9 +197,9 @@ fn construct_runtime_parsed(definition: RuntimeDefinition) -> Result<TokenStream
 
 		#outer_origin
 
-		#all_modules
+		#all_pallets
 
-		#module_to_index
+		#pallet_to_index
 
 		#dispatch
 
@@ -219,16 +219,16 @@ fn construct_runtime_parsed(definition: RuntimeDefinition) -> Result<TokenStream
 
 fn decl_validate_unsigned<'a>(
 	runtime: &'a Ident,
-	module_declarations: impl Iterator<Item = &'a Module>,
+	pallet_declarations: impl Iterator<Item = &'a Pallet>,
 	scrate: &'a TokenStream2,
 ) -> TokenStream2 {
-	let modules_tokens = module_declarations
-		.filter(|module_declaration| module_declaration.exists_part("ValidateUnsigned"))
-		.map(|module_declaration| &module_declaration.name);
+	let pallets_tokens = pallet_declarations
+		.filter(|pallet_declaration| pallet_declaration.exists_part("ValidateUnsigned"))
+		.map(|pallet_declaration| &pallet_declaration.name);
 	quote!(
 		#scrate::impl_outer_validate_unsigned!(
 			impl ValidateUnsigned for #runtime {
-				#( #modules_tokens )*
+				#( #pallets_tokens )*
 			}
 		);
 	)
@@ -237,13 +237,13 @@ fn decl_validate_unsigned<'a>(
 fn decl_outer_inherent<'a>(
 	block: &'a syn::TypePath,
 	unchecked_extrinsic: &'a syn::TypePath,
-	module_declarations: impl Iterator<Item = &'a Module>,
+	pallet_declarations: impl Iterator<Item = &'a Pallet>,
 	scrate: &'a TokenStream2,
 ) -> TokenStream2 {
-	let modules_tokens = module_declarations.filter_map(|module_declaration| {
-		let maybe_config_part = module_declaration.find_part("Inherent");
+	let pallets_tokens = pallet_declarations.filter_map(|pallet_declaration| {
+		let maybe_config_part = pallet_declaration.find_part("Inherent");
 		maybe_config_part.map(|_| {
-			let name = &module_declaration.name;
+			let name = &pallet_declaration.name;
 			quote!(#name,)
 		})
 	});
@@ -253,7 +253,7 @@ fn decl_outer_inherent<'a>(
 				Block = #block,
 				UncheckedExtrinsic = #unchecked_extrinsic
 			{
-				#(#modules_tokens)*
+				#(#pallets_tokens)*
 			}
 		);
 	)
@@ -261,37 +261,37 @@ fn decl_outer_inherent<'a>(
 
 fn decl_outer_config<'a>(
 	runtime: &'a Ident,
-	module_declarations: impl Iterator<Item = &'a Module>,
+	pallet_declarations: impl Iterator<Item = &'a Pallet>,
 	scrate: &'a TokenStream2,
 ) -> TokenStream2 {
-	let modules_tokens = module_declarations
-		.filter_map(|module_declaration| {
-			module_declaration.find_part("Config").map(|part| {
+	let pallets_tokens = pallet_declarations
+		.filter_map(|pallet_declaration| {
+			pallet_declaration.find_part("Config").map(|part| {
 				let transformed_generics: Vec<_> = part
 					.generics
 					.params
 					.iter()
 					.map(|param| quote!(<#param>))
 					.collect();
-				(module_declaration, transformed_generics)
+				(pallet_declaration, transformed_generics)
 			})
 		})
-		.map(|(module_declaration, generics)| {
-			let module = &module_declaration.module;
+		.map(|(pallet_declaration, generics)| {
+			let pallet = &pallet_declaration.pallet;
 			let name = Ident::new(
-				&format!("{}Config", module_declaration.name),
-				module_declaration.name.span(),
+				&format!("{}Config", pallet_declaration.name),
+				pallet_declaration.name.span(),
 			);
-			let instance = module_declaration.instance.as_ref().into_iter();
+			let instance = pallet_declaration.instance.as_ref().into_iter();
 			quote!(
 				#name =>
-					#module #(#instance)* #(#generics)*,
+					#pallet #(#instance)* #(#generics)*,
 			)
 		});
 	quote!(
 		#scrate::impl_outer_config! {
-			pub struct GenesisConfig for #runtime where AllModulesWithSystem = AllModulesWithSystem {
-				#(#modules_tokens)*
+			pub struct GenesisConfig for #runtime where AllPalletsWithSystem = AllPalletsWithSystem {
+				#(#pallets_tokens)*
 			}
 		}
 	)
@@ -299,63 +299,63 @@ fn decl_outer_config<'a>(
 
 fn decl_runtime_metadata<'a>(
 	runtime: &'a Ident,
-	module_declarations: impl Iterator<Item = &'a Module>,
+	pallet_declarations: impl Iterator<Item = &'a Pallet>,
 	scrate: &'a TokenStream2,
 	extrinsic: &TypePath,
 ) -> TokenStream2 {
-	let modules_tokens = module_declarations
-		.filter_map(|module_declaration| {
-			module_declaration.find_part("Module").map(|_| {
-				let filtered_names: Vec<_> = module_declaration
-					.module_parts()
+	let pallets_tokens = pallet_declarations
+		.filter_map(|pallet_declaration| {
+			pallet_declaration.find_part("Pallet").map(|_| {
+				let filtered_names: Vec<_> = pallet_declaration
+					.pallet_parts()
 					.iter()
-					.filter(|part| part.name() != "Module")
+					.filter(|part| part.name() != "Pallet")
 					.map(|part| part.ident())
 					.collect();
-				(module_declaration, filtered_names)
+				(pallet_declaration, filtered_names)
 			})
 		})
-		.map(|(module_declaration, filtered_names)| {
-			let module = &module_declaration.module;
-			let name = &module_declaration.name;
-			let instance = module_declaration
+		.map(|(pallet_declaration, filtered_names)| {
+			let pallet = &pallet_declaration.pallet;
+			let name = &pallet_declaration.name;
+			let instance = pallet_declaration
 				.instance
 				.as_ref()
 				.map(|name| quote!(<#name>))
 				.into_iter();
 
-			let index = module_declaration.index;
+			let index = pallet_declaration.index;
 
 			quote!(
-				#module::Module #(#instance)* as #name { index #index } with #(#filtered_names)*,
+				#pallet::Pallet #(#instance)* as #name { index #index } with #(#filtered_names)*,
 			)
 		});
 	quote!(
 		#scrate::impl_runtime_metadata!{
-			for #runtime with modules where Extrinsic = #extrinsic
-				#(#modules_tokens)*
+			for #runtime with pallets where Extrinsic = #extrinsic
+				#(#pallets_tokens)*
 		}
 	)
 }
 
 fn decl_outer_dispatch<'a>(
 	runtime: &'a Ident,
-	module_declarations: impl Iterator<Item = &'a Module>,
+	pallet_declarations: impl Iterator<Item = &'a Pallet>,
 	scrate: &'a TokenStream2,
 ) -> TokenStream2 {
-	let modules_tokens = module_declarations
-		.filter(|module_declaration| module_declaration.exists_part("Call"))
-		.map(|module_declaration| {
-			let module = &module_declaration.module;
-			let name = &module_declaration.name;
-			let index = module_declaration.index;
-			quote!(#[codec(index = #index)] #module::#name)
+	let pallets_tokens = pallet_declarations
+		.filter(|pallet_declaration| pallet_declaration.exists_part("Call"))
+		.map(|pallet_declaration| {
+			let pallet = &pallet_declaration.pallet;
+			let name = &pallet_declaration.name;
+			let index = pallet_declaration.index;
+			quote!(#[codec(index = #index)] #pallet::#name)
 		});
 
 	quote!(
 		#scrate::impl_outer_dispatch! {
 			pub enum Call for #runtime where origin: Origin {
-				#(#modules_tokens,)*
+				#(#pallets_tokens,)*
 			}
 		}
 	)
@@ -363,32 +363,32 @@ fn decl_outer_dispatch<'a>(
 
 fn decl_outer_origin<'a>(
 	runtime_name: &'a Ident,
-	modules_except_system: impl Iterator<Item = &'a Module>,
-	system_module: &'a Module,
+	pallets_except_system: impl Iterator<Item = &'a Pallet>,
+	system_pallet: &'a Pallet,
 	scrate: &'a TokenStream2,
 ) -> syn::Result<TokenStream2> {
-	let mut modules_tokens = TokenStream2::new();
-	for module_declaration in modules_except_system {
-		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;
+	let mut pallets_tokens = TokenStream2::new();
+	for pallet_declaration in pallets_except_system {
+		if let Some(pallet_entry) = pallet_declaration.find_part("Origin") {
+			let pallet = &pallet_declaration.pallet;
+			let instance = pallet_declaration.instance.as_ref();
+			let generics = &pallet_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
+					"Instantiable pallet with no generic `Origin` cannot \
+					 be constructed: pallet `{}` must have generic `Origin`",
+					pallet_declaration.name
 				);
-				return Err(syn::Error::new(module_declaration.name.span(), msg));
+				return Err(syn::Error::new(pallet_declaration.name.span(), msg));
 			}
-			let index = module_declaration.index;
-			let tokens = quote!(#[codec(index = #index)] #module #instance #generics,);
-			modules_tokens.extend(tokens);
+			let index = pallet_declaration.index;
+			let tokens = quote!(#[codec(index = #index)] #pallet #instance #generics,);
+			pallets_tokens.extend(tokens);
 		}
 	}
 
-	let system_name = &system_module.module;
-	let system_index = system_module.index;
+	let system_name = &system_pallet.pallet;
+	let system_index = system_pallet.index;
 
 	Ok(quote!(
 		#scrate::impl_outer_origin! {
@@ -396,7 +396,7 @@ fn decl_outer_origin<'a>(
 				system = #system_name,
 				system_index = #system_index
 			{
-				#modules_tokens
+				#pallets_tokens
 			}
 		}
 	))
@@ -404,89 +404,99 @@ fn decl_outer_origin<'a>(
 
 fn decl_outer_event<'a>(
 	runtime_name: &'a Ident,
-	module_declarations: impl Iterator<Item = &'a Module>,
+	pallet_declarations: impl Iterator<Item = &'a Pallet>,
 	scrate: &'a TokenStream2,
 ) -> syn::Result<TokenStream2> {
-	let mut modules_tokens = TokenStream2::new();
-	for module_declaration in module_declarations {
-		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;
+	let mut pallets_tokens = TokenStream2::new();
+	for pallet_declaration in pallet_declarations {
+		if let Some(pallet_entry) = pallet_declaration.find_part("Event") {
+			let pallet = &pallet_declaration.pallet;
+			let instance = pallet_declaration.instance.as_ref();
+			let generics = &pallet_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,
+					"Instantiable pallet with no generic `Event` cannot \
+					 be constructed: pallet `{}` must have generic `Event`",
+					pallet_declaration.name,
 				);
-				return Err(syn::Error::new(module_declaration.name.span(), msg));
+				return Err(syn::Error::new(pallet_declaration.name.span(), msg));
 			}
 
-			let index = module_declaration.index;
-			let tokens = quote!(#[codec(index = #index)] #module #instance #generics,);
-			modules_tokens.extend(tokens);
+			let index = pallet_declaration.index;
+			let tokens = quote!(#[codec(index = #index)] #pallet #instance #generics,);
+			pallets_tokens.extend(tokens);
 		}
 	}
 
 	Ok(quote!(
 		#scrate::impl_outer_event! {
 			pub enum Event for #runtime_name {
-				#modules_tokens
+				#pallets_tokens
 			}
 		}
 	))
 }
 
-fn decl_all_modules<'a>(
+fn decl_all_pallets<'a>(
 	runtime: &'a Ident,
-	module_declarations: impl Iterator<Item = &'a Module>,
+	pallet_declarations: impl Iterator<Item = &'a Pallet>,
 ) -> TokenStream2 {
 	let mut types = TokenStream2::new();
 	let mut names = Vec::new();
-	for module_declaration in module_declarations {
-		let type_name = &module_declaration.name;
-		let module = &module_declaration.module;
+	for pallet_declaration in pallet_declarations {
+		let type_name = &pallet_declaration.name;
+		let pallet = &pallet_declaration.pallet;
 		let mut generics = vec![quote!(#runtime)];
 		generics.extend(
-			module_declaration
+			pallet_declaration
 				.instance
 				.iter()
-				.map(|name| quote!(#module::#name)),
+				.map(|name| quote!(#pallet::#name)),
 		);
 		let type_decl = quote!(
-			pub type #type_name = #module::Module <#(#generics),*>;
+			pub type #type_name = #pallet::Pallet <#(#generics),*>;
 		);
 		types.extend(type_decl);
-		names.push(&module_declaration.name);
+		names.push(&pallet_declaration.name);
 	}
 	// Make nested tuple structure like (((Babe, Consensus), Grandpa), ...)
-	// But ignore the system module.
-	let all_modules = names.iter()
-		.filter(|n| **n != SYSTEM_MODULE_NAME)
+	// But ignore the system pallet.
+	let all_pallets = names.iter()
+		.filter(|n| **n != SYSTEM_PALLET_NAME)
 		.fold(TokenStream2::default(), |combined, name| quote!((#name, #combined)));
 
-	let all_modules_with_system = names.iter()
+	let all_pallets_with_system = names.iter()
 		.fold(TokenStream2::default(), |combined, name| quote!((#name, #combined)));
 
 	quote!(
 		#types
 		/// All pallets included in the runtime as a nested tuple of types.
 		/// Excludes the System pallet.
-		pub type AllModules = ( #all_modules );
+		pub type AllPallets = ( #all_pallets );
 		/// All pallets included in the runtime as a nested tuple of types.
-		pub type AllModulesWithSystem = ( #all_modules_with_system );
+		pub type AllPalletsWithSystem = ( #all_pallets_with_system );
+
+		/// All modules included in the runtime as a nested tuple of types.
+		/// Excludes the System pallet.
+		#[deprecated(note = "use `AllPallets` instead")]
+		#[allow(dead_code)]
+		pub type AllModules = ( #all_pallets );
+		/// All modules included in the runtime as a nested tuple of types.
+		#[deprecated(note = "use `AllPalletsWithSystem` instead")]
+		#[allow(dead_code)]
+		pub type AllModulesWithSystem = ( #all_pallets_with_system );
 	)
 }
 
 fn decl_pallet_runtime_setup(
-	module_declarations: &[Module],
+	pallet_declarations: &[Pallet],
 	scrate: &TokenStream2,
 ) -> TokenStream2 {
-	let names = module_declarations.iter().map(|d| &d.name);
-	let names2 = module_declarations.iter().map(|d| &d.name);
-	let name_strings = module_declarations.iter().map(|d| d.name.to_string());
-	let indices = module_declarations.iter()
-		.map(|module| module.index as usize);
+	let names = pallet_declarations.iter().map(|d| &d.name);
+	let names2 = pallet_declarations.iter().map(|d| &d.name);
+	let name_strings = pallet_declarations.iter().map(|d| d.name.to_string());
+	let indices = pallet_declarations.iter()
+		.map(|pallet| pallet.index as usize);
 
 	quote!(
 		/// Provides an implementation of `PalletInfo` to provide information
@@ -527,7 +537,7 @@ fn decl_integrity_test(scrate: &TokenStream2) -> TokenStream2 {
 
 			#[test]
 			pub fn runtime_integrity_tests() {
-				<AllModules as #scrate::traits::IntegrityTest>::integrity_test();
+				<AllPallets as #scrate::traits::IntegrityTest>::integrity_test();
 			}
 		}
 	)

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

@@ -28,7 +28,7 @@ mod keyword {
 	syn::custom_keyword!(Block);
 	syn::custom_keyword!(NodeBlock);
 	syn::custom_keyword!(UncheckedExtrinsic);
-	syn::custom_keyword!(Module);
+	syn::custom_keyword!(Pallet);
 	syn::custom_keyword!(Call);
 	syn::custom_keyword!(Storage);
 	syn::custom_keyword!(Event);
@@ -44,7 +44,7 @@ pub struct RuntimeDefinition {
 	pub enum_token: Token![enum],
 	pub name: Ident,
 	pub where_section: WhereSection,
-	pub modules: ext::Braces<ext::Punctuated<ModuleDeclaration, Token![,]>>,
+	pub pallets: ext::Braces<ext::Punctuated<PalletDeclaration, Token![,]>>,
 }
 
 impl Parse for RuntimeDefinition {
@@ -54,7 +54,7 @@ impl Parse for RuntimeDefinition {
 			enum_token: input.parse()?,
 			name: input.parse()?,
 			where_section: input.parse()?,
-			modules: input.parse()?,
+			pallets: input.parse()?,
 		})
 	}
 }
@@ -150,20 +150,20 @@ impl Parse for WhereDefinition {
 }
 
 #[derive(Debug, Clone)]
-pub struct ModuleDeclaration {
+pub struct PalletDeclaration {
 	pub name: Ident,
 	/// Optional fixed index (e.g. `MyPallet ...  = 3,`)
 	pub index: Option<u8>,
-	pub module: Ident,
+	pub pallet: Ident,
 	pub instance: Option<Ident>,
-	pub module_parts: Vec<ModulePart>,
+	pub pallet_parts: Vec<PalletPart>,
 }
 
-impl Parse for ModuleDeclaration {
+impl Parse for PalletDeclaration {
 	fn parse(input: ParseStream) -> Result<Self> {
 		let name = input.parse()?;
 		let _: Token![:] = input.parse()?;
-		let module = input.parse()?;
+		let pallet = input.parse()?;
 		let instance = if input.peek(Token![::]) && input.peek3(Token![<]) {
 			let _: Token![::] = input.parse()?;
 			let _: Token![<] = input.parse()?;
@@ -175,7 +175,7 @@ impl Parse for ModuleDeclaration {
 		};
 
 		let _: Token![::] = input.parse()?;
-		let module_parts = parse_module_parts(input)?;
+		let pallet_parts = parse_pallet_parts(input)?;
 
 		let index = if input.peek(Token![=]) {
 			input.parse::<Token![=]>()?;
@@ -188,9 +188,9 @@ impl Parse for ModuleDeclaration {
 
 		let parsed = Self {
 			name,
-			module,
+			pallet,
 			instance,
-			module_parts,
+			pallet_parts,
 			index,
 		};
 
@@ -198,14 +198,14 @@ impl Parse for ModuleDeclaration {
 	}
 }
 
-/// Parse [`ModulePart`]'s from a braces enclosed list that is split by commas, e.g.
+/// Parse [`PalletPart`]'s from a braces enclosed list that is split by commas, e.g.
 ///
 /// `{ Call, Event }`
-fn parse_module_parts(input: ParseStream) -> Result<Vec<ModulePart>> {
-	let module_parts :ext::Braces<ext::Punctuated<ModulePart, Token![,]>> = input.parse()?;
+fn parse_pallet_parts(input: ParseStream) -> Result<Vec<PalletPart>> {
+	let pallet_parts :ext::Braces<ext::Punctuated<PalletPart, Token![,]>> = input.parse()?;
 
 	let mut resolved = HashSet::new();
-	for part in module_parts.content.inner.iter() {
+	for part in pallet_parts.content.inner.iter() {
 		if !resolved.insert(part.name()) {
 			let msg = format!(
 				"`{}` was already declared before. Please remove the duplicate declaration",
@@ -215,12 +215,12 @@ fn parse_module_parts(input: ParseStream) -> Result<Vec<ModulePart>> {
 		}
 	}
 
-	Ok(module_parts.content.inner.into_iter().collect())
+	Ok(pallet_parts.content.inner.into_iter().collect())
 }
 
 #[derive(Debug, Clone)]
-pub enum ModulePartKeyword {
-	Module(keyword::Module),
+pub enum PalletPartKeyword {
+	Pallet(keyword::Pallet),
 	Call(keyword::Call),
 	Storage(keyword::Storage),
 	Event(keyword::Event),
@@ -230,12 +230,12 @@ pub enum ModulePartKeyword {
 	ValidateUnsigned(keyword::ValidateUnsigned),
 }
 
-impl Parse for ModulePartKeyword {
+impl Parse for PalletPartKeyword {
 	fn parse(input: ParseStream) -> Result<Self> {
 		let lookahead = input.lookahead1();
 
-		if lookahead.peek(keyword::Module) {
-			Ok(Self::Module(input.parse()?))
+		if lookahead.peek(keyword::Pallet) {
+			Ok(Self::Pallet(input.parse()?))
 		} else if lookahead.peek(keyword::Call) {
 			Ok(Self::Call(input.parse()?))
 		} else if lookahead.peek(keyword::Storage) {
@@ -256,11 +256,11 @@ impl Parse for ModulePartKeyword {
 	}
 }
 
-impl ModulePartKeyword {
+impl PalletPartKeyword {
 	/// Returns the name of `Self`.
 	fn name(&self) -> &'static str {
 		match self {
-			Self::Module(_) => "Module",
+			Self::Pallet(_) => "Pallet",
 			Self::Call(_) => "Call",
 			Self::Storage(_) => "Storage",
 			Self::Event(_) => "Event",
@@ -276,21 +276,21 @@ impl ModulePartKeyword {
 		Ident::new(self.name(), self.span())
 	}
 
-	/// Returns `true` if this module part is allowed to have generic arguments.
+	/// Returns `true` if this pallet part is allowed to have generic arguments.
 	fn allows_generic(&self) -> bool {
 		Self::all_generic_arg().iter().any(|n| *n == self.name())
 	}
 
-	/// Returns the names of all module parts that allow to have a generic argument.
+	/// Returns the names of all pallet parts that allow to have a generic argument.
 	fn all_generic_arg() -> &'static [&'static str] {
 		&["Event", "Origin", "Config"]
 	}
 }
 
-impl Spanned for ModulePartKeyword {
+impl Spanned for PalletPartKeyword {
 	fn span(&self) -> Span {
 		match self {
-			Self::Module(inner) => inner.span(),
+			Self::Pallet(inner) => inner.span(),
 			Self::Call(inner) => inner.span(),
 			Self::Storage(inner) => inner.span(),
 			Self::Event(inner) => inner.span(),
@@ -303,21 +303,21 @@ impl Spanned for ModulePartKeyword {
 }
 
 #[derive(Debug, Clone)]
-pub struct ModulePart {
-	pub keyword: ModulePartKeyword,
+pub struct PalletPart {
+	pub keyword: PalletPartKeyword,
 	pub generics: syn::Generics,
 }
 
-impl Parse for ModulePart {
+impl Parse for PalletPart {
 	fn parse(input: ParseStream) -> Result<Self> {
-		let keyword: ModulePartKeyword = input.parse()?;
+		let keyword: PalletPartKeyword = input.parse()?;
 
 		let generics: syn::Generics = input.parse()?;
 		if !generics.params.is_empty() && !keyword.allows_generic() {
-			let valid_generics = ModulePart::format_names(ModulePartKeyword::all_generic_arg());
+			let valid_generics = PalletPart::format_names(PalletPartKeyword::all_generic_arg());
 			let msg = format!(
 				"`{}` is not allowed to have generics. \
-				 Only the following modules are allowed to have generics: {}.",
+				 Only the following pallets are allowed to have generics: {}.",
 				keyword.name(),
 				valid_generics,
 			);
@@ -331,18 +331,18 @@ impl Parse for ModulePart {
 	}
 }
 
-impl ModulePart {
+impl PalletPart {
 	pub fn format_names(names: &[&'static str]) -> String {
 		let res: Vec<_> = names.iter().map(|s| format!("`{}`", s)).collect();
 		res.join(", ")
 	}
 
-	/// The name of this module part.
+	/// The name of this pallet part.
 	pub fn name(&self) -> &'static str {
 		self.keyword.name()
 	}
 
-	/// The name of this module part as `Ident`.
+	/// The name of this pallet part as `Ident`.
 	pub fn ident(&self) -> Ident {
 		self.keyword.ident()
 	}