Fixing warnings

ethcore/src/evm/interpreter.rs

@@ -17,7 +17,6 @@
 ///! Rust VM implementation
 
 use common::*;
-use trace::VMTracer;
 use super::instructions as instructions;
 use super::instructions::{Instruction, get_info};
 use std::marker::Copy;

ethcore/src/executive.rs

@@ -81,14 +81,14 @@ impl<'a> Executive<'a> {
 	}
 
 	/// Creates `Externalities` from `Executive`.
-	pub fn as_externalities<'_, T, V>(
-		&'_ mut self,
+	pub fn as_externalities<'any, T, V>(
+		&'any mut self,
 		origin_info: OriginInfo,
-		substate: &'_ mut Substate,
-		output: OutputPolicy<'_, '_>,
-		tracer: &'_ mut T,
-		vm_tracer: &'_ mut V
-	) -> Externalities<'_, T, V> where T: Tracer, V: VMTracer {
+		substate: &'any mut Substate,
+		output: OutputPolicy<'any, 'any>,
+		tracer: &'any mut T,
+		vm_tracer: &'any mut V
+	) -> Externalities<'any, T, V> where T: Tracer, V: VMTracer {
 		Externalities::new(self.state, self.info, self.engine, self.vm_factory, self.depth, origin_info, substate, output, tracer, vm_tracer)
 	}
 

ethcore/src/trace/executive_tracer.rs

@@ -117,7 +117,7 @@ impl VMTracer for ExecutiveVMTracer {
 		self.data.operations.push(VMOperation {
 			pc: pc,
 			instruction: instruction,
-			gas_cost: gas_cost.clone(),	
+			gas_cost: gas_cost.clone(),
 			executed: None,
 		});
 		true
@@ -133,10 +133,10 @@ impl VMTracer for ExecutiveVMTracer {
 		self.data.operations.last_mut().expect("trace_executed is always called after a trace_prepare_execute").executed = Some(ex);
 	}
 
-	fn prepare_subtrace(&self, code: &Bytes) -> Self {
+	fn prepare_subtrace(&self, code: &[u8]) -> Self {
 		ExecutiveVMTracer { data: VMTrace {
 			parent_step: self.data.operations.len(),
-			code: code.clone(),
+			code: code.to_vec(),
 			operations: vec![],
 			subs: vec![],
 		}}

ethcore/src/trace/mod.rs

@@ -98,7 +98,7 @@ pub trait VMTracer: Send {
 	fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem_diff: Option<(usize, &[u8])>, _store_diff: Option<(U256, U256)>) {}
 
 	/// Spawn subtracer which will be used to trace deeper levels of execution.
-	fn prepare_subtrace(&self, code: &Bytes) -> Self where Self: Sized;
+	fn prepare_subtrace(&self, code: &[u8]) -> Self where Self: Sized;
 
 	/// Spawn subtracer which will be used to trace deeper levels of execution.
 	fn done_subtrace(&mut self, sub: Self) where Self: Sized;

ethcore/src/trace/noop_tracer.rs

@@ -75,7 +75,7 @@ impl VMTracer for NoopVMTracer {
 	fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem_diff: Option<(usize, &[u8])>, _store_diff: Option<(U256, U256)>) {}
 
 	/// Spawn subtracer which will be used to trace deeper levels of execution.
-	fn prepare_subtrace(&self, _code: &Bytes) -> Self { NoopVMTracer }
+	fn prepare_subtrace(&self, _code: &[u8]) -> Self { NoopVMTracer }
 
 	/// Spawn subtracer which will be used to trace deeper levels of execution.
 	fn done_subtrace(&mut self, _sub: Self) {}

parity/hypervisor/service.rs.in

@@ -15,7 +15,6 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::sync::{RwLock,Arc};
-use std::ops::*;
 use ipc::IpcConfig;
 use std::collections::HashMap;
 use std::mem;

sync/src/chain.rs

@@ -918,7 +918,7 @@ impl ChainSync {
 		let skip: usize = try!(r.val_at(2));
 		let reverse: bool = try!(r.val_at(3));
 		let last = io.chain().chain_info().best_block_number;
-		let mut number = if try!(r.at(0)).size() == 32 {
+		let number = if try!(r.at(0)).size() == 32 {
 			// id is a hash
 			let hash: H256 = try!(r.val_at(0));
 			trace!(target: "sync", "-> GetBlockHeaders (hash: {}, max: {}, skip: {}, reverse:{})", hash, max_headers, skip, reverse);
@@ -931,11 +931,11 @@ impl ChainSync {
 			try!(r.val_at(0))
 		};
 
-		if reverse {
-			number = min(last, number);
+		let mut number = if reverse {
+			min(last, number)
 		} else {
-			number = max(0, number);
-		}
+			max(0, number)
+		};
 		let max_count = min(MAX_HEADERS_TO_SEND, max_headers);
 		let mut count = 0;
 		let mut data = Bytes::new();
@@ -1188,11 +1188,12 @@ impl ChainSync {
 		let mut sent = 0;
 		let last_parent = HeaderView::new(&io.chain().block_header(BlockID::Hash(chain_info.best_block_hash.clone())).unwrap()).parent_hash();
 		for (peer_id, peer_number) in lucky_peers {
-			let mut peer_best = self.peers.get(&peer_id).unwrap().latest_hash.clone();
-			if chain_info.best_block_number - peer_number > MAX_PEER_LAG_PROPAGATION as BlockNumber {
+			let peer_best = if chain_info.best_block_number - peer_number > MAX_PEER_LAG_PROPAGATION as BlockNumber {
 				// If we think peer is too far behind just send one latest hash
-				peer_best = last_parent.clone();
-			}
+				last_parent.clone()
+			} else {
+				self.peers.get(&peer_id).unwrap().latest_hash.clone()
+			};
 			sent += match ChainSync::create_new_hashes_rlp(io.chain(), &peer_best, &chain_info.best_block_hash) {
 				Some(rlp) => {
 					{

sync/src/lib.rs

@@ -162,6 +162,7 @@ impl NetworkProtocolHandler<SyncMessage> for EthSync {
 		self.sync.write().unwrap().maintain_sync(&mut NetSyncIo::new(io, self.chain.deref()));
 	}
 
+	#[cfg_attr(feature="dev", allow(single_match))]
 	fn message(&self, io: &NetworkContext<SyncMessage>, message: &SyncMessage) {
 		match *message {
 			SyncMessage::NewChainBlocks { ref imported, ref invalid, ref enacted, ref retracted } => {

util/src/hash.rs

@@ -501,8 +501,8 @@ macro_rules! impl_hash {
 			}
 		}
 
-		impl<'_> From<&'_ str> for $from {
-			fn from(s: &'_ str) -> $from {
+		impl<'a> From<&'a str> for $from {
+			fn from(s: &'a str) -> $from {
 				use std::str::FromStr;
 				if s.len() % 2 == 1 {
 					$from::from_str(&("0".to_owned() + &(clean_0x(s).to_owned()))[..]).unwrap_or_else(|_| $from::new())
@@ -524,8 +524,8 @@ impl From<U256> for H256 {
 	}
 }
 
-impl<'_> From<&'_ U256> for H256 {
-	fn from(value: &'_ U256) -> H256 {
+impl<'a> From<&'a U256> for H256 {
+	fn from(value: &'a U256) -> H256 {
 		unsafe {
 			let mut ret: H256 = ::std::mem::uninitialized();
 			value.to_raw_bytes(&mut ret);
@@ -540,8 +540,8 @@ impl From<H256> for U256 {
 	}
 }
 
-impl<'_> From<&'_ H256> for U256 {
-	fn from(value: &'_ H256) -> U256 {
+impl<'a> From<&'a H256> for U256 {
+	fn from(value: &'a H256) -> U256 {
 		U256::from(value.bytes())
 	}
 }
@@ -566,8 +566,8 @@ impl From<H256> for H64 {
 	}
 }
 /*
-impl<'_> From<&'_ H256> for Address {
-	fn from(value: &'_ H256) -> Address {
+impl<'a> From<&'a H256> for Address {
+	fn from(value: &'a H256) -> Address {
 		unsafe {
 			let mut ret: Address = ::std::mem::uninitialized();
 			::std::ptr::copy(value.as_ptr().offset(12), ret.as_mut_ptr(), 20);
@@ -586,8 +586,8 @@ impl From<Address> for H256 {
 	}
 }
 
-impl<'_> From<&'_ Address> for H256 {
-	fn from(value: &'_ Address) -> H256 {
+impl<'a> From<&'a Address> for H256 {
+	fn from(value: &'a Address) -> H256 {
 		unsafe {
 			let mut ret = H256::new();
 			::std::ptr::copy(value.as_ptr(), ret.as_mut_ptr().offset(12), 20);

util/src/network/discovery.rs

@@ -494,10 +494,11 @@ impl Discovery {
 	}
 
 	pub fn update_registration<Host:Handler>(&self, event_loop: &mut EventLoop<Host>) -> Result<(), NetworkError> {
-		let mut registration = EventSet::readable();
-		if !self.send_queue.is_empty() {
-			registration = registration | EventSet::writable();
-		}
+		let registration = if !self.send_queue.is_empty() {
+			EventSet::readable() | EventSet::writable()
+		} else {
+			EventSet::readable()
+		};
 		event_loop.reregister(&self.udp_socket, Token(self.token), registration, PollOpt::edge()).expect("Error reregistering UDP socket");
 		Ok(())
 	}

util/src/network/host.rs

@@ -712,28 +712,25 @@ impl<Message> Host<Message> where Message: Send + Sync + Clone {
 		let mut failure_id = None;
 		let mut deregister = false;
 		let mut expired_session = None;
-		match token {
-			FIRST_SESSION ... LAST_SESSION => {
-				let sessions = self.sessions.write().unwrap();
-				if let Some(session) = sessions.get(token).cloned() {
-					expired_session = Some(session.clone());
-					let mut s = session.lock().unwrap();
-					if !s.expired() {
-						if s.is_ready() {
-							for (p, _) in self.handlers.read().unwrap().iter() {
-								if s.have_capability(p)  {
-									self.num_sessions.fetch_sub(1, AtomicOrdering::SeqCst);
-									to_disconnect.push(p);
-								}
+		if let FIRST_SESSION ... LAST_SESSION = token {
+			let sessions = self.sessions.write().unwrap();
+			if let Some(session) = sessions.get(token).cloned() {
+				expired_session = Some(session.clone());
+				let mut s = session.lock().unwrap();
+				if !s.expired() {
+					if s.is_ready() {
+						for (p, _) in self.handlers.read().unwrap().iter() {
+							if s.have_capability(p)  {
+								self.num_sessions.fetch_sub(1, AtomicOrdering::SeqCst);
+								to_disconnect.push(p);
 							}
 						}
-						s.set_expired();
-						failure_id = s.id().cloned();
 					}
-					deregister = remote || s.done();
+					s.set_expired();
+					failure_id = s.id().cloned();
 				}
-			},
-			_ => {},
+				deregister = remote || s.done();
+			}
 		}
 		if let Some(id) = failure_id {
 			if remote {