Fix clippyisms

implementations/rust/src/symbol.rs

@@ -12,7 +12,7 @@ impl serde::Serialize for Symbol {
 impl<'de> serde::Deserialize<'de> for Symbol {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 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()))
     }
 }

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
+                } else if v.is_simple_record("None", Some(0)) || v.is_simple_record("Some", Some(1)) {
-                    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<V>(self, visitor: V) -> Result<V::Value> 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<V>(self, visitor: V) -> Result<V::Value> 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<V>(self, visitor: V) -> Result<V::Value> 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<V>(self, visitor: V) -> Result<V::Value> 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<V>(self, visitor: V) -> Result<V::Value> 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<V>(self, visitor: V) -> Result<V::Value> 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<V>(self, visitor: V) -> Result<V::Value> 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<V>(self, visitor: V) -> Result<V::Value> 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<V>(self, visitor: V) -> Result<V::Value> 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<N>,
+    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<N>) -> 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<N, N>) -> Self {
-        DictMap{ pending: None, iter: Box::new(d.into_iter()), de }
+        DictMap{ pending: None, iter: Box::new(d.iter()), de }
     }
 }
 

implementations/rust/src/value/decoder.rs

@@ -50,10 +50,17 @@ impl Error {
 
 pub type DecodePlaceholderMap<N> = Map<usize, Value<N>>;
 
+#[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<Option<Option<u8>>>,
+    buf: Box<PeekState>,
     placeholders: Option<&'b DecodePlaceholderMap<N>>,
     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)? {
+                *self.buf = match self.read.read(bs)? {
-                    0 => None,
+                    0 => PeekState::Eof,
                     1 => {
-                        self.index = self.index + 1;
+                        self.index += 1;
-                        Some(bs[0])
+                        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<u8> {
         self.prime()?;
         match *self.buf {
-            Some(Some(v)) => Ok(v),
+            PeekState::Full(v) => Ok(v),
-            Some(None) => Err(Error::Eof),
+            PeekState::Eof => Err(Error::Eof),
-            None => unreachable!()
+            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<Vec<u8>> {
-        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<N> = 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<N>) -> Result<N> {
         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()?;

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(())
                 }
             }
         }

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 a & 0x8000_0000 != 0 { a ^= 0x7fff_ffff; }
-        if b & 0x80000000 != 0 { b ^= 0x7fffffff; }
+        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 a & 0x8000_0000_0000_0000 != 0 { a ^= 0x7fff_ffff_ffff_ffff; }
-        if b & 0x8000000000000000 != 0 { b ^= 0x7fffffffffffffff; }
+        if b & 0x8000_0000_0000_0000 != 0 { b ^= 0x7fff_ffff_ffff_ffff; }
         (a as i64).cmp(&(b as i64))
     }
 }
@@ -153,14 +153,14 @@ impl<N: NestedValue> From<bool> for Value<N> { fn from(v: bool) -> Self { Value:
 impl<N: NestedValue> From<f32> for Value<N> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
 impl<N: NestedValue> From<f64> for Value<N> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
 
-impl<N: NestedValue> From<u8> for Value<N> { fn from(v: u8) -> Self { Value::from(v as i128) } }
+impl<N: NestedValue> From<u8> for Value<N> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue> From<i8> for Value<N> { fn from(v: i8) -> Self { Value::from(v as i128) } }
+impl<N: NestedValue> From<i8> for Value<N> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue> From<u16> for Value<N> { fn from(v: u16) -> Self { Value::from(v as i128) } }
+impl<N: NestedValue> From<u16> for Value<N> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue> From<i16> for Value<N> { fn from(v: i16) -> Self { Value::from(v as i128) } }
+impl<N: NestedValue> From<i16> for Value<N> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue> From<u32> for Value<N> { fn from(v: u32) -> Self { Value::from(v as i128) } }
+impl<N: NestedValue> From<u32> for Value<N> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue> From<i32> for Value<N> { fn from(v: i32) -> Self { Value::from(v as i128) } }
+impl<N: NestedValue> From<i32> for Value<N> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue> From<u64> for Value<N> { fn from(v: u64) -> Self { Value::from(v as i128) } }
+impl<N: NestedValue> From<u64> for Value<N> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue> From<i64> for Value<N> { fn from(v: i64) -> Self { Value::from(v as i128) } }
+impl<N: NestedValue> From<i64> for Value<N> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
 impl<N: NestedValue> From<u128> for Value<N> { fn from(v: u128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
 impl<N: NestedValue> From<i128> for Value<N> { fn from(v: i128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
 impl<N: NestedValue> From<BigInt> for Value<N> { fn from(v: BigInt) -> Self { Value::SignedInteger(v) } }
@@ -193,7 +193,7 @@ impl<N: NestedValue> Debug for Value<N> {
             }
             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<N: NestedValue> serde::Serialize for Value<N> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
         let mut buf: Vec<u8> = 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<N> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 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<S, N>(v: &N, serializer: S) ->
     Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue
 {
     use serde::Serialize;
     let mut buf: Vec<u8> = 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")))
 }
 
 //---------------------------------------------------------------------------