lael-labs/gitoxide

gitoxide-core/src/index/information.rs+5−5

 #[cfg(feature = "serde")]
 mod serde_only {
+    use gix::index::entry::Stage;
     mod ext {
         #[derive(serde::Serialize)]
                     let (mut intent_to_add, mut skip_worktree) = (0, 0);
                     for entry in f.entries() {
                         match entry.flags.stage() {
-                            0 => stage_0_merged += 1,
+                            Stage::Unconflicted => stage_0_merged += 1,
-                            1 => stage_1_base += 1,
+                            Stage::Base => stage_1_base += 1,
-                            2 => stage_2_ours += 1,
+                            Stage::Ours => stage_2_ours += 1,
-                            3 => stage_3_theirs += 1,
+                            Stage::Theirs => stage_3_theirs += 1,
-                            invalid => anyhow::bail!("Invalid stage {} encountered", invalid),
                         }
                         match entry.mode {
                             gix::index::entry::Mode::DIR => dir += 1,

gitoxide-core/src/repository/attributes/validate_baseline.rs+7−0

     }
     #[derive(Debug)]
+    // See note on `Mismatch`
+    #[allow(dead_code)]
     pub struct ExcludeLocation {
         pub line: usize,
         pub rela_source_file: String,
     }
     #[derive(Debug)]
+    // We debug-print this structure, which makes all fields 'used', but it doesn't count.
+    // TODO: find a way to not have to do more work, but make the warning go away.
+    #[allow(dead_code)]
     pub enum Mismatch {
         Attributes {
             actual: Vec<gix::attrs::Assignment>,
     }
     #[derive(Debug)]
+    // See note on `Mismatch`
+    #[allow(dead_code)]
     pub struct ExcludeMatch {
         pub pattern: gix::glob::Pattern,
         pub source: Option<PathBuf>,

gitoxide-core/src/repository/index/entries.rs+5−5

         io::{BufWriter, Write},
     };
+    use gix::index::entry::Stage;
     use gix::{
         bstr::{BStr, BString},
         worktree::IndexPersistedOrInMemory,
             out,
             "{} {}{:?} {} {}{}{}",
             match entry.flags.stage() {
-                0 => "       ",
+                Stage::Unconflicted => "       ",
-                1 => "BASE   ",
+                Stage::Base => "BASE   ",
-                2 => "OURS   ",
+                Stage::Ours => "OURS   ",
-                3 => "THEIRS ",
+                Stage::Theirs => "THEIRS ",
-                _ => "UNKNOWN",
             },
             if entry.flags.is_empty() {
                 "".to_string()

gix-config/src/file/includes/mod.rs+8−1

         }
         buf.clear();
-        std::io::copy(&mut std::fs::File::open(&config_path)?, buf)?;
+        std::io::copy(
+            &mut std::fs::File::open(&config_path).map_err(|err| Error::Io {
+                source: err,
+                path: config_path.to_owned(),
+            })?,
+            buf,
+        )
+        .map_err(Error::CopyBuffer)?;
         let config_meta = Metadata {
             path: Some(config_path),
             trust: meta.trust,

gix-config/src/file/includes/types.rs+5−2

 use crate::{parse, path::interpolate};
+use std::path::PathBuf;
 /// The error returned when following includes.
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum Error {
-    #[error(transparent)]
+    #[error("Failed to copy configuration file into buffer")]
-    Io(#[from] std::io::Error),
+    CopyBuffer(#[source] std::io::Error),
+    #[error("Could not read included configuration file at '{}'", path.display())]
+    Io { path: PathBuf, source: std::io::Error },
     #[error(transparent)]
     Parse(#[from] parse::Error),
     #[error(transparent)]

gix-index/src/access/mod.rs+10−9

 use bstr::{BStr, ByteSlice, ByteVec};
 use filetime::FileTime;
+use crate::entry::{Stage, StageRaw};
 use crate::{entry, extension, AccelerateLookup, Entry, PathStorage, PathStorageRef, State, Version};
 // TODO: integrate this somehow, somewhere, depending on later usage.
                 res
             })
             .ok()?;
-        self.entry_index_by_idx_and_stage(path, idx, stage, stage_cmp)
+        self.entry_index_by_idx_and_stage(path, idx, stage as StageRaw, stage_cmp)
     }
     /// Walk as far in `direction` as possible, with [`Ordering::Greater`] towards higher stages, and [`Ordering::Less`]
         &self,
         path: &BStr,
         idx: usize,
-        wanted_stage: entry::Stage,
+        wanted_stage: entry::StageRaw,
         stage_cmp: Ordering,
     ) -> Option<usize> {
         match stage_cmp {
                 .enumerate()
                 .rev()
                 .take_while(|(_, e)| e.path(self) == path)
-                .find_map(|(idx, e)| (e.stage() == wanted_stage).then_some(idx)),
+                .find_map(|(idx, e)| (e.stage_raw() == wanted_stage).then_some(idx)),
             Ordering::Equal => Some(idx),
             Ordering::Less => self
                 .entries
                 .iter()
                 .enumerate()
                 .take_while(|(_, e)| e.path(self) == path)
-                .find_map(|(ofs, e)| (e.stage() == wanted_stage).then_some(idx + ofs + 1)),
+                .find_map(|(ofs, e)| (e.stage_raw() == wanted_stage).then_some(idx + ofs + 1)),
         }
     }
             .binary_search_by(|e| {
                 let res = e.path(self).cmp(path);
                 if res.is_eq() {
-                    stage_at_index = e.stage();
+                    stage_at_index = e.stage_raw();
                 }
                 res
             })
         let idx = if stage_at_index == 0 || stage_at_index == 2 {
             idx
         } else {
-            self.entry_index_by_idx_and_stage(path, idx, 2, stage_at_index.cmp(&2))?
+            self.entry_index_by_idx_and_stage(path, idx, Stage::Ours as StageRaw, stage_at_index.cmp(&2))?
         };
         Some(&self.entries[idx])
     }
             + self.entries[low..].partition_point(|e| e.path(self).get(..prefix_len).map_or(false, |p| p <= prefix));
         let low_entry = &self.entries.get(low)?;
-        if low_entry.stage() != 0 {
+        if low_entry.stage_raw() != 0 {
             low = self
                 .walk_entry_stages(low_entry.path(self), low, Ordering::Less)
                 .unwrap_or(low);
         }
         if let Some(high_entry) = self.entries.get(high) {
-            if high_entry.stage() != 0 {
+            if high_entry.stage_raw() != 0 {
                 high = self
                     .walk_entry_stages(high_entry.path(self), high, Ordering::Less)
                     .unwrap_or(high);
             .binary_search_by(|e| {
                 let res = e.path(self).cmp(path);
                 if res.is_eq() {
-                    stage_at_index = e.stage();
+                    stage_at_index = e.stage_raw();
                 }
                 res
             })

gix-index/src/entry/flags.rs+17−0

@@ -62,6 +62,23 @@ bitflags! { · 61 unmodified lines
62	impl Flags {	62	impl Flags {
63	/// Return the stage as extracted from the bits of this instance.	63	/// Return the stage as extracted from the bits of this instance.
64	pub fn stage(&self) -> Stage {	64	pub fn stage(&self) -> Stage {
		65	match self.stage_raw() {
		66	0 => Stage::Unconflicted,
		67	1 => Stage::Base,
		68	2 => Stage::Ours,
		69	3 => Stage::Theirs,
		70	_ => unreachable!("BUG: Flags::STAGE_MASK is two bits, whose 4 possible values we have covered"),
		71	}
		72	}
		73
		74	/// Return an entry's stage as raw number between 0 and 4.
		75	/// Possible values are:
		76	///
		77	/// * 0 = no conflict,
		78	/// * 1 = base,
		79	/// * 2 = ours,
		80	/// * 3 = theirs
		81	pub fn stage_raw(&self) -> u32 {
65	(*self & Flags::STAGE_MASK).bits() >> 12	82	(*self & Flags::STAGE_MASK).bits() >> 12
66	}	83	}
67		84

gix-index/src/entry/mod.rs+27−2

@@ -1,9 +1,23 @@
1	/// The stage of an entry, one of…	1	/// The stage of an entry.
		2	#[derive(Default, Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
		3	pub enum Stage {
		4	/// This is the default, and most entries are in this stage.
		5	#[default]
		6	Unconflicted = 0,
		7	/// The entry is the common base between 'our' change and 'their' change, for comparison.
		8	Base = 1,
		9	/// The entry represents our change.
		10	Ours = 2,
		11	/// The entry represents their change.
		12	Theirs = 3,
		13	}
		14
		15	// The stage of an entry, one of…
2	/// * 0 = no conflict,	16	/// * 0 = no conflict,
3	/// * 1 = base,	17	/// * 1 = base,
4	/// * 2 = ours,	18	/// * 2 = ours,
5	/// * 3 = theirs	19	/// * 3 = theirs
6	pub type Stage = u32;	20	pub type StageRaw = u32;
7		21
8	///	22	///
9	#[allow(clippy::empty_docs)]	23	#[allow(clippy::empty_docs)]
@@ -78,6 +92,17 @@ mod access { · 68 unmodified lines
78	pub fn stage(&self) -> entry::Stage {	92	pub fn stage(&self) -> entry::Stage {
79	self.flags.stage()	93	self.flags.stage()
80	}	94	}
		95
		96	/// Return an entry's stage as raw number between 0 and 4.
		97	/// Possible values are:
		98	///
		99	/// * 0 = no conflict,
		100	/// * 1 = base,
		101	/// * 2 = ours,
		102	/// * 3 = theirs
		103	pub fn stage_raw(&self) -> u32 {
		104	self.flags.stage_raw()
		105	}
81	}	106	}
82	}	107	}
83		108

gix-index/src/extension/fs_monitor.rs+1−0

@@ -6,6 +6,7 @@ use crate::{ · 5 unmodified lines
6	};	6	};
7		7
8	#[derive(Clone)]	8	#[derive(Clone)]
		9	#[allow(dead_code)]
9	pub enum Token {	10	pub enum Token {
10	V1 { nanos_since_1970: u64 },	11	V1 { nanos_since_1970: u64 },
11	V2 { token: BString },	12	V2 { token: BString },

gix-index/src/lib.rs+5−5

 }
 mod impls {
+    use crate::entry::Stage;
     use std::fmt::{Debug, Formatter};
     use crate::State;
                     f,
                     "{} {}{:?} {} {}",
                     match entry.flags.stage() {
-                        0 => "       ",
+                        Stage::Unconflicted => "       ",
-                        1 => "BASE   ",
+                        Stage::Base => "BASE   ",
-                        2 => "OURS   ",
+                        Stage::Ours => "OURS   ",
-                        3 => "THEIRS ",
+                        Stage::Theirs => "THEIRS ",
-                        _ => "UNKNOWN",
                     },
                     if entry.flags.is_empty() {
                         "".to_string()

gix-index/tests/index/access.rs+10−9

 use crate::index::Fixture;
 use bstr::{BString, ByteSlice};
+use gix_index::entry::Stage;
 fn icase_fixture() -> gix_index::File {
     Fixture::Generated("v2_icase_name_clashes").open()
     for entry in file.entries() {
         let path = entry.path(&file);
         assert_eq!(file.entry_by_path(path), Some(entry));
-        assert_eq!(file.entry_by_path_and_stage(path, 0), Some(entry));
+        assert_eq!(file.entry_by_path_and_stage(path, Stage::Unconflicted), Some(entry));
     }
 }
     for entry in file.entries() {
         let path = entry.path(&file);
         assert_eq!(
-            file.entry_index_by_path_and_stage(path, 0)
+            file.entry_index_by_path_and_stage(path, Stage::Unconflicted)
                 .map(|idx| &file.entries()[idx]),
             Some(entry)
         );
-        assert_eq!(file.entry_by_path_and_stage(path, 0), Some(entry));
+        assert_eq!(file.entry_by_path_and_stage(path, Stage::Unconflicted), Some(entry));
     }
 }
 #[test]
 fn entry_by_path_with_conflicting_file() {
     let file = Fixture::Loose("conflicting-file").open();
-    for expected_stage in [1 /* common ancestor */, 2 /* ours */, 3 /* theirs */] {
+    for expected_stage in [Stage::Base, Stage::Ours, Stage::Theirs] {
         assert!(
             file.entry_by_path_and_stage("file".into(), expected_stage).is_some(),
-            "we have no stage 0 during a conflict, but all other ones. Missed {expected_stage}"
+            "we have no stage 0 during a conflict, but all other ones. Missed {expected_stage:?}"
         );
     }
     assert_eq!(
         file.entry_by_path("file".into()).expect("found").stage(),
-        2,
+        Stage::Ours,
         "we always find our stage while in a merge"
     );
 }
     for (idx, entry) in file.entries()[..valid_entries].iter().enumerate() {
         assert_eq!(
-            file.entry_index_by_path_and_stage_bounded(entry.path(&file), 0, valid_entries),
+            file.entry_index_by_path_and_stage_bounded(entry.path(&file), Stage::Unconflicted, valid_entries),
             Some(idx),
             "we can still find entries in the correctly sorted region"
         );
     }
     assert_eq!(
-        file.entry_by_path_and_stage(new_entry_path, 0),
+        file.entry_by_path_and_stage(new_entry_path, Stage::Unconflicted),
         None,
         "new entry can't be found due to incorrect order"
     );
     assert!(file.verify_entries().is_ok(), "sorting of entries restores invariants");
     assert_eq!(
-        file.entry_by_path_and_stage(new_entry_path, 0)
+        file.entry_by_path_and_stage(new_entry_path, Stage::Unconflicted)
             .expect("can be found")
             .path(&file),
         new_entry_path,

gix-status/src/index_as_worktree/function.rs+4−4

@@ -157,11 +157,11 @@ where · 156 unmodified lines
157	let mut idx = 0;	157	let mut idx = 0;
158	while let Some(entry) = chunk_entries.get(idx) {	158	while let Some(entry) = chunk_entries.get(idx) {
159	let absolute_entry_index = entry_offset + idx;	159	let absolute_entry_index = entry_offset + idx;
160	if idx == 0 && entry.stage() != 0 {	160	if idx == 0 && entry.stage_raw() != 0 {
161	let offset = entry_offset.checked_sub(1).and_then(\|prev_idx\| {	161	let offset = entry_offset.checked_sub(1).and_then(\|prev_idx\| {
162	let prev_entry = &all_entries[prev_idx];	162	let prev_entry = &all_entries[prev_idx];
163	let entry_path = entry.path_in(state.path_backing);	163	let entry_path = entry.path_in(state.path_backing);
164	if prev_entry.stage() == 0 \|\| prev_entry.path_in(state.path_backing) != entry_path {	164	if prev_entry.stage_raw() == 0 \|\| prev_entry.path_in(state.path_backing) != entry_path {
165	// prev_entry (in previous chunk) does not belong to our conflict	165	// prev_entry (in previous chunk) does not belong to our conflict
166	return None;	166	return None;
167	}	167	}
@@ -286,7 +286,7 @@ impl<'index> State<'_, 'index> { · 118 unmodified lines
286	self.skipped_by_pathspec.fetch_add(1, Ordering::Relaxed);	286	self.skipped_by_pathspec.fetch_add(1, Ordering::Relaxed);
287	return None;	287	return None;
288	}	288	}
289	let status = if entry.stage() != 0 {	289	let status = if entry.stage_raw() != 0 {
290	Ok(	290	Ok(
291	Conflict::try_from_entry(entries, self.path_backing, entry_index, path).map(\|(conflict, offset)\| {	291	Conflict::try_from_entry(entries, self.path_backing, entry_index, path).map(\|(conflict, offset)\| {
292	*outer_entry_index += offset; // let out loop skip over entries related to the conflict	292	*outer_entry_index += offset; // let out loop skip over entries related to the conflict
@@ -604,7 +604,7 @@ impl Conflict { · 311 unmodified lines
604	let mut count = 0_usize;	604	let mut count = 0_usize;
605	for stage in (start_index..(start_index + 3).min(entries.len())).filter_map(\|idx\| {	605	for stage in (start_index..(start_index + 3).min(entries.len())).filter_map(\|idx\| {
606	let entry = &entries[idx];	606	let entry = &entries[idx];
607	let stage = entry.stage();	607	let stage = entry.stage_raw();
608	(stage > 0 && entry.path_in(path_backing) == entry_path).then_some(stage)	608	(stage > 0 && entry.path_in(path_backing) == entry_path).then_some(stage)
609	}) {	609	}) {
610	// This could be `1 << (stage - 1)` but let's be specific.	610	// This could be `1 << (stage - 1)` but let's be specific.

gix-worktree/src/stack/platform.rs+1−0

@@ -20,6 +20,7 @@ impl<'a> Platform<'a> { · 19 unmodified lines
20	/// # Panics	20	/// # Panics
21	///	21	///
22	/// If the cache was configured without exclude patterns.	22	/// If the cache was configured without exclude patterns.
		23	#[doc(alias = "is_path_ignored", alias = "git2")]
23	pub fn is_excluded(&self) -> bool {	24	pub fn is_excluded(&self) -> bool {
24	self.matching_exclude_pattern()	25	self.matching_exclude_pattern()
25	.map_or(false, \|m\| !m.pattern.is_negative())	26	.map_or(false, \|m\| !m.pattern.is_negative())

gix-worktree/src/stack/state/mod.rs+1−1

@@ -131,7 +131,7 @@ impl State { · 130 unmodified lines
131		131
132	// Stage 0 means there is no merge going on, stage 2 means it's 'our' side of the merge, but then	132	// Stage 0 means there is no merge going on, stage 2 means it's 'our' side of the merge, but then
133	// there won't be a stage 0.	133	// there won't be a stage 0.
134	if entry.mode == gix_index::entry::Mode::FILE && (entry.stage() == 0 \|\| entry.stage() == 2) {	134	if entry.mode == gix_index::entry::Mode::FILE && (entry.stage_raw() == 0 \|\| entry.stage_raw() == 2) {
135	let basename = path.rfind_byte(b'/').map_or(path, \|pos\| path[pos + 1..].as_bstr());	135	let basename = path.rfind_byte(b'/').map_or(path, \|pos\| path[pos + 1..].as_bstr());
136	let ignore_source = names.iter().find_map(\|t\| {	136	let ignore_source = names.iter().find_map(\|t\| {
137	match case {	137	match case {

gix/src/attribute_stack.rs+1−0

@@ -39,6 +39,7 @@ impl<'repo> AttributeStack<'repo> { · 38 unmodified lines
39	/// path is created as directory. If it's not known it is assumed to be a file.	39	/// path is created as directory. If it's not known it is assumed to be a file.
40	///	40	///
41	/// Provide access to cached information for that `relative` path via the returned platform.	41	/// Provide access to cached information for that `relative` path via the returned platform.
		42	#[doc(alias = "is_path_ignored", alias = "git2")]
42	pub fn at_path(	43	pub fn at_path(
43	&mut self,	44	&mut self,
44	relative: impl AsRef<std::path::Path>,	45	relative: impl AsRef<std::path::Path>,

gix/src/repository/attributes.rs+1−0

@@ -106,6 +106,7 @@ impl Repository { · 105 unmodified lines
106	/// When only excludes are desired, this is the most efficient way to obtain them. Otherwise use	106	/// When only excludes are desired, this is the most efficient way to obtain them. Otherwise use
107	/// [`Repository::attributes()`] for accessing both attributes and excludes.	107	/// [`Repository::attributes()`] for accessing both attributes and excludes.
108	// TODO: test	108	// TODO: test
		109	#[doc(alias = "is_path_ignored", alias = "git2")]
109	#[cfg(feature = "excludes")]	110	#[cfg(feature = "excludes")]
110	pub fn excludes(	111	pub fn excludes(
111	&self,	112	&self,

gix/src/repository/index.rs+5−0

     /// Return a shared worktree index which is updated automatically if the in-memory snapshot has become stale as the underlying file
     /// on disk has changed.
     ///
+    /// ### Notes
+    ///
+    /// * This will fail if the file doesn't exist, like in a newly initialized repository. If that is the case, use
+    ///   [index_or_empty()](Self::index_or_empty) or [try_index()](Self::try_index) instead.
+    ///
     /// The index file is shared across all clones of this repository.
     pub fn index(&self) -> Result<worktree::Index, worktree::open_index::Error> {
         self.try_index().and_then(|opt| match opt {

gix/src/revision/spec/parse/delegate/navigate.rs+14−8

 use std::collections::HashSet;
 use gix_hash::ObjectId;
+use gix_index::entry::Stage;
 use gix_revision::spec::parse::{
     delegate,
     delegate::{PeelTo, Traversal},
     }
     fn index_lookup(&mut self, path: &BStr, stage: u8) -> Option<()> {
+        let stage = match stage {
+            0 => Stage::Unconflicted,
+            1 => Stage::Base,
+            2 => Stage::Ours,
+            3 => Stage::Theirs,
+            _ => unreachable!(
+                "BUG: driver will not pass invalid stages (and it uses integer to avoid gix-index as dependency)"
+            ),
+        };
         self.unset_disambiguate_call();
         match self.repo.index() {
-            Ok(index) => match index.entry_by_path_and_stage(path, stage.into()) {
+            Ok(index) => match index.entry_by_path_and_stage(path, stage) {
                 Some(entry) => {
                     self.objs[self.idx]
                         .get_or_insert_with(HashSet::default)
                     Some(())
                 }
                 None => {
-                    let stage_hint = [0, 1, 2]
+                    let stage_hint = [Stage::Unconflicted, Stage::Base, Stage::Ours]
                         .iter()
                         .filter(|our_stage| **our_stage != stage)
-                        .find_map(|stage| {
+                        .find_map(|stage| index.entry_index_by_path_and_stage(path, *stage).map(|_| *stage));
-                            index
-                                .entry_index_by_path_and_stage(path, (*stage).into())
-                                .map(|_| (*stage).into())
-                        });
                     let exists = self
                         .repo
                         .work_dir()
                         .map_or(false, |root| root.join(gix_path::from_bstr(path)).exists());
                     self.err.push(Error::IndexLookup {
                         desired_path: path.into(),
-                        desired_stage: stage.into(),
+                        desired_stage: stage,
                         exists,
                         stage_hint,
                     });

gix/src/revision/spec/parse/types.rs+1−1

@@ -98,7 +98,7 @@ pub enum Error { · 97 unmodified lines
98	desired: usize,	98	desired: usize,
99	available: usize,	99	available: usize,
100	},	100	},
101	#[error("Path {desired_path:?} did not exist in index at stage {desired_stage}{}{}", stage_hint.map(\|actual\|format!(". It does exist at stage {actual}")).unwrap_or_default(), exists.then(\|\| ". It exists on disk").unwrap_or(". It does not exist on disk"))]	101	#[error("Path {desired_path:?} did not exist in index at stage {}{}{}", *desired_stage as u8, stage_hint.map(\|actual\|format!(". It does exist at stage {}", actual as u8)).unwrap_or_default(), exists.then(\|\| ". It exists on disk").unwrap_or(". It does not exist on disk"))]
102	IndexLookup {	102	IndexLookup {
103	desired_path: BString,	103	desired_path: BString,
104	desired_stage: gix_index::entry::Stage,	104	desired_stage: gix_index::entry::Stage,

gix/src/status/index_worktree.rs+8−6

             let local_repo = repo.to_thread_local();
             let submodule_paths = match local_repo.submodules()? {
                 Some(sm) => {
-                    let mut v: Vec<_> = sm
+                    let mut v: Vec<_> = sm.filter_map(|sm| sm.path().ok().map(Cow::into_owned)).collect();
-                        .filter(|sm| sm.is_active().unwrap_or_default())
-                        .filter_map(|sm| sm.path().ok().map(Cow::into_owned))
-                        .collect();
                     v.sort();
                     v
                 }
 ///
 /// ### Submodules
 ///
-/// Note that submodules can be set to 'inactive' which automatically excludes them from the status operation.
+/// Note that submodules can be set to 'inactive', which will not exclude them from the status operation, similar to
+/// how `git status` includes them.
 ///
 /// ### Index Changes
 ///
         ///
         /// * `patterns`
         ///     - Optional patterns to use to limit the paths to look at. If empty, all paths are considered.
-        pub fn into_index_worktree_iter(self, patterns: Vec<BString>) -> Result<index_worktree::Iter, Error> {
+        pub fn into_index_worktree_iter(
+            self,
+            patterns: impl IntoIterator<Item = BString>,
+        ) -> Result<index_worktree::Iter, Error> {
             let index = match self.index {
                 None => IndexPersistedOrInMemory::Persisted(self.repo.index_or_empty()?),
                 Some(index) => index,
             {
                 let (tx, rx) = std::sync::mpsc::channel();
                 let mut collect = Collect { tx };
+                let patterns: Vec<_> = patterns.into_iter().collect();
                 let join = std::thread::Builder::new()
                     .name("gix::status::index_worktree::iter::producer".into())
                     .spawn({