Iterative loop for ls recursive directory search

src/uu/ls/src/ls.rs

@@ -14,7 +14,6 @@ use std::os::windows::fs::MetadataExt;
 use std::{
     cell::{LazyCell, OnceCell},
     cmp::Reverse,
-    collections::HashSet,
     ffi::{OsStr, OsString},
     fmt::Write as FmtWrite,
     fs::{self, DirEntry, FileType, Metadata, ReadDir},
@@ -38,6 +37,8 @@ use thiserror::Error;
 
 #[cfg(unix)]
 use uucore::entries;
+#[cfg(target_os = "windows")]
+use uucore::fs::FileInformation;
 #[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
 use uucore::fsxattr::has_acl;
 #[cfg(unix)]
@@ -60,7 +61,6 @@ use uucore::{
     error::{UError, UResult, set_exit_code},
     format::human::{SizeFormat, human_readable},
     format_usage,
-    fs::FileInformation,
     fs::display_permissions,
     fsext::{MetadataTimeField, metadata_get_time},
     line_ending::LineEnding,
@@ -2058,19 +2058,8 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
                 writeln!(state.out)?;
             }
         }
-        let mut listed_ancestors = HashSet::new();
-        listed_ancestors.insert(FileInformation::from_path(
-            &path_data.p_buf,
-            path_data.must_dereference,
-        )?);
-        enter_directory(
-            path_data,
-            read_dir,
-            config,
-            &mut state,
-            &mut listed_ancestors,
-            &mut dired,
-        )?;
+
+        recursive_loop(path_data, read_dir, config, &mut state, &mut dired)?;
     }
     if config.dired && !config.hyperlink {
         dired::print_dired_output(config, &dired, &mut state.out)?;
@@ -2183,15 +2172,13 @@ fn should_display(entry: &DirEntry, config: &Config) -> bool {
         .any(|p| p.matches_with(&file_name, options))
 }
 
-#[allow(clippy::cognitive_complexity)]
 fn enter_directory(
     path_data: &PathData,
     read_dir: ReadDir,
     config: &Config,
     state: &mut ListState,
-    listed_ancestors: &mut HashSet<FileInformation>,
     dired: &mut DiredOutput,
-) -> UResult<()> {
+) -> UResult<Vec<PathData>> {
     // Create vec of entries with initial dot files
     let mut entries: Vec<PathData> = if config.files == Files::All {
         vec![
@@ -2245,52 +2232,91 @@ fn enter_directory(
 
     display_items(&entries, config, state, dired)?;
 
+    let res = entries
+        .into_iter()
+        .skip(if config.files == Files::All { 2 } else { 0 })
+        .filter(|p| p.file_type(&mut state.out).is_some_and(|ft| ft.is_dir()))
+        .rev()
+        .collect();
+
+    Ok(res)
+}
+
+fn recursive_loop(
+    path_data: &PathData,
+    read_dir: ReadDir,
+    config: &Config,
+    state: &mut ListState,
+    dired: &mut DiredOutput,
+) -> UResult<()> {
+    let mut queue: Vec<PathData> = enter_directory(path_data, read_dir, config, state, dired)?;
+
+    #[cfg(target_os = "windows")]
+    let listed_ancestor_md =
+        FileInformation::from_path(&path_data.p_buf, path_data.must_dereference)?;
+
+    #[cfg(not(target_os = "windows"))]
+    let listed_ancestor_md = match path_data.get_metadata(&mut state.out) {
+        Some(md) => md,
+        None => &get_metadata_with_deref_opt(&path_data.p_buf, path_data.must_dereference)?,
+    };
+
     if config.recursive {
-        for e in entries
-            .iter()
-            .skip(if config.files == Files::All { 2 } else { 0 })
-            .filter(|p| {
-                p.ft.get()
-                    .is_some_and(|o_ft| o_ft.is_some_and(|ft| ft.is_dir()))
-            })
-        {
-            match fs::read_dir(&e.p_buf) {
+        while let Some(item) = queue.pop() {
+            match fs::read_dir(&item.p_buf) {
                 Err(err) => {
                     state.out.flush()?;
                     show!(LsError::IOErrorContext(
-                        e.p_buf.clone(),
+                        item.p_buf.clone(),
                         err,
-                        e.command_line
+                        item.command_line
                     ));
                 }
                 Ok(rd) => {
-                    if listed_ancestors
-                        .insert(FileInformation::from_path(&e.p_buf, e.must_dereference)?)
-                    {
-                        // when listing several directories in recursive mode, we show
-                        // "dirname:" at the beginning of the file list
-                        writeln!(state.out)?;
-                        if config.dired {
-                            // We already injected the first dir
-                            // Continue with the others
-                            // 2 = \n + \n
-                            dired.padding = 2;
-                            dired::indent(&mut state.out)?;
-                            let dir_name_size = e.p_buf.to_string_lossy().len();
-                            dired::calculate_subdired(dired, dir_name_size);
-                            // inject dir name
-                            dired::add_dir_name(dired, dir_name_size);
-                        }
+                    #[cfg(target_os = "windows")]
+                    let item_md = FileInformation::from_path(&item.p_buf, item.must_dereference)?;
 
-                        show_dir_name(e, &mut state.out, config)?;
-                        writeln!(state.out)?;
-                        enter_directory(e, rd, config, state, listed_ancestors, dired)?;
-                        listed_ancestors
-                            .remove(&FileInformation::from_path(&e.p_buf, e.must_dereference)?);
-                    } else {
+                    #[cfg(not(target_os = "windows"))]
+                    let item_md = match item.get_metadata(&mut state.out) {
+                        Some(md) => md,
+                        None => &get_metadata_with_deref_opt(&item.p_buf, item.must_dereference)?,
+                    };
+
+                    #[cfg(target_os = "windows")]
+                    if item_md == listed_ancestor_md {
                         state.out.flush()?;
-                        show!(LsError::AlreadyListedError(e.p_buf.clone()));
+                        show!(LsError::AlreadyListedError(item.p_buf.clone()));
+                        continue;
                     }
+
+                    #[cfg(not(target_os = "windows"))]
+                    if item_md.dev() == listed_ancestor_md.dev()
+                        && item_md.ino() == listed_ancestor_md.ino()
+                    {
+                        state.out.flush()?;
+                        show!(LsError::AlreadyListedError(item.p_buf.clone()));
+                        continue;
+                    }
+
+                    // when listing several directories in recursive mode, we show
+                    // "dirname:" at the beginning of the file list
+                    writeln!(state.out)?;
+                    if config.dired {
+                        // We already injected the first dir
+                        // Continue with the others
+                        // 2 = \n + \n
+                        dired.padding = 2;
+                        dired::indent(&mut state.out)?;
+                        let dir_name_size = item.p_buf.to_string_lossy().len();
+                        dired::calculate_subdired(dired, dir_name_size);
+                        // inject dir name
+                        dired::add_dir_name(dired, dir_name_size);
+                    }
+
+                    show_dir_name(&item, &mut state.out, config)?;
+                    writeln!(state.out)?;
+                    let mut res = enter_directory(&item, rd, config, state, dired)?;
+                    queue.append(&mut res);
                 }
             }
         }
@@ -2301,10 +2327,10 @@ fn enter_directory(
 
 fn get_metadata_with_deref_opt(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
     if dereference {
-        p_buf.metadata()
-    } else {
-        p_buf.symlink_metadata()
+        return p_buf.metadata();
     }
+
+    p_buf.symlink_metadata()
 }
 
 fn display_dir_entry_size(