From 92f6686b490d6bea0a5e6c6cdcab62ea2c168c40 Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Tue, 27 Dec 2016 12:53:56 +0100 Subject: [PATCH] Port `try` macro to new `?` operator. (#3962) * initial untry sweep * restore try in ipc codegen, fix inference * change a few missed try instances --- src/untrusted_rlp.rs | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/src/untrusted_rlp.rs b/src/untrusted_rlp.rs index 5bb9690..1fb94a1 100644 --- a/src/untrusted_rlp.rs +++ b/src/untrusted_rlp.rs @@ -64,7 +64,7 @@ fn calculate_payload_info(header_bytes: &[u8], len_of_len: usize) -> Result (), } if header_bytes.len() < header_len { return Err(DecoderError::RlpIsTooShort); } - let value_len = try!(usize::from_bytes(&header_bytes[1..header_len])); + let value_len = usize::from_bytes(&header_bytes[1..header_len])?; Ok(PayloadInfo::new(header_len, value_len)) } @@ -129,11 +129,11 @@ impl<'a> fmt::Display for UntrustedRlp<'a> { Ok(Prototype::Null) => write!(f, "null"), Ok(Prototype::Data(_)) => write!(f, "\"0x{}\"", self.data().unwrap().to_hex()), Ok(Prototype::List(len)) => { - try!(write!(f, "[")); + write!(f, "[")?; for i in 0..len-1 { - try!(write!(f, "{}, ", self.at(i).unwrap())); + write!(f, "{}, ", self.at(i).unwrap())?; } - try!(write!(f, "{}", self.at(len - 1).unwrap())); + write!(f, "{}", self.at(len - 1).unwrap())?; write!(f, "]") }, Err(err) => write!(f, "{:?}", err) @@ -177,7 +177,7 @@ impl<'a, 'view> View<'a, 'view> for UntrustedRlp<'a> where 'a: 'view { } fn data(&'view self) -> Self::Data { - let pi = try!(BasicDecoder::payload_info(self.bytes)); + let pi = BasicDecoder::payload_info(self.bytes)?; Ok(&self.bytes[pi.header_len..(pi.header_len + pi.value_len)]) } @@ -212,18 +212,18 @@ impl<'a, 'view> View<'a, 'view> for UntrustedRlp<'a> where 'a: 'view { // current search index, otherwise move to beginning of list let c = self.offset_cache.get(); let (mut bytes, to_skip) = match c.index <= index { - true => (try!(UntrustedRlp::consume(self.bytes, c.offset)), index - c.index), - false => (try!(self.consume_list_prefix()), index), + true => (UntrustedRlp::consume(self.bytes, c.offset)?, index - c.index), + false => (self.consume_list_prefix()?, index), }; // skip up to x items - bytes = try!(UntrustedRlp::consume_items(bytes, to_skip)); + bytes = UntrustedRlp::consume_items(bytes, to_skip)?; // update the cache self.offset_cache.set(OffsetCache::new(index, self.bytes.len() - bytes.len())); // construct new rlp - let found = try!(BasicDecoder::payload_info(bytes)); + let found = BasicDecoder::payload_info(bytes)?; Ok(UntrustedRlp::new(&bytes[0..found.header_len + found.value_len])) } @@ -266,15 +266,15 @@ impl<'a, 'view> View<'a, 'view> for UntrustedRlp<'a> where 'a: 'view { } fn val_at(&self, index: usize) -> Result where T: RlpDecodable { - try!(self.at(index)).as_val() + self.at(index)?.as_val() } } impl<'a> UntrustedRlp<'a> { /// consumes first found prefix fn consume_list_prefix(&self) -> Result<&'a [u8], DecoderError> { - let item = try!(BasicDecoder::payload_info(self.bytes)); - let bytes = try!(UntrustedRlp::consume(self.bytes, item.header_len)); + let item = BasicDecoder::payload_info(self.bytes)?; + let bytes = UntrustedRlp::consume(self.bytes, item.header_len)?; Ok(bytes) } @@ -282,8 +282,8 @@ impl<'a> UntrustedRlp<'a> { fn consume_items(bytes: &'a [u8], items: usize) -> Result<&'a [u8], DecoderError> { let mut result = bytes; for _ in 0..items { - let i = try!(BasicDecoder::payload_info(result)); - result = try!(UntrustedRlp::consume(result, (i.header_len + i.value_len))); + let i = BasicDecoder::payload_info(result)?; + result = UntrustedRlp::consume(result, (i.header_len + i.value_len))?; } Ok(result) } @@ -340,7 +340,7 @@ impl<'a> BasicDecoder<'a> { /// Return first item info. fn payload_info(bytes: &[u8]) -> Result { - let item = try!(PayloadInfo::from(bytes)); + let item = PayloadInfo::from(bytes)?; match item.header_len.checked_add(item.value_len) { Some(x) if x <= bytes.len() => Ok(item), _ => Err(DecoderError::RlpIsTooShort), @@ -358,7 +358,7 @@ impl<'a> Decoder for BasicDecoder<'a> { // RLP is too short. None => Err(DecoderError::RlpIsTooShort), // Single byte value. - Some(l @ 0...0x7f) => Ok(try!(f(&[l]))), + Some(l @ 0...0x7f) => Ok(f(&[l])?), // 0-55 bytes Some(l @ 0x80...0xb7) => { let last_index_of = 1 + l as usize - 0x80; @@ -369,7 +369,7 @@ impl<'a> Decoder for BasicDecoder<'a> { if l == 0x81 && d[0] < 0x80 { return Err(DecoderError::RlpInvalidIndirection); } - Ok(try!(f(d))) + Ok(f(d)?) }, // Longer than 55 bytes. Some(l @ 0xb8...0xbf) => { @@ -378,13 +378,13 @@ impl<'a> Decoder for BasicDecoder<'a> { if bytes.len() < begin_of_value { return Err(DecoderError::RlpInconsistentLengthAndData); } - let len = try!(usize::from_bytes(&bytes[1..begin_of_value])); + let len = usize::from_bytes(&bytes[1..begin_of_value])?; let last_index_of_value = begin_of_value + len; if bytes.len() < last_index_of_value { return Err(DecoderError::RlpInconsistentLengthAndData); } - Ok(try!(f(&bytes[begin_of_value..last_index_of_value]))) + Ok(f(&bytes[begin_of_value..last_index_of_value])?) } // We are reading value, not a list! _ => Err(DecoderError::RlpExpectedToBeData) @@ -402,7 +402,7 @@ impl<'a> Decoder for BasicDecoder<'a> { impl Decodable for T where T: FromBytes { fn decode(decoder: &D) -> Result where D: Decoder { - decoder.read_value(&|bytes: &[u8]| Ok(try!(T::from_bytes(bytes)))) + decoder.read_value(&|bytes: &[u8]| Ok(T::from_bytes(bytes)?)) } } @@ -436,7 +436,7 @@ macro_rules! impl_array_decodable { } for i in 0..decoders.item_count() { - result[i] = try!(T::decode(&BasicDecoder::new(try!(decoders.at(i))))); + result[i] = T::decode(&BasicDecoder::new(decoders.at(i)?))?; } Ok(result) @@ -484,7 +484,7 @@ impl FromBytes for DecodableU8 { impl RlpDecodable for u8 { fn decode(decoder: &D) -> Result where D: Decoder { - let u: DecodableU8 = try!(Decodable::decode(decoder)); + let u: DecodableU8 = Decodable::decode(decoder)?; Ok(u.0) } }