From 94c609ca9a9a71c21ba2cec2e495880f83661c7e Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Thu, 7 Feb 2019 11:42:43 +0900 Subject: [PATCH] Transition libserialize to 2018 edition --- src/libserialize/Cargo.toml | 1 + src/libserialize/collection_impls.rs | 2 +- src/libserialize/hex.rs | 4 +- src/libserialize/json.rs | 60 ++++++++++++++-------------- src/libserialize/lib.rs | 6 +-- src/libserialize/opaque.rs | 8 ++-- src/libserialize/serialize.rs | 2 +- 7 files changed, 42 insertions(+), 41 deletions(-) diff --git a/src/libserialize/Cargo.toml b/src/libserialize/Cargo.toml index 3e040818d37..949af0e2b97 100644 --- a/src/libserialize/Cargo.toml +++ b/src/libserialize/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "serialize" version = "0.0.0" +edition = "2018" [lib] name = "serialize" diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs index f3afc3b5341..c0a8fa9d001 100644 --- a/src/libserialize/collection_impls.rs +++ b/src/libserialize/collection_impls.rs @@ -2,7 +2,7 @@ use std::hash::{Hash, BuildHasher}; -use {Decodable, Encodable, Decoder, Encoder}; +use crate::{Decodable, Encodable, Decoder, Encoder}; use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet}; use std::rc::Rc; use std::sync::Arc; diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs index 6127440a6d7..c5217b962ce 100644 --- a/src/libserialize/hex.rs +++ b/src/libserialize/hex.rs @@ -60,7 +60,7 @@ pub enum FromHexError { } impl fmt::Display for FromHexError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self { InvalidHexCharacter(ch, idx) => write!(f, "Invalid character '{}' at position {}", ch, idx), @@ -146,7 +146,7 @@ impl FromHex for str { mod tests { extern crate test; use self::test::Bencher; - use hex::{FromHex, ToHex}; + use crate::hex::{FromHex, ToHex}; #[test] pub fn test_to_hex() { diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 362b4574ee2..dc089218a9f 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -201,7 +201,7 @@ use std::string; use std::{char, f64, fmt, str}; use std; -use Encodable; +use crate::Encodable; /// Represents a json value #[derive(Clone, PartialEq, PartialOrd, Debug)] @@ -221,8 +221,8 @@ pub type Object = BTreeMap; pub struct PrettyJson<'a> { inner: &'a Json } -pub struct AsJson<'a, T: 'a> { inner: &'a T } -pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option } +pub struct AsJson<'a, T> { inner: &'a T } +pub struct AsPrettyJson<'a, T> { inner: &'a T, indent: Option } /// The errors that can arise while parsing a JSON stream. #[derive(Clone, Copy, PartialEq, Debug)] @@ -295,18 +295,18 @@ pub fn error_str(error: ErrorCode) -> &'static str { } /// Shortcut function to decode a JSON `&str` into an object -pub fn decode(s: &str) -> DecodeResult { +pub fn decode(s: &str) -> DecodeResult { let json = match from_str(s) { Ok(x) => x, Err(e) => return Err(ParseError(e)) }; let mut decoder = Decoder::new(json); - ::Decodable::decode(&mut decoder) + crate::Decodable::decode(&mut decoder) } /// Shortcut function to encode a `T` into a JSON `String` -pub fn encode(object: &T) -> Result { +pub fn encode(object: &T) -> Result { let mut s = String::new(); { let mut encoder = Encoder::new(&mut s); @@ -316,7 +316,7 @@ pub fn encode(object: &T) -> Result fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { error_str(*self).fmt(f) } } @@ -326,14 +326,14 @@ fn io_error_to_error(io: io::Error) -> ParserError { } impl fmt::Display for ParserError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // FIXME this should be a nicer error fmt::Debug::fmt(self, f) } } impl fmt::Display for DecoderError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // FIXME this should be a nicer error fmt::Debug::fmt(self, f) } @@ -344,7 +344,7 @@ impl std::error::Error for DecoderError { } impl fmt::Display for EncoderError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // FIXME this should be a nicer error fmt::Debug::fmt(self, f) } @@ -477,7 +477,7 @@ macro_rules! emit_enquoted_if_mapkey { }) } -impl<'a> ::Encoder for Encoder<'a> { +impl<'a> crate::Encoder for Encoder<'a> { type Error = EncoderError; fn emit_unit(&mut self) -> EncodeResult { @@ -727,7 +727,7 @@ impl<'a> PrettyEncoder<'a> { } } -impl<'a> ::Encoder for PrettyEncoder<'a> { +impl<'a> crate::Encoder for PrettyEncoder<'a> { type Error = EncoderError; fn emit_unit(&mut self) -> EncodeResult { @@ -997,7 +997,7 @@ impl<'a> ::Encoder for PrettyEncoder<'a> { } impl Encodable for Json { - fn encode(&self, e: &mut E) -> Result<(), E::Error> { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { match *self { Json::I64(v) => v.encode(e), Json::U64(v) => v.encode(e), @@ -1013,20 +1013,20 @@ impl Encodable for Json { /// Create an `AsJson` wrapper which can be used to print a value as JSON /// on-the-fly via `write!` -pub fn as_json(t: &T) -> AsJson { +pub fn as_json(t: &T) -> AsJson<'_, T> { AsJson { inner: t } } /// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON /// on-the-fly via `write!` -pub fn as_pretty_json(t: &T) -> AsPrettyJson { +pub fn as_pretty_json(t: &T) -> AsPrettyJson<'_, T> { AsPrettyJson { inner: t, indent: None } } impl Json { /// Borrow this json object as a pretty object to generate a pretty /// representation for it via `Display`. - pub fn pretty(&self) -> PrettyJson { + pub fn pretty(&self) -> PrettyJson<'_> { PrettyJson { inner: self } } @@ -1300,7 +1300,7 @@ impl Stack { /// Provides access to the StackElement at a given index. /// lower indices are at the bottom of the stack while higher indices are /// at the top. - pub fn get(&self, idx: usize) -> StackElement { + pub fn get(&self, idx: usize) -> StackElement<'_> { match self.stack[idx] { InternalIndex(i) => StackElement::Index(i), InternalKey(start, size) => { @@ -1311,8 +1311,8 @@ impl Stack { } } - /// Compares this stack with an array of StackElements. - pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool { + /// Compares this stack with an array of StackElement<'_>s. + pub fn is_equal_to(&self, rhs: &[StackElement<'_>]) -> bool { if self.stack.len() != rhs.len() { return false; } for (i, r) in rhs.iter().enumerate() { if self.get(i) != *r { return false; } @@ -1322,7 +1322,7 @@ impl Stack { /// Returns true if the bottom-most elements of this stack are the same as /// the ones passed as parameter. - pub fn starts_with(&self, rhs: &[StackElement]) -> bool { + pub fn starts_with(&self, rhs: &[StackElement<'_>]) -> bool { if self.stack.len() < rhs.len() { return false; } for (i, r) in rhs.iter().enumerate() { if self.get(i) != *r { return false; } @@ -1332,7 +1332,7 @@ impl Stack { /// Returns true if the top-most elements of this stack are the same as /// the ones passed as parameter. - pub fn ends_with(&self, rhs: &[StackElement]) -> bool { + pub fn ends_with(&self, rhs: &[StackElement<'_>]) -> bool { if self.stack.len() < rhs.len() { return false; } let offset = self.stack.len() - rhs.len(); for (i, r) in rhs.iter().enumerate() { @@ -1342,7 +1342,7 @@ impl Stack { } /// Returns the top-most element (if any). - pub fn top(&self) -> Option { + pub fn top(&self) -> Option> { match self.stack.last() { None => None, Some(&InternalIndex(i)) => Some(StackElement::Index(i)), @@ -2115,7 +2115,7 @@ macro_rules! read_primitive { } } -impl ::Decoder for Decoder { +impl crate::Decoder for Decoder { type Error = DecoderError; fn read_nil(&mut self) -> DecodeResult<()> { @@ -2172,7 +2172,7 @@ impl ::Decoder for Decoder { Err(ExpectedError("single character string".to_owned(), s.to_string())) } - fn read_str(&mut self) -> DecodeResult> { + fn read_str(&mut self) -> DecodeResult> { expect!(self.pop(), String).map(Cow::Owned) } @@ -2518,7 +2518,7 @@ impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> { impl fmt::Display for Json { /// Encodes a json value into a string - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut shim = FormatShim { inner: f }; let mut encoder = Encoder::new(&mut shim); match self.encode(&mut encoder) { @@ -2530,7 +2530,7 @@ impl fmt::Display for Json { impl<'a> fmt::Display for PrettyJson<'a> { /// Encodes a json value into a string - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut shim = FormatShim { inner: f }; let mut encoder = PrettyEncoder::new(&mut shim); match self.inner.encode(&mut encoder) { @@ -2542,7 +2542,7 @@ impl<'a> fmt::Display for PrettyJson<'a> { impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> { /// Encodes a json value into a string - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut shim = FormatShim { inner: f }; let mut encoder = Encoder::new(&mut shim); match self.inner.encode(&mut encoder) { @@ -2562,7 +2562,7 @@ impl<'a, T> AsPrettyJson<'a, T> { impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> { /// Encodes a json value into a string - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut shim = FormatShim { inner: f }; let mut encoder = PrettyEncoder::new(&mut shim); if let Some(n) = self.indent { @@ -2587,7 +2587,7 @@ mod tests { extern crate test; use self::Animal::*; use self::test::Bencher; - use {Encodable, Decodable}; + use crate::{Encodable, Decodable}; use super::Json::*; use super::ErrorCode::*; use super::ParserError::*; @@ -3515,7 +3515,7 @@ mod tests { #[test] fn test_hashmap_with_enum_key() { use std::collections::HashMap; - use json; + use crate::json; #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)] enum Enum { Foo, diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index e8d185a9cc0..9b73a5e686e 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -10,6 +10,8 @@ Core encoding and decoding interfaces. html_playground_url = "https://play.rust-lang.org/", test(attr(allow(unused_variables), deny(warnings))))] +#![deny(rust_2018_idioms)] + #![feature(box_syntax)] #![feature(core_intrinsics)] #![feature(specialization)] @@ -22,8 +24,6 @@ pub use self::serialize::{Decoder, Encoder, Decodable, Encodable}; pub use self::serialize::{SpecializationError, SpecializedEncoder, SpecializedDecoder}; pub use self::serialize::{UseSpecializedEncodable, UseSpecializedDecodable}; -extern crate smallvec; - mod serialize; mod collection_impls; @@ -34,5 +34,5 @@ pub mod opaque; pub mod leb128; mod rustc_serialize { - pub use serialize::*; + pub use crate::serialize::*; } diff --git a/src/libserialize/opaque.rs b/src/libserialize/opaque.rs index b8d4f8a79f3..8636c202d66 100644 --- a/src/libserialize/opaque.rs +++ b/src/libserialize/opaque.rs @@ -1,6 +1,6 @@ -use leb128::{self, read_signed_leb128, write_signed_leb128}; +use crate::leb128::{self, read_signed_leb128, write_signed_leb128}; use std::borrow::Cow; -use serialize; +use crate::serialize; // ----------------------------------------------------------------------------- // Encoder @@ -312,7 +312,7 @@ impl<'a> serialize::Decoder for Decoder<'a> { } #[inline] - fn read_str(&mut self) -> Result, Self::Error> { + fn read_str(&mut self) -> Result, Self::Error> { let len = self.read_usize()?; let s = ::std::str::from_utf8(&self.data[self.position..self.position + len]).unwrap(); self.position += len; @@ -328,7 +328,7 @@ impl<'a> serialize::Decoder for Decoder<'a> { #[cfg(test)] mod tests { - use serialize::{Encodable, Decodable}; + use crate::serialize::{Encodable, Decodable}; use std::fmt::Debug; use super::{Encoder, Decoder}; diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs index 03844b387ac..977a36a220f 100644 --- a/src/libserialize/serialize.rs +++ b/src/libserialize/serialize.rs @@ -175,7 +175,7 @@ pub trait Decoder { fn read_f64(&mut self) -> Result; fn read_f32(&mut self) -> Result; fn read_char(&mut self) -> Result; - fn read_str(&mut self) -> Result, Self::Error>; + fn read_str(&mut self) -> Result, Self::Error>; // Compound types: fn read_enum(&mut self, _name: &str, f: F) -> Result