feat!: make it possible to consider worktrees to be 'tracked' (#1464)

That way it's possibel for them to be equivalent to submodules, which
would never be deleted by accident due to their 'tracked' status.

This works by passing repository-relative paths of worktree locations
that are within this repository.

Author: Byron

gix-dir/src/lib.rs

@@ -53,6 +53,8 @@ pub struct Entry {
     /// Further specify what the entry is on disk, similar to a file mode.
     pub disk_kind: Option<entry::Kind>,
     /// The kind of entry according to the index, if tracked. *Usually* the same as `disk_kind`.
+    /// Note that even if tracked, this might be `None` which indicates this is a worktree placed
+    /// within the parent repository.
     pub index_kind: Option<entry::Kind>,
     /// Indicate how the pathspec matches the entry. See more in [`EntryRef::pathspec_match`].
     pub pathspec_match: Option<entry::PathspecMatch>,

gix-dir/src/walk/classify.rs

@@ -13,7 +13,7 @@ pub fn root(
     worktree_root: &Path,
     buf: &mut BString,
     worktree_relative_root: &Path,
-    options: Options,
+    options: Options<'_>,
     ctx: &mut Context<'_>,
 ) -> Result<(Outcome, bool), Error> {
     buf.clear();
@@ -135,8 +135,9 @@ pub fn path(
         for_deletion,
         classify_untracked_bare_repositories,
         symlinks_to_directories_are_ignored_like_directories,
+        worktree_relative_worktree_dirs,
         ..
-    }: Options,
+    }: Options<'_>,
     ctx: &mut Context<'_>,
 ) -> Result<Outcome, Error> {
     let mut out = Outcome {
@@ -191,19 +192,25 @@ pub fn path(
     );
     let mut kind = uptodate_index_kind.or(disk_kind).or_else(on_demand_disk_kind);
 
+    // We always check the pathspec to have the value filled in reliably.
+    out.pathspec_match = ctx
+        .pathspec
+        .pattern_matching_relative_path(rela_path.as_bstr(), kind.map(|ft| ft.is_dir()), ctx.pathspec_attributes)
+        .map(Into::into);
+
+    if worktree_relative_worktree_dirs.map_or(false, |worktrees| worktrees.contains(&*rela_path)) {
+        return Ok(out
+            .with_kind(Some(entry::Kind::Repository), None)
+            .with_status(entry::Status::Tracked));
+    }
+
     let maybe_status = if property.is_none() {
         (index_kind.map(|k| k.is_dir()) == kind.map(|k| k.is_dir())).then_some(entry::Status::Tracked)
     } else {
         out.property = property;
         Some(entry::Status::Pruned)
     };
 
-    // We always check the pathspec to have the value filled in reliably.
-    out.pathspec_match = ctx
-        .pathspec
-        .pattern_matching_relative_path(rela_path.as_bstr(), kind.map(|ft| ft.is_dir()), ctx.pathspec_attributes)
-        .map(Into::into);
-
     let is_dir = if symlinks_to_directories_are_ignored_like_directories
         && ctx.excludes.is_some()
         && kind.map_or(false, |ft| ft == entry::Kind::Symlink)

gix-dir/src/walk/function.rs

@@ -42,7 +42,7 @@ use crate::{entry, EntryRef};
 pub fn walk(
     worktree_root: &Path,
     mut ctx: Context<'_>,
-    options: Options,
+    options: Options<'_>,
     delegate: &mut dyn Delegate,
 ) -> Result<(Outcome, PathBuf), Error> {
     let root = match ctx.explicit_traversal_root {
@@ -182,7 +182,7 @@ pub(super) fn emit_entry(
         emit_ignored,
         emit_empty_directories,
         ..
-    }: Options,
+    }: Options<'_>,
     out: &mut Outcome,
     delegate: &mut dyn Delegate,
 ) -> Action {

gix-dir/src/walk/mod.rs

@@ -1,5 +1,6 @@
 use crate::{entry, EntryRef};
-use bstr::BStr;
+use bstr::{BStr, BString};
+use std::collections::BTreeSet;
 use std::path::PathBuf;
 use std::sync::atomic::AtomicBool;
 
@@ -143,12 +144,12 @@ pub enum ForDeletionMode {
 
 /// Options for use in [`walk()`](function::walk()) function.
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
-pub struct Options {
-    /// If true, the filesystem will store paths as decomposed unicode, i.e. `ä` becomes `"a\u{308}"`, which means that
+pub struct Options<'a> {
+    /// If `true`, the filesystem will store paths as decomposed unicode, i.e. `ä` becomes `"a\u{308}"`, which means that
     /// we have to turn these forms back from decomposed to precomposed unicode before storing it in the index or generally
     /// using it. This also applies to input received from the command-line, so callers may have to be aware of this and
     /// perform conversions accordingly.
-    /// If false, no conversions will be performed.
+    /// If `false`, no conversions will be performed.
     pub precompose_unicode: bool,
     /// If true, the filesystem ignores the case of input, which makes `A` the same file as `a`.
     /// This is also called case-folding.
@@ -192,6 +193,11 @@ pub struct Options {
     ///
     /// In other words, for Git compatibility this flag should be `false`, the default, for `git2` compatibility it should be `true`.
     pub symlinks_to_directories_are_ignored_like_directories: bool,
+    /// A set of all git worktree checkouts that are located within the main worktree directory.
+    ///
+    /// They will automatically be detected as 'tracked', but without providing index information (as there is no actual index entry).
+    /// Note that the unicode composition must match the `precompose_unicode` field so that paths will match verbatim.
+    pub worktree_relative_worktree_dirs: Option<&'a BTreeSet<BString>>,
 }
 
 /// All information that is required to perform a dirwalk, and classify paths properly.

gix-dir/src/walk/readdir.rs

@@ -21,7 +21,7 @@ pub(super) fn recursive(
     current_bstr: &mut BString,
     current_info: classify::Outcome,
     ctx: &mut Context<'_>,
-    opts: Options,
+    opts: Options<'_>,
     delegate: &mut dyn Delegate,
     out: &mut Outcome,
     state: &mut State,
@@ -141,7 +141,7 @@ pub(super) struct State {
 
 impl State {
     /// Hold the entry with the given `status` if it's a candidate for collapsing the containing directory.
-    fn held_for_directory_collapse(&mut self, rela_path: &BStr, info: classify::Outcome, opts: &Options) -> bool {
+    fn held_for_directory_collapse(&mut self, rela_path: &BStr, info: classify::Outcome, opts: &Options<'_>) -> bool {
         if opts.should_hold(info.status) {
             self.on_hold
                 .push(EntryRef::from_outcome(Cow::Borrowed(rela_path), info).into_owned());
@@ -186,7 +186,7 @@ impl State {
     pub(super) fn emit_remaining(
         &mut self,
         may_collapse: bool,
-        opts: Options,
+        opts: Options<'_>,
         out: &mut walk::Outcome,
         delegate: &mut dyn walk::Delegate,
     ) {
@@ -217,7 +217,7 @@ impl Mark {
         dir_path: &Path,
         dir_rela_path: &BStr,
         dir_info: classify::Outcome,
-        opts: Options,
+        opts: Options<'_>,
         out: &mut walk::Outcome,
         ctx: &mut Context<'_>,
         delegate: &mut dyn walk::Delegate,
@@ -266,7 +266,7 @@ impl Mark {
     fn emit_all_held(
         &mut self,
         state: &mut State,
-        opts: Options,
+        opts: Options<'_>,
         out: &mut walk::Outcome,
         delegate: &mut dyn walk::Delegate,
     ) -> Action {
@@ -287,7 +287,7 @@ impl Mark {
         dir_info: classify::Outcome,
         state: &mut State,
         out: &mut walk::Outcome,
-        opts: Options,
+        opts: Options<'_>,
         ctx: &mut Context<'_>,
         delegate: &mut dyn walk::Delegate,
     ) -> Option<Action> {
@@ -408,7 +408,7 @@ fn filter_dir_pathspec(current: Option<PathspecMatch>) -> Option<PathspecMatch>
     })
 }
 
-impl Options {
+impl Options<'_> {
     fn should_hold(&self, status: entry::Status) -> bool {
         if status.is_pruned() {
             return false;

gix-dir/tests/fixtures/many.sh

@@ -438,3 +438,9 @@ git init with-sub-repo
   git add -f .gitignore
   git clone ../dir-with-file sub-repo
 )
+
+git clone dir-with-tracked-file in-repo-worktree
+(cd in-repo-worktree
+  git worktree add worktree
+  git worktree add -b other-worktree dir/worktree
+)

gix-dir/tests/walk/mod.rs

@@ -1,5 +1,6 @@
 use gix_dir::{walk, EntryRef};
 use pretty_assertions::assert_eq;
+use std::collections::BTreeSet;
 use std::sync::atomic::AtomicBool;
 
 use crate::walk_utils::{
@@ -4493,3 +4494,59 @@ fn ignored_sub_repo() -> crate::Result {
     }
     Ok(())
 }
+
+#[test]
+fn in_repo_worktree() -> crate::Result {
+    let root = fixture("in-repo-worktree");
+    let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
+    assert_eq!(
+        out,
+        walk::Outcome {
+            read_dir_calls: 2,
+            returned_entries: entries.len(),
+            seen_entries: 4,
+        }
+    );
+    assert_eq!(
+        entries,
+        &[
+            entry_nokind(".git", Pruned).with_property(DotGit).with_match(Always),
+            entry("dir/file", Tracked, File),
+            entry("dir/worktree", Untracked, Repository),
+            entry("worktree", Untracked, Repository),
+        ],
+        "without passing worktree information, they count as untracked repositories, making them vulnerable"
+    );
+
+    let ((out, _root), entries) = collect(&root, None, |keep, ctx| {
+        walk(
+            &root,
+            ctx,
+            walk::Options {
+                worktree_relative_worktree_dirs: Some(&BTreeSet::from(["worktree".into(), "dir/worktree".into()])),
+                ..options_emit_all()
+            },
+            keep,
+        )
+    });
+    assert_eq!(
+        out,
+        walk::Outcome {
+            read_dir_calls: 2,
+            returned_entries: entries.len(),
+            seen_entries: 4,
+        }
+    );
+    assert_eq!(
+        entries,
+        &[
+            entry_nokind(".git", Pruned).with_property(DotGit).with_match(Always),
+            entry("dir/file", Tracked, File),
+            entry("dir/worktree", Tracked, Repository).no_index_kind(),
+            entry("worktree", Tracked, Repository).no_index_kind(),
+        ],
+        "But when worktree information is passed, it is identified as tracked to look similarly to a submodule.\
+         What gives it away is that the index-kind is None, which is unusual for a tracked file."
+    );
+    Ok(())
+}

gix-dir/tests/walk_utils/mod.rs

@@ -14,12 +14,12 @@ pub fn fixture(name: &str) -> PathBuf {
 }
 
 /// Default options
-pub fn options() -> walk::Options {
+pub fn options() -> walk::Options<'static> {
     walk::Options::default()
 }
 
 /// Default options
-pub fn options_emit_all() -> walk::Options {
+pub fn options_emit_all() -> walk::Options<'static> {
     walk::Options {
         precompose_unicode: false,
         ignore_case: false,
@@ -33,6 +33,7 @@ pub fn options_emit_all() -> walk::Options {
         emit_empty_directories: true,
         emit_collapsed: None,
         symlinks_to_directories_are_ignored_like_directories: false,
+        worktree_relative_worktree_dirs: None,
     }
 }
 
@@ -145,6 +146,7 @@ pub trait EntryExt {
     fn with_match(self, m: entry::PathspecMatch) -> Self;
     fn no_match(self) -> Self;
     fn no_kind(self) -> Self;
+    fn no_index_kind(self) -> Self;
 }
 
 impl EntryExt for (Entry, Option<entry::Status>) {
@@ -169,6 +171,10 @@ impl EntryExt for (Entry, Option<entry::Status>) {
         self.0.disk_kind = None;
         self
     }
+    fn no_index_kind(mut self) -> Self {
+        self.0.index_kind = None;
+        self
+    }
 }
 
 pub fn collect(