From 9b2d4ad9ffbd5d886b95b9f05bf31c0fdd322205 Mon Sep 17 00:00:00 2001 From: Kent Fredric Date: Tue, 26 Nov 2019 05:00:18 +1300 Subject: [PATCH 1/5] Stop using deprecated inclusive elipsis --- src/hex.rs | 6 +++--- src/json.rs | 26 +++++++++++++------------- src/lib.rs | 1 + 3 files changed, 17 insertions(+), 16 deletions(-) diff --git a/src/hex.rs b/src/hex.rs index 3c7df19..a26b8a3 100644 --- a/src/hex.rs +++ b/src/hex.rs @@ -134,9 +134,9 @@ impl FromHex for str { buf <<= 4; match byte { - b'A'...b'F' => buf |= byte - b'A' + 10, - b'a'...b'f' => buf |= byte - b'a' + 10, - b'0'...b'9' => buf |= byte - b'0', + b'A'..=b'F' => buf |= byte - b'A' + 10, + b'a'..=b'f' => buf |= byte - b'a' + 10, + b'0'..=b'9' => buf |= byte - b'0', b' '|b'\r'|b'\n'|b'\t' => { buf >>= 4; continue diff --git a/src/json.rs b/src/json.rs index e478fe8..3b02e33 100644 --- a/src/json.rs +++ b/src/json.rs @@ -1540,14 +1540,14 @@ impl> Parser { // A leading '0' must be the only digit before the decimal point. match self.ch_or_null() { - '0' ... '9' => return self.error(InvalidNumber), + '0' ..= '9' => return self.error(InvalidNumber), _ => () } }, - '1' ... '9' => { + '1' ..= '9' => { while !self.eof() { match self.ch_or_null() { - c @ '0' ... '9' => { + c @ '0' ..= '9' => { macro_rules! try_or_invalid { ($e: expr) => { match $e { @@ -1576,7 +1576,7 @@ impl> Parser { // Make sure a digit follows the decimal place. match self.ch_or_null() { - '0' ... '9' => (), + '0' ..= '9' => (), _ => return self.error(InvalidNumber) } @@ -1584,7 +1584,7 @@ impl> Parser { let mut frac = 0.0; while !self.eof() { match self.ch_or_null() { - c @ '0' ... '9' => { + c @ '0' ..= '9' => { dec /= 10.0; frac += (((c as isize) - ('0' as isize)) as f64) * dec; self.bump(); @@ -1613,12 +1613,12 @@ impl> Parser { // Make sure a digit follows the exponent place. match self.ch_or_null() { - '0' ... '9' => (), + '0' ..= '9' => (), _ => return self.error(InvalidNumber) } while !self.eof() { match self.ch_or_null() { - c @ '0' ... '9' => { + c @ '0' ..= '9' => { exp *= 10; exp += (c as usize) - ('0' as usize); @@ -1644,9 +1644,9 @@ impl> Parser { while i < 4 { self.bump(); n = match self.ch_or_null() { - c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)), - c @ 'a' ... 'f' => n * 16 + (10 + (c as u16) - ('a' as u16)), - c @ 'A' ... 'F' => n * 16 + (10 + (c as u16) - ('A' as u16)), + c @ '0' ..= '9' => n * 16 + ((c as u16) - ('0' as u16)), + c @ 'a' ..= 'f' => n * 16 + (10 + (c as u16) - ('a' as u16)), + c @ 'A' ..= 'F' => n * 16 + (10 + (c as u16) - ('A' as u16)), _ => return self.error(InvalidEscape) }; @@ -1677,13 +1677,13 @@ impl> Parser { 'r' => res.push('\r'), 't' => res.push('\t'), 'u' => match try!(self.decode_hex_escape()) { - 0xDC00 ... 0xDFFF => { + 0xDC00 ..= 0xDFFF => { return self.error(LoneLeadingSurrogateInHexEscape) } // Non-BMP characters are encoded as a sequence of // two hex escapes, representing UTF-16 surrogates. - n1 @ 0xD800 ... 0xDBFF => { + n1 @ 0xD800 ..= 0xDBFF => { match (self.next_char(), self.next_char()) { (Some('\\'), Some('u')) => (), _ => return self.error(UnexpectedEndOfHexEscape), @@ -1913,7 +1913,7 @@ impl> Parser { 'n' => { self.parse_ident("ull", NullValue) } 't' => { self.parse_ident("rue", BooleanValue(true)) } 'f' => { self.parse_ident("alse", BooleanValue(false)) } - '0' ... '9' | '-' => self.parse_number(), + '0' ..= '9' | '-' => self.parse_number(), '"' => match self.parse_str() { Ok(s) => StringValue(s), Err(e) => Error(e), diff --git a/src/lib.rs b/src/lib.rs index 8b0fb22..5110f05 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -41,6 +41,7 @@ html_favicon_url = "https://www.rust-lang.org/favicon.ico", html_root_url = "https://doc.rust-lang.org/rustc-serialize/")] #![cfg_attr(test, deny(warnings))] +#![deny(ellipsis_inclusive_range_patterns)] #![allow(trivial_numeric_casts)] #![cfg_attr(rust_build, feature(staged_api))] #![cfg_attr(rust_build, staged_api)] From a9e3ace04bf4de8a83e2a33e28ad4ef585cf5c8d Mon Sep 17 00:00:00 2001 From: Kent Fredric Date: Tue, 26 Nov 2019 05:28:02 +1300 Subject: [PATCH 2/5] Replace use of deprecated "try!()" with "?" operator. --- src/collection_impls.rs | 32 ++++---- src/json.rs | 164 ++++++++++++++++++++-------------------- src/serialize.rs | 50 ++++++------ 3 files changed, 123 insertions(+), 123 deletions(-) diff --git a/src/collection_impls.rs b/src/collection_impls.rs index f8074c9..cbc6e23 100644 --- a/src/collection_impls.rs +++ b/src/collection_impls.rs @@ -21,7 +21,7 @@ impl< fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { - try!(s.emit_seq_elt(i, |s| e.encode(s))); + s.emit_seq_elt(i, |s| e.encode(s))?; } Ok(()) }) @@ -33,7 +33,7 @@ impl Decodable for LinkedList { d.read_seq(|d, len| { let mut list = LinkedList::new(); for i in 0..len { - list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); + list.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?); } Ok(list) }) @@ -44,7 +44,7 @@ impl Encodable for VecDeque { fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { - try!(s.emit_seq_elt(i, |s| e.encode(s))); + s.emit_seq_elt(i, |s| e.encode(s))?; } Ok(()) }) @@ -56,7 +56,7 @@ impl Decodable for VecDeque { d.read_seq(|d, len| { let mut deque: VecDeque = VecDeque::new(); for i in 0..len { - deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); + deque.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?); } Ok(deque) }) @@ -71,8 +71,8 @@ impl< e.emit_map(self.len(), |e| { let mut i = 0; for (key, val) in self.iter() { - try!(e.emit_map_elt_key(i, |e| key.encode(e))); - try!(e.emit_map_elt_val(i, |e| val.encode(e))); + e.emit_map_elt_key(i, |e| key.encode(e))?; + e.emit_map_elt_val(i, |e| val.encode(e))?; i += 1; } Ok(()) @@ -88,8 +88,8 @@ impl< d.read_map(|d, len| { let mut map = BTreeMap::new(); for i in 0..len { - let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d))); - let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d))); + let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?; + let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?; map.insert(key, val); } Ok(map) @@ -104,7 +104,7 @@ impl< s.emit_seq(self.len(), |s| { let mut i = 0; for e in self.iter() { - try!(s.emit_seq_elt(i, |s| e.encode(s))); + s.emit_seq_elt(i, |s| e.encode(s))?; i += 1; } Ok(()) @@ -119,7 +119,7 @@ impl< d.read_seq(|d, len| { let mut set = BTreeSet::new(); for i in 0..len { - set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); + set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?); } Ok(set) }) @@ -134,8 +134,8 @@ impl Encodable for HashMap e.emit_map(self.len(), |e| { let mut i = 0; for (key, val) in self.iter() { - try!(e.emit_map_elt_key(i, |e| key.encode(e))); - try!(e.emit_map_elt_val(i, |e| val.encode(e))); + e.emit_map_elt_key(i, |e| key.encode(e))?; + e.emit_map_elt_val(i, |e| val.encode(e))?; i += 1; } Ok(()) @@ -151,8 +151,8 @@ impl Decodable for HashMap d.read_map(|d, len| { let mut map = HashMap::with_capacity(cap_capacity::<(K, V)>(len)); for i in 0..len { - let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d))); - let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d))); + let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?; + let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?; map.insert(key, val); } Ok(map) @@ -165,7 +165,7 @@ impl Encodable for HashSet where T: Encodable + Hash + Eq { s.emit_seq(self.len(), |s| { let mut i = 0; for e in self.iter() { - try!(s.emit_seq_elt(i, |s| e.encode(s))); + s.emit_seq_elt(i, |s| e.encode(s))?; i += 1; } Ok(()) @@ -178,7 +178,7 @@ impl Decodable for HashSet where T: Decodable + Hash + Eq, { d.read_seq(|d, len| { let mut set = HashSet::with_capacity(cap_capacity::(len)); for i in 0..len { - set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); + set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?); } Ok(set) }) diff --git a/src/json.rs b/src/json.rs index 3b02e33..f106a20 100644 --- a/src/json.rs +++ b/src/json.rs @@ -391,7 +391,7 @@ pub fn encode(object: &T) -> EncodeResult { let mut s = String::new(); { let mut encoder = Encoder::new(&mut s); - try!(object.encode(&mut encoder)); + object.encode(&mut encoder)?; } Ok(s) } @@ -458,7 +458,7 @@ pub type EncodeResult = Result; pub type DecodeResult = Result; fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult<()> { - try!(wr.write_str("\"")); + wr.write_str("\"")?; let mut start = 0; @@ -503,19 +503,19 @@ fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult<()> { }; if start < i { - try!(wr.write_str(&v[start..i])); + wr.write_str(&v[start..i])?; } - try!(wr.write_str(escaped)); + wr.write_str(escaped)?; start = i + 1; } if start != v.len() { - try!(wr.write_str(&v[start..])); + wr.write_str(&v[start..])?; } - try!(wr.write_str("\"")); + wr.write_str("\"")?; Ok(()) } @@ -531,12 +531,12 @@ fn spaces(wr: &mut fmt::Write, n: u32) -> EncodeResult<()> { const BUF: &'static str = " "; while n >= BUF.len() { - try!(wr.write_str(BUF)); + wr.write_str(BUF)?; n -= BUF.len(); } if n > 0 { - try!(wr.write_str(&BUF[..n])); + wr.write_str(&BUF[..n])?; } Ok(()) } @@ -556,10 +556,10 @@ fn fmt_number_or_null(v: f64) -> string::String { macro_rules! emit_enquoted_if_mapkey { ($enc:ident,$e:expr) => { if $enc.is_emitting_map_key { - try!(write!($enc.writer, "\"{}\"", $e)); + write!($enc.writer, "\"{}\"", $e)?; Ok(()) } else { - try!(write!($enc.writer, "{}", $e)); + write!($enc.writer, "{}", $e)?; Ok(()) } } @@ -624,7 +624,7 @@ impl<'a> ::Encoder for Encoder<'a> { fn emit_nil(&mut self) -> EncodeResult<()> { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } - try!(write!(self.writer, "null")); + write!(self.writer, "null")?; Ok(()) } @@ -643,9 +643,9 @@ impl<'a> ::Encoder for Encoder<'a> { fn emit_bool(&mut self, v: bool) -> EncodeResult<()> { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if v { - try!(write!(self.writer, "true")); + write!(self.writer, "true")?; } else { - try!(write!(self.writer, "false")); + write!(self.writer, "false")?; } Ok(()) } @@ -686,31 +686,31 @@ impl<'a> ::Encoder for Encoder<'a> { } else { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format { - try!(write!(self.writer, "{{\n")); + write!(self.writer, "{{\n")?; *curr_indent += indent; - try!(spaces(self.writer, *curr_indent)); - try!(write!(self.writer, "\"variant\": ")); - try!(escape_str(self.writer, name)); - try!(write!(self.writer, ",\n")); - try!(spaces(self.writer, *curr_indent)); - try!(write!(self.writer, "\"fields\": [\n")); + spaces(self.writer, *curr_indent)?; + write!(self.writer, "\"variant\": ")?; + escape_str(self.writer, name)?; + write!(self.writer, ",\n")?; + spaces(self.writer, *curr_indent)?; + write!(self.writer, "\"fields\": [\n")?; *curr_indent += indent; } else { - try!(write!(self.writer, "{{\"variant\":")); - try!(escape_str(self.writer, name)); - try!(write!(self.writer, ",\"fields\":[")); + write!(self.writer, "{{\"variant\":")?; + escape_str(self.writer, name)?; + write!(self.writer, ",\"fields\":[")?; } - try!(f(self)); + f(self)?; if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format { *curr_indent -= indent; - try!(write!(self.writer, "\n")); - try!(spaces(self.writer, *curr_indent)); + write!(self.writer, "\n")?; + spaces(self.writer, *curr_indent)?; *curr_indent -= indent; - try!(write!(self.writer, "]\n")); - try!(spaces(self.writer, *curr_indent)); - try!(write!(self.writer, "}}")); + write!(self.writer, "]\n")?; + spaces(self.writer, *curr_indent)?; + write!(self.writer, "}}")?; } else { - try!(write!(self.writer, "]}}")); + write!(self.writer, "]}}")?; } Ok(()) } @@ -721,13 +721,13 @@ impl<'a> ::Encoder for Encoder<'a> { { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if idx != 0 { - try!(write!(self.writer, ",")); + write!(self.writer, ",")?; if let EncodingFormat::Pretty{..} = self.format { - try!(write!(self.writer, "\n")); + write!(self.writer, "\n")?; } } if let EncodingFormat::Pretty{curr_indent, ..} = self.format { - try!(spaces(self.writer, curr_indent)); + spaces(self.writer, curr_indent)?; } f(self) } @@ -759,19 +759,19 @@ impl<'a> ::Encoder for Encoder<'a> { { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if len == 0 { - try!(write!(self.writer, "{{}}")); + write!(self.writer, "{{}}")?; } else { - try!(write!(self.writer, "{{")); + write!(self.writer, "{{")?; if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format { *curr_indent += indent; } - try!(f(self)); + f(self)?; if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format { *curr_indent -= indent; - try!(write!(self.writer, "\n")); - try!(spaces(self.writer, *curr_indent)); + write!(self.writer, "\n")?; + spaces(self.writer, *curr_indent)?; } - try!(write!(self.writer, "}}")); + write!(self.writer, "}}")?; } Ok(()) } @@ -781,17 +781,17 @@ impl<'a> ::Encoder for Encoder<'a> { { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if idx != 0 { - try!(write!(self.writer, ",")); + write!(self.writer, ",")?; } if let EncodingFormat::Pretty{curr_indent, ..} = self.format { - try!(write!(self.writer, "\n")); - try!(spaces(self.writer, curr_indent)); + write!(self.writer, "\n")?; + spaces(self.writer, curr_indent)?; } - try!(escape_str(self.writer, name)); + escape_str(self.writer, name)?; if let EncodingFormat::Pretty{..} = self.format { - try!(write!(self.writer, ": ")); + write!(self.writer, ": ")?; } else { - try!(write!(self.writer, ":")); + write!(self.writer, ":")?; } f(self) } @@ -844,19 +844,19 @@ impl<'a> ::Encoder for Encoder<'a> { { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if len == 0 { - try!(write!(self.writer, "[]")); + write!(self.writer, "[]")?; } else { - try!(write!(self.writer, "[")); + write!(self.writer, "[")?; if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format { *curr_indent += indent; } - try!(f(self)); + f(self)?; if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format { *curr_indent -= indent; - try!(write!(self.writer, "\n")); - try!(spaces(self.writer, *curr_indent)); + write!(self.writer, "\n")?; + spaces(self.writer, *curr_indent)?; } - try!(write!(self.writer, "]")); + write!(self.writer, "]")?; } Ok(()) } @@ -866,11 +866,11 @@ impl<'a> ::Encoder for Encoder<'a> { { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if idx != 0 { - try!(write!(self.writer, ",")); + write!(self.writer, ",")?; } if let EncodingFormat::Pretty{ref mut curr_indent, ..} = self.format { - try!(write!(self.writer, "\n")); - try!(spaces(self.writer, *curr_indent)); + write!(self.writer, "\n")?; + spaces(self.writer, *curr_indent)?; } f(self) } @@ -880,19 +880,19 @@ impl<'a> ::Encoder for Encoder<'a> { { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if len == 0 { - try!(write!(self.writer, "{{}}")); + write!(self.writer, "{{}}")?; } else { - try!(write!(self.writer, "{{")); + write!(self.writer, "{{")?; if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format { *curr_indent += indent; } - try!(f(self)); + f(self)?; if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format { *curr_indent -= indent; - try!(write!(self.writer, "\n")); - try!(spaces(self.writer, *curr_indent)); + write!(self.writer, "\n")?; + spaces(self.writer, *curr_indent)?; } - try!(write!(self.writer, "}}")); + write!(self.writer, "}}")?; } Ok(()) } @@ -902,14 +902,14 @@ impl<'a> ::Encoder for Encoder<'a> { { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if idx != 0 { - try!(write!(self.writer, ",")); + write!(self.writer, ",")?; } if let EncodingFormat::Pretty{curr_indent, ..} = self.format { - try!(write!(self.writer, "\n")); - try!(spaces(self.writer, curr_indent)); + write!(self.writer, "\n")?; + spaces(self.writer, curr_indent)?; } self.is_emitting_map_key = true; - try!(f(self)); + f(self)?; self.is_emitting_map_key = false; Ok(()) } @@ -919,9 +919,9 @@ impl<'a> ::Encoder for Encoder<'a> { { if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); } if let EncodingFormat::Pretty{..} = self.format { - try!(write!(self.writer, ": ")); + write!(self.writer, ": ")?; } else { - try!(write!(self.writer, ":")); + write!(self.writer, ":")?; } f(self) } @@ -959,7 +959,7 @@ impl Json { pub fn from_reader(rdr: &mut io::Read) -> Result { let contents = { let mut c = Vec::new(); - try!(rdr.read_to_end(&mut c)); + rdr.read_to_end(&mut c)?; c }; let s = match str::from_utf8(&contents).ok() { @@ -1676,7 +1676,7 @@ impl> Parser { 'n' => res.push('\n'), 'r' => res.push('\r'), 't' => res.push('\t'), - 'u' => match try!(self.decode_hex_escape()) { + 'u' => match self.decode_hex_escape()? { 0xDC00 ..= 0xDFFF => { return self.error(LoneLeadingSurrogateInHexEscape) } @@ -1689,7 +1689,7 @@ impl> Parser { _ => return self.error(UnexpectedEndOfHexEscape), } - let n2 = try!(self.decode_hex_escape()); + let n2 = self.decode_hex_escape()?; if n2 < 0xDC00 || n2 > 0xDFFF { return self.error(LoneLeadingSurrogateInHexEscape) } @@ -2060,14 +2060,14 @@ impl Decoder { macro_rules! expect { ($e:expr, Null) => ({ - match try!($e) { + match $e? { Json::Null => Ok(()), other => Err(ExpectedError("Null".to_string(), format!("{}", other))) } }); ($e:expr, $t:ident) => ({ - match try!($e) { + match $e? { Json::$t(v) => Ok(v), other => { Err(ExpectedError(stringify!($t).to_string(), @@ -2081,7 +2081,7 @@ macro_rules! read_primitive { ($name:ident, $ty:ident) => { #[allow(unused_comparisons)] fn $name(&mut self) -> DecodeResult<$ty> { - match try!(self.pop()) { + match self.pop()? { Json::I64(i) => { let other = i as $ty; if i == other as i64 && (other > 0) == (i > 0) { @@ -2138,7 +2138,7 @@ impl ::Decoder for Decoder { } fn read_f64(&mut self) -> DecodeResult { - match try!(self.pop()) { + match self.pop()? { Json::I64(f) => Ok(f as f64), Json::U64(f) => Ok(f as f64), Json::F64(f) => Ok(f), @@ -2160,7 +2160,7 @@ impl ::Decoder for Decoder { } fn read_char(&mut self) -> DecodeResult { - let s = try!(self.read_str()); + let s = self.read_str()?; { let mut it = s.chars(); match (it.next(), it.next()) { @@ -2186,7 +2186,7 @@ impl ::Decoder for Decoder { mut f: F) -> DecodeResult where F: FnMut(&mut Decoder, usize) -> DecodeResult, { - let name = match try!(self.pop()) { + let name = match self.pop()? { Json::String(s) => s, Json::Object(mut o) => { let n = match o.remove(&"variant".to_string()) { @@ -2250,8 +2250,8 @@ impl ::Decoder for Decoder { fn read_struct(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult where F: FnOnce(&mut Decoder) -> DecodeResult, { - let value = try!(f(self)); - try!(self.pop()); + let value = f(self)?; + self.pop()?; Ok(value) } @@ -2262,7 +2262,7 @@ impl ::Decoder for Decoder { -> DecodeResult where F: FnOnce(&mut Decoder) -> DecodeResult, { - let mut obj = try!(expect!(self.pop(), Object)); + let mut obj = expect!(self.pop(), Object)?; let value = match obj.remove(&name.to_string()) { None => { @@ -2276,7 +2276,7 @@ impl ::Decoder for Decoder { }, Some(json) => { self.stack.push(json); - try!(f(self)) + f(self)? } }; self.stack.push(Json::Object(obj)); @@ -2323,7 +2323,7 @@ impl ::Decoder for Decoder { fn read_option(&mut self, mut f: F) -> DecodeResult where F: FnMut(&mut Decoder, bool) -> DecodeResult, { - match try!(self.pop()) { + match self.pop()? { Json::Null => f(self, false), value => { self.stack.push(value); f(self, true) } } @@ -2332,7 +2332,7 @@ impl ::Decoder for Decoder { fn read_seq(&mut self, f: F) -> DecodeResult where F: FnOnce(&mut Decoder, usize) -> DecodeResult, { - let array = try!(expect!(self.pop(), Array)); + let array = expect!(self.pop(), Array)?; let len = array.len(); for v in array.into_iter().rev() { self.stack.push(v); @@ -2349,7 +2349,7 @@ impl ::Decoder for Decoder { fn read_map(&mut self, f: F) -> DecodeResult where F: FnOnce(&mut Decoder, usize) -> DecodeResult, { - let obj = try!(expect!(self.pop(), Object)); + let obj = expect!(self.pop(), Object)?; let len = obj.len(); for (key, value) in obj.into_iter() { self.stack.push(value); diff --git a/src/serialize.rs b/src/serialize.rs index 296f3d4..9c6b08a 100644 --- a/src/serialize.rs +++ b/src/serialize.rs @@ -1116,13 +1116,13 @@ impl Encodable for Box { impl< T: Decodable> Decodable for Box { fn decode(d: &mut D) -> Result, D::Error> { - Ok(Box::new(try!(Decodable::decode(d)))) + Ok(Box::new(Decodable::decode(d)?)) } } impl< T: Decodable> Decodable for Box<[T]> { fn decode(d: &mut D) -> Result, D::Error> { - let v: Vec = try!(Decodable::decode(d)); + let v: Vec = Decodable::decode(d)?; Ok(v.into_boxed_slice()) } } @@ -1137,7 +1137,7 @@ impl Encodable for Rc { impl Decodable for Rc { #[inline] fn decode(d: &mut D) -> Result, D::Error> { - Ok(Rc::new(try!(Decodable::decode(d)))) + Ok(Rc::new(Decodable::decode(d)?)) } } @@ -1153,7 +1153,7 @@ impl<'a, T: ?Sized> Decodable for Cow<'a, T> { #[inline] fn decode(d: &mut D) -> Result, D::Error> { - Ok(Cow::Owned(try!(Decodable::decode(d)))) + Ok(Cow::Owned(Decodable::decode(d)?)) } } @@ -1161,7 +1161,7 @@ impl Encodable for [T] { fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { - try!(s.emit_seq_elt(i, |s| e.encode(s))) + s.emit_seq_elt(i, |s| e.encode(s))? } Ok(()) }) @@ -1172,7 +1172,7 @@ impl Encodable for Vec { fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { - try!(s.emit_seq_elt(i, |s| e.encode(s))) + s.emit_seq_elt(i, |s| e.encode(s))? } Ok(()) }) @@ -1184,7 +1184,7 @@ impl Decodable for Vec { d.read_seq(|d, len| { let mut v = Vec::with_capacity(cap_capacity::(len)); for i in 0..len { - v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); + v.push(d.read_seq_elt(i, |d| Decodable::decode(d))?); } Ok(v) }) @@ -1206,7 +1206,7 @@ impl Decodable for Option { fn decode(d: &mut D) -> Result, D::Error> { d.read_option(|d, b| { if b { - Ok(Some(try!(Decodable::decode(d)))) + Ok(Some(Decodable::decode(d)?)) } else { Ok(None) } @@ -1220,17 +1220,17 @@ impl Encodable for Result { match *self { Ok(ref v) => { s.emit_enum_variant("Ok", 0, 1, |s| { - try!(s.emit_enum_variant_arg(0, |s| { + s.emit_enum_variant_arg(0, |s| { v.encode(s) - })); + })?; Ok(()) }) } Err(ref v) => { s.emit_enum_variant("Err", 1, 1, |s| { - try!(s.emit_enum_variant_arg(0, |s| { + s.emit_enum_variant_arg(0, |s| { v.encode(s) - })); + })?; Ok(()) }) } @@ -1292,10 +1292,10 @@ macro_rules! tuple { let len: usize = count_idents!($($name,)*); d.read_tuple(len, |d| { let mut i = 0; - let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 }, + let ret = ($(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name,D::Error> { Decodable::decode(d) - })),)*); + })?,)*); return Ok(ret); }) } @@ -1308,7 +1308,7 @@ macro_rules! tuple { $(let $name = $name; n += 1;)* s.emit_tuple(n, |s| { let mut i = 0; - $(try!(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s)));)* + $(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s))?;)* Ok(()) }) } @@ -1329,8 +1329,8 @@ macro_rules! array { return Err(d.error("wrong array length")); } Ok([$( - try!(d.read_seq_elt($len - $idx - 1, - |d| Decodable::decode(d))) + d.read_seq_elt($len - $idx - 1, + |d| Decodable::decode(d))? ),*]) }) } @@ -1340,7 +1340,7 @@ macro_rules! array { fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq($len, |s| { for i in 0..$len { - try!(s.emit_seq_elt(i, |s| self[i].encode(s))); + s.emit_seq_elt(i, |s| self[i].encode(s))?; } Ok(()) }) @@ -1391,7 +1391,7 @@ impl Decodable for path::PathBuf { #[cfg(unix)] fn decode(d: &mut D) -> Result { use std::os::unix::prelude::*; - let bytes: Vec = try!(Decodable::decode(d)); + let bytes: Vec = Decodable::decode(d)?; let s: OsString = OsStringExt::from_vec(bytes); let mut p = path::PathBuf::new(); p.push(s); @@ -1416,7 +1416,7 @@ impl Encodable for Cell { impl Decodable for Cell { fn decode(d: &mut D) -> Result, D::Error> { - Ok(Cell::new(try!(Decodable::decode(d)))) + Ok(Cell::new(Decodable::decode(d)?)) } } @@ -1433,7 +1433,7 @@ impl Encodable for RefCell { impl Decodable for RefCell { fn decode(d: &mut D) -> Result, D::Error> { - Ok(RefCell::new(try!(Decodable::decode(d)))) + Ok(RefCell::new(Decodable::decode(d)?)) } } @@ -1445,7 +1445,7 @@ impl Encodable for Arc { impl Decodable for Arc { fn decode(d: &mut D) -> Result, D::Error> { - Ok(Arc::new(try!(Decodable::decode(d)))) + Ok(Arc::new(Decodable::decode(d)?)) } } @@ -1498,9 +1498,9 @@ impl EncoderHelpers for S { { self.emit_seq(v.len(), |this| { for (i, e) in v.iter().enumerate() { - try!(this.emit_seq_elt(i, |this| { + this.emit_seq_elt(i, |this| { f(this, e) - })); + })?; } Ok(()) }) @@ -1554,7 +1554,7 @@ impl DecoderHelpers for D { self.read_seq(|this, len| { let mut v = Vec::with_capacity(cap_capacity::(len)); for i in 0..len { - v.push(try!(this.read_seq_elt(i, |this| f(this)))); + v.push(this.read_seq_elt(i, |this| f(this))?); } Ok(v) }) From 7343d3e5168a9768ad44ce113b724cab4e941c43 Mon Sep 17 00:00:00 2001 From: Kent Fredric Date: Tue, 26 Nov 2019 05:38:13 +1300 Subject: [PATCH 3/5] Stipulate explicit 'dyn' for trait objects --- src/json.rs | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/json.rs b/src/json.rs index f106a20..0616752 100644 --- a/src/json.rs +++ b/src/json.rs @@ -404,7 +404,7 @@ impl fmt::Debug for ErrorCode { impl StdError for DecoderError { fn description(&self) -> &str { "decoder error" } - fn cause(&self) -> Option<&StdError> { + fn cause(&self) -> Option<&dyn StdError> { match *self { DecoderError::ParseError(ref e) => Some(e), _ => None, @@ -457,7 +457,7 @@ impl From for EncoderError { pub type EncodeResult = Result; pub type DecodeResult = Result; -fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult<()> { +fn escape_str(wr: &mut dyn fmt::Write, v: &str) -> EncodeResult<()> { wr.write_str("\"")?; let mut start = 0; @@ -519,14 +519,14 @@ fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult<()> { Ok(()) } -fn escape_char(writer: &mut fmt::Write, v: char) -> EncodeResult<()> { +fn escape_char(writer: &mut dyn fmt::Write, v: char) -> EncodeResult<()> { let mut buf = [0; 4]; let _ = write!(&mut &mut buf[..], "{}", v); let buf = unsafe { str::from_utf8_unchecked(&buf[..v.len_utf8()]) }; escape_str(writer, buf) } -fn spaces(wr: &mut fmt::Write, n: u32) -> EncodeResult<()> { +fn spaces(wr: &mut dyn fmt::Write, n: u32) -> EncodeResult<()> { let mut n = n as usize; const BUF: &'static str = " "; @@ -575,7 +575,7 @@ enum EncodingFormat { /// A structure for implementing serialization to JSON. pub struct Encoder<'a> { - writer: &'a mut (fmt::Write+'a), + writer: &'a mut dyn fmt::Write, format : EncodingFormat, is_emitting_map_key: bool, } @@ -583,7 +583,7 @@ pub struct Encoder<'a> { impl<'a> Encoder<'a> { /// Creates a new encoder whose output will be written in human-readable /// JSON to the specified writer - pub fn new_pretty(writer: &'a mut fmt::Write) -> Encoder<'a> { + pub fn new_pretty(writer: &'a mut dyn fmt::Write) -> Encoder<'a> { Encoder { writer: writer, format: EncodingFormat::Pretty { @@ -596,7 +596,7 @@ impl<'a> Encoder<'a> { /// Creates a new encoder whose output will be written in compact /// JSON to the specified writer - pub fn new(writer: &'a mut fmt::Write) -> Encoder<'a> { + pub fn new(writer: &'a mut dyn fmt::Write) -> Encoder<'a> { Encoder { writer: writer, format: EncodingFormat::Compact, @@ -956,7 +956,7 @@ pub fn as_pretty_json(t: &T) -> AsPrettyJson { impl Json { /// Decodes a json value from an `&mut io::Read` - pub fn from_reader(rdr: &mut io::Read) -> Result { + pub fn from_reader(rdr: &mut dyn io::Read) -> Result { let contents = { let mut c = Vec::new(); rdr.read_to_end(&mut c)?; From 60c275aea2e782685791f1313a068337bc87fdca Mon Sep 17 00:00:00 2001 From: Kent Fredric Date: Tue, 26 Nov 2019 06:33:11 +1300 Subject: [PATCH 4/5] Remove tests dependent on only Rust-Only Derive Macros These are gone from recent rust releases and no longer work, thus, tests that require them can only fail. --- src/json.rs | 261 +--------------------------------------------------- 1 file changed, 1 insertion(+), 260 deletions(-) diff --git a/src/json.rs b/src/json.rs index 0616752..5841a5b 100644 --- a/src/json.rs +++ b/src/json.rs @@ -2587,8 +2587,6 @@ impl FromStr for Json { #[cfg(test)] mod tests { - use self::Animal::*; - use {Encodable, Decodable}; use super::Json::*; use super::ErrorCode::*; use super::ParserError::*; @@ -2596,56 +2594,11 @@ mod tests { use super::JsonEvent::*; use super::StackElement::*; use super::{Json, DecodeResult, DecoderError, JsonEvent, Parser, - StackElement, Stack, Decoder, Encoder, EncoderError}; + StackElement, Stack, Decoder}; use std::{i64, u64, f32, f64}; use std::collections::BTreeMap; use std::string; - #[derive(RustcDecodable, Eq, PartialEq, Debug)] - struct OptionData { - opt: Option, - } - - #[test] - fn test_decode_option_none() { - let s ="{}"; - let obj: OptionData = super::decode(s).unwrap(); - assert_eq!(obj, OptionData { opt: None }); - } - - #[test] - fn test_decode_option_some() { - let s = "{ \"opt\": 10 }"; - let obj: OptionData = super::decode(s).unwrap(); - assert_eq!(obj, OptionData { opt: Some(10) }); - } - - #[test] - fn test_decode_option_malformed() { - check_err::("{ \"opt\": [] }", - ExpectedError("Number".to_string(), "[]".to_string())); - check_err::("{ \"opt\": false }", - ExpectedError("Number".to_string(), "false".to_string())); - } - - #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] - enum Animal { - Dog, - Frog(string::String, isize) - } - - #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] - struct Inner { - a: (), - b: usize, - c: Vec, - } - - #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] - struct Outer { - inner: Vec, - } - fn mk_object(items: &[(string::String, Json)]) -> Json { let mut d = BTreeMap::new(); @@ -2826,35 +2779,6 @@ mod tests { assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap()); } - #[test] - fn test_write_enum() { - let animal = Dog; - assert_eq!( - format!("{}", super::as_json(&animal)), - "\"Dog\"" - ); - assert_eq!( - format!("{}", super::as_pretty_json(&animal)), - "\"Dog\"" - ); - - let animal = Frog("Henry".to_string(), 349); - assert_eq!( - format!("{}", super::as_json(&animal)), - "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}" - ); - assert_eq!( - format!("{}", super::as_pretty_json(&animal)), - "{\n \ - \"variant\": \"Frog\",\n \ - \"fields\": [\n \ - \"Henry\",\n \ - 349\n \ - ]\n\ - }" - ); - } - macro_rules! check_encoder_for_simple { ($value:expr, $expected:expr) => ({ let s = format!("{}", super::as_json(&$value)); @@ -3161,39 +3085,6 @@ mod tests { ])); } - #[test] - fn test_decode_struct() { - let s = "{ - \"inner\": [ - { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] } - ] - }"; - - let v: Outer = super::decode(s).unwrap(); - assert_eq!( - v, - Outer { - inner: vec![ - Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] } - ] - } - ); - } - - #[derive(RustcDecodable)] - struct FloatStruct { - f: f64, - a: Vec - } - #[test] - fn test_decode_struct_with_nan() { - let s = "{\"f\":null,\"a\":[null,123]}"; - let obj: FloatStruct = super::decode(s).unwrap(); - assert!(obj.f.is_nan()); - assert!(obj.a[0].is_nan()); - assert_eq!(obj.a[1], 123f64); - } - #[test] fn test_decode_option() { let value: Option = super::decode("null").unwrap(); @@ -3203,16 +3094,6 @@ mod tests { assert_eq!(value, Some("jodhpurs".to_string())); } - #[test] - fn test_decode_enum() { - let value: Animal = super::decode("\"Dog\"").unwrap(); - assert_eq!(value, Dog); - - let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"; - let value: Animal = super::decode(s).unwrap(); - assert_eq!(value, Frog("Henry".to_string(), 349)); - } - #[test] fn test_decode_result() { let value: Result = Ok(4); @@ -3222,23 +3103,12 @@ mod tests { assert_eq!(decoded_value, Ok(4)); } - #[test] - fn test_decode_map() { - let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\ - \"fields\":[\"Henry\", 349]}}"; - let mut map: BTreeMap = super::decode(s).unwrap(); - - assert_eq!(map.remove(&"a".to_string()), Some(Dog)); - assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349))); - } - #[test] fn test_multiline_errors() { assert_eq!(Json::from_str("{\n \"foo\":\n \"bar\""), Err(SyntaxError(EOFWhileParsingObject, 3, 8))); } - #[derive(RustcDecodable)] #[allow(dead_code)] struct DecodeStruct { x: f64, @@ -3246,54 +3116,6 @@ mod tests { z: string::String, w: Vec } - #[derive(RustcDecodable)] - enum DecodeEnum { - A(f64), - B(string::String) - } - fn check_err(to_parse: &'static str, expected: DecoderError) { - let res: DecodeResult = match Json::from_str(to_parse) { - Err(e) => Err(ParseError(e)), - Ok(json) => Decodable::decode(&mut Decoder::new(json)) - }; - match res { - Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`", - to_parse, expected), - Err(ParseError(e)) => panic!("`{}` is not valid json: {:?}", - to_parse, e), - Err(e) => { - assert_eq!(e, expected); - } - } - } - #[test] - fn test_decode_errors_struct() { - check_err::("[]", ExpectedError("Object".to_string(), "[]".to_string())); - check_err::("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}", - ExpectedError("Number".to_string(), "true".to_string())); - check_err::("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}", - ExpectedError("Boolean".to_string(), "[]".to_string())); - check_err::("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}", - ExpectedError("String".to_string(), "{}".to_string())); - check_err::("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}", - ExpectedError("Array".to_string(), "null".to_string())); - check_err::("{\"x\": 1, \"y\": true, \"z\": \"\"}", - MissingFieldError("w".to_string())); - } - #[test] - fn test_decode_errors_enum() { - check_err::("{}", - MissingFieldError("variant".to_string())); - check_err::("{\"variant\": 1}", - ExpectedError("String".to_string(), "1".to_string())); - check_err::("{\"variant\": \"A\"}", - MissingFieldError("fields".to_string())); - check_err::("{\"variant\": \"A\", \"fields\": null}", - ExpectedError("Array".to_string(), "null".to_string())); - check_err::("{\"variant\": \"C\", \"fields\": []}", - UnknownVariantError("C".to_string())); - } - #[test] fn test_find(){ let json_value = Json::from_str("{\"dog\" : \"cat\"}").unwrap(); @@ -3550,24 +3372,6 @@ mod tests { let _hm: HashMap = Decodable::decode(&mut decoder).unwrap(); } - #[test] - fn test_hashmap_with_enum_key() { - use std::collections::HashMap; - use json; - #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)] - enum Enum { - Foo, - #[allow(dead_code)] - Bar, - } - let mut map = HashMap::new(); - map.insert(Enum::Foo, 0); - let result = json::encode(&map).unwrap(); - assert_eq!(result, r#"{"Foo":0}"#); - let decoded: HashMap = json::decode(&result).unwrap(); - assert_eq!(map, decoded); - } - #[test] fn test_hashmap_with_numeric_key_will_error_with_string_keys() { use std::collections::HashMap; @@ -3926,69 +3730,6 @@ mod tests { assert_eq!(None::.to_json(), Null); } - #[test] - fn test_encode_hashmap_with_arbitrary_key() { - use std::collections::HashMap; - #[derive(PartialEq, Eq, Hash, RustcEncodable)] - struct ArbitraryType(u32); - let mut hm: HashMap = HashMap::new(); - hm.insert(ArbitraryType(1), true); - let mut mem_buf = string::String::new(); - let mut encoder = Encoder::new(&mut mem_buf); - let result = hm.encode(&mut encoder); - match result.err().unwrap() { - EncoderError::BadHashmapKey => (), - _ => panic!("expected bad hash map key") - } - } - - #[test] - fn test_encode_decode_phantom_data() { - use std::marker::PhantomData; - - #[derive(Debug, RustcDecodable, RustcEncodable, Eq, PartialEq)] - struct Foo

{ - phantom_data: PhantomData

- } - - let f: Foo = Foo { - phantom_data: PhantomData - }; - let s = super::encode(&f).unwrap(); - let d: Foo = super::decode(&s).unwrap(); - assert_eq!(f, d); - } - - #[test] - fn test_bad_json_stack_depleted() { - use json; - #[derive(Debug, RustcDecodable)] - enum ChatEvent { - Variant(i32) - } - let serialized = "{\"variant\": \"Variant\", \"fields\": []}"; - let r: Result = json::decode(serialized); - assert!(r.unwrap_err() == EOF); - } - - #[test] - fn fixed_length_array() { - #[derive(Debug, RustcDecodable, RustcEncodable, Eq, PartialEq)] - struct Foo { - a: [u8; 1], - b: [i32; 2], - c: [u64; 3], - } - let f = Foo { - a: [0], - b: [1, 2], - c: [3, 4, 5], - }; - let s = super::encode(&f).unwrap(); - let d = super::decode(&s).unwrap(); - assert_eq!(f, d); - } - #[test] fn test_unexpected_token() { match Json::from_str("{\"\":\"\",\"\":{\"\":\"\",\"\":[{\"\":\"\",}}}") { From 53080de3f2b362a63eba82e2278d6faab56fee06 Mon Sep 17 00:00:00 2001 From: Kent Fredric Date: Tue, 26 Nov 2019 19:48:29 +1300 Subject: [PATCH 5/5] Replace deprecated trim_left_matches with trim_start_matches --- src/json.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/json.rs b/src/json.rs index 5841a5b..2a2a207 100644 --- a/src/json.rs +++ b/src/json.rs @@ -3332,7 +3332,7 @@ mod tests { // Helper function for counting indents fn indents(source: &str) -> usize { - let trimmed = source.trim_left_matches(' '); + let trimmed = source.trim_start_matches(' '); source.len() - trimmed.len() }