Revert "Upgrade to jwalk 0.5; stop following symlinks during traversal"

This reverts commit 4990fa4202f2b687ee2476efe0a406fdfe23fd96.

Performance regression  - it only uses a single thread for most of the
iteration.

4 files changed, 39 insertions, 49 deletions

diff --git a/src/aggregate.rs b/src/aggregate.rs
index b8d3f6b..0652a03 100644
--- a/src/aggregate.rs
+++ b/src/aggregate.rs
@@ -29,24 +29,26 @@ pub fn aggregate(
             stats.entries_traversed += 1;
             match entry {
                 Ok(entry) => {
-                    let file_size = match entry.metadata() {
-                        Ok(ref m) if !m.is_dir() && (options.count_hard_links || inodes.add(m)) => {
+                    let file_size = match entry.metadata {
+                        Some(Ok(ref m)) if !m.is_dir() && (options.count_hard_links || inodes.add(m)) => {
                             if options.apparent_size {
                                 m.len()
                             } else {
-                                filesize::file_real_size_fast(&entry.path(), m).unwrap_or_else(
-                                    |_| {
+                                filesize::file_real_size_fast(&entry.path(), m)
+                                    .unwrap_or_else(|_| {
                                         num_errors += 1;
                                         0
-                                    },
-                                )
+                                    })
                             }
-                        }
-                        Ok(_) => 0,
-                        Err(_) => {
+                        },
+                        Some(Ok(_)) => 0,
+                        Some(Err(_)) => {
                             num_errors += 1;
                             0
                         }
+                        None => unreachable!(
+                            "we ask for metadata, so we at least have Some(Err(..))). Issue in jwalk?"
+                        ),
                     };
                     stats.largest_file_in_bytes = stats.largest_file_in_bytes.max(file_size);
                     stats.smallest_file_in_bytes = stats.smallest_file_in_bytes.min(file_size);
diff --git a/src/common.rs b/src/common.rs
index c4a71df..a1551b8 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -161,17 +161,13 @@ pub struct WalkOptions {
 impl WalkOptions {
     pub(crate) fn iter_from_path(&self, path: &Path) -> WalkDir {
         WalkDir::new(path)
-            .follow_links(false)
+            .preload_metadata(true)
             .sort(match self.sorting {
                 TraversalSorting::None => false,
                 TraversalSorting::AlphabeticalByFileName => true,
             })
             .skip_hidden(false)
-            .parallelism(if self.threads == 0 {
-                jwalk::Parallelism::RayonDefaultPool
-            } else {
-                jwalk::Parallelism::RayonNewPool(self.threads)
-            })
+            .num_threads(self.threads)
     }
 }
 
diff --git a/src/interactive/app_test/utils.rs b/src/interactive/app_test/utils.rs
index ca9841c..f95efce 100644
--- a/src/interactive/app_test/utils.rs
+++ b/src/interactive/app_test/utils.rs
@@ -73,11 +73,8 @@ fn delete_recursive(path: impl AsRef<Path>) -> Result<(), Error> {
     let mut files: Vec<_> = Vec::new();
     let mut dirs: Vec<_> = Vec::new();
 
-    for entry in WalkDir::new(&path)
-        .parallelism(jwalk::Parallelism::Serial)
-        .into_iter()
-    {
-        let entry: DirEntry<_> = entry?;
+    for entry in WalkDir::new(&path).num_threads(1).into_iter() {
+        let entry: DirEntry = entry?;
         let p = entry.path();
         match p.is_dir() {
             true => dirs.push(p),
@@ -102,11 +99,8 @@ fn delete_recursive(path: impl AsRef<Path>) -> Result<(), Error> {
 }
 
 fn copy_recursive(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> Result<(), Error> {
-    for entry in WalkDir::new(&src)
-        .parallelism(jwalk::Parallelism::Serial)
-        .into_iter()
-    {
-        let entry: DirEntry<_> = entry?;
+    for entry in WalkDir::new(&src).num_threads(1).into_iter() {
+        let entry: DirEntry = entry?;
         let entry_path = entry.path();
         entry_path
             .strip_prefix(&src)
diff --git a/src/traverse.rs b/src/traverse.rs
index ffbd5d9..a65595e 100644
--- a/src/traverse.rs
+++ b/src/traverse.rs
@@ -88,36 +88,34 @@ impl Traversal {
                 let mut data = EntryData::default();
                 match entry {
                     Ok(entry) => {
-                        let metadata = entry.metadata();
                         data.name = if entry.depth < 1 {
                             path.clone().into()
                         } else {
                             entry.file_name
                         };
-                        let file_size = match metadata {
-                            Ok(ref m)
-                                if !m.is_dir()
-                                    && (walk_options.count_hard_links || inodes.add(m)) =>
-                            {
-                                if walk_options.apparent_size {
-                                    m.len()
-                                } else {
-                                    filesize::file_real_size_fast(&data.name, m).unwrap_or_else(
-                                        |_| {
-                                            t.io_errors += 1;
-                                            data.metadata_io_error = true;
-                                            0
-                                        },
-                                    )
+                        let file_size = match entry.metadata {
+                                Some(Ok(ref m)) if !m.is_dir() && (walk_options.count_hard_links || inodes.add(m)) => {
+                                    if walk_options.apparent_size {
+                                        m.len()
+                                    } else {
+                                        filesize::file_real_size_fast(&data.name, m)
+                                            .unwrap_or_else(|_| {
+                                                t.io_errors += 1;
+                                                data.metadata_io_error = true;
+                                                0
+                                            })
+                                    }
+                                },
+                                Some(Ok(_)) => 0,
+                                Some(Err(_)) => {
+                                    t.io_errors += 1;
+                                    data.metadata_io_error = true;
+                                    0
                                 }
-                            }
-                            Ok(_) => 0,
-                            Err(_) => {
-                                t.io_errors += 1;
-                                data.metadata_io_error = true;
-                                0
-                            }
-                        };
+                                None => unreachable!(
+                                    "we ask for metadata, so we at least have Some(Err(..))). Issue in jwalk?"
+                                ),
+                            };
 
                         match (entry.depth, previous_depth) {
                             (n, p) if n > p => {