From 488bfdc59c690a5ff1daf374cd6d1abed1c01e92 Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Sun, 20 Oct 2019 13:57:04 +0100 Subject: [PATCH] Fix clippyisms --- implementations/rust/src/symbol.rs | 2 +- implementations/rust/src/value/de.rs | 29 +++++++-------- implementations/rust/src/value/decoder.rs | 44 +++++++++++++---------- implementations/rust/src/value/encoder.rs | 12 ++++--- implementations/rust/src/value/value.rs | 38 ++++++++++---------- 5 files changed, 67 insertions(+), 58 deletions(-) diff --git a/implementations/rust/src/symbol.rs b/implementations/rust/src/symbol.rs index 67f1603..f2e2b63 100644 --- a/implementations/rust/src/symbol.rs +++ b/implementations/rust/src/symbol.rs @@ -12,7 +12,7 @@ impl serde::Serialize for Symbol { impl<'de> serde::Deserialize<'de> for Symbol { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { let v = PlainValue::deserialize(deserializer)?; - let s = v.value().as_symbol().ok_or(serde::de::Error::custom("Expected symbol"))?; + let s = v.value().as_symbol().ok_or_else(|| serde::de::Error::custom("Expected symbol"))?; Ok(Symbol(s.clone())) } } diff --git a/implementations/rust/src/value/de.rs b/implementations/rust/src/value/de.rs index a3a0775..9d6e266 100644 --- a/implementations/rust/src/value/de.rs +++ b/implementations/rust/src/value/de.rs @@ -54,10 +54,7 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali self.deserialize_unit(visitor) } else if v.is_simple_record("UnicodeScalar", Some(1)) { self.deserialize_char(visitor) - } else - if v.is_simple_record("None", Some(0)) || - v.is_simple_record("Some", Some(1)) - { + } else if v.is_simple_record("None", Some(0)) || v.is_simple_record("Some", Some(1)) { self.deserialize_option(visitor) } else if v.is_simple_record("tuple", None) { visitor.visit_seq(VecSeq::new(self, v.as_simple_record("tuple", None).unwrap())) @@ -78,49 +75,49 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali fn deserialize_i8(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; - visitor.visit_i8(i.to_i8().ok_or(Error::NumberTooLarge(i.clone()))?) + visitor.visit_i8(i.to_i8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } fn deserialize_i16(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; - visitor.visit_i16(i.to_i16().ok_or(Error::NumberTooLarge(i.clone()))?) + visitor.visit_i16(i.to_i16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } fn deserialize_i32(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; - visitor.visit_i32(i.to_i32().ok_or(Error::NumberTooLarge(i.clone()))?) + visitor.visit_i32(i.to_i32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } fn deserialize_i64(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; - visitor.visit_i64(i.to_i64().ok_or(Error::NumberTooLarge(i.clone()))?) + visitor.visit_i64(i.to_i64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } fn deserialize_u8(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; - visitor.visit_u8(i.to_u8().ok_or(Error::NumberTooLarge(i.clone()))?) + visitor.visit_u8(i.to_u8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } fn deserialize_u16(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; - visitor.visit_u16(i.to_u16().ok_or(Error::NumberTooLarge(i.clone()))?) + visitor.visit_u16(i.to_u16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } fn deserialize_u32(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; - visitor.visit_u32(i.to_u32().ok_or(Error::NumberTooLarge(i.clone()))?) + visitor.visit_u32(i.to_u32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } fn deserialize_u64(self, visitor: V) -> Result where V: Visitor<'de> { let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?; - visitor.visit_u64(i.to_u64().ok_or(Error::NumberTooLarge(i.clone()))?) + visitor.visit_u64(i.to_u64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?) } fn deserialize_f32(self, visitor: V) -> Result where V: Visitor<'de> @@ -269,12 +266,12 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali pub struct VecSeq<'a, 'de: 'a, N: NestedValue> { index: usize, - vec: &'de Vec, + vec: &'de [N], de: &'a mut Deserializer<'de, N>, } impl<'de, 'a, N: NestedValue> VecSeq<'a, 'de, N> { - fn new(de: &'a mut Deserializer<'de, N>, vec: &'de Vec) -> Self { + fn new(de: &'a mut Deserializer<'de, N>, vec: &'de [N]) -> Self { VecSeq{ index: 0, vec, de } } } @@ -290,7 +287,7 @@ impl<'de, 'a, N: NestedValue> SeqAccess<'de> for VecSeq<'a, 'de, N> { } self.de.input = &self.vec[self.index]; - self.index = self.index + 1; + self.index += 1; let value = seed.deserialize(&mut *self.de)?; Ok(Some(value)) } @@ -304,7 +301,7 @@ pub struct DictMap<'a, 'de: 'a, N: NestedValue> { impl<'de, 'a, N: NestedValue> DictMap<'a, 'de, N> { fn new(de: &'a mut Deserializer<'de, N>, d: &'de Map) -> Self { - DictMap{ pending: None, iter: Box::new(d.into_iter()), de } + DictMap{ pending: None, iter: Box::new(d.iter()), de } } } diff --git a/implementations/rust/src/value/decoder.rs b/implementations/rust/src/value/decoder.rs index 92386df..35dbc05 100644 --- a/implementations/rust/src/value/decoder.rs +++ b/implementations/rust/src/value/decoder.rs @@ -50,10 +50,17 @@ impl Error { pub type DecodePlaceholderMap = Map>; +#[derive(PartialEq, Eq)] +enum PeekState { + Empty, + Eof, + Full(u8), +} + pub struct Decoder<'a, 'b, R: Read, N: NestedValue> { read: &'a mut R, index: usize, - buf: Box>>, + buf: Box, placeholders: Option<&'b DecodePlaceholderMap>, read_annotations: bool, } @@ -67,46 +74,47 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> { Decoder{ read, index: 0, - buf: Box::new(None), + buf: Box::new(PeekState::Empty), placeholders, read_annotations: true, } } - pub fn set_read_annotations(&mut self, read_annotations: bool) -> () { + pub fn set_read_annotations(&mut self, read_annotations: bool) { self.read_annotations = read_annotations } fn prime(&mut self) -> Result<()> { match *self.buf { - None => { + PeekState::Empty => { let bs = &mut [0]; - *self.buf = Some(match self.read.read(bs)? { - 0 => None, + *self.buf = match self.read.read(bs)? { + 0 => PeekState::Eof, 1 => { - self.index = self.index + 1; - Some(bs[0]) + self.index += 1; + PeekState::Full(bs[0]) }, _ => panic!("buffer overrun") - }) + } } - Some(_) => () + PeekState::Eof => (), + PeekState::Full(_) => (), } Ok(()) } pub fn skip(&mut self) -> Result<()> { self.prime()?; - *self.buf = None; + *self.buf = PeekState::Empty; Ok(()) } pub fn peek(&mut self) -> Result { self.prime()?; match *self.buf { - Some(Some(v)) => Ok(v), - Some(None) => Err(Error::Eof), - None => unreachable!() + PeekState::Full(v) => Ok(v), + PeekState::Eof => Err(Error::Eof), + PeekState::Empty => unreachable!() } } @@ -117,7 +125,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> { } pub fn readbytes(&mut self, n: usize) -> Result> { - if (*self.buf).is_some() { + if *self.buf != PeekState::Empty { unreachable!(); } let mut bs = vec![0; n]; @@ -139,7 +147,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> { let mut pieces: Vec = Vec::with_capacity(count); while count > 0 { pieces.push(self.next()?); - count = count - 1; + count -= 1; } Ok(pieces) } @@ -190,7 +198,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> { pub fn decodecompound(minor: CompoundMinor, mut pieces: Vec) -> Result { match minor { CompoundMinor::Record => - if pieces.len() == 0 { + if pieces.is_empty() { Err(Error::Syntax("Too few elements in encoded record")) } else { let label = pieces.remove(0); @@ -257,7 +265,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> { annotations.push(self.next()?); } let v = self.next()?; - assert!(v.annotations().len() == 0); + assert!(v.annotations().is_empty()); Ok(N::wrap_ann(annotations, v.value_owned())) } else { self.next()?; diff --git a/implementations/rust/src/value/encoder.rs b/implementations/rust/src/value/encoder.rs index f3e8ff0..a629ac0 100644 --- a/implementations/rust/src/value/encoder.rs +++ b/implementations/rust/src/value/encoder.rs @@ -99,19 +99,23 @@ impl<'a, 'b, W: Write, N: NestedValue> Encoder<'a, 'b, W, N> { Value::Record((ref l, ref fs)) => { self.write_header(Op::Compound(CompoundMinor::Record), fs.len() + 1)?; self.write(N::boxunwrap(l))?; - Ok(for f in fs { self.write(f)?; }) + for f in fs { self.write(f)?; } + Ok(()) } Value::Sequence(ref vs) => { self.write_header(Op::Compound(CompoundMinor::Sequence), vs.len())?; - Ok(for v in vs { self.write(v)?; }) + for v in vs { self.write(v)?; } + Ok(()) } Value::Set(ref vs) => { self.write_header(Op::Compound(CompoundMinor::Set), vs.len())?; - Ok(for v in vs { self.write(v)?; }) + for v in vs { self.write(v)?; } + Ok(()) } Value::Dictionary(ref vs) => { self.write_header(Op::Compound(CompoundMinor::Dictionary), vs.len() << 1)?; - Ok(for (k, v) in vs { self.write(k)?; self.write(v)?; }) + for (k, v) in vs { self.write(k)?; self.write(v)?; } + Ok(()) } } } diff --git a/implementations/rust/src/value/value.rs b/implementations/rust/src/value/value.rs index 40bb83c..78755bd 100644 --- a/implementations/rust/src/value/value.rs +++ b/implementations/rust/src/value/value.rs @@ -92,8 +92,8 @@ impl Ord for Float { fn cmp(&self, other: &Self) -> Ordering { let mut a: u32 = self.0.to_bits(); let mut b: u32 = other.0.to_bits(); - if a & 0x80000000 != 0 { a ^= 0x7fffffff; } - if b & 0x80000000 != 0 { b ^= 0x7fffffff; } + if a & 0x8000_0000 != 0 { a ^= 0x7fff_ffff; } + if b & 0x8000_0000 != 0 { b ^= 0x7fff_ffff; } (a as i32).cmp(&(b as i32)) } } @@ -126,7 +126,7 @@ impl Hash for Double { impl PartialEq for Double { fn eq(&self, other: &Self) -> bool { - return self.0.to_bits() == other.0.to_bits(); + self.0.to_bits() == other.0.to_bits() } } @@ -134,8 +134,8 @@ impl Ord for Double { fn cmp(&self, other: &Self) -> Ordering { let mut a: u64 = self.0.to_bits(); let mut b: u64 = other.0.to_bits(); - if a & 0x8000000000000000 != 0 { a ^= 0x7fffffffffffffff; } - if b & 0x8000000000000000 != 0 { b ^= 0x7fffffffffffffff; } + if a & 0x8000_0000_0000_0000 != 0 { a ^= 0x7fff_ffff_ffff_ffff; } + if b & 0x8000_0000_0000_0000 != 0 { b ^= 0x7fff_ffff_ffff_ffff; } (a as i64).cmp(&(b as i64)) } } @@ -153,14 +153,14 @@ impl From for Value { fn from(v: bool) -> Self { Value: impl From for Value { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } } impl From for Value { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } } -impl From for Value { fn from(v: u8) -> Self { Value::from(v as i128) } } -impl From for Value { fn from(v: i8) -> Self { Value::from(v as i128) } } -impl From for Value { fn from(v: u16) -> Self { Value::from(v as i128) } } -impl From for Value { fn from(v: i16) -> Self { Value::from(v as i128) } } -impl From for Value { fn from(v: u32) -> Self { Value::from(v as i128) } } -impl From for Value { fn from(v: i32) -> Self { Value::from(v as i128) } } -impl From for Value { fn from(v: u64) -> Self { Value::from(v as i128) } } -impl From for Value { fn from(v: i64) -> Self { Value::from(v as i128) } } +impl From for Value { fn from(v: u8) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: i8) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: u16) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: i16) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: u32) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: i32) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: u64) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: i64) -> Self { Value::from(i128::from(v)) } } impl From for Value { fn from(v: u128) -> Self { Value::SignedInteger(BigInt::from(v)) } } impl From for Value { fn from(v: i128) -> Self { Value::SignedInteger(BigInt::from(v)) } } impl From for Value { fn from(v: BigInt) -> Self { Value::SignedInteger(v) } } @@ -193,7 +193,7 @@ impl Debug for Value { } Value::Symbol(ref v) => { // TODO: proper escaping! - if v.len() == 0 { + if v.is_empty() { f.write_str("||") } else { write!(f, "{}", v) @@ -558,7 +558,7 @@ impl serde::Serialize for Value { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { let mut buf: Vec = Vec::new(); crate::value::Encoder::new(&mut buf, None).write_value(self) - .or(Err(serde::ser::Error::custom("Internal error")))?; + .or_else(|_| Err(serde::ser::Error::custom("Internal error")))?; ValueWrapper(buf).serialize(serializer) } } @@ -567,18 +567,18 @@ impl<'de, N: NestedValue> serde::Deserialize<'de> for Value { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?; let v: N = crate::value::Decoder::new(&mut &buf[..], None).next() - .or(Err(serde::de::Error::custom("Internal error")))?; + .or_else(|_| Err(serde::de::Error::custom("Internal error")))?; Ok(v.value_owned()) } } -pub fn serialize_nested_value<'de, S, N>(v: &N, serializer: S) -> +pub fn serialize_nested_value(v: &N, serializer: S) -> Result where S: serde::Serializer, N: NestedValue { use serde::Serialize; let mut buf: Vec = Vec::new(); crate::value::Encoder::new(&mut buf, None).write(v) - .or(Err(serde::ser::Error::custom("Internal error")))?; + .or_else(|_| Err(serde::ser::Error::custom("Internal error")))?; ValueWrapper(buf).serialize(serializer) } @@ -588,7 +588,7 @@ pub fn deserialize_nested_value<'de, D, N>(deserializer: D) -> use serde::Deserialize; let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?; crate::value::Decoder::new(&mut &buf[..], None).next() - .or(Err(serde::de::Error::custom("Internal error"))) + .or_else(|_| Err(serde::de::Error::custom("Internal error"))) } //---------------------------------------------------------------------------