2018 edition

Author: jonhoo

Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "msql-srv"
 version = "0.8.5"
+edition = "2018"
 
 description = "Bindings for emulating a MySQL/MariaDB server"
 readme = "README.md"

examples/psql_as_mysql.rs

@@ -187,7 +187,7 @@ impl<W: io::Write> MysqlShim<W> for Postgres {
                 // we can only do that by first boxing all the values (so they can be kept in a
                 // single vec), and then collecting a *second* vec with references to those, and
                 // *then* take a slice of that vec.
-                let args: Vec<Box<postgres::types::ToSql>> = ps
+                let args: Vec<Box<dyn postgres::types::ToSql>> = ps
                     .into_iter()
                     .map(|p| match p.coltype {
                         ColumnType::MYSQL_TYPE_SHORT => {

src/commands.rs

@@ -1,4 +1,4 @@
-use myc::constants::{CapabilityFlags, Command as CommandByte};
+use crate::myc::constants::{CapabilityFlags, Command as CommandByte};
 use nom;
 
 #[derive(Debug)]
@@ -9,7 +9,7 @@ pub struct ClientHandshake<'a> {
     username: &'a [u8],
 }
 
-pub fn client_handshake(i: &[u8]) -> nom::IResult<&[u8], ClientHandshake> {
+pub fn client_handshake(i: &[u8]) -> nom::IResult<&[u8], ClientHandshake<'_>> {
     let (i, cap) = nom::number::complete::le_u32(i)?;
     let (i, maxps) = nom::number::complete::le_u32(i)?;
     let (i, collation) = nom::bytes::complete::take(1u8)(i)?;
@@ -47,14 +47,14 @@ pub enum Command<'a> {
     Quit,
 }
 
-pub fn execute(i: &[u8]) -> nom::IResult<&[u8], Command> {
+pub fn execute(i: &[u8]) -> nom::IResult<&[u8], Command<'_>> {
     let (i, stmt) = nom::number::complete::le_u32(i)?;
     let (i, _flags) = nom::bytes::complete::take(1u8)(i)?;
     let (i, _iterations) = nom::number::complete::le_u32(i)?;
     Ok((&[], Command::Execute { stmt, params: i }))
 }
 
-pub fn send_long_data(i: &[u8]) -> nom::IResult<&[u8], Command> {
+pub fn send_long_data(i: &[u8]) -> nom::IResult<&[u8], Command<'_>> {
     let (i, stmt) = nom::number::complete::le_u32(i)?;
     let (i, param) = nom::number::complete::le_u16(i)?;
     Ok((
@@ -67,7 +67,7 @@ pub fn send_long_data(i: &[u8]) -> nom::IResult<&[u8], Command> {
     ))
 }
 
-pub fn parse(i: &[u8]) -> nom::IResult<&[u8], Command> {
+pub fn parse(i: &[u8]) -> nom::IResult<&[u8], Command<'_>> {
     use nom::bytes::complete::tag;
     use nom::combinator::{map, rest};
     use nom::sequence::preceded;
@@ -108,8 +108,8 @@ pub fn parse(i: &[u8]) -> nom::IResult<&[u8], Command> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use myc::constants::{CapabilityFlags, UTF8_GENERAL_CI};
-    use packet::PacketReader;
+    use crate::myc::constants::{CapabilityFlags, UTF8_GENERAL_CI};
+    use crate::packet::PacketReader;
     use std::io::Cursor;
 
     #[test]

src/lib.rs

@@ -80,6 +80,7 @@
 //! }
 //! ```
 #![deny(missing_docs)]
+#![deny(rust_2018_idioms)]
 
 // Note to developers: you can find decent overviews of the protocol at
 //
@@ -91,18 +92,15 @@
 //
 // Wireshark also does a pretty good job at parsing the MySQL protocol.
 
-extern crate byteorder;
-extern crate chrono;
 extern crate mysql_common as myc;
-extern crate nom;
 
 use std::collections::HashMap;
 use std::io;
 use std::io::prelude::*;
 use std::iter;
 use std::net;
 
-pub use myc::constants::{ColumnFlags, ColumnType, StatusFlags};
+pub use crate::myc::constants::{ColumnFlags, ColumnType, StatusFlags};
 
 mod commands;
 mod errorcodes;
@@ -132,10 +130,10 @@ pub struct Column {
     pub colflags: ColumnFlags,
 }
 
-pub use errorcodes::ErrorKind;
-pub use params::{ParamParser, ParamValue, Params};
-pub use resultset::{InitWriter, QueryResultWriter, RowWriter, StatementMetaWriter};
-pub use value::{ToMysqlValue, Value, ValueInner};
+pub use crate::errorcodes::ErrorKind;
+pub use crate::params::{ParamParser, ParamValue, Params};
+pub use crate::resultset::{InitWriter, QueryResultWriter, RowWriter, StatementMetaWriter};
+pub use crate::value::{ToMysqlValue, Value, ValueInner};
 
 /// Implementors of this trait can be used to drive a MySQL-compatible database backend.
 pub trait MysqlShim<W: Write> {
@@ -149,7 +147,11 @@ pub trait MysqlShim<W: Write> {
     /// The provided [`StatementMetaWriter`](struct.StatementMetaWriter.html) should be used to
     /// notify the client of the statement id assigned to the prepared statement, as well as to
     /// give metadata about the types of parameters and returned columns.
-    fn on_prepare(&mut self, query: &str, info: StatementMetaWriter<W>) -> Result<(), Self::Error>;
+    fn on_prepare(
+        &mut self,
+        query: &str,
+        info: StatementMetaWriter<'_, W>,
+    ) -> Result<(), Self::Error>;
 
     /// Called when the client executes a previously prepared statement.
     ///
@@ -159,8 +161,8 @@ pub trait MysqlShim<W: Write> {
     fn on_execute(
         &mut self,
         id: u32,
-        params: ParamParser,
-        results: QueryResultWriter<W>,
+        params: ParamParser<'_>,
+        results: QueryResultWriter<'_, W>,
     ) -> Result<(), Self::Error>;
 
     /// Called when the client wishes to deallocate resources associated with a previously prepared
@@ -171,10 +173,14 @@ pub trait MysqlShim<W: Write> {
     ///
     /// Results should be returned using the given
     /// [`QueryResultWriter`](struct.QueryResultWriter.html).
-    fn on_query(&mut self, query: &str, results: QueryResultWriter<W>) -> Result<(), Self::Error>;
+    fn on_query(
+        &mut self,
+        query: &str,
+        results: QueryResultWriter<'_, W>,
+    ) -> Result<(), Self::Error>;
 
     /// Called when client switches database.
-    fn on_init(&mut self, _: &str, _: InitWriter<W>) -> Result<(), Self::Error> {
+    fn on_init(&mut self, _: &str, _: InitWriter<'_, W>) -> Result<(), Self::Error> {
         Ok(())
     }
 }
@@ -259,7 +265,7 @@ impl<B: MysqlShim<W>, R: Read, W: Write> MysqlIntermediary<B, R, W> {
     }
 
     fn run(mut self) -> Result<(), B::Error> {
-        use commands::Command;
+        use crate::commands::Command;
 
         let mut stmts: HashMap<u32, _> = HashMap::new();
         while let Some((seq, packet)) = self.reader.next()? {

src/packet.rs

@@ -81,7 +81,7 @@ impl<R> PacketReader<R> {
 }
 
 impl<R: Read> PacketReader<R> {
-    pub fn next(&mut self) -> io::Result<Option<(u8, Packet)>> {
+    pub fn next(&mut self) -> io::Result<Option<(u8, Packet<'_>)>> {
         self.start = self.bytes.len() - self.remaining;
 
         loop {
@@ -193,13 +193,13 @@ impl<'a> Deref for Packet<'a> {
     }
 }
 
-fn packet(i: &[u8]) -> nom::IResult<&[u8], (u8, Packet)> {
+fn packet(i: &[u8]) -> nom::IResult<&[u8], (u8, Packet<'_>)> {
     nom::combinator::map(
         nom::sequence::pair(
             nom::multi::fold_many0(
                 fullpacket,
                 (0, None),
-                |(seq, pkt): (_, Option<Packet>), (nseq, p)| {
+                |(seq, pkt): (_, Option<Packet<'_>>), (nseq, p)| {
                     let pkt = if let Some(mut pkt) = pkt {
                         assert_eq!(nseq, seq + 1);
                         pkt.extend(p);

src/params.rs

@@ -1,6 +1,6 @@
-use myc;
+use crate::myc;
 use std::collections::HashMap;
-use {StatementData, Value};
+use crate::{StatementData, Value};
 
 /// A `ParamParser` decodes query parameters included in a client's `EXECUTE` command given
 /// type information for the expected parameters.

src/resultset.rs

@@ -1,15 +1,15 @@
+use crate::myc::constants::{ColumnFlags, StatusFlags};
+use crate::packet::PacketWriter;
+use crate::value::ToMysqlValue;
+use crate::writers;
+use crate::{Column, ErrorKind, StatementData};
 use byteorder::WriteBytesExt;
-use myc::constants::{ColumnFlags, StatusFlags};
-use packet::PacketWriter;
 use std::borrow::Borrow;
 use std::collections::HashMap;
 use std::io::{self, Write};
-use value::ToMysqlValue;
-use writers;
-use {Column, ErrorKind, StatementData};
 
 /// Convenience type for responding to a client `USE <db>` command.
-pub struct InitWriter<'a, W: Write + 'a> {
+pub struct InitWriter<'a, W: Write> {
     pub(crate) writer: &'a mut PacketWriter<W>,
 }
 
@@ -37,7 +37,7 @@ impl<'a, W: Write + 'a> InitWriter<'a, W> {
 /// [`reply`](struct.StatementMetaWriter.html#method.reply) or
 /// [`error`](struct.StatementMetaWriter.html#method.error).
 #[must_use]
-pub struct StatementMetaWriter<'a, W: Write + 'a> {
+pub struct StatementMetaWriter<'a, W: Write> {
     pub(crate) writer: &'a mut PacketWriter<W>,
     pub(crate) stmts: &'a mut HashMap<u32, StatementData>,
 }
@@ -100,7 +100,7 @@ enum Finalizer {
 /// program may panic if an I/O error occurs when sending the end-of-records marker to the client.
 /// To handle such errors, call `no_more_results` explicitly.
 #[must_use]
-pub struct QueryResultWriter<'a, W: Write + 'a> {
+pub struct QueryResultWriter<'a, W: Write> {
     // XXX: specialization instead?
     pub(crate) is_bin: bool,
     pub(crate) writer: &'a mut PacketWriter<W>,
@@ -195,7 +195,7 @@ impl<'a, W: Write> Drop for QueryResultWriter<'a, W> {
 /// if an I/O error occurs when sending the end-of-records marker to the client. To avoid this,
 /// call [`finish`](struct.RowWriter.html#method.finish) explicitly.
 #[must_use]
-pub struct RowWriter<'a, W: Write + 'a> {
+pub struct RowWriter<'a, W: Write> {
     result: Option<QueryResultWriter<'a, W>>,
     bitmap_len: usize,
     data: Vec<u8>,

src/value/decode.rs

@@ -1,6 +1,6 @@
 use byteorder::{LittleEndian, ReadBytesExt};
-use myc::constants::ColumnType;
-use myc::io::ReadMysqlExt;
+use crate::myc::constants::ColumnType;
+use crate::myc::io::ReadMysqlExt;
 use std::io;
 
 /// MySQL value as provided when executing prepared statements.
@@ -283,10 +283,10 @@ impl<'a> Into<Duration> for Value<'a> {
 mod tests {
     use super::Value;
     use chrono::{self, TimeZone};
-    use myc;
-    use myc::io::WriteMysqlExt;
+    use crate::myc;
+    use crate::myc::io::WriteMysqlExt;
     use std::time;
-    use {Column, ColumnFlags, ColumnType};
+    use crate::{Column, ColumnFlags, ColumnType};
 
     macro_rules! rt {
         ($name:ident, $t:ty, $v:expr, $ct:expr) => {

src/value/encode.rs

@@ -1,9 +1,9 @@
 use byteorder::{LittleEndian, WriteBytesExt};
-use myc;
-use myc::constants::{ColumnFlags, ColumnType};
-use myc::io::WriteMysqlExt;
+use crate::myc;
+use crate::myc::constants::{ColumnFlags, ColumnType};
+use crate::myc::io::WriteMysqlExt;
 use std::io::{self, Write};
-use Column;
+use crate::Column;
 
 /// Implementors of this trait can be sent as a single resultset value to a MySQL/MariaDB client.
 pub trait ToMysqlValue {
@@ -659,10 +659,10 @@ impl ToMysqlValue for myc::value::Value {
 mod tests {
     use super::ToMysqlValue;
     use chrono::{self, TimeZone};
-    use myc::value;
-    use myc::value::convert::from_value;
+    use crate::myc::value;
+    use crate::myc::value::convert::from_value;
     use std::time;
-    use {Column, ColumnFlags, ColumnType};
+    use crate::{Column, ColumnFlags, ColumnType};
 
     mod roundtrip_text {
         use super::*;

src/writers.rs

@@ -1,9 +1,9 @@
 use byteorder::{LittleEndian, WriteBytesExt};
-use myc::constants::StatusFlags;
-use myc::io::WriteMysqlExt;
-use packet::PacketWriter;
+use crate::myc::constants::StatusFlags;
+use crate::myc::io::WriteMysqlExt;
+use crate::packet::PacketWriter;
 use std::io::{self, Write};
-use {Column, ErrorKind};
+use crate::{Column, ErrorKind};
 
 pub(crate) fn write_eof_packet<W: Write>(
     w: &mut PacketWriter<W>,
@@ -80,7 +80,7 @@ where
     let mut empty = true;
     for c in i {
         let c = c.borrow();
-        use myc::constants::UTF8_GENERAL_CI;
+        use crate::myc::constants::UTF8_GENERAL_CI;
         w.write_lenenc_str(b"def")?;
         w.write_lenenc_str(b"")?;
         w.write_lenenc_str(c.table.as_bytes())?;