Derivable Encode & Decode (#509)

* Derive macro for simple structs.

* Derive Encode/Decode wherever we can.

* Derive for enums.

* Support discriminant.

* Get rid of some repetition.

* Support custom indices.

* Derive codec for enums wherever possible.

* Fix no_std

* WASM rebuilt

* Avoid excessive import.

* Fix compilation.

* Address review grumbles.

polkadot/primitives/src/lib.rs

@@ -21,13 +21,16 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(feature = "std"), feature(alloc))]
 
-extern crate substrate_runtime_std as rstd;
+extern crate substrate_codec as codec;
 extern crate substrate_primitives as primitives;
 extern crate substrate_runtime_primitives as runtime_primitives;
+extern crate substrate_runtime_std as rstd;
+
 #[cfg(test)]
 extern crate substrate_serializer;
 
-extern crate substrate_codec as codec;
+#[macro_use]
+extern crate substrate_codec_derive;
 
 #[cfg(feature = "std")]
 #[macro_use]
@@ -42,7 +45,6 @@ use primitives::bytes;
 use rstd::prelude::*;
 use runtime_primitives::traits::BlakeTwo256;
 use runtime_primitives::generic;
-use codec::{Encode, Decode, Input, Output};
 
 pub mod parachain;
 
@@ -105,18 +107,6 @@ pub type Balance = u128;
 pub type BlockId = generic::BlockId<Block>;
 
 /// A log entry in the block.
-#[derive(PartialEq, Eq, Clone, Default)]
+#[derive(PartialEq, Eq, Clone, Default, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
 pub struct Log(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
-
-impl Decode for Log {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		Vec::<u8>::decode(input).map(Log)
-	}
-}
-
-impl Encode for Log {
-	fn encode_to<T: Output>(&self, dest: &mut T) {
-		self.0.encode_to(dest)
-	}
-}

polkadot/primitives/src/parachain.rs

@@ -16,7 +16,6 @@
 
 //! Polkadot parachain types.
 
-use codec::{Encode, Decode, Input, Output};
 use rstd::prelude::*;
 use rstd::cmp::Ordering;
 use super::Hash;
@@ -28,7 +27,7 @@ use primitives::bytes;
 pub type CandidateSignature = ::runtime_primitives::Ed25519Signature;
 
 /// Unique identifier of a parachain.
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
 pub struct Id(u32);
 
@@ -47,20 +46,8 @@ impl Id {
 	}
 }
 
-impl Decode for Id {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		u32::decode(input).map(Id)
-	}
-}
-
-impl Encode for Id {
-	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		self.0.using_encoded(f)
-	}
-}
-
 /// Identifier for a chain, either one of a number of parachains or the relay chain.
-#[derive(Copy, Clone, PartialEq)]
+#[derive(Copy, Clone, PartialEq, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Debug))]
 pub enum Chain {
 	/// The relay chain.
@@ -69,31 +56,8 @@ pub enum Chain {
 	Parachain(Id),
 }
 
-impl Decode for Chain {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		let disc = input.read_byte()?;
-		match disc {
-			0 => Some(Chain::Relay),
-			1 => Some(Chain::Parachain(Decode::decode(input)?)),
-			_ => None,
-		}
-	}
-}
-
-impl Encode for Chain {
-	fn encode_to<T: Output>(&self, dest: &mut T) {
-		match *self {
-			Chain::Relay => { dest.push_byte(0); }
-			Chain::Parachain(id) => {
-				dest.push_byte(1u8);
-				dest.push(&id);
-			}
-		}
-	}
-}
-
 /// The duty roster specifying what jobs each validator must do.
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Default, Debug))]
 pub struct DutyRoster {
 	/// Lookup from validator index to chain on which that validator has a duty to validate.
@@ -103,22 +67,6 @@ pub struct DutyRoster {
 	pub guarantor_duty: Vec<Chain>,
 }
 
-impl Decode for DutyRoster {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		Some(DutyRoster {
-			validator_duty: Decode::decode(input)?,
-			guarantor_duty: Decode::decode(input)?,
-		})
-	}
-}
-
-impl Encode for DutyRoster {
-	fn encode_to<T: Output>(&self, dest: &mut T) {
-		dest.push(&self.validator_duty);
-		dest.push(&self.guarantor_duty);
-	}
-}
-
 /// Extrinsic data for a parachain.
 #[derive(PartialEq, Eq, Clone)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
@@ -127,7 +75,7 @@ impl Encode for DutyRoster {
 pub struct Extrinsic;
 
 /// Candidate receipt type.
-#[derive(PartialEq, Eq, Clone)]
+#[derive(PartialEq, Eq, Clone, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
 #[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
 #[cfg_attr(feature = "std", serde(deny_unknown_fields))]
@@ -150,34 +98,6 @@ pub struct CandidateReceipt {
 	pub block_data_hash: Hash,
 }
 
-impl Encode for CandidateReceipt {
-	fn encode_to<T: Output>(&self, dest: &mut T) {
-		dest.push(&self.parachain_index);
-		dest.push(&self.collator);
-		dest.push(&self.signature);
-		dest.push(&self.head_data.0);
-		dest.push(&self.balance_uploads);
-		dest.push(&self.egress_queue_roots);
-		dest.push(&self.fees);
-		dest.push(&self.block_data_hash);
-	}
-}
-
-impl Decode for CandidateReceipt {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		Some(CandidateReceipt {
-			parachain_index: Decode::decode(input)?,
-			collator: Decode::decode(input)?,
-			signature: Decode::decode(input)?,
-			head_data: Decode::decode(input).map(HeadData)?,
-			balance_uploads: Decode::decode(input)?,
-			egress_queue_roots: Decode::decode(input)?,
-			fees: Decode::decode(input)?,
-			block_data_hash: Decode::decode(input)?,
-		})
-	}
-}
-
 impl CandidateReceipt {
 	/// Get the blake2_256 hash
 	#[cfg(feature = "std")]
@@ -213,7 +133,7 @@ impl Ord for CandidateReceipt {
 }
 
 /// A full collation.
-#[derive(PartialEq, Eq, Clone)]
+#[derive(PartialEq, Eq, Clone, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
 #[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
 #[cfg_attr(feature = "std", serde(deny_unknown_fields))]
@@ -224,22 +144,6 @@ pub struct Collation {
 	pub receipt: CandidateReceipt,
 }
 
-impl Decode for Collation {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		Some(Collation {
-			block_data: Decode::decode(input)?,
-			receipt: Decode::decode(input)?,
-		})
-	}
-}
-
-impl Encode for Collation {
-	fn encode_to<T: Output>(&self, dest: &mut T) {
-		dest.push(&self.block_data);
-		dest.push(&self.receipt);
-	}
-}
-
 /// Parachain ingress queue message.
 #[derive(PartialEq, Eq, Clone)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
@@ -256,7 +160,7 @@ pub struct ConsolidatedIngress(pub Vec<(Id, Vec<Message>)>);
 /// Parachain block data.
 ///
 /// contains everything required to validate para-block, may contain block and witness data
-#[derive(PartialEq, Eq, Clone)]
+#[derive(PartialEq, Eq, Clone, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
 pub struct BlockData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
 
@@ -268,26 +172,13 @@ impl BlockData {
 		BlakeTwo256::hash(&self.0[..])
 	}
 }
-
-impl Decode for BlockData {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		Some(BlockData(Decode::decode(input)?))
-	}
-}
-
-impl Encode for BlockData {
-	fn encode_to<T: Output>(&self, dest: &mut T) {
-		dest.push(&self.0);
-	}
-}
-
 /// Parachain header raw bytes wrapper type.
 #[derive(PartialEq, Eq)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
 pub struct Header(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
 
 /// Parachain head data included in the chain.
-#[derive(PartialEq, Eq, Clone, PartialOrd, Ord)]
+#[derive(PartialEq, Eq, Clone, PartialOrd, Ord, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
 pub struct HeadData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
 
@@ -297,22 +188,10 @@ pub struct HeadData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8
 pub struct ValidationCode(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
 
 /// Activitiy bit field
-#[derive(PartialEq, Eq, Clone, Default)]
+#[derive(PartialEq, Eq, Clone, Default, Encode, Decode)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
 pub struct Activity(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
 
-impl Decode for Activity {
-	fn decode<I: Input>(input: &mut I) -> Option<Self> {
-		Vec::<u8>::decode(input).map(Activity)
-	}
-}
-
-impl Encode for Activity {
-	fn encode_to<T: Output>(&self, dest: &mut T) {
-		self.0.encode_to(dest)
-	}
-}
-
 /// Statements which can be made about parachain candidates.
 #[derive(Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]