Merge branch 'master' into jsonrpc2

ethcore/src/block.rs

@@ -267,7 +267,7 @@ impl<'x, 'y> OpenBlock<'x, 'y> {
 		s.block.base.header.uncles_hash = uncle_bytes.sha3();
 		s.block.base.header.state_root = s.block.state.root().clone();
 		s.block.base.header.receipts_root = ordered_trie_root(s.block.receipts.iter().map(|ref r| r.rlp_bytes().to_vec()).collect());
-		s.block.base.header.log_bloom = s.block.receipts.iter().fold(LogBloom::zero(), |mut b, r| {b |= &r.log_bloom; b});
+		s.block.base.header.log_bloom = s.block.receipts.iter().fold(LogBloom::zero(), |mut b, r| {b = &b | &r.log_bloom; b}); //TODO: use |= operator
 		s.block.base.header.gas_used = s.block.receipts.last().map_or(U256::zero(), |r| r.gas_used);
 		s.block.base.header.note_dirty();
 

ethcore/src/client.rs

@@ -170,7 +170,7 @@ impl ClientReport {
 	pub fn accrue_block(&mut self, block: &PreVerifiedBlock) {
 		self.blocks_imported += 1;
 		self.transactions_applied += block.transactions.len();
-		self.gas_processed += block.header.gas_used;
+		self.gas_processed = self.gas_processed + block.header.gas_used;
 	}
 }
 

ethcore/src/evm/interpreter.rs

@@ -299,7 +299,7 @@ impl evm::Evm for Interpreter {
 			let (gas_cost, mem_size) = try!(self.get_gas_cost_mem(ext, instruction, &mut mem, &stack));
 			try!(self.verify_gas(&current_gas, &gas_cost));
 			mem.expand(mem_size);
-			current_gas -= gas_cost;
+			current_gas = current_gas - gas_cost; //TODO: use operator -=
 
 			evm_debug!({
 				println!("[0x{:x}][{}(0x{:x}) Gas: {:x}\n  Gas Before: {:x}",
@@ -320,7 +320,7 @@ impl evm::Evm for Interpreter {
 			match result {
 				InstructionResult::Ok => {},
 				InstructionResult::UnusedGas(gas) => {
-					current_gas += gas;
+					current_gas = current_gas + gas; //TODO: use operator +=
 				},
 				InstructionResult::UseAllGas => {
 					current_gas = U256::zero();

ethcore/src/lib.rs

@@ -15,11 +15,8 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 #![warn(missing_docs)]
-#![feature(cell_extras)]
-#![feature(augmented_assignments)]
-#![feature(plugin)]
-// Clippy
-#![plugin(clippy)]
+#![cfg_attr(feature="dev", feature(plugin))]
+#![cfg_attr(feature="dev", plugin(clippy))]
 // TODO [todr] not really sure
 #![allow(needless_range_loop)]
 // Shorter than if-else
@@ -27,7 +24,6 @@
 // Keeps consistency (all lines with `.clone()`) and helpful when changing ref to non-ref.
 #![allow(clone_on_copy)]
 
-
 //! Ethcore library
 //!
 //! ### Rust version:

ethcore/src/receipt.rs

@@ -39,7 +39,7 @@ impl Receipt {
 		Receipt {
 			state_root: state_root,
 			gas_used: gas_used,
-			log_bloom: logs.iter().fold(LogBloom::new(), |mut b, l| { b |= &l.bloom(); b }),
+			log_bloom: logs.iter().fold(LogBloom::new(), |mut b, l| { b = &b | &l.bloom(); b }), //TODO: use |= operator
 			logs: logs,
 		}
 	}

ethcore/src/service.rs

@@ -124,6 +124,8 @@ impl IoHandler<NetSyncMessage> for ClientIoHandler {
 	}
 }
 
+// TODO: rewrite into something that doesn't dependent on the testing environment having a particular port ready for use.
+/*
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -138,3 +140,4 @@ mod tests {
 		assert!(service.is_ok());
 	}
 }
+*/

ethcore/src/state.rs

@@ -282,7 +282,7 @@ impl State {
 
 	/// Pull account `a` in our cache from the trie DB and return it.
 	/// `require_code` requires that the code be cached, too.
-	fn get(&self, a: &Address, require_code: bool) -> Ref<Option<Account>> {
+	fn get<'a>(&'a self, a: &Address, require_code: bool) -> &'a Option<Account> {
 		let have_key = self.cache.borrow().contains_key(a);
 		if !have_key {
 			self.insert_cache(a, SecTrieDB::new(&self.db, &self.root).get(&a).map(Account::from_rlp))
@@ -292,17 +292,17 @@ impl State {
 				account.cache_code(&AccountDB::new(&self.db, a));
 			}
 		}
-		Ref::map(self.cache.borrow(), |m| m.get(a).unwrap())
+		unsafe { ::std::mem::transmute(self.cache.borrow().get(a).unwrap()) }
 	}
 
 	/// Pull account `a` in our cache from the trie DB. `require_code` requires that the code be cached, too.
-	fn require(&self, a: &Address, require_code: bool) -> RefMut<Account> {
+	fn require<'a>(&'a self, a: &Address, require_code: bool) -> &'a mut Account {
 		self.require_or_from(a, require_code, || Account::new_basic(U256::from(0u8), self.account_start_nonce), |_|{})
 	}
 
 	/// Pull account `a` in our cache from the trie DB. `require_code` requires that the code be cached, too.
 	/// If it doesn't exist, make account equal the evaluation of `default`.
-	fn require_or_from<F: FnOnce() -> Account, G: FnOnce(&mut Account)>(&self, a: &Address, require_code: bool, default: F, not_default: G) -> RefMut<Account> {
+	fn require_or_from<'a, F: FnOnce() -> Account, G: FnOnce(&mut Account)>(&self, a: &Address, require_code: bool, default: F, not_default: G) -> &'a mut Account {
 		let have_key = self.cache.borrow().contains_key(a);
 		if !have_key {
 			self.insert_cache(a, SecTrieDB::new(&self.db, &self.root).get(&a).map(Account::from_rlp))
@@ -316,13 +316,12 @@ impl State {
 			not_default(self.cache.borrow_mut().get_mut(a).unwrap().as_mut().unwrap());
 		}
 
-		let b = self.cache.borrow_mut();
-		RefMut::map(b, |m| m.get_mut(a).unwrap().as_mut().map(|account| {
+		unsafe { ::std::mem::transmute(self.cache.borrow_mut().get_mut(a).unwrap().as_mut().map(|account| {
 			if require_code {
 				account.cache_code(&AccountDB::new(&self.db, a));
 			}
 			account
-		}).unwrap())
+		}).unwrap()) }
 	}
 }