Extend PalletInfoAccess with module_name and crate_version method (#9690)

* Record pallet indices in CallMetadata

* Resurrect PalletVersion infrastructure and rename as CrateVersion

* cargo fmt

* Add missing runtime generics to pallet struct

* Fix path to instance

* Fix test

* Fix UI test expectations

* Fix UI test expectations

* Move crate_version function to PalletInfoAccess

* Update UI test expectations

* Add crate_name method to PalletInfo

* Convert path to module name instead of exposing crate name

* cargo fmt

* Keep the double colons when constructing the module name

* Remove unused import

* Update UI test expectations

* Update frame/support/src/traits/metadata.rs

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>

* Update UI test expectations

Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com>

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

@@ -132,7 +132,7 @@ fn construct_runtime_parsed(definition: RuntimeDefinition) -> Result<TokenStream
 
 	let outer_origin = expand::expand_outer_origin(&name, &pallets, pallets_token, &scrate)?;
 	let all_pallets = decl_all_pallets(&name, pallets.iter());
-	let pallet_to_index = decl_pallet_runtime_setup(&pallets, &scrate);
+	let pallet_to_index = decl_pallet_runtime_setup(&name, &pallets, &scrate);
 
 	let dispatch = expand::expand_outer_dispatch(&name, &pallets, &scrate);
 	let metadata = expand::expand_runtime_metadata(&name, &pallets, &scrate, &unchecked_extrinsic);
@@ -236,13 +236,24 @@ fn decl_all_pallets<'a>(
 }
 
 fn decl_pallet_runtime_setup(
+	runtime: &Ident,
 	pallet_declarations: &[Pallet],
 	scrate: &TokenStream2,
 ) -> TokenStream2 {
-	let names = pallet_declarations.iter().map(|d| &d.name);
-	let names2 = pallet_declarations.iter().map(|d| &d.name);
+	let names = pallet_declarations.iter().map(|d| &d.name).collect::<Vec<_>>();
 	let name_strings = pallet_declarations.iter().map(|d| d.name.to_string());
+	let module_names = pallet_declarations.iter().map(|d| d.path.module_name());
 	let indices = pallet_declarations.iter().map(|pallet| pallet.index as usize);
+	let pallet_structs = pallet_declarations
+		.iter()
+		.map(|pallet| {
+			let path = &pallet.path;
+			match pallet.instance.as_ref() {
+				Some(inst) => quote!(#path::Pallet<#runtime, #path::#inst>),
+				None => quote!(#path::Pallet<#runtime>),
+			}
+		})
+		.collect::<Vec<_>>();
 
 	quote!(
 		/// Provides an implementation of `PalletInfo` to provide information
@@ -264,13 +275,37 @@ fn decl_pallet_runtime_setup(
 			fn name<P: 'static>() -> Option<&'static str> {
 				let type_id = #scrate::sp_std::any::TypeId::of::<P>();
 				#(
-					if type_id == #scrate::sp_std::any::TypeId::of::<#names2>() {
+					if type_id == #scrate::sp_std::any::TypeId::of::<#names>() {
 						return Some(#name_strings)
 					}
 				)*
 
 				None
 			}
+
+			fn module_name<P: 'static>() -> Option<&'static str> {
+				let type_id = #scrate::sp_std::any::TypeId::of::<P>();
+				#(
+					if type_id == #scrate::sp_std::any::TypeId::of::<#names>() {
+						return Some(#module_names)
+					}
+				)*
+
+				None
+			}
+
+			fn crate_version<P: 'static>() -> Option<#scrate::traits::CrateVersion> {
+				let type_id = #scrate::sp_std::any::TypeId::of::<P>();
+				#(
+					if type_id == #scrate::sp_std::any::TypeId::of::<#names>() {
+						return Some(
+							<#pallet_structs as #scrate::traits::PalletInfoAccess>::crate_version()
+						)
+					}
+				)*
+
+				None
+			}
 		}
 	)
 }

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

@@ -188,6 +188,18 @@ pub struct PalletPath {
 	pub inner: Path,
 }
 
+impl PalletPath {
+	pub fn module_name(&self) -> String {
+		self.inner.segments.iter().fold(String::new(), |mut acc, segment| {
+			if !acc.is_empty() {
+				acc.push_str("::");
+			}
+			acc.push_str(&segment.ident.to_string());
+			acc
+		})
+	}
+}
+
 impl Parse for PalletPath {
 	fn parse(input: ParseStream) -> Result<Self> {
 		let mut lookahead = input.lookahead1();

substrate/frame/support/procedural/src/crate_version.rs

@@ -0,0 +1,54 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020-2021 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Implementation of macros related to crate versioning.
+
+use super::get_cargo_env_var;
+use frame_support_procedural_tools::generate_crate_access_2018;
+use proc_macro2::{Span, TokenStream};
+use syn::{Error, Result};
+
+/// Create an error that will be shown by rustc at the call site of the macro.
+fn create_error(message: &str) -> Error {
+	Error::new(Span::call_site(), message)
+}
+
+/// Implementation of the `crate_to_crate_version!` macro.
+pub fn crate_to_crate_version(input: proc_macro::TokenStream) -> Result<TokenStream> {
+	if !input.is_empty() {
+		return Err(create_error("No arguments expected!"))
+	}
+
+	let major_version = get_cargo_env_var::<u16>("CARGO_PKG_VERSION_MAJOR")
+		.map_err(|_| create_error("Major version needs to fit into `u16`"))?;
+
+	let minor_version = get_cargo_env_var::<u8>("CARGO_PKG_VERSION_MINOR")
+		.map_err(|_| create_error("Minor version needs to fit into `u8`"))?;
+
+	let patch_version = get_cargo_env_var::<u8>("CARGO_PKG_VERSION_PATCH")
+		.map_err(|_| create_error("Patch version needs to fit into `u8`"))?;
+
+	let crate_ = generate_crate_access_2018("frame-support")?;
+
+	Ok(quote::quote! {
+		#crate_::traits::CrateVersion {
+			major: #major_version,
+			minor: #minor_version,
+			patch: #patch_version,
+		}
+	})
+}

substrate/frame/support/procedural/src/lib.rs

@@ -21,6 +21,7 @@
 
 mod clone_no_bound;
 mod construct_runtime;
+mod crate_version;
 mod debug_no_bound;
 mod default_no_bound;
 mod dummy_part_checker;
@@ -31,7 +32,7 @@ mod storage;
 mod transactional;
 
 use proc_macro::TokenStream;
-use std::cell::RefCell;
+use std::{cell::RefCell, str::FromStr};
 pub(crate) use storage::INHERENT_INSTANCE_NAME;
 
 thread_local! {
@@ -52,6 +53,16 @@ impl Counter {
 	}
 }
 
+/// Get the value from the given environment variable set by cargo.
+///
+/// The value is parsed into the requested destination type.
+fn get_cargo_env_var<T: FromStr>(version_env: &str) -> std::result::Result<T, ()> {
+	let version = std::env::var(version_env)
+		.unwrap_or_else(|_| panic!("`{}` is always set by cargo; qed", version_env));
+
+	T::from_str(&version).map_err(drop)
+}
+
 /// Declares strongly-typed wrappers around codec-compatible types in storage.
 ///
 /// ## Example
@@ -462,6 +473,13 @@ pub fn require_transactional(attr: TokenStream, input: TokenStream) -> TokenStre
 		.unwrap_or_else(|e| e.to_compile_error().into())
 }
 
+#[proc_macro]
+pub fn crate_to_crate_version(input: TokenStream) -> TokenStream {
+	crate_version::crate_to_crate_version(input)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
 /// The number of module instances supported by the runtime, starting at index 1,
 /// and up to `NUMBER_OF_INSTANCE`.
 pub(crate) const NUMBER_OF_INSTANCE: u8 = 16;

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

@@ -219,6 +219,18 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
 					.expect("Pallet is part of the runtime because pallet `Config` trait is \
 						implemented by the runtime")
 			}
+
+			fn module_name() -> &'static str {
+				<
+					<T as #frame_system::Config>::PalletInfo as #frame_support::traits::PalletInfo
+				>::module_name::<Self>()
+					.expect("Pallet is part of the runtime because pallet `Config` trait is \
+						implemented by the runtime")
+			}
+
+			fn crate_version() -> #frame_support::traits::CrateVersion {
+				#frame_support::crate_to_crate_version!()
+			}
 		}
 
 		#storage_info