Replace try! for ? (#1134)

* Replace try for ?

chain/src/store.rs

@@ -20,12 +20,12 @@ use lru_cache::LruCache;
 
 use util::secp::pedersen::Commitment;
 
-use types::*;
-use core::core::hash::{Hash, Hashed};
-use core::core::{Block, BlockHeader};
 use core::consensus::TargetError;
+use core::core::hash::{Hash, Hashed};
 use core::core::target::Difficulty;
+use core::core::{Block, BlockHeader};
 use grin_store::{self, option_to_not_found, to_key, Error, u64_to_key};
+use types::*;
 
 const STORE_SUBPATH: &'static str = "chain";
 
@@ -63,7 +63,7 @@ impl ChainStore for ChainKVStore {
 	}
 
 	fn head_header(&self) -> Result<BlockHeader, Error> {
-		self.get_block_header(&try!(self.head()).last_block_h)
+		self.get_block_header(&self.head()?.last_block_h)
 	}
 
 	fn save_head(&self, t: &Tip) -> Result<(), Error> {

chain/src/types.rs

@@ -228,19 +228,19 @@ impl Tip {
 /// Serialization of a tip, required to save to datastore.
 impl ser::Writeable for Tip {
 	fn write<W: ser::Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
-		try!(writer.write_u64(self.height));
-		try!(writer.write_fixed_bytes(&self.last_block_h));
-		try!(writer.write_fixed_bytes(&self.prev_block_h));
+		writer.write_u64(self.height)?;
+		writer.write_fixed_bytes(&self.last_block_h)?;
+		writer.write_fixed_bytes(&self.prev_block_h)?;
 		self.total_difficulty.write(writer)
 	}
 }
 
 impl ser::Readable for Tip {
 	fn read(reader: &mut ser::Reader) -> Result<Tip, ser::Error> {
-		let height = try!(reader.read_u64());
-		let last = try!(Hash::read(reader));
-		let prev = try!(Hash::read(reader));
-		let diff = try!(Difficulty::read(reader));
+		let height = reader.read_u64()?;
+		let last = Hash::read(reader)?;
+		let prev = Hash::read(reader)?;
+		let diff = Difficulty::read(reader)?;
 		Ok(Tip {
 			height: height,
 			last_block_h: last,

core/src/core/pmmr.rs

@@ -1330,9 +1330,9 @@ mod test {
 
 	impl Writeable for TestElem {
 		fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
-			try!(writer.write_u32(self.0[0]));
-			try!(writer.write_u32(self.0[1]));
-			try!(writer.write_u32(self.0[2]));
+			writer.write_u32(self.0[0])?;
+			writer.write_u32(self.0[1])?;
+			writer.write_u32(self.0[2])?;
 			writer.write_u32(self.0[3])
 		}
 	}

core/src/macros.rs

@@ -19,33 +19,27 @@
 /// around every map call.
 #[macro_export]
 macro_rules! map_vec {
-  ($thing:expr, $mapfn:expr ) => {
-    $thing.iter()
-      .map($mapfn)
-      .collect::<Vec<_>>();
-  }
+	($thing:expr, $mapfn:expr) => {
+		$thing.iter().map($mapfn).collect::<Vec<_>>();
+	};
 }
 
 /// Same as map_vec when the map closure returns Results. Makes sure the
 /// results are "pushed up" and wraps with a try.
 #[macro_export]
 macro_rules! try_map_vec {
-  ($thing:expr, $mapfn:expr ) => {
-    try!($thing.iter()
-      .map($mapfn)
-      .collect::<Result<Vec<_>, _>>());
-  }
+	($thing:expr, $mapfn:expr) => {
+		$thing.iter().map($mapfn).collect::<Result<Vec<_>, _>>()?;
+	};
 }
 
 /// Eliminates some of the verbosity in having iter and collect
 /// around every filter_map call.
 #[macro_export]
 macro_rules! filter_map_vec {
-  ($thing:expr, $mapfn:expr ) => {
-    $thing.iter()
-      .filter_map($mapfn)
-      .collect::<Vec<_>>();
-  }
+	($thing:expr, $mapfn:expr) => {
+		$thing.iter().filter_map($mapfn).collect::<Vec<_>>();
+	};
 }
 
 /// Allows the conversion of an expression that doesn't return anything to one
@@ -55,12 +49,10 @@ macro_rules! filter_map_vec {
 ///   println!(tee!(foo, foo.append(vec![3,4,5]))
 #[macro_export]
 macro_rules! tee {
-  ($thing:ident, $thing_expr:expr) => {
-    {
+	($thing:ident, $thing_expr:expr) => {{
 		$thing_expr;
 		$thing
-    }
-  }
+		}};
 }
 
 /// Eliminate some of the boilerplate of deserialization (package ser) by
@@ -70,8 +62,8 @@ macro_rules! tee {
 ///   let bar = try!(reader.read_u32());
 ///   let fixed_byte_var = try!(reader.read_fixed_bytes(64));
 /// Example after:
-///   let (foo, bar, fixed_byte_var) = ser_multiread!(reader, read_u64, read_u32,
-///   read_fixed_bytes(64));
+/// let (foo, bar, fixed_byte_var) = ser_multiread!(reader, read_u64,
+/// read_u32,   read_fixed_bytes(64));
 #[macro_export]
 macro_rules! ser_multiread {
   ($rdr:ident, $($read_call:ident $(($val:expr)),*),*) => {
@@ -96,7 +88,7 @@ macro_rules! ser_multiwrite {
 // don't seem to be able to define an Ord implementation for Hash due to
 // Ord being defined on all pointers, resorting to a macro instead
 macro_rules! hashable_ord {
-	($hashable: ident) => {
+	($hashable:ident) => {
 		impl Ord for $hashable {
 			fn cmp(&self, other: &$hashable) -> Ordering {
 				self.hash().cmp(&other.hash())
@@ -113,5 +105,5 @@ macro_rules! hashable_ord {
 			}
 		}
 		impl Eq for $hashable {}
-	}
+	};
 }

core/src/pow/cuckoo.rs

@@ -188,8 +188,8 @@ impl Miner {
 			if us[0] == 0 {
 				continue; // ignore duplicate edges
 			}
-			let nu = try!(self.path(u, &mut us)) as usize;
-			let nv = try!(self.path(v, &mut vs)) as usize;
+			let nu = self.path(u, &mut us)? as usize;
+			let nv = self.path(v, &mut vs)? as usize;
 
 			let sol = self.find_sol(nu, &us, nv, &vs);
 			match sol {

core/src/ser.rs

@@ -163,7 +163,7 @@ pub trait Writer {
 	/// Writes a variable number of bytes. The length is encoded as a 64-bit
 	/// prefix.
 	fn write_bytes<T: AsFixedBytes>(&mut self, bytes: &T) -> Result<(), Error> {
-		try!(self.write_u64(bytes.as_ref().len() as u64));
+		self.write_u64(bytes.as_ref().len() as u64)?;
 		self.write_fixed_bytes(bytes)
 	}
 
@@ -258,7 +258,7 @@ pub fn serialize<W: Writeable>(sink: &mut Write, thing: &W) -> Result<(), Error>
 /// Vec<u8>.
 pub fn ser_vec<W: Writeable>(thing: &W) -> Result<Vec<u8>, Error> {
 	let mut vec = Vec::new();
-	try!(serialize(&mut vec, thing));
+	serialize(&mut vec, thing)?;
 	Ok(vec)
 }
 
@@ -290,13 +290,13 @@ impl<'a> Reader for BinReader<'a> {
 	}
 	/// Read a variable size vector from the underlying Read. Expects a usize
 	fn read_vec(&mut self) -> Result<Vec<u8>, Error> {
-		let len = try!(self.read_u64());
+		let len = self.read_u64()?;
 		self.read_fixed_bytes(len as usize)
 	}
 	/// Read limited variable size vector from the underlying Read. Expects a
 	/// usize
 	fn read_limited_vec(&mut self, max: usize) -> Result<Vec<u8>, Error> {
-		let len = cmp::min(max, try!(self.read_u64()) as usize);
+		let len = cmp::min(max, self.read_u64()? as usize);
 		self.read_fixed_bytes(len as usize)
 	}
 	fn read_fixed_bytes(&mut self, length: usize) -> Result<Vec<u8>, Error> {
@@ -312,7 +312,7 @@ impl<'a> Reader for BinReader<'a> {
 	}
 
 	fn expect_u8(&mut self, val: u8) -> Result<u8, Error> {
-		let b = try!(self.read_u8());
+		let b = self.read_u8()?;
 		if b == val {
 			Ok(b)
 		} else {
@@ -326,7 +326,7 @@ impl<'a> Reader for BinReader<'a> {
 
 impl Readable for Commitment {
 	fn read(reader: &mut Reader) -> Result<Commitment, Error> {
-		let a = try!(reader.read_fixed_bytes(PEDERSEN_COMMITMENT_SIZE));
+		let a = reader.read_fixed_bytes(PEDERSEN_COMMITMENT_SIZE)?;
 		let mut c = [0; PEDERSEN_COMMITMENT_SIZE];
 		for i in 0..PEDERSEN_COMMITMENT_SIZE {
 			c[i] = a[i];
@@ -395,7 +395,7 @@ impl PMMRable for RangeProof {
 
 impl Readable for Signature {
 	fn read(reader: &mut Reader) -> Result<Signature, Error> {
-		let a = try!(reader.read_fixed_bytes(AGG_SIGNATURE_SIZE));
+		let a = reader.read_fixed_bytes(AGG_SIGNATURE_SIZE)?;
 		let mut c = [0; AGG_SIGNATURE_SIZE];
 		for i in 0..AGG_SIGNATURE_SIZE {
 			c[i] = a[i];
@@ -423,7 +423,7 @@ impl<'a> Writer for BinWriter<'a> {
 
 	fn write_fixed_bytes<T: AsFixedBytes>(&mut self, fixed: &T) -> Result<(), Error> {
 		let bs = fixed.as_ref();
-		try!(self.sink.write_all(bs));
+		self.sink.write_all(bs)?;
 		Ok(())
 	}
 }
@@ -504,30 +504,30 @@ impl<'a, A: Writeable> Writeable for &'a A {
 
 impl<A: Writeable, B: Writeable> Writeable for (A, B) {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
-		try!(Writeable::write(&self.0, writer));
+		Writeable::write(&self.0, writer)?;
 		Writeable::write(&self.1, writer)
 	}
 }
 
 impl<A: Readable, B: Readable> Readable for (A, B) {
 	fn read(reader: &mut Reader) -> Result<(A, B), Error> {
-		Ok((try!(Readable::read(reader)), try!(Readable::read(reader))))
+		Ok((Readable::read(reader)?, Readable::read(reader)?))
 	}
 }
 
 impl<A: Writeable, B: Writeable, C: Writeable> Writeable for (A, B, C) {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
-		try!(Writeable::write(&self.0, writer));
-		try!(Writeable::write(&self.1, writer));
+		Writeable::write(&self.0, writer)?;
+		Writeable::write(&self.1, writer)?;
 		Writeable::write(&self.2, writer)
 	}
 }
 
 impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable> Writeable for (A, B, C, D) {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
-		try!(Writeable::write(&self.0, writer));
-		try!(Writeable::write(&self.1, writer));
-		try!(Writeable::write(&self.2, writer));
+		Writeable::write(&self.0, writer)?;
+		Writeable::write(&self.1, writer)?;
+		Writeable::write(&self.2, writer)?;
 		Writeable::write(&self.3, writer)
 	}
 }
@@ -535,9 +535,9 @@ impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable> Writeable for (A, B
 impl<A: Readable, B: Readable, C: Readable> Readable for (A, B, C) {
 	fn read(reader: &mut Reader) -> Result<(A, B, C), Error> {
 		Ok((
-			try!(Readable::read(reader)),
-			try!(Readable::read(reader)),
-			try!(Readable::read(reader)),
+			Readable::read(reader)?,
+			Readable::read(reader)?,
+			Readable::read(reader)?,
 		))
 	}
 }
@@ -545,10 +545,10 @@ impl<A: Readable, B: Readable, C: Readable> Readable for (A, B, C) {
 impl<A: Readable, B: Readable, C: Readable, D: Readable> Readable for (A, B, C, D) {
 	fn read(reader: &mut Reader) -> Result<(A, B, C, D), Error> {
 		Ok((
-			try!(Readable::read(reader)),
-			try!(Readable::read(reader)),
-			try!(Readable::read(reader)),
-			try!(Readable::read(reader)),
+			Readable::read(reader)?,
+			Readable::read(reader)?,
+			Readable::read(reader)?,
+			Readable::read(reader)?,
 		))
 	}
 }

keychain/src/extkey.rs

@@ -12,17 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{error, fmt, num};
 use std::cmp::min;
+use std::{error, fmt, num};
 
 use serde::{de, ser};
 
-use byteorder::{BigEndian, ByteOrder};
 use blake2::blake2b::blake2b;
+use byteorder::{BigEndian, ByteOrder};
+use util;
 use util::secp;
 use util::secp::Secp256k1;
 use util::secp::key::{PublicKey, SecretKey};
-use util;
 
 // Size of an identifier in bytes
 pub const IDENTIFIER_SIZE: usize = 10;
@@ -162,8 +162,8 @@ impl AsRef<[u8]> for Identifier {
 
 impl ::std::fmt::Debug for Identifier {
 	fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-		try!(write!(f, "{}(", stringify!(Identifier)));
-		try!(write!(f, "{}", self.to_hex()));
+		write!(f, "{}(", stringify!(Identifier))?;
+		write!(f, "{}", self.to_hex())?;
 		write!(f, ")")
 	}
 }
@@ -269,10 +269,10 @@ impl ExtendedKey {
 mod test {
 	use serde_json;
 
-	use util::secp::Secp256k1;
-	use util::secp::key::SecretKey;
 	use super::{ExtendedKey, Identifier};
 	use util;
+	use util::secp::Secp256k1;
+	use util::secp::key::SecretKey;
 
 	fn from_hex(hex_str: &str) -> Vec<u8> {
 		util::from_hex(hex_str.to_string()).unwrap()

p2p/src/msg.rs

@@ -21,9 +21,9 @@ use std::thread;
 use std::time;
 
 use core::consensus::{MAX_MSG_LEN, MAX_TX_INPUTS, MAX_TX_KERNELS, MAX_TX_OUTPUTS};
+use core::core::BlockHeader;
 use core::core::hash::Hash;
 use core::core::target::Difficulty;
-use core::core::BlockHeader;
 use core::ser::{self, Readable, Reader, Writeable, Writer};
 
 use types::*;
@@ -291,8 +291,8 @@ impl Writeable for MsgHeader {
 
 impl Readable for MsgHeader {
 	fn read(reader: &mut Reader) -> Result<MsgHeader, ser::Error> {
-		try!(reader.expect_u8(MAGIC[0]));
-		try!(reader.expect_u8(MAGIC[1]));
+		reader.expect_u8(MAGIC[0])?;
+		reader.expect_u8(MAGIC[1])?;
 		let (t, len) = ser_multiread!(reader, read_u8, read_u64);
 		match Type::from_u8(t) {
 			Some(ty) => Ok(MsgHeader {
@@ -347,13 +347,13 @@ impl Writeable for Hand {
 impl Readable for Hand {
 	fn read(reader: &mut Reader) -> Result<Hand, ser::Error> {
 		let (version, capab, nonce) = ser_multiread!(reader, read_u32, read_u32, read_u64);
-		let capabilities = try!(Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData,));
-		let total_diff = try!(Difficulty::read(reader));
-		let sender_addr = try!(SockAddr::read(reader));
-		let receiver_addr = try!(SockAddr::read(reader));
-		let ua = try!(reader.read_vec());
-		let user_agent = try!(String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData));
-		let genesis = try!(Hash::read(reader));
+		let capabilities = Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData)?;
+		let total_diff = Difficulty::read(reader)?;
+		let sender_addr = SockAddr::read(reader)?;
+		let receiver_addr = SockAddr::read(reader)?;
+		let ua = reader.read_vec()?;
+		let user_agent = String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData)?;
+		let genesis = Hash::read(reader)?;
 		Ok(Hand {
 			version: version,
 			capabilities: capabilities,
@@ -400,11 +400,11 @@ impl Writeable for Shake {
 impl Readable for Shake {
 	fn read(reader: &mut Reader) -> Result<Shake, ser::Error> {
 		let (version, capab) = ser_multiread!(reader, read_u32, read_u32);
-		let capabilities = try!(Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData,));
-		let total_diff = try!(Difficulty::read(reader));
-		let ua = try!(reader.read_vec());
-		let user_agent = try!(String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData));
-		let genesis = try!(Hash::read(reader));
+		let capabilities = Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData)?;
+		let total_diff = Difficulty::read(reader)?;
+		let ua = reader.read_vec()?;
+		let user_agent = String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData)?;
+		let genesis = Hash::read(reader)?;
 		Ok(Shake {
 			version: version,
 			capabilities: capabilities,
@@ -429,8 +429,8 @@ impl Writeable for GetPeerAddrs {
 
 impl Readable for GetPeerAddrs {
 	fn read(reader: &mut Reader) -> Result<GetPeerAddrs, ser::Error> {
-		let capab = try!(reader.read_u32());
-		let capabilities = try!(Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData,));
+		let capab = reader.read_u32()?;
+		let capabilities = Capabilities::from_bits(capab).ok_or(ser::Error::CorruptedData)?;
 		Ok(GetPeerAddrs {
 			capabilities: capabilities,
 		})
@@ -446,7 +446,7 @@ pub struct PeerAddrs {
 
 impl Writeable for PeerAddrs {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
-		try!(writer.write_u32(self.peers.len() as u32));
+		writer.write_u32(self.peers.len() as u32)?;
 		for p in &self.peers {
 			p.write(writer).unwrap();
 		}
@@ -456,7 +456,7 @@ impl Writeable for PeerAddrs {
 
 impl Readable for PeerAddrs {
 	fn read(reader: &mut Reader) -> Result<PeerAddrs, ser::Error> {
-		let peer_count = try!(reader.read_u32());
+		let peer_count = reader.read_u32()?;
 		if peer_count > MAX_PEER_ADDRS {
 			return Err(ser::Error::TooLargeReadErr);
 		} else if peer_count == 0 {
@@ -490,7 +490,7 @@ impl Writeable for PeerError {
 impl Readable for PeerError {
 	fn read(reader: &mut Reader) -> Result<PeerError, ser::Error> {
 		let (code, msg) = ser_multiread!(reader, read_u32, read_vec);
-		let message = try!(String::from_utf8(msg).map_err(|_| ser::Error::CorruptedData,));
+		let message = String::from_utf8(msg).map_err(|_| ser::Error::CorruptedData)?;
 		Ok(PeerError {
 			code: code,
 			message: message,
@@ -516,11 +516,11 @@ impl Writeable for SockAddr {
 				);
 			}
 			SocketAddr::V6(sav6) => {
-				try!(writer.write_u8(1));
+				writer.write_u8(1)?;
 				for seg in &sav6.ip().segments() {
-					try!(writer.write_u16(*seg));
+					writer.write_u16(*seg)?;
 				}
-				try!(writer.write_u16(sav6.port()));
+				writer.write_u16(sav6.port())?;
 			}
 		}
 		Ok(())
@@ -529,17 +529,17 @@ impl Writeable for SockAddr {
 
 impl Readable for SockAddr {
 	fn read(reader: &mut Reader) -> Result<SockAddr, ser::Error> {
-		let v4_or_v6 = try!(reader.read_u8());
+		let v4_or_v6 = reader.read_u8()?;
 		if v4_or_v6 == 0 {
-			let ip = try!(reader.read_fixed_bytes(4));
-			let port = try!(reader.read_u16());
+			let ip = reader.read_fixed_bytes(4)?;
+			let port = reader.read_u16()?;
 			Ok(SockAddr(SocketAddr::V4(SocketAddrV4::new(
 				Ipv4Addr::new(ip[0], ip[1], ip[2], ip[3]),
 				port,
 			))))
 		} else {
 			let ip = try_map_vec!([0..8], |_| reader.read_u16());
-			let port = try!(reader.read_u16());
+			let port = reader.read_u16()?;
 			Ok(SockAddr(SocketAddr::V6(SocketAddrV6::new(
 				Ipv6Addr::new(ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7]),
 				port,

store/src/lib.rs

@@ -91,7 +91,7 @@ impl Store {
 		opts.set_compaction_style(DBCompactionStyle::Universal);
 		opts.set_max_open_files(256);
 		opts.set_use_fsync(false);
-		let db = try!(DB::open(&opts, &path));
+		let db = DB::open(&opts, &path)?;
 		Ok(Store {
 			rdb: RwLock::new(db),
 		})
@@ -135,11 +135,11 @@ impl Store {
 		key: &[u8],
 		len: usize,
 	) -> Result<Option<T>, Error> {
-		let data = try!(self.get(key));
+		let data = self.get(key)?;
 		match data {
 			Some(val) => {
 				let mut lval = if len > 0 { &val[..len] } else { &val[..] };
-				let r = try!(ser::deserialize(&mut lval).map_err(Error::SerErr));
+				let r = ser::deserialize(&mut lval).map_err(Error::SerErr)?;
 				Ok(Some(r))
 			}
 			None => Ok(None),