ignore: polish

Like previous commits, we do a bit of polishing and bring the style up
to my current practice.

crates/ignore/src/lib.rs

@@ -46,9 +46,6 @@ See the documentation for `WalkBuilder` for many other options.
 
 #![deny(missing_docs)]
 
-use std::error;
-use std::fmt;
-use std::io;
 use std::path::{Path, PathBuf};
 
 pub use crate::walk::{
@@ -101,7 +98,7 @@ pub enum Error {
         child: PathBuf,
     },
     /// An error that occurs when doing I/O, such as reading an ignore file.
-    Io(io::Error),
+    Io(std::io::Error),
     /// An error that occurs when trying to parse a glob.
     Glob {
         /// The original glob that caused this error. This glob, when
@@ -125,21 +122,23 @@ impl Clone for Error {
         match *self {
             Error::Partial(ref errs) => Error::Partial(errs.clone()),
             Error::WithLineNumber { line, ref err } => {
-                Error::WithLineNumber { line: line, err: err.clone() }
+                Error::WithLineNumber { line, err: err.clone() }
             }
             Error::WithPath { ref path, ref err } => {
                 Error::WithPath { path: path.clone(), err: err.clone() }
             }
             Error::WithDepth { depth, ref err } => {
-                Error::WithDepth { depth: depth, err: err.clone() }
+                Error::WithDepth { depth, err: err.clone() }
             }
             Error::Loop { ref ancestor, ref child } => Error::Loop {
                 ancestor: ancestor.clone(),
                 child: child.clone(),
             },
             Error::Io(ref err) => match err.raw_os_error() {
-                Some(e) => Error::Io(io::Error::from_raw_os_error(e)),
-                None => Error::Io(io::Error::new(err.kind(), err.to_string())),
+                Some(e) => Error::Io(std::io::Error::from_raw_os_error(e)),
+                None => {
+                    Error::Io(std::io::Error::new(err.kind(), err.to_string()))
+                }
             },
             Error::Glob { ref glob, ref err } => {
                 Error::Glob { glob: glob.clone(), err: err.clone() }
@@ -183,22 +182,22 @@ impl Error {
         }
     }
 
-    /// Inspect the original [`io::Error`] if there is one.
+    /// Inspect the original [`std::io::Error`] if there is one.
     ///
     /// [`None`] is returned if the [`Error`] doesn't correspond to an
-    /// [`io::Error`]. This might happen, for example, when the error was
+    /// [`std::io::Error`]. This might happen, for example, when the error was
     /// produced because a cycle was found in the directory tree while
     /// following symbolic links.
     ///
     /// This method returns a borrowed value that is bound to the lifetime of the [`Error`]. To
     /// obtain an owned value, the [`into_io_error`] can be used instead.
     ///
-    /// > This is the original [`io::Error`] and is _not_ the same as
-    /// > [`impl From<Error> for std::io::Error`][impl] which contains additional context about the
-    /// error.
+    /// > This is the original [`std::io::Error`] and is _not_ the same as
+    /// > [`impl From<Error> for std::io::Error`][impl] which contains
+    /// > additional context about the error.
     ///
     /// [`None`]: https://doc.rust-lang.org/stable/std/option/enum.Option.html#variant.None
-    /// [`io::Error`]: https://doc.rust-lang.org/stable/std/io/struct.Error.html
+    /// [`std::io::Error`]: https://doc.rust-lang.org/stable/std/io/struct.Error.html
     /// [`From`]: https://doc.rust-lang.org/stable/std/convert/trait.From.html
     /// [`Error`]: struct.Error.html
     /// [`into_io_error`]: struct.Error.html#method.into_io_error
@@ -224,10 +223,10 @@ impl Error {
     }
 
     /// Similar to [`io_error`] except consumes self to convert to the original
-    /// [`io::Error`] if one exists.
+    /// [`std::io::Error`] if one exists.
     ///
     /// [`io_error`]: struct.Error.html#method.io_error
-    /// [`io::Error`]: https://doc.rust-lang.org/stable/std/io/struct.Error.html
+    /// [`std::io::Error`]: https://doc.rust-lang.org/stable/std/io/struct.Error.html
     pub fn into_io_error(self) -> Option<std::io::Error> {
         match self {
             Error::Partial(mut errs) => {
@@ -268,7 +267,7 @@ impl Error {
 
     /// Turn an error into a tagged error with the given depth.
     fn with_depth(self, depth: usize) -> Error {
-        Error::WithDepth { depth: depth, err: Box::new(self) }
+        Error::WithDepth { depth, err: Box::new(self) }
     }
 
     /// Turn an error into a tagged error with the given file path and line
@@ -287,7 +286,7 @@ impl Error {
         let depth = err.depth();
         if let (Some(anc), Some(child)) = (err.loop_ancestor(), err.path()) {
             return Error::WithDepth {
-                depth: depth,
+                depth,
                 err: Box::new(Error::Loop {
                     ancestor: anc.to_path_buf(),
                     child: child.to_path_buf(),
@@ -295,15 +294,15 @@ impl Error {
             };
         }
         let path = err.path().map(|p| p.to_path_buf());
-        let mut ig_err = Error::Io(io::Error::from(err));
+        let mut ig_err = Error::Io(std::io::Error::from(err));
         if let Some(path) = path {
-            ig_err = Error::WithPath { path: path, err: Box::new(ig_err) };
+            ig_err = Error::WithPath { path, err: Box::new(ig_err) };
         }
         ig_err
     }
 }
 
-impl error::Error for Error {
+impl std::error::Error for Error {
     #[allow(deprecated)]
     fn description(&self) -> &str {
         match *self {
@@ -320,8 +319,8 @@ impl error::Error for Error {
     }
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match *self {
             Error::Partial(ref errs) => {
                 let msgs: Vec<String> =
@@ -359,8 +358,8 @@ impl fmt::Display for Error {
     }
 }
 
-impl From<io::Error> for Error {
-    fn from(err: io::Error) -> Error {
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Error {
         Error::Io(err)
     }
 }
@@ -488,19 +487,18 @@ impl<T> Match<T> {
 
 #[cfg(test)]
 mod tests {
-    use std::env;
-    use std::error;
-    use std::fs;
-    use std::path::{Path, PathBuf};
-    use std::result;
+    use std::{
+        env, fs,
+        path::{Path, PathBuf},
+    };
 
     /// A convenient result type alias.
-    pub type Result<T> =
-        result::Result<T, Box<dyn error::Error + Send + Sync>>;
+    pub(crate) type Result<T> =
+        std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 
     macro_rules! err {
         ($($tt:tt)*) => {
-            Box::<dyn error::Error + Send + Sync>::from(format!($($tt)*))
+            Box::<dyn std::error::Error + Send + Sync>::from(format!($($tt)*))
         }
     }