more natural top-level handling

- when deleting items, we will always list them according to the prefix
- when listing items otherwise, the top-level only if the traversal starts
  in the worktree.

Author: Byron

gix-dir/src/walk/function.rs

@@ -18,6 +18,10 @@ use crate::{entry, EntryRef};
 /// * `ctx` - everything needed to classify the paths seen during the traversal.
 /// * `delegate` - an implementation of [`Delegate`] to control details of the traversal and receive its results.
 ///
+/// Returns `(outcome, traversal_root)`, with the `traversal_root` actually being used for the traversal,
+/// useful to transform the paths returned for the user. It's always within the `worktree_root`, or the same,
+/// but is hard to guess due to additional logic affecting it.
+///
 /// ### Performance Notes
 ///
 /// In theory, parallel directory traversal can be significantly faster, and what's possible for our current
@@ -40,7 +44,7 @@ pub fn walk(
     mut ctx: Context<'_>,
     options: Options,
     delegate: &mut dyn Delegate,
-) -> Result<Outcome, Error> {
+) -> Result<(Outcome, PathBuf), Error> {
     let root = match ctx.explicit_traversal_root {
         Some(root) => root.to_owned(),
         None => ctx
@@ -78,12 +82,17 @@ pub fn walk(
             &mut out,
             delegate,
         );
-        return Ok(out);
+        return Ok((out, root.to_owned()));
     }
 
-    let mut state = readdir::State::default();
-    let _ = readdir::recursive(
-        true,
+    let mut state = readdir::State::new(worktree_root, ctx.current_dir, options.for_deletion.is_some());
+    let may_collapse = if options.for_deletion.is_some() {
+        false
+    } else {
+        root != worktree_root
+    };
+    let (action, _) = readdir::recursive(
+        may_collapse,
         &mut current,
         &mut buf,
         root_info,
@@ -93,8 +102,12 @@ pub fn walk(
         &mut out,
         &mut state,
     )?;
+    if action != Action::Cancel {
+        state.emit_remaining(may_collapse, options, &mut out, delegate);
+        assert_eq!(state.on_hold.len(), 0, "BUG: after emission, on hold must be empty");
+    }
     gix_trace::debug!(statistics = ?out);
-    Ok(out)
+    Ok((out, root.to_owned()))
 }
 
 /// Note that we only check symlinks on the way from `worktree_root` to `root`,

gix-dir/src/walk/mod.rs

@@ -182,6 +182,8 @@ pub struct Context<'a> {
     pub git_dir_realpath: &'a std::path::Path,
     /// The current working directory as returned by `gix_fs::current_dir()` to assure it respects `core.precomposeUnicode`.
     /// It's used to produce the realpath of the git-dir of a repository candidate to assure it's not our own repository.
+    ///
+    /// It is also used to assure that when the walk is for deletion, that the current working dir will not be collapsed.
     pub current_dir: &'a std::path::Path,
     /// The index to quickly understand if a file or directory is tracked or not.
     ///
@@ -233,7 +235,7 @@ pub struct Context<'a> {
 }
 
 /// Additional information collected as outcome of [`walk()`](function::walk()).
-#[derive(Default, Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq)]
+#[derive(Default, Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub struct Outcome {
     /// The amount of calls to read the directory contents.
     pub read_dir_calls: u32,

gix-dir/src/walk/readdir.rs

@@ -1,6 +1,6 @@
 use bstr::{BStr, BString, ByteSlice};
 use std::borrow::Cow;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use crate::entry::{PathspecMatch, Status};
 use crate::walk::function::{can_recurse, emit_entry};
@@ -13,7 +13,7 @@ use crate::{entry, walk, Entry};
 /// Git mostly silently ignores IO errors and stops iterating seemingly quietly, while we error loudly.
 #[allow(clippy::too_many_arguments)]
 pub(super) fn recursive(
-    is_top_level: bool,
+    may_collapse: bool,
     current: &mut PathBuf,
     current_bstr: &mut BString,
     current_info: classify::Outcome,
@@ -30,7 +30,7 @@ pub(super) fn recursive(
     })?;
 
     let mut num_entries = 0;
-    let mark = state.mark(is_top_level);
+    let mark = state.mark(may_collapse);
     let mut prevent_collapse = false;
     for entry in entries {
         let entry = entry.map_err(|err| Error::DirEntry {
@@ -64,8 +64,18 @@ pub(super) fn recursive(
         )?;
 
         if can_recurse(current_bstr.as_bstr(), info, opts.for_deletion, delegate) {
-            let (action, subdir_prevent_collapse) =
-                recursive(false, current, current_bstr, info, ctx, opts, delegate, out, state)?;
+            let subdir_may_collapse = state.may_collapse(current);
+            let (action, subdir_prevent_collapse) = recursive(
+                subdir_may_collapse,
+                current,
+                current_bstr,
+                info,
+                ctx,
+                opts,
+                delegate,
+                out,
+                state,
+            )?;
             prevent_collapse |= subdir_prevent_collapse;
             if action != Action::Continue {
                 return Ok((action, prevent_collapse));
@@ -94,10 +104,11 @@ pub(super) fn recursive(
     Ok((res, prevent_collapse))
 }
 
-#[derive(Default)]
 pub(super) struct State {
     /// The entries to hold back until it's clear what to do with them.
     pub on_hold: Vec<Entry>,
+    /// The path the user is currently in, as seen from the workdir root.
+    worktree_relative_current_dir: Option<PathBuf>,
 }
 
 impl State {
@@ -119,17 +130,60 @@ impl State {
 
     /// Keep track of state we need to later resolve the state.
     /// Top-level directories are special, as they don't fold.
-    fn mark(&self, is_top_level: bool) -> Mark {
+    fn mark(&self, may_collapse: bool) -> Mark {
         Mark {
             start_index: self.on_hold.len(),
-            is_top_level,
+            may_collapse,
         }
     }
+
+    pub(super) fn new(worktree_root: &Path, current_dir: &Path, is_delete_mode: bool) -> Self {
+        dbg!(current_dir, worktree_root);
+        let worktree_relative_current_dir = if is_delete_mode {
+            gix_path::realpath_opts(worktree_root, current_dir, gix_path::realpath::MAX_SYMLINKS)
+                .ok()
+                .and_then(|real_worktree_root| current_dir.strip_prefix(real_worktree_root).ok().map(ToOwned::to_owned))
+                .map(|relative_cwd| worktree_root.join(relative_cwd))
+        } else {
+            None
+        };
+        Self {
+            on_hold: Vec::new(),
+            worktree_relative_current_dir,
+        }
+    }
+
+    /// Returns `true` if the worktree-relative `directory_to_traverse` is not the current working directory.
+    /// This is only the case when
+    pub(super) fn may_collapse(&self, directory_to_traverse: &Path) -> bool {
+        dbg!(self.worktree_relative_current_dir.as_ref(), directory_to_traverse);
+        self.worktree_relative_current_dir
+            .as_ref()
+            .map_or(true, |cwd| cwd != directory_to_traverse)
+    }
+
+    pub(super) fn emit_remaining(
+        &mut self,
+        is_top_level: bool,
+        opts: Options,
+        out: &mut walk::Outcome,
+        delegate: &mut dyn walk::Delegate,
+    ) {
+        if self.on_hold.is_empty() {
+            return;
+        }
+
+        _ = Mark {
+            start_index: 0,
+            may_collapse: is_top_level,
+        }
+        .emit_all_held(self, opts, out, delegate);
+    }
 }
 
 struct Mark {
     start_index: usize,
-    is_top_level: bool,
+    may_collapse: bool,
 }
 
 impl Mark {
@@ -211,7 +265,7 @@ impl Mark {
         ctx: &mut Context<'_>,
         delegate: &mut dyn walk::Delegate,
     ) -> Option<Action> {
-        if self.is_top_level {
+        if !self.may_collapse {
             return None;
         }
         let (mut expendable, mut precious, mut untracked, mut entries, mut matching_entries) = (0, 0, 0, 0, 0);

gix-dir/tests/dir_walk_cwd.rs

@@ -13,7 +13,7 @@ fn prefixes_work_as_expected() -> gix_testtools::Result {
     let root = fixture("only-untracked");
     std::env::set_current_dir(root.join("d"))?;
     let troot = Path::new("..").join("d");
-    let (out, entries) = collect(Path::new(".."), Some(&troot), |keep, ctx| {
+    let ((out, _root), entries) = collect(Path::new(".."), Some(&troot), |keep, ctx| {
         walk(Path::new(".."), ctx, options(), keep)
     });
     assert_eq!(