Refactor away dodgy trait.

demo/primitives/src/lib.rs

@@ -21,7 +21,6 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(feature = "std"), feature(alloc))]
 
-#[cfg(feature = "std")] #[macro_use] extern crate serde_derive;
 #[cfg(feature = "std")] extern crate serde;
 
 extern crate substrate_runtime_std as rstd;

demo/runtime/src/lib.rs

@@ -36,18 +36,6 @@ use demo_primitives::{AccountId, Balance, BlockNumber, Hash, Index, SessionKey,
 use runtime_primitives::{generic, Identity, HasPublicAux};
 pub use runtime_primitives::BuildExternalities;
 
-// TODO: refactor so that each module gets to be able to attempt to extract a PrivCall into
-// Some(its own PrivCall) or None.
-impl democracy::IsCancelReferendum for PrivCall {
-	fn is_cancel_referendum(&self) -> Option<democracy::ReferendumIndex> {
-		if let &PrivCall::Democracy(democracy::PrivCall::cancel_referendum(ref ref_index)) = self {
-			Some(*ref_index)
-		} else {
-			None
-		}
-	}
-}
-
 pub struct Concrete;
 
 impl HasPublicAux for Concrete {

substrate/runtime-support/src/dispatch.rs

@@ -377,6 +377,10 @@ macro_rules! __decl_dispatch_module_common {
 	}
 }
 
+pub trait IsSubType<T: Callable> {
+	fn is_sub_type(&self) -> Option<&<T as Callable>::Call>;
+}
+
 /// Implement a meta-dispatch module to dispatch to other dispatchers.
 #[macro_export]
 macro_rules! impl_outer_dispatch {
@@ -438,6 +442,17 @@ macro_rules! impl_outer_dispatch {
 				}
 			}
 		}
+		$(
+			impl $crate::dispatch::IsSubType<$camelcase> for $call_type {
+				fn is_sub_type(&self) -> Option<&<$camelcase as $crate::dispatch::Callable>::Call> {
+					if let $call_type::$camelcase ( ref r ) = *self {
+						Some(r)
+					} else {
+						None
+					}
+				}
+			}
+		)*
 		impl_outer_dispatch!{ $($rest)* }
 	}
 }

substrate/runtime-support/src/lib.rs

@@ -38,4 +38,4 @@ mod hashable;
 
 pub use self::storage::{StorageVec, StorageList, StorageValue, StorageMap};
 pub use self::hashable::Hashable;
-pub use self::dispatch::{Parameter, Dispatchable, Callable, AuxDispatchable, AuxCallable};
+pub use self::dispatch::{Parameter, Dispatchable, Callable, AuxDispatchable, AuxCallable, IsSubType};

substrate/runtime/council/src/lib.rs

@@ -577,15 +577,6 @@ mod tests {
 			Democracy = 1,
 		}
 	}
-	impl democracy::IsCancelReferendum for Proposal {
-		fn is_cancel_referendum(&self) -> Option<democracy::ReferendumIndex> {
-			if let &Proposal::Democracy(democracy::PrivCall::cancel_referendum(ref ref_index)) = self {
-				Some(*ref_index)
-			} else {
-				None
-			}
-		}
-	}
 
 	pub struct Test;
 	impl HasPublicAux for Test {

substrate/runtime/council/src/voting.rs

@@ -20,10 +20,9 @@ use rstd::prelude::*;
 use rstd::borrow::Borrow;
 use primitives::{Executable, RefInto};
 use runtime_io::Hashing;
-use runtime_support::{StorageValue, StorageMap};
+use runtime_support::{StorageValue, StorageMap, IsSubType};
 use {system, democracy};
 use super::{Trait, Module as Council};
-use democracy::IsCancelReferendum;
 
 decl_module! {
 	pub struct Module<T: Trait>;
@@ -173,7 +172,7 @@ impl<T: Trait> Module<T> {
 	fn end_block(now: T::BlockNumber) {
 		while let Some((proposal, proposal_hash)) = Self::take_proposal_if_expiring_at(now) {
 			let tally = Self::take_tally(&proposal_hash);
-			if let Some(ref_index) = proposal.is_cancel_referendum() {
+			if let Some(&democracy::PrivCall::cancel_referendum(ref_index)) = IsSubType::<democracy::Module<T>>::is_sub_type(&proposal) {
 				if let (_, 0, 0) = tally {
 					<democracy::Module<T>>::internal_cancel_referendum(ref_index);
 				}

substrate/runtime/democracy/src/lib.rs

@@ -33,7 +33,7 @@ extern crate substrate_runtime_system as system;
 
 use rstd::prelude::*;
 use primitives::{Zero, Executable, RefInto, As};
-use runtime_support::{StorageValue, StorageMap, Parameter, Dispatchable};
+use runtime_support::{StorageValue, StorageMap, Parameter, Dispatchable, IsSubType};
 
 mod vote_threshold;
 pub use vote_threshold::{Approved, VoteThreshold};
@@ -43,13 +43,8 @@ pub type PropIndex = u32;
 /// A referendum index.
 pub type ReferendumIndex = u32;
 
-/// Is a proposal the "cancel_referendum"?
-pub trait IsCancelReferendum {
-	fn is_cancel_referendum(&self) -> Option<ReferendumIndex>;
-}
-
-pub trait Trait: staking::Trait {
-	type Proposal: Parameter + Dispatchable + IsCancelReferendum;
+pub trait Trait: staking::Trait + Sized {
+	type Proposal: Parameter + Dispatchable + IsSubType<Module<Self>>;
 }
 
 decl_module! {
@@ -331,17 +326,9 @@ mod tests {
 
 	impl_outer_dispatch! {
 		pub enum Proposal {
-			Staking = 0,
-			Democracy = 1,
-		}
-	}
-	impl IsCancelReferendum for Proposal {
-		fn is_cancel_referendum(&self) -> Option<ReferendumIndex> {
-			if let &Proposal::Democracy(PrivCall::cancel_referendum(ref ref_index)) = self {
-				Some(*ref_index)
-			} else {
-				None
-			}
+			Session = 0,
+			Staking = 1,
+			Democracy = 2,
 		}
 	}
 
@@ -400,6 +387,7 @@ mod tests {
 	}
 
 	type System = system::Module<Test>;
+	type Session = session::Module<Test>;
 	type Staking = staking::Module<Test>;
 	type Democracy = Module<Test>;