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 is_top_level = if options.for_deletion.is_some() {
+        true
+    } else {
+        root == worktree_root
+    };
+    let (action, _) = readdir::recursive(
+        is_top_level,
         &mut current,
         &mut buf,
         root_info,
@@ -93,8 +102,12 @@ pub fn walk(
         &mut out,
         &mut state,
     )?;
+    if action != Action::Cancel {
+        state.emit_remaining(is_top_level, 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

@@ -233,7 +233,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

@@ -125,6 +125,24 @@ impl State {
             is_top_level,
         }
     }
+
+    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,
+            is_top_level,
+        }
+        .emit_all_held(self, opts, out, delegate);
+    }
 }
 
 struct Mark {

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!(