Merge remote-tracking branch 'origin/master' into gav-new-staking

srml/balances/src/lib.rs

@@ -30,7 +30,7 @@ use parity_codec::Codec;
 use parity_codec_derive::{Encode, Decode};
 use srml_support::{StorageValue, StorageMap, Parameter, decl_event, decl_storage, decl_module, ensure};
 use srml_support::traits::{
-	UpdateBalanceOutcome, Currency, EnsureAccountLiquid, OnFreeBalanceZero, TransferAsset, WithdrawReason
+	UpdateBalanceOutcome, Currency, EnsureAccountLiquid, OnFreeBalanceZero, TransferAsset, WithdrawReason, ArithmeticType
 };
 use srml_support::dispatch::Result;
 use primitives::traits::{

srml/democracy/src/lib.rs

@@ -24,7 +24,7 @@ use primitives::traits::{Zero, As};
 use parity_codec_derive::{Encode, Decode};
 use srml_support::{StorageValue, StorageMap, Parameter, Dispatchable, IsSubType};
 use srml_support::{decl_module, decl_storage, decl_event, ensure};
-use srml_support::traits::{Currency, OnFreeBalanceZero, EnsureAccountLiquid, WithdrawReason};
+use srml_support::traits::{Currency, OnFreeBalanceZero, EnsureAccountLiquid, WithdrawReason, ArithmeticType};
 use srml_support::dispatch::Result;
 use system::ensure_signed;
 

srml/fees/src/lib.rs

@@ -20,11 +20,11 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use srml_support::{
-	dispatch::Result, Parameter, StorageMap, decl_event, decl_storage, decl_module,
-	traits::{ChargeBytesFee, ChargeFee, TransferAsset, WithdrawReason}
+	dispatch::Result, StorageMap, decl_event, decl_storage, decl_module,
+	traits::{ArithmeticType, ChargeBytesFee, ChargeFee, TransferAsset, WithdrawReason}
 };
 use runtime_primitives::traits::{
-	As, Member, SimpleArithmetic, CheckedAdd, CheckedSub, CheckedMul, Zero
+	As, SimpleArithmetic, CheckedAdd, CheckedSub, CheckedMul, Zero
 };
 use system;
 

srml/staking/src/lib.rs

@@ -26,7 +26,7 @@ use parity_codec_derive::{Encode, Decode};
 use srml_support::{Parameter, StorageValue, StorageMap, EnumerableStorageMap, dispatch::Result};
 use srml_support::{decl_module, decl_event, decl_storage, ensure};
 use srml_support::traits::{
-	Currency, OnDilution, EnsureAccountLiquid, OnFreeBalanceZero, WithdrawReason
+	Currency, OnDilution, EnsureAccountLiquid, OnFreeBalanceZero, WithdrawReason, ArithmeticType
 };
 use session::OnSessionChange;
 use primitives::Perbill;
@@ -146,7 +146,7 @@ pub struct Exposure<AccountId, Balance: HasCompact> {
 	pub others: Vec<IndividualExposure<AccountId, Balance>>,
 }
 
-type BalanceOf<T> = <<T as Trait>::Currency as Currency<<T as system::Trait>::AccountId>>::Balance;
+type BalanceOf<T> = <<T as Trait>::Currency as ArithmeticType>::Type;
 
 pub trait Trait: system::Trait + session::Trait {
 	/// The staking balance.

srml/staking/src/mock.rs

@@ -78,32 +78,6 @@ pub struct ExtBuilder {
 	sessions_per_era: u64,
 	current_era: u64,
 	monied: bool,
-<<<<<<< HEAD
-	reward: u64
-) -> runtime_io::TestExternalities<Blake2Hasher> {
-	let mut t = system::GenesisConfig::<Test>::default().build_storage().unwrap().0;
-	let balance_factor = if ext_deposit > 0 {
-		256
-	} else {
-		1
-	};
-	t.extend(consensus::GenesisConfig::<Test>{
-		code: vec![],
-		authorities: vec![],
-	}.build_storage().unwrap().0);
-	t.extend(session::GenesisConfig::<Test>{
-		session_length,
-		validators: vec![10, 20],
-		keys: vec![],
-	}.build_storage().unwrap().0);
-	t.extend(balances::GenesisConfig::<Test>{
-		balances: if monied {
-			if reward > 0 {
-				vec![(1, 10 * balance_factor), (2, 20 * balance_factor), (3, 30 * balance_factor), (4, 40 * balance_factor), (10, balance_factor), (11, balance_factor * 10), (20, balance_factor), (21, balance_factor * 20)]
-			} else {
-				vec![(1, 10 * balance_factor), (2, 20 * balance_factor), (3, 30 * balance_factor), (4, 40 * balance_factor)]
-			}
-=======
 	reward: u64,
 }
 
@@ -149,7 +123,6 @@ impl ExtBuilder {
 		let mut t = system::GenesisConfig::<Test>::default().build_storage().unwrap().0;
 		let balance_factor = if self.existential_deposit > 0 {
 			256
->>>>>>> 7042842877876b54716c34d834f6670fa60135e4
 		} else {
 			1
 		};

srml/support/procedural/src/storage/impls.rs

@@ -193,10 +193,10 @@ impl<'a> Impls<'a> {
 		let head_key = format!("head of {}", prefix);
 		let prefix = format!("{}", prefix);
 		let name_lowercase = name.to_string().to_lowercase();
-		let key_for = syn::Ident::new(&format!("__decl_storage_key_for_{}", name_lowercase), name.span());
-		let linkage = syn::Ident::new(&format!("__DeclStorageLinkage{}", name), name.span());
-		let enumerator = syn::Ident::new(&format!("__DeclStorageEnumerator{}", name), name.span());
+		let inner_module = syn::Ident::new(&format!("__linked_map_details_for_{}_do_not_use", name_lowercase), name.span());
+		let linkage = syn::Ident::new(&format!("__LinkageFor{}DoNotUse", name), name.span());
 		let phantom_data = quote! { #scrate::storage::generator::PhantomData };
+		let as_map = quote!{ <Self as #scrate::storage::generator::StorageMap<#kty, #typ>> };
 		let put_or_insert = quote! {
 			match linkage {
 				Some(linkage) => storage.put(key_for, &(val, linkage)),
@@ -216,65 +216,103 @@ impl<'a> Impls<'a> {
 
 		// generator for linked map
 		let helpers = quote! {
-			#[derive(parity_codec_derive::Encode, parity_codec_derive::Decode)]
-			struct #linkage<Key> {
+			/// Linkage data of an element (it's successor and predecessor)
+			#[derive(#scrate::parity_codec_derive::Encode, #scrate::parity_codec_derive::Decode)]
+			pub(crate) struct #linkage<Key> {
 				/// Previous element key in storage (None for the first element)
-				previous: Option<Key>,
+				pub previous: Option<Key>,
 				/// Next element key in storage (None for the last element)
-				next: Option<Key>,
+				pub next: Option<Key>,
 			}
 
-			impl<Key> Default for #linkage<Key> {
-				fn default() -> Self {
-					Self {
-						previous: None,
-						next: None,
+			mod #inner_module {
+				use super::*;
+
+				/// Re-exported version of linkage to overcome proc-macro derivation issue.
+				pub(crate) use super::#linkage as Linkage;
+
+				impl<Key> Default for Linkage<Key> {
+					fn default() -> Self {
+						Self {
+							previous: None,
+							next: None,
+						}
 					}
 				}
-
-			struct #enumerator<'a, S, K, V> {
-				storage: &'a S,
-				next: Option<K>,
-				_data: #phantom_data<V>,
 			}
 
-			impl<'a, S: #scrate::GenericStorage, K, V> Iterator for #enumerator<'a, S, K, V> where
-				K: 'a + #scrate::codec::Codec,
-				V: 'a + #scrate::codec::Decode,
-			{
-				type Item = (K, V);
-
-				fn next(&mut self) -> Option<Self::Item> {
-					let next = self.next.take()?;
-					let key_for = #key_for(&next);
-					let (val, linkage): (V, #linkage<K>) = self.storage.get(&*key_for)
-						.expect("previous/next only contain existing entires; we enumerate using next; entry exists; qed");
-					self.next = linkage.next;
-					Some((next, val))
+				/// A key-value pair iterator for enumerable map.
+				pub(crate) struct Enumerator<'a, S, K, V> {
+					pub storage: &'a S,
+					pub next: Option<K>,
+					pub _data: #phantom_data<V>,
 				}
 			}
 
-			fn #key_for<Key: #scrate::codec::Encode>(key: &Key) -> #scrate::rstd::vec::Vec<u8> {
-				let mut key_for = #prefix.as_bytes().to_vec();
-				#scrate::codec::Encode::encode_to(&key, &mut key_for);
-				key_for
+				impl<'a, S: #scrate::GenericStorage, K, V> Iterator for Enumerator<'a, S, K, V> where
+					K: 'a + #scrate::codec::Codec,
+					V: 'a + #scrate::codec::Decode,
+				{
+					type Item = (K, V);
+
+					fn next(&mut self) -> Option<Self::Item> {
+						let next = self.next.take()?;
+						let key_for = key_for(&next);
+						let (val, linkage): (V, Linkage<K>) = self.storage.get(&*key_for)
+							.expect("previous/next only contain existing entires; we enumerate using next; entry exists; qed");
+						self.next = linkage.next;
+						Some((next, val))
+					}
+				}
+
+				/// Generate a storage key for given item.
+				pub(crate) fn key_for<Key: #scrate::codec::Encode>(key: &Key) -> #scrate::rstd::vec::Vec<u8> {
+					let mut key_for = #prefix.as_bytes().to_vec();
+					#scrate::codec::Encode::encode_to(&key, &mut key_for);
+					key_for
+				}
+
+				pub(crate) trait Utils<#traitinstance: #traittype> {
+					/// Update linkage when this element is removed.
+					///
+					/// Takes care of updating previous and next elements points
+					/// as well as updates head if the element is first or last.
+					fn remove_linkage<S: #scrate::GenericStorage>(linkage: Linkage<#kty>, storage: &S);
+
+					/// Read the contained data and it's linkage.
+					fn read_with_linkage<S: #scrate::GenericStorage>(storage: &S, key: &[u8]) -> Option<(#value_type, Linkage<#kty>)>;
+
+					/// Generate linkage for newly inserted element.
+					///
+					/// Takes care of updating head and previous head's pointer.
+					fn new_head_linkage<S: #scrate::GenericStorage>(
+						storage: &S,
+						key: &#kty,
+					) -> Linkage<#kty>;
+
+					/// Read current head pointer.
+					fn read_head<S: #scrate::GenericStorage>(storage: &S) -> Option<#kty>;
+
+					/// Overwrite current head pointer.
+					///
+					/// If `None` is given head is removed from storage.
+					fn write_head<S: #scrate::GenericStorage>(storage: &S, head: Option<&#kty>);
+				}
 			}
 		};
 
 		let structure = quote! {
 			#visibility struct #name<#traitinstance: #traittype>(#phantom_data<#traitinstance>);
 
-			impl<#traitinstance: #traittype> #name<#traitinstance> {
-				/// Update linkage when this element is removed.
-				///
-				/// Takes care of updating previous and next elements points
-				/// as well as updates head if the element is first or last.
+			impl<#traitinstance: #traittype> self::#inner_module::Utils<#traitinstance> for #name<#traitinstance> {
 				fn remove_linkage<S: #scrate::GenericStorage>(
-					linkage: #linkage<#kty>,
+					linkage: self::#inner_module::Linkage<#kty>,
 					storage: &S,
 				) {
-					let next_key = linkage.next.as_ref().map(|x| #key_for(x));
-					let prev_key = linkage.previous.as_ref().map(|x| #key_for(x));
+					use self::#inner_module::{key_for, Utils};
+
+					let next_key = linkage.next.as_ref().map(|x| key_for(x));
+					let prev_key = linkage.previous.as_ref().map(|x| key_for(x));
 
 					if let Some(prev_key) = prev_key {
 						// Retrieve previous element and update `next`
@@ -296,52 +334,49 @@ impl<'a> Impls<'a> {
 					}
 				}
 
-				/// Read the contained data and it's linkage.
-				fn read_with_linkage<S: #scrate::GenericStorage>(storage: &S, key: &[u8]) -> Option<(#value_type, #linkage<#kty>)> {
+				fn read_with_linkage<S: #scrate::GenericStorage>(
+					storage: &S,
+					key: &[u8],
+				) -> Option<(#value_type, self::#inner_module::Linkage<#kty>)> {
 					storage.get(key)
 				}
 
-				/// Generate linkage for newly inserted element.
-				///
-				/// Takes care of updating head and previous head's pointer.
 				fn new_head_linkage<S: #scrate::GenericStorage>(
 					storage: &S,
 					key: &#kty,
-				) -> #linkage<#kty> {
+				) -> self::#inner_module::Linkage<#kty> {
+					use self::#inner_module::{key_for, Utils};
+
 					if let Some(head) = Self::read_head(storage) {
 						// update previous head predecessor
 						{
-							let head_key = #key_for(&head);
+							let head_key = key_for(&head);
 							let (data, linkage) = Self::read_with_linkage(storage, &*head_key).expect(r#"
 								head is set when first element is inserted and unset when last element is removed;
 								if head is Some then it points to existing key; qed
 							"#);
-							storage.put(&*head_key, &(data, #linkage {
+							storage.put(&*head_key, &(data, self::#inner_module::Linkage {
 								next: linkage.next.as_ref(),
 								previous: Some(key),
 							}));
 						}
 						// update to current head
 						Self::write_head(storage, Some(key));
 						// return linkage with pointer to previous head
-						let mut linkage = #linkage::default();
+						let mut linkage = self::#inner_module::Linkage::default();
 						linkage.next = Some(head);
 						linkage
 					} else {
 						// we are first - update the head and produce empty linkage
 						Self::write_head(storage, Some(key));
-						#linkage::default()
+						self::#inner_module::Linkage::default()
 					}
 				}
 
-				/// Read current head pointer.
 				fn read_head<S: #scrate::GenericStorage>(storage: &S) -> Option<#kty> {
 					storage.get(#head_key.as_bytes())
 				}
 
-				/// Overwrite current head pointer.
-				///
-				/// If `None` is given head is removed from storage.
 				fn write_head<S: #scrate::GenericStorage>(storage: &S, head: Option<&#kty>) {
 					match head {
 						Some(head) => storage.put(#head_key.as_bytes(), head),
@@ -376,7 +411,9 @@ impl<'a> Impls<'a> {
 
 				/// Take the value, reading and removing it.
 				fn take<S: #scrate::GenericStorage>(key: &#kty, storage: &S) -> Self::Query {
-					let res: Option<(#value_type, #linkage<#kty>)> = storage.take(&*#key_for(key));
+					use self::#inner_module::{Utils, key_for};
+
+					let res: Option<(#value_type, self::#inner_module::Linkage<#kty>)> = storage.take(&*key_for(key));
 					match res {
 						Some((data, linkage)) => {
 							Self::remove_linkage(linkage, storage);
@@ -393,7 +430,9 @@ impl<'a> Impls<'a> {
 
 				/// Store a value to be associated with the given key from the map.
 				fn insert<S: #scrate::GenericStorage>(key: &#kty, val: &#typ, storage: &S) {
-					let key_for = &*#key_for(key);
+					use self::#inner_module::{Utils, key_for};
+
+					let key_for = &*key_for(key);
 					let linkage = match Self::read_with_linkage(storage, key_for) {
 						// overwrite but reuse existing linkage
 						Some((_data, linkage)) => linkage,
@@ -405,7 +444,9 @@ impl<'a> Impls<'a> {
 
 				/// Mutate the value under a key
 				fn mutate<R, F: FnOnce(&mut Self::Query) -> R, S: #scrate::GenericStorage>(key: &#kty, f: F, storage: &S) -> R {
-					let key_for = &*#key_for(key);
+					use self::#inner_module::{Utils, key_for};
+
+					let key_for = &*key_for(key);
 					let (mut val, linkage) = Self::read_with_linkage(storage, key_for)
 						.map(|(data, linkage)| (data, Some(linkage)))
 						.unwrap_or_else(|| (#fielddefault, None));
@@ -418,14 +459,18 @@ impl<'a> Impls<'a> {
 
 			impl<#traitinstance: #traittype> #scrate::storage::generator::EnumerableStorageMap<#kty, #typ> for #name<#traitinstance> {
 				fn head<S: #scrate::GenericStorage>(storage: &S) -> Option<#kty> {
+					use self::#inner_module::Utils;
+
 					Self::read_head(storage)
 				}
 
 				fn enumerate<'a, S: #scrate::GenericStorage>(storage: &'a S) -> #scrate::storage::generator::Box<dyn Iterator<Item = (#kty, #typ)> + 'a> where
 					#kty: 'a,
 					#typ: 'a,
 				{
-					#scrate::storage::generator::Box::new(#enumerator {
+					use self::#inner_module::{Utils, Enumerator};
+
+					#scrate::storage::generator::Box::new(Enumerator {
 						next: Self::read_head(storage),
 						storage,
 						_data: #phantom_data::<#typ>::default(),