feat!: add entries-relative index to each change.

That way it's possible to lookup other, surrounding entries in case
of conflicts or easily find entries that didn't change.

Author: Byron

gix-status/src/index_as_worktree/function.rs

@@ -1,3 +1,4 @@
+use std::slice::ChunksMut;
 use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
 use std::{io, marker::PhantomData, path::Path};
 
@@ -19,7 +20,7 @@ use crate::{
 
 /// Calculates the changes that need to be applied to an `index` to match the state of the `worktree` and makes them
 /// observable in `collector`, along with information produced by `compare` which gets to see blobs that may have changes, and
-/// `submodule` which can take a look at submodules in detail to produce status information.
+/// `submodule` which can take a look at submodules in detail to produce status information (BASE version if its conflicting).
 /// `options` are used to configure the operation.
 ///
 /// Note that `index` is updated with the latest seen stat information from the worktree, and its timestamp is adjusted to
@@ -85,6 +86,7 @@ where
     );
     let (entries, path_backing) = index.entries_mut_and_pathbacking();
     let mut num_entries = entries.len();
+    let entry_index_offset = range.start;
     let entries = &mut entries[range];
 
     let _span = gix_features::trace::detail!("gix_status::index_as_worktree", 
@@ -137,14 +139,21 @@ where
     };
     in_parallel_if(
         || true, // TODO: heuristic: when is parallelization not worth it? Git says 500 items per thread, but to 20 threads, we can be more fine-grained though.
-        gix_features::interrupt::Iter::new(entries.chunks_mut(chunk_size), should_interrupt),
+        gix_features::interrupt::Iter::new(
+            OffsetIter {
+                inner: entries.chunks_mut(chunk_size),
+                offset: entry_index_offset,
+            },
+            should_interrupt,
+        ),
         thread_limit,
         new_state,
-        |entries, (state, blobdiff, submdule, find, pathspec)| {
+        |(entry_offset, entries), (state, blobdiff, submdule, find, pathspec)| {
             entries
                 .iter_mut()
-                .filter_map(|entry| {
-                    let res = state.process(entry, pathspec, blobdiff, submdule, find);
+                .enumerate()
+                .filter_map(|(entry_index, entry)| {
+                    let res = state.process(entry, entry_offset + entry_index, pathspec, blobdiff, submdule, find);
                     count.fetch_add(1, Ordering::Relaxed);
                     res
                 })
@@ -198,12 +207,22 @@ struct State<'a, 'b> {
     odb_reads: &'a AtomicUsize,
 }
 
-type StatusResult<'index, T, U> = Result<(&'index gix_index::Entry, &'index BStr, Option<Change<T, U>>, bool), Error>;
+type StatusResult<'index, T, U> = Result<
+    (
+        &'index gix_index::Entry,
+        usize,
+        &'index BStr,
+        Option<Change<T, U>>,
+        bool,
+    ),
+    Error,
+>;
 
 impl<'index> State<'_, 'index> {
     fn process<T, U, Find, E1, E2>(
         &mut self,
         entry: &'index mut gix_index::Entry,
+        entry_index: usize,
         pathspec: &mut impl Pathspec,
         diff: &mut impl CompareBlobs<Output = T>,
         submodule: &mut impl SubmoduleStatus<Output = U, Error = E2>,
@@ -234,7 +253,7 @@ impl<'index> State<'_, 'index> {
             return None;
         }
         let status = self.compute_status(&mut *entry, path, diff, submodule, find);
-        Some(status.map(move |status| (&*entry, path, status, conflict)))
+        Some(status.map(move |status| (&*entry, entry_index, path, status, conflict)))
     }
 
     /// # On how racy-git is handled here
@@ -412,8 +431,8 @@ impl<'index, T, U, C: VisitEntry<'index, ContentChange = T, SubmoduleStatus = U>
 
     fn feed(&mut self, items: Self::Input) -> Result<Self::FeedProduce, Self::Error> {
         for item in items {
-            let (entry, path, change, conflict) = item?;
-            self.collector.visit_entry(entry, path, change, conflict);
+            let (entry, entry_index, path, change, conflict) = item?;
+            self.collector.visit_entry(entry, entry_index, path, change, conflict);
         }
         Ok(())
     }
@@ -511,3 +530,19 @@ where
         Ok(out)
     }
 }
+
+struct OffsetIter<'a, T> {
+    inner: ChunksMut<'a, T>,
+    offset: usize,
+}
+
+impl<'a, T> Iterator for OffsetIter<'a, T> {
+    type Item = (usize, &'a mut [T]);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let block = self.inner.next()?;
+        let offset = self.offset;
+        self.offset += block.len();
+        Some((offset, block))
+    }
+}

gix-status/src/index_as_worktree/recorder.rs

@@ -10,6 +10,8 @@ use crate::index_as_worktree::{Change, VisitEntry};
 pub struct Record<'index, T, U> {
     /// The index entry that is changed.
     pub entry: &'index index::Entry,
+    /// The index of the `entry` relative to all entries in the input index.
+    pub entry_index: usize,
     /// The path to the entry.
     pub relative_path: &'index BStr,
     /// The change itself, or `None` if there is only a conflict.
@@ -32,13 +34,15 @@ impl<'index, T: Send, U: Send> VisitEntry<'index> for Recorder<'index, T, U> {
     fn visit_entry(
         &mut self,
         entry: &'index index::Entry,
+        entry_index: usize,
         rela_path: &'index BStr,
         change: Option<Change<Self::ContentChange, Self::SubmoduleStatus>>,
         conflict: bool,
     ) {
         if conflict || change.is_some() {
             self.records.push(Record {
                 entry,
+                entry_index,
                 relative_path: rela_path,
                 change,
                 conflict,

gix-status/src/index_as_worktree/types.rs

@@ -118,12 +118,13 @@ pub trait VisitEntry<'index> {
     type ContentChange;
     /// Data obtained when checking the submodule status.
     type SubmoduleStatus;
-    /// Observe the `change` of `entry` at the repository-relative `rela_path`, indicating whether
-    /// or not it has a `conflict`.
+    /// Observe the `change` of `entry` at the repository-relative `rela_path` at `entry_index`
+    /// (relative to the complete list of all index entries), indicating whether or not it has a `conflict`.
     /// If `change` is `None`, there is no change.
     fn visit_entry(
         &mut self,
         entry: &'index gix_index::Entry,
+        entry_index: usize,
         rela_path: &'index BStr,
         change: Option<Change<Self::ContentChange, Self::SubmoduleStatus>>,
         conflict: bool,

gix-status/tests/fixtures/generated-archives/status_submodule.tar.xz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c2d7b75f62872a98ad670d1239e5ff6867b004a84ffacb050c1f4bc06b5a1d17
-size 14876
+oid sha256:18a83500a44dbb5ab3865281645d45f8a81d469cdc7a719c2bb93e92f2fac00e
+size 16940

gix-status/tests/fixtures/status_submodule.sh

@@ -32,3 +32,17 @@ cp -R no-change empty-dir-no-change
   rm -Rf m1
   mkdir m1
 )
+
+cp -R no-change conflict
+(cd conflict
+  (cd m1
+    git checkout @~1
+  )
+
+  git commit -am "change submodule head"
+  git checkout -b other @~1
+  git rm -rf m1
+  git commit -m "removed submodule"
+
+  git merge main || :
+)