Add pallet attribute macro to declare pallets (#6877)

* rename system Config to system Trait.

command used:
```
find frame/ bin/ test-utils/ utils/ -name *.rs -exec sed -i 's/system::Trait>::/system::Config>::/g' {} \;
find frame/ bin/ test-utils/ utils/ -name *.rs -exec sed -i 's/impl frame_system::Trait for /impl frame_system::Config for /g' {} \;
find frame/ bin/ test-utils/ utils/ -name *.rs -exec sed -i 's/impl system::Trait for /impl system::Config for /g' {} \;
```
plus some manual ones especially for frame-support tests and frame-system

* make construct_runtime handle Pallet and Module

pallets can now be implemented on struct named Pallet or Module, both
definition are valid.
This is because next macro will generate only Pallet placeholder.

* introduce pallet attribute macro

currently just with tests, frame_system and other example hasn't been
upgraded

* allow to print some upgrade helper from decl_storage

* Improved error msg, typo.

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>

* Improved error msg, typo.

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>

* Improved error message on unexpected attributes + ui test

* add test for transactional

* various typo

* some tips when spans are lost

* allow pallet to depend on other pallet instances

* make event type metadata consistent with call and constant

* error messages

* ignore doc example

* fix pallet upgrade template

* fixup

* fix doc

* fix indentation

* Apply suggestions code formatting

Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* some renames + fix compilation

* remove unsupported genesis config type alias

* merge fixup

* fix ui tests

* additional doc

* implement StorageInstance with new syntax

* fix line width

* fix doc: because pallet doc goes below reexport doc

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

Co-authored-by: Andrew Jones <ascjones@gmail.com>

* Update frame/system/src/lib.rs

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* Update frame/support/test/tests/pallet_ui.rs

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* improve doc as suggested

* revert construct_runtime Pallet part.

This revert the changes on construct_runtime. Now construct_runtime is
unchanged and instead pallet macro create a type alias
`type Module<..> = Pallet<..>` to be used by construct_runtime

* refactor with less intricated code

* fix ui test with new image

* fix ui tests

* add minor tests

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
Co-authored-by: Andrew Jones <ascjones@gmail.com>
Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

substrate/frame/support/src/instances.rs

@@ -0,0 +1,96 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Some instance placeholder to be used in [`frame_support::pallet`] attribute macro.
+//!
+//! [`frame_support::pallet`] attribute macro does only requires the instance generic `I` to be
+//! static (contrary to `decl_*` macro which requires instance generic to implement
+//! [`frame_support::traits::Instance`]).
+//!
+//! Thus support provides some instance types to be used, This allow some instantiable pallet to
+//! depend on specific instance of another:
+//! ```
+//! # mod another_pallet { pub trait Config<I: 'static = ()> {} }
+//! pub trait Config<I: 'static = ()>: another_pallet::Config<I> {}
+//! ```
+//!
+//! NOTE: [`frame_support::pallet`] will reexport them inside the module, in order to make them
+//! accessible to [`frame_support::construct_runtime`].
+
+/// Instance0 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance0;
+
+/// Instance1 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance1;
+
+/// Instance2 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance2;
+
+/// Instance3 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance3;
+
+/// Instance4 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance4;
+
+/// Instance5 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance5;
+
+/// Instance6 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance6;
+
+/// Instance7 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance7;
+
+/// Instance8 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance8;
+
+/// Instance9 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance9;
+
+/// Instance10 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance10;
+
+/// Instance11 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance11;
+
+/// Instance12 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance12;
+
+/// Instance13 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance13;
+
+/// Instance14 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance14;
+
+/// Instance15 to be used for instantiable pallet define with `pallet` macro.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance15;

substrate/frame/support/src/traits.rs

@@ -1869,6 +1869,79 @@ pub trait IsSubType<T> {
 	fn is_sub_type(&self) -> Option<&T>;
 }
 
+/// The pallet hooks trait. Implementing this lets you express some logic to execute.
+pub trait Hooks<BlockNumber> {
+	/// The block is being finalized. Implement to have something happen.
+	fn on_finalize(_n: BlockNumber) {}
+
+	/// The block is being initialized. Implement to have something happen.
+	///
+	/// Return the non-negotiable weight consumed in the block.
+	fn on_initialize(_n: BlockNumber) -> crate::weights::Weight { 0 }
+
+	/// Perform a module upgrade.
+	///
+	/// NOTE: this doesn't include all pallet logic triggered on runtime upgrade. For instance it
+	/// doesn't include the write of the pallet version in storage. The final complete logic
+	/// triggered on runtime upgrade is given by implementation of `OnRuntimeUpgrade` trait by
+	/// `Pallet`.
+	///
+	/// # Warning
+	///
+	/// This function will be called before we initialized any runtime state, aka `on_initialize`
+	/// wasn't called yet. So, information like the block number and any other
+	/// block local data are not accessible.
+	///
+	/// Return the non-negotiable weight consumed for runtime upgrade.
+	fn on_runtime_upgrade() -> crate::weights::Weight { 0 }
+
+	/// Implementing this function on a module allows you to perform long-running tasks
+	/// that make (by default) validators generate transactions that feed results
+	/// of those long-running computations back on chain.
+	///
+	/// NOTE: This function runs off-chain, so it can access the block state,
+	/// but cannot preform any alterations. More specifically alterations are
+	/// not forbidden, but they are not persisted in any way after the worker
+	/// has finished.
+	///
+	/// This function is being called after every block import (when fully synced).
+	///
+	/// Implement this and use any of the `Offchain` `sp_io` set of APIs
+	/// to perform off-chain computations, calls and submit transactions
+	/// with results to trigger any on-chain changes.
+	/// Any state alterations are lost and are not persisted.
+	fn offchain_worker(_n: BlockNumber) {}
+
+	/// Run integrity test.
+	///
+	/// The test is not executed in a externalities provided environment.
+	fn integrity_test() {}
+}
+
+/// A trait to define the build function of a genesis config, T and I are placeholder for pallet
+/// trait and pallet instance.
+#[cfg(feature = "std")]
+pub trait GenesisBuild<T, I=()>: Default + MaybeSerializeDeserialize {
+	/// The build function is called within an externalities allowing storage APIs.
+	/// Thus one can write to storage using regular pallet storages.
+	fn build(&self);
+
+	/// Build the storage using `build` inside default storage.
+	fn build_storage(&self) -> Result<sp_runtime::Storage, String> {
+		let mut storage = Default::default();
+		self.assimilate_storage(&mut storage)?;
+		Ok(storage)
+	}
+
+	/// Assimilate the storage for this module into pre-existing overlays.
+	fn assimilate_storage(&self, storage: &mut sp_runtime::Storage) -> Result<(), String> {
+		sp_state_machine::BasicExternalities::execute_with_storage(storage, || {
+			self.build();
+			Ok(())
+		})
+	}
+}
+
 /// The storage key postfix that is used to store the [`PalletVersion`] per pallet.
 ///
 /// The full storage key is built by using: