fix some constrain, instance compat and unisgned

Author: gui1117

frame/support/procedural/src/pallet/parse/event.rs

@@ -149,6 +149,12 @@ impl EventDef {
 			item.ident.span()
 		)? {
 			instances.push(u);
+		} else {
+			// construct_runtime only allow generic event for instantiable pallet.
+			instances.push(helper::InstanceUsage {
+				has_instance: false,
+				span: item.ident.span(),
+			})
 		}
 
 		let event = syn::parse2::<keyword::Event>(item.ident.to_token_stream())?;

frame/support/procedural/src/pallet/parse/mod.rs

@@ -31,6 +31,7 @@ pub mod event;
 pub mod helper;
 pub mod genesis_config;
 pub mod genesis_build;
+pub mod validate_unsigned;
 
 use syn::spanned::Spanned;
 use frame_support_procedural_tools::generate_crate_access;
@@ -53,6 +54,7 @@ pub struct Def {
 	pub inherent: Option<inherent::InherentDef>,
 	pub genesis_config: Option<genesis_config::GenesisConfigDef>,
 	pub genesis_build: Option<genesis_build::GenesisBuildDef>,
+	pub validate_unsigned: Option<validate_unsigned::ValidateUnsignedDef>,
 }
 
 impl Def {
@@ -74,6 +76,7 @@ impl Def {
 		let mut inherent = None;
 		let mut genesis_config = None;
 		let mut genesis_build = None;
+		let mut validate_unsigned = None;
 		let mut storages = vec![];
 
 		for (index, item) in items.iter_mut().enumerate() {
@@ -103,6 +106,10 @@ impl Def {
 					inherent = Some(inherent::InherentDef::try_from(index, item)?),
 				Some(PalletAttr::Storage) =>
 					storages.push(storage::StorageDef::try_from(index, item)?),
+				Some(PalletAttr::ValidateUnsigned) => {
+					let v = validate_unsigned::ValidateUnsignedDef::try_from(index, item)?;
+					validate_unsigned = Some(v);
+				},
 				None => (),
 			}
 		}
@@ -129,6 +136,7 @@ impl Def {
 			call: call.ok_or_else(|| syn::Error::new(item_span, "Missing `#[pallet::call]"))?,
 			genesis_config,
 			genesis_build,
+			validate_unsigned,
 			error,
 			event,
 			origin,
@@ -296,6 +304,7 @@ mod keyword {
 	syn::custom_keyword!(storage);
 	syn::custom_keyword!(genesis_build);
 	syn::custom_keyword!(genesis_config);
+	syn::custom_keyword!(validate_unsigned);
 }
 
 /// Parse attributes for item in pallet module
@@ -312,6 +321,7 @@ pub enum PalletAttr {
 	Storage,
 	GenesisConfig,
 	GenesisBuild,
+	ValidateUnsigned,
 }
 
 impl syn::parse::Parse for PalletAttr {
@@ -356,6 +366,9 @@ impl syn::parse::Parse for PalletAttr {
 		} else if lookahead.peek(keyword::genesis_build) {
 			content.parse::<keyword::genesis_build>()?;
 			Ok(PalletAttr::GenesisBuild)
+		} else if lookahead.peek(keyword::validate_unsigned) {
+			content.parse::<keyword::validate_unsigned>()?;
+			Ok(PalletAttr::ValidateUnsigned)
 		} else {
 			Err(lookahead.error())
 		}

frame/support/procedural/src/pallet/parse/origin.rs

@@ -50,9 +50,14 @@ impl OriginDef {
 		let is_generic = generics.params.len() > 0;
 
 		let mut instances = vec![];
-		// TODO TODO: is it ok not to be generic over I ? maybe should be same as storage, at least it doesn't seem supported by construct_runtime right now
 		if let Some(u) = helper::check_type_def_optional_generics(&generics, item.span())? {
 			instances.push(u);
+		} else {
+			// construct_runtime only allow generic event for instantiable pallet.
+			instances.push(helper::InstanceUsage {
+				has_instance: false,
+				span: ident.span(),
+			})
 		}
 
 		if !matches!(vis, syn::Visibility::Public(_)) {

frame/support/procedural/src/pallet/parse/validate_unsigned.rs

@@ -0,0 +1,61 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020 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.
+
+use syn::spanned::Spanned;
+use super::helper;
+
+/// The definition of the pallet validate unsigned implementation.
+pub struct ValidateUnsignedDef {
+	/// The index of validate unsigned item in pallet module.
+	pub index: usize,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+}
+
+impl ValidateUnsignedDef {
+	pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+		let item = if let syn::Item::Impl(item) = item {
+			item
+		} else {
+			let msg = "Invalid pallet::validate_unsigned, expect item impl";
+			return Err(syn::Error::new(item.span(), msg));
+		};
+
+		if item.trait_.is_none() {
+			let msg = "Invalid pallet::validate_unsigned, expect impl<..> ValidateUnsigned for \
+				Module<..>";
+			return Err(syn::Error::new(item.span(), msg));
+		}
+
+		if let Some(last) = item.trait_.as_ref().unwrap().1.segments.last() {
+			if last.ident != "ValidateUnsigned" {
+				let msg = "Invalid pallet::validate_unsigned, expect trait ValidateUnsigned";
+				return Err(syn::Error::new(last.span(), msg));
+			}
+		} else {
+			let msg = "Invalid pallet::validate_unsigned, expect impl<..> ValidateUnsigned for \
+				Module<..>";
+			return Err(syn::Error::new(item.span(), msg));
+		}
+
+		let mut instances = vec![];
+		instances.push(helper::check_module_usage(&item.self_ty)?);
+		instances.push(helper::check_impl_generics(&item.generics, item.impl_token.span())?);
+
+		Ok(ValidateUnsignedDef { index, instances })
+	}
+}