Moves Block, NodeBlock and UncheckedExtrinsic to frame_system, instead of construct_runtime

bin/node-template/runtime/src/lib.rs

@@ -154,6 +154,12 @@ parameter_types! {
 impl frame_system::Config for Runtime {
 	/// The basic call filter to use in dispatchable.
 	type BaseCallFilter = frame_support::traits::Everything;
+	/// The block type for the runtime.
+	type Block = Block;
+	/// The block type for the node.
+	type NodeBlock = Block;
+	/// The UncheckedExtrinsic type for the runtime.
+	type UncheckedExtrinsic = UncheckedExtrinsic;
 	/// Block & extrinsics weights: base values and limits.
 	type BlockWeights = BlockWeights;
 	/// The maximum length of a block (in bytes).
@@ -277,10 +283,6 @@ impl pallet_template::Config for Runtime {
 // Create the runtime by composing the FRAME pallets that were previously configured.
 construct_runtime!(
 	pub struct Runtime
-	where
-		Block = Block,
-		NodeBlock = opaque::Block,
-		UncheckedExtrinsic = UncheckedExtrinsic,
 	{
 		System: frame_system,
 		Timestamp: pallet_timestamp,

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

@@ -19,12 +19,12 @@ use crate::construct_runtime::Pallet;
 use proc_macro2::TokenStream;
 use quote::quote;
 use std::str::FromStr;
-use syn::{Ident, TypePath};
+use syn::Ident;
 
 pub fn expand_outer_inherent(
 	runtime: &Ident,
-	block: &TypePath,
-	unchecked_extrinsic: &TypePath,
+	block: &TokenStream,
+	unchecked_extrinsic: &TokenStream,
 	pallet_decls: &[Pallet],
 	scrate: &TokenStream,
 ) -> TokenStream {

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

@@ -19,13 +19,13 @@ use crate::construct_runtime::Pallet;
 use proc_macro2::TokenStream;
 use quote::quote;
 use std::str::FromStr;
-use syn::{Ident, TypePath};
+use syn::Ident;
 
 pub fn expand_runtime_metadata(
 	runtime: &Ident,
 	pallet_declarations: &[Pallet],
 	scrate: &TokenStream,
-	extrinsic: &TypePath,
+	extrinsic: &TokenStream,
 ) -> TokenStream {
 	let pallets = pallet_declarations
 		.iter()

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

@@ -151,7 +151,6 @@ use frame_support_procedural_tools::{
 use itertools::Itertools;
 use parse::{
 	ExplicitRuntimeDeclaration, ImplicitRuntimeDeclaration, Pallet, RuntimeDeclaration,
-	WhereSection,
 };
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
@@ -216,7 +215,6 @@ fn construct_runtime_final_expansion(
 ) -> Result<TokenStream2> {
 	let ExplicitRuntimeDeclaration {
 		name,
-		where_section: WhereSection { block, node_block, unchecked_extrinsic },
 		pallets,
 		pallets_token,
 	} = definition;
@@ -256,6 +254,11 @@ fn construct_runtime_final_expansion(
 	let scrate = generate_crate_access(hidden_crate_name, "frame-support");
 	let scrate_decl = generate_hidden_includes(hidden_crate_name, "frame-support");
 
+	let frame_system = generate_crate_access_2018("frame-system")?;
+	let block = quote!(<#name as #frame_system::Config>::Block);
+	let node_block = quote!(<#name as #frame_system::Config>::NodeBlock);
+	let unchecked_extrinsic = quote!(<#name as #frame_system::Config>::UncheckedExtrinsic);
+
 	let outer_event = expand::expand_outer_event(&name, &pallets, &scrate)?;
 
 	let outer_origin = expand::expand_outer_origin(&name, system_pallet, &pallets, &scrate)?;

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

@@ -16,7 +16,7 @@
 // limitations under the License.
 
 use frame_support_procedural_tools::syn_ext as ext;
-use proc_macro2::{Span, TokenStream};
+use proc_macro2::TokenStream;
 use quote::ToTokens;
 use std::collections::{HashMap, HashSet};
 use syn::{
@@ -62,15 +62,13 @@ pub enum RuntimeDeclaration {
 #[derive(Debug)]
 pub struct ImplicitRuntimeDeclaration {
 	pub name: Ident,
-	pub where_section: WhereSection,
 	pub pallets: Vec<PalletDeclaration>,
 }
 
 /// Declaration of a runtime with all pallet having explicit declaration of parts.
 #[derive(Debug)]
 pub struct ExplicitRuntimeDeclaration {
 	pub name: Ident,
-	pub where_section: WhereSection,
 	pub pallets: Vec<Pallet>,
 	pub pallets_token: token::Brace,
 }
@@ -87,7 +85,6 @@ impl Parse for RuntimeDeclaration {
 		}
 
 		let name = input.parse::<syn::Ident>()?;
-		let where_section = input.parse()?;
 		let pallets =
 			input.parse::<ext::Braces<ext::Punctuated<PalletDeclaration, Token![,]>>>()?;
 		let pallets_token = pallets.token;
@@ -96,95 +93,18 @@ impl Parse for RuntimeDeclaration {
 			PalletsConversion::Implicit(pallets) =>
 				Ok(RuntimeDeclaration::Implicit(ImplicitRuntimeDeclaration {
 					name,
-					where_section,
 					pallets,
 				})),
 			PalletsConversion::Explicit(pallets) =>
 				Ok(RuntimeDeclaration::Explicit(ExplicitRuntimeDeclaration {
 					name,
-					where_section,
 					pallets,
 					pallets_token,
 				})),
 		}
 	}
 }
 
-#[derive(Debug)]
-pub struct WhereSection {
-	pub block: syn::TypePath,
-	pub node_block: syn::TypePath,
-	pub unchecked_extrinsic: syn::TypePath,
-}
-
-impl Parse for WhereSection {
-	fn parse(input: ParseStream) -> Result<Self> {
-		input.parse::<token::Where>()?;
-		let mut definitions = Vec::new();
-		while !input.peek(token::Brace) {
-			let definition: WhereDefinition = input.parse()?;
-			definitions.push(definition);
-			if !input.peek(Token![,]) {
-				if !input.peek(token::Brace) {
-					return Err(input.error("Expected `,` or `{`"))
-				}
-				break
-			}
-			input.parse::<Token![,]>()?;
-		}
-		let block = remove_kind(input, WhereKind::Block, &mut definitions)?.value;
-		let node_block = remove_kind(input, WhereKind::NodeBlock, &mut definitions)?.value;
-		let unchecked_extrinsic =
-			remove_kind(input, WhereKind::UncheckedExtrinsic, &mut definitions)?.value;
-		if let Some(WhereDefinition { ref kind_span, ref kind, .. }) = definitions.first() {
-			let msg = format!(
-				"`{:?}` was declared above. Please use exactly one declaration for `{:?}`.",
-				kind, kind
-			);
-			return Err(Error::new(*kind_span, msg))
-		}
-		Ok(Self { block, node_block, unchecked_extrinsic })
-	}
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
-pub enum WhereKind {
-	Block,
-	NodeBlock,
-	UncheckedExtrinsic,
-}
-
-#[derive(Debug)]
-pub struct WhereDefinition {
-	pub kind_span: Span,
-	pub kind: WhereKind,
-	pub value: syn::TypePath,
-}
-
-impl Parse for WhereDefinition {
-	fn parse(input: ParseStream) -> Result<Self> {
-		let lookahead = input.lookahead1();
-		let (kind_span, kind) = if lookahead.peek(keyword::Block) {
-			(input.parse::<keyword::Block>()?.span(), WhereKind::Block)
-		} else if lookahead.peek(keyword::NodeBlock) {
-			(input.parse::<keyword::NodeBlock>()?.span(), WhereKind::NodeBlock)
-		} else if lookahead.peek(keyword::UncheckedExtrinsic) {
-			(input.parse::<keyword::UncheckedExtrinsic>()?.span(), WhereKind::UncheckedExtrinsic)
-		} else {
-			return Err(lookahead.error())
-		};
-
-		Ok(Self {
-			kind_span,
-			kind,
-			value: {
-				let _: Token![=] = input.parse()?;
-				input.parse()?
-			},
-		})
-	}
-}
-
 /// The declaration of a pallet.
 #[derive(Debug, Clone)]
 pub struct PalletDeclaration {
@@ -502,22 +422,6 @@ impl PalletPart {
 	}
 }
 
-fn remove_kind(
-	input: ParseStream,
-	kind: WhereKind,
-	definitions: &mut Vec<WhereDefinition>,
-) -> Result<WhereDefinition> {
-	if let Some(pos) = definitions.iter().position(|d| d.kind == kind) {
-		Ok(definitions.remove(pos))
-	} else {
-		let msg = format!(
-			"Missing associated type for `{:?}`. Add `{:?}` = ... to where section.",
-			kind, kind
-		);
-		Err(input.error(msg))
-	}
-}
-
 /// The declaration of a part without its generics
 #[derive(Debug, Clone)]
 pub struct PalletPartNoGeneric {

frame/system/src/lib.rs

@@ -72,8 +72,8 @@ use sp_runtime::traits::TrailingZeroInput;
 use sp_runtime::{
 	generic,
 	traits::{
-		self, AtLeast32Bit, AtLeast32BitUnsigned, BadOrigin, BlockNumberProvider, Bounded,
-		CheckEqual, Dispatchable, Hash, Lookup, LookupError, MaybeDisplay,
+		self, AtLeast32Bit, AtLeast32BitUnsigned, BadOrigin, Block, BlockNumberProvider, Bounded,
+		CheckEqual, Dispatchable, Extrinsic, Hash, Lookup, LookupError, MaybeDisplay,
 		MaybeSerializeDeserialize, Member, One, Saturating, SimpleBitOps, StaticLookup, Zero,
 	},
 	DispatchError, RuntimeDebug,
@@ -209,6 +209,15 @@ pub mod pallet {
 		/// except Root.
 		type BaseCallFilter: Contains<Self::RuntimeCall>;
 
+		/// The Block type used by the runtime.
+		type Block: Block;
+
+		/// The Block type used by the node.
+		type NodeBlock: Block;
+
+		/// The UncheckedExtrinsic type used by the runtime.
+		type UncheckedExtrinsic: Extrinsic;
+
 		/// Block & extrinsics weights: base values and limits.
 		#[pallet::constant]
 		type BlockWeights: Get<limits::BlockWeights>;