Apply select clippy recommendations

clippy.toml

@@ -0,0 +1 @@
+msrv = "1.33.0"

csv-core/src/reader.rs

@@ -439,7 +439,7 @@ enum NfaState {
 }
 
 /// A list of NFA states that have an explicit representation in the DFA.
-const NFA_STATES: &'static [NfaState] = &[
+const NFA_STATES: &[NfaState] = &[
     NfaState::StartRecord,
     NfaState::StartField,
     NfaState::EndFieldDelim,
@@ -1238,7 +1238,7 @@ impl DfaClasses {
             panic!("added too many classes")
         }
         self.classes[b as usize] = self.next_class as u8;
-        self.next_class = self.next_class + 1;
+        self.next_class += 1;
     }
 
     fn num_classes(&self) -> usize {

csv-core/src/writer.rs

@@ -27,7 +27,7 @@ impl WriterBuilder {
             escape: b'\\',
             double_quote: true,
         };
-        WriterBuilder { wtr: wtr }
+        WriterBuilder { wtr }
     }
 
     /// Builder a CSV writer from this configuration.
@@ -171,12 +171,10 @@ pub struct Writer {
 impl Clone for Writer {
     fn clone(&self) -> Writer {
         let mut requires_quotes = [false; 256];
-        for i in 0..256 {
-            requires_quotes[i] = self.requires_quotes[i];
-        }
+        requires_quotes[..256].clone_from_slice(&self.requires_quotes[..256]);
         Writer {
             state: self.state.clone(),
-            requires_quotes: requires_quotes,
+            requires_quotes,
             delimiter: self.delimiter,
             term: self.term,
             style: self.style,
@@ -497,7 +495,7 @@ pub fn is_non_numeric(input: &[u8]) -> bool {
     // I suppose this could be faster if we wrote validators of numbers instead
     // of using the actual parser, but that's probably a lot of work for a bit
     // of a niche feature.
-    !s.parse::<f64>().is_ok() && !s.parse::<i128>().is_ok()
+    s.parse::<f64>().is_err() && s.parse::<i128>().is_err()
 }
 
 /// Escape quotes `input` and writes the result to `output`.

csv-index/src/simple.rs

@@ -1,7 +1,6 @@
 use std::io;
 
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
-use csv;
 
 /// A simple index for random access to CSV records.
 ///
@@ -153,7 +152,7 @@ impl<R: io::Read + io::Seek> RandomAccessSimple<R> {
     pub fn open(mut rdr: R) -> csv::Result<RandomAccessSimple<R>> {
         rdr.seek(io::SeekFrom::End(-8))?;
         let len = rdr.read_u64::<BigEndian>()?;
-        Ok(RandomAccessSimple { rdr: rdr, len: len })
+        Ok(RandomAccessSimple { rdr, len })
     }
 
     /// Get the position of the record at index `i`.

src/byte_record.rs

@@ -681,7 +681,7 @@ impl Bounds {
             None => 0,
             Some(&start) => start,
         };
-        Some(ops::Range { start: start, end: end })
+        Some(ops::Range { start, end })
     }
 
     /// Returns a slice of ending positions of all fields.
@@ -695,7 +695,7 @@ impl Bounds {
     /// If there are no fields, this returns `0`.
     #[inline]
     fn end(&self) -> usize {
-        self.ends().last().map(|&i| i).unwrap_or(0)
+        self.ends().last().copied().unwrap_or(0)
     }
 
     /// Returns the number of fields in these bounds.

src/deserializer.rs

@@ -30,7 +30,7 @@ pub fn deserialize_string_record<'de, D: Deserialize<'de>>(
     D::deserialize(&mut deser).map_err(|err| {
         Error::new(ErrorKind::Deserialize {
             pos: record.position().map(Clone::clone),
-            err: err,
+            err,
         })
     })
 }
@@ -47,7 +47,7 @@ pub fn deserialize_byte_record<'de, D: Deserialize<'de>>(
     D::deserialize(&mut deser).map_err(|err| {
         Error::new(ErrorKind::Deserialize {
             pos: record.position().map(Clone::clone),
-            err: err,
+            err,
         })
     })
 }
@@ -199,7 +199,7 @@ impl<'r> DeRecord<'r> for DeStringRecord<'r> {
     fn error(&self, kind: DeserializeErrorKind) -> DeserializeError {
         DeserializeError {
             field: Some(self.field.saturating_sub(1)),
-            kind: kind,
+            kind,
         }
     }
 
@@ -287,13 +287,13 @@ impl<'r> DeRecord<'r> for DeByteRecord<'r> {
 
     #[inline]
     fn peek_field(&mut self) -> Option<&'r [u8]> {
-        self.it.peek().map(|s| *s)
+        self.it.peek().copied()
     }
 
     fn error(&self, kind: DeserializeErrorKind) -> DeserializeError {
         DeserializeError {
             field: Some(self.field.saturating_sub(1)),
-            kind: kind,
+            kind,
         }
     }
 
@@ -335,8 +335,8 @@ macro_rules! deserialize_int {
             visitor: V,
         ) -> Result<V::Value, Self::Error> {
             let field = self.next_field()?;
-            let num = if field.starts_with("0x") {
-                <$inttype>::from_str_radix(&field[2..], 16)
+            let num = if let Some(stripped) = field.strip_prefix("0x") {
+                <$inttype>::from_str_radix(stripped, 16)
             } else {
                 field.parse()
             };
@@ -913,7 +913,7 @@ mod tests {
         struct Foo;
 
         #[derive(Deserialize, Debug, PartialEq)]
-        struct Bar {};
+        struct Bar {}
 
         let got = de_headers::<Foo>(&[], &[]);
         assert_eq!(got.unwrap(), Foo);

src/error.rs

@@ -228,7 +228,7 @@ pub struct FromUtf8Error {
 impl FromUtf8Error {
     /// Create a new FromUtf8Error.
     pub(crate) fn new(rec: ByteRecord, err: Utf8Error) -> FromUtf8Error {
-        FromUtf8Error { record: rec, err: err }
+        FromUtf8Error { record: rec, err }
     }
 
     /// Access the underlying `ByteRecord` that failed UTF-8 validation.
@@ -271,7 +271,7 @@ pub struct Utf8Error {
 
 /// Create a new UTF-8 error.
 pub fn new_utf8_error(field: usize, valid_up_to: usize) -> Utf8Error {
-    Utf8Error { field: field, valid_up_to: valid_up_to }
+    Utf8Error { field, valid_up_to }
 }
 
 impl Utf8Error {
@@ -315,7 +315,7 @@ impl<W> IntoInnerError<W> {
     /// (This is a visibility hack. It's public in this module, but not in the
     /// crate.)
     pub(crate) fn new(wtr: W, err: io::Error) -> IntoInnerError<W> {
-        IntoInnerError { wtr: wtr, err: err }
+        IntoInnerError { wtr, err }
     }
 
     /// Returns the error which caused the call to `into_inner` to fail.

src/reader.rs

@@ -1927,9 +1927,9 @@ impl<R: io::Read, D: DeserializeOwned> DeserializeRecordsIntoIter<R, D> {
             rdr.headers().ok().map(Clone::clone)
         };
         DeserializeRecordsIntoIter {
-            rdr: rdr,
+            rdr,
             rec: StringRecord::new(),
-            headers: headers,
+            headers,
             _priv: PhantomData,
         }
     }
@@ -1985,9 +1985,9 @@ impl<'r, R: io::Read, D: DeserializeOwned> DeserializeRecordsIter<'r, R, D> {
             rdr.headers().ok().map(Clone::clone)
         };
         DeserializeRecordsIter {
-            rdr: rdr,
+            rdr,
             rec: StringRecord::new(),
-            headers: headers,
+            headers,
             _priv: PhantomData,
         }
     }
@@ -2025,7 +2025,7 @@ pub struct StringRecordsIntoIter<R> {
 
 impl<R: io::Read> StringRecordsIntoIter<R> {
     fn new(rdr: Reader<R>) -> StringRecordsIntoIter<R> {
-        StringRecordsIntoIter { rdr: rdr, rec: StringRecord::new() }
+        StringRecordsIntoIter { rdr, rec: StringRecord::new() }
     }
 
     /// Return a reference to the underlying CSV reader.
@@ -2067,7 +2067,7 @@ pub struct StringRecordsIter<'r, R: 'r> {
 
 impl<'r, R: io::Read> StringRecordsIter<'r, R> {
     fn new(rdr: &'r mut Reader<R>) -> StringRecordsIter<'r, R> {
-        StringRecordsIter { rdr: rdr, rec: StringRecord::new() }
+        StringRecordsIter { rdr, rec: StringRecord::new() }
     }
 
     /// Return a reference to the underlying CSV reader.
@@ -2101,7 +2101,7 @@ pub struct ByteRecordsIntoIter<R> {
 
 impl<R: io::Read> ByteRecordsIntoIter<R> {
     fn new(rdr: Reader<R>) -> ByteRecordsIntoIter<R> {
-        ByteRecordsIntoIter { rdr: rdr, rec: ByteRecord::new() }
+        ByteRecordsIntoIter { rdr, rec: ByteRecord::new() }
     }
 
     /// Return a reference to the underlying CSV reader.
@@ -2143,7 +2143,7 @@ pub struct ByteRecordsIter<'r, R: 'r> {
 
 impl<'r, R: io::Read> ByteRecordsIter<'r, R> {
     fn new(rdr: &'r mut Reader<R>) -> ByteRecordsIter<'r, R> {
-        ByteRecordsIter { rdr: rdr, rec: ByteRecord::new() }
+        ByteRecordsIter { rdr, rec: ByteRecord::new() }
     }
 
     /// Return a reference to the underlying CSV reader.

src/serializer.rs

@@ -2,8 +2,6 @@ use std::fmt;
 use std::io;
 use std::mem;
 
-use itoa;
-use ryu;
 use serde::ser::{
     Error as SerdeError, Serialize, SerializeMap, SerializeSeq,
     SerializeStruct, SerializeStructVariant, SerializeTuple,
@@ -20,7 +18,7 @@ pub fn serialize<S: Serialize, W: io::Write>(
     wtr: &mut Writer<W>,
     value: S,
 ) -> Result<(), Error> {
-    value.serialize(&mut SeRecord { wtr: wtr })
+    value.serialize(&mut SeRecord { wtr })
 }
 
 struct SeRecord<'w, W: 'w + io::Write> {
@@ -452,7 +450,7 @@ struct SeHeader<'w, W: 'w + io::Write> {
 
 impl<'w, W: io::Write> SeHeader<'w, W> {
     fn new(wtr: &'w mut Writer<W>) -> Self {
-        SeHeader { wtr: wtr, state: HeaderState::Write }
+        SeHeader { wtr, state: HeaderState::Write }
     }
 
     fn wrote_header(&self) -> bool {

src/string_record.rs

@@ -646,7 +646,7 @@ impl StringRecord {
         match (read_res, utf8_res) {
             (Err(err), _) => Err(err),
             (Ok(_), Err(err)) => {
-                Err(Error::new(ErrorKind::Utf8 { pos: Some(pos), err: err }))
+                Err(Error::new(ErrorKind::Utf8 { pos: Some(pos), err }))
             }
             (Ok(eof), Ok(())) => Ok(eof),
         }