fix various IDE warnings

src/core/dir_entry.rs

@@ -9,7 +9,7 @@ use crate::{ClientState, Error, ReadDirSpec, Result};
 /// Representation of a file or directory.
 ///
 /// This representation does not wrap a `std::fs::DirEntry`. Instead it copies
-/// `file_name`, `file_type`, and optionaly `metadata` out of the underlying
+/// `file_name`, `file_type`, and optionally `metadata` out of the underlying
 /// `std::fs::DirEntry`. This allows it to quickly drop the underlying file
 /// descriptor.
 pub struct DirEntry<C: ClientState> {
@@ -37,7 +37,7 @@ pub struct DirEntry<C: ClientState> {
     pub read_children_error: Option<Error>,
     // True if [`follow_links`] is `true` AND was created from a symlink path.
     follow_link: bool,
-    // Origins of synlinks followed to get to this entry.
+    // Origins of symlinks followed to get to this entry.
     follow_link_ancestors: Arc<Vec<Arc<Path>>>,
 }
 
@@ -114,7 +114,7 @@ impl<C: ClientState> DirEntry<C> {
     /// This never makes any system calls.
     ///
     /// [`follow_links`]: struct.WalkDir.html#method.follow_links
-    pub fn file_type(&self) -> fs::FileType {
+    pub fn file_type(&self) -> FileType {
         self.file_type
     }
 
@@ -129,8 +129,8 @@ impl<C: ClientState> DirEntry<C> {
     /// Returns the depth at which this entry was created relative to the root.
     ///
     /// The smallest depth is `0` and always corresponds to the path given
-    /// to the `new` function on `WalkDir`. Its direct descendents have depth
-    /// `1`, and their descendents have depth `2`, and so on.
+    /// to the `new` function on `WalkDir`. Its direct descendants have depth
+    /// `1`, and their descendants have depth `2`, and so on.
     pub fn depth(&self) -> usize {
         self.depth
     }
@@ -212,7 +212,7 @@ impl<C: ClientState> DirEntry<C> {
         let dir_entry = DirEntry::from_path(self.depth, &path, true, origins)?;
 
         if dir_entry.file_type.is_dir() {
-            let target = std::fs::read_link(&path).unwrap();
+            let target = fs::read_link(&path).unwrap();
             for ancestor in self.follow_link_ancestors.iter().rev() {
                 if target.as_path() == ancestor.as_ref() {
                     return Err(Error::from_loop(

src/core/dir_entry_iter.rs

@@ -8,7 +8,7 @@ use crate::Result;
 /// Yields entries from recursive traversal of filesystem.
 pub struct DirEntryIter<C: ClientState> {
     min_depth: usize,
-    // iterator yeilding next ReadDir results when needed
+    // iterator yielding next ReadDir results when needed
     read_dir_iter: Peekable<ReadDirIter<C>>,
     // stack of ReadDir results, track location in filesystem traversal
     read_dir_results_stack: Vec<vec::IntoIter<Result<DirEntry<C>>>>,

src/core/error.rs

@@ -82,8 +82,8 @@ impl Error {
     /// Returns the depth at which this error occurred relative to the root.
     ///
     /// The smallest depth is `0` and always corresponds to the path given to
-    /// the [`new`] function on [`WalkDir`]. Its direct descendents have depth
-    /// `1`, and their descendents have depth `2`, and so on.
+    /// the [`new`] function on [`WalkDir`]. Its direct descendants have depth
+    /// `1`, and their descendants have depth `2`, and so on.
     ///
     /// [`new`]: struct.WalkDir.html#method.new
     /// [`WalkDir`]: struct.WalkDir.html
@@ -207,6 +207,13 @@ impl Error {
 }
 
 impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self.inner {
+            ErrorInner::Io { ref err, .. } => Some(err),
+            ErrorInner::Loop { .. } => None,
+        }
+    }
+
     #[allow(deprecated)]
     fn description(&self) -> &str {
         match self.inner {
@@ -218,13 +225,6 @@ impl error::Error for Error {
     fn cause(&self) -> Option<&dyn error::Error> {
         self.source()
     }
-
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        match self.inner {
-            ErrorInner::Io { ref err, .. } => Some(err),
-            ErrorInner::Loop { .. } => None,
-        }
-    }
 }
 
 impl fmt::Display for Error {

src/core/ordered_queue.rs

@@ -69,7 +69,7 @@ impl<T> OrderedQueue<T>
 where
     T: Send,
 {
-    pub fn push(&self, ordered: Ordered<T>) -> std::result::Result<(), SendError<Ordered<T>>> {
+    pub fn push(&self, ordered: Ordered<T>) -> Result<(), SendError<Ordered<T>>> {
         self.pending_count.fetch_add(1, AtomicOrdering::SeqCst);
         self.sender.send(ordered)
     }
@@ -124,7 +124,7 @@ where
 
     fn try_next_strict(&mut self) -> Result<Ordered<T>, TryRecvError> {
         let looking_for = &self.ordered_matcher.looking_for;
-        
+
         loop {
             if self.is_stop() {
                 return Err(TryRecvError::Disconnected);

src/core/read_dir_iter.rs

@@ -9,9 +9,9 @@ pub(crate) type ReadDirCallback<C> =
 
 /// Result<ReadDir> Iterator.
 ///
-/// Yeilds ReadDirs (results of fs::read_dir) in order required for recursive
+/// Yields ReadDirs (results of fs::read_dir) in order required for recursive
 /// directory traversal. Depending on Walk/ParWalk state these reads might be
-/// computed in parellel.
+/// computed in parallel.
 pub enum ReadDirIter<C: ClientState> {
     Walk {
         read_dir_spec_stack: Vec<ReadDirSpec<C>>,
@@ -113,12 +113,12 @@ fn multi_threaded_walk_dir<C: ClientState>(
         ..
     } = ordered_read_dir_spec;
 
-    let read_dir_result = (run_context.core_read_dir_callback)(read_dir_spec);    
+    let read_dir_result = (run_context.core_read_dir_callback)(read_dir_spec);
     let ordered_read_children_specs = read_dir_result
         .as_ref()
         .ok()
         .map(|read_dir| read_dir.ordered_read_children_specs(&index_path));
-    
+
     let ordered_read_dir_result = Ordered::new(
         read_dir_result,
         index_path,

src/core/read_dir_spec.rs

@@ -22,6 +22,6 @@ pub struct ReadDirSpec<C: ClientState> {
     /// when reading this directory's parent. One intended use case is to store
     /// `.gitignore` state to filter entries during the walk.
     pub client_read_state: C::ReadDirState,
-    // Origins of synlinks followed to get to this entry.
+    // Origins of symlinks followed to get to this entry.
     pub(crate) follow_link_ancestors: Arc<Vec<Arc<Path>>>,
 }