Store index data in the snapshot, and resolve it as well.

Author: Byron

crates/but-core/src/diff/mod.rs

@@ -4,8 +4,10 @@ use bstr::{BStr, ByteSlice};
 pub use tree_changes::tree_changes;
 
 mod worktree;
-use crate::{ChangeState, ModeFlags, TreeChange, TreeStatus, TreeStatusKind};
-pub use worktree::worktree_changes;
+use crate::{
+    ChangeState, IgnoredWorktreeChange, ModeFlags, TreeChange, TreeStatus, TreeStatusKind,
+};
+pub use worktree::{worktree_changes, worktree_changes_no_renames};
 
 /// conversion functions for use in the UI
 pub mod ui;
@@ -68,6 +70,15 @@ impl std::fmt::Debug for TreeChange {
     }
 }
 
+impl std::fmt::Debug for IgnoredWorktreeChange {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("IgnoredWorktreeChange")
+            .field("path", &self.path)
+            .field("status", &self.status)
+            .finish()
+    }
+}
+
 impl ModeFlags {
     fn calculate(old: &ChangeState, new: &ChangeState) -> Option<Self> {
         Self::calculate_inner(old.kind, new.kind)

crates/but-core/src/diff/worktree.rs

@@ -33,20 +33,44 @@ enum Origin {
 /// to get a commit with a tree equal to the current worktree.
 #[instrument(skip(repo), err(Debug))]
 pub fn worktree_changes(repo: &gix::Repository) -> anyhow::Result<WorktreeChanges> {
-    let rewrites = gix::diff::Rewrites::default(); /* standard Git rewrite handling for everything */
-    debug_assert!(
-        rewrites.copies.is_none(),
-        "TODO: copy tracking needs specific support wherever 'previous_path()' is called."
-    );
+    worktree_changes_inner(repo, RenameTracking::Always)
+}
+
+/// Just like [`worktree_changes()`], but don't do any rename tracking for performance.
+#[instrument(skip(repo), err(Debug))]
+pub fn worktree_changes_no_renames(repo: &gix::Repository) -> anyhow::Result<WorktreeChanges> {
+    worktree_changes_inner(repo, RenameTracking::Disabled)
+}
+
+enum RenameTracking {
+    Always,
+    Disabled,
+}
+
+fn worktree_changes_inner(
+    repo: &gix::Repository,
+    renames: RenameTracking,
+) -> anyhow::Result<WorktreeChanges> {
+    let (tree_index_rewrites, worktree_rewrites) = match renames {
+        RenameTracking::Always => {
+            let rewrites = gix::diff::Rewrites::default(); /* standard Git rewrite handling for everything */
+            debug_assert!(
+                rewrites.copies.is_none(),
+                "TODO: copy tracking needs specific support wherever 'previous_path()' is called."
+            );
+            (TrackRenames::Given(rewrites), Some(rewrites))
+        }
+        RenameTracking::Disabled => (TrackRenames::Disabled, None),
+    };
     let has_submodule_ignore_configuration = repo.modules()?.is_some_and(|modules| {
         modules
             .names()
             .any(|name| modules.ignore(name).ok().flatten().is_some())
     });
     let status_changes = repo
         .status(gix::progress::Discard)?
-        .tree_index_track_renames(TrackRenames::Given(rewrites))
-        .index_worktree_rewrites(rewrites)
+        .tree_index_track_renames(tree_index_rewrites)
+        .index_worktree_rewrites(worktree_rewrites)
         // Learn about submodule changes, but only do the cheap checks, showing only what we could commit.
         .index_worktree_submodules(if has_submodule_ignore_configuration {
             gix::status::Submodule::AsConfigured { check_dirty: true }
@@ -415,6 +439,7 @@ pub fn worktree_changes(repo: &gix::Repository) -> anyhow::Result<WorktreeChange
                 ignored_changes.push(IgnoredWorktreeChange {
                     path: rela_path,
                     status: IgnoredWorktreeTreeChangeStatus::Conflict,
+                    status_item: Some(change),
                 });
                 continue;
             }
@@ -483,15 +508,17 @@ pub fn worktree_changes(repo: &gix::Repository) -> anyhow::Result<WorktreeChange
                     changes.push(merged);
                     IgnoredWorktreeTreeChangeStatus::TreeIndex
                 }
-                [Some(first), Some(second)] => {
+                [Some(mut first), Some(mut second)] => {
                     ignored_changes.push(IgnoredWorktreeChange {
                         path: first.path.clone(),
                         status: IgnoredWorktreeTreeChangeStatus::TreeIndex,
+                        status_item: first.status_item.take(),
                     });
                     changes.push(first);
                     ignored_changes.push(IgnoredWorktreeChange {
                         path: second.path.clone(),
                         status: IgnoredWorktreeTreeChangeStatus::TreeIndex,
+                        status_item: second.status_item.take(),
                     });
                     changes.push(second);
                     continue;
@@ -500,6 +527,7 @@ pub fn worktree_changes(repo: &gix::Repository) -> anyhow::Result<WorktreeChange
             ignored_changes.push(IgnoredWorktreeChange {
                 path: change_path,
                 status,
+                status_item: None,
             });
             continue;
         }

crates/but-core/src/lib.rs

@@ -332,13 +332,17 @@ pub enum IgnoredWorktreeTreeChangeStatus {
 }
 
 /// A way to indicate that a path in the index isn't suitable for committing and needs to be dealt with.
-#[derive(Debug, Clone, Serialize)]
+#[derive(Clone, Serialize)]
 pub struct IgnoredWorktreeChange {
     /// The worktree-relative path to the change.
     #[serde(serialize_with = "gitbutler_serde::bstring_lossy::serialize")]
     pub path: BString,
     /// The status that caused this change to be ignored.
     pub status: IgnoredWorktreeTreeChangeStatus,
+    /// The status item that this change is derived from, used in places that need detailed information.
+    /// It's `None` if the status item is already present in non-ignored changes.
+    #[serde(skip)]
+    pub status_item: Option<gix::status::Item>,
 }
 
 /// The type returned by [`worktree_changes()`](diff::worktree_changes).

crates/but-workspace/src/branch/create_reference.rs

@@ -106,7 +106,7 @@ impl<'a> ReferenceAnchor<'a> {
 }
 
 pub(super) mod function {
-    #![allow(clippy::indexing_slicing)]
+    #![expect(clippy::indexing_slicing)]
 
     use crate::branch::{ReferenceAnchor, ReferencePosition};
     use anyhow::{Context, bail};

crates/but-workspace/src/ref_info.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::indexing_slicing)]
+#![expect(clippy::indexing_slicing)]
 // TODO: rename this module to `workspace`, make it private, and pub-use all content in the top-level, as we now literally
 //       get the workspace, while possibly processing it for use in the UI.
 

crates/but-workspace/src/snapshot/create_tree.rs

@@ -5,7 +5,7 @@ use std::collections::BTreeSet;
 /// A way to determine what should be included in the snapshot when calling [create_tree()](function::create_tree).
 #[derive(Debug, Clone)]
 pub struct State {
-    /// The result of a previous worktree changes call.
+    /// The result of a previous worktree changes call, but [the one **without** renames](but_core::diff::worktree_changes_no_renames()).
     ///
     /// It contains detailed information about the complete set of possible changes to become part of the worktree.
     pub changes: but_core::WorktreeChanges,
@@ -59,9 +59,13 @@ pub fn no_workspace_and_meta() -> Option<(
 pub(super) mod function {
     use super::{Outcome, State};
     use crate::{DiffSpec, commit_engine};
-    use anyhow::bail;
-    use but_core::RefMetadata;
+    use anyhow::{Context, bail};
+    use bstr::{BString, ByteSlice};
+    use but_core::{ChangeState, RefMetadata};
+    use gix::diff::index::Change;
     use gix::object::tree::EntryKind;
+    use gix::status::plumbing::index_as_worktree::EntryStatus;
+    use std::collections::BTreeSet;
     use tracing::instrument;
 
     /// Create a tree that represents the snapshot for the given `selection`, whereas the basis for these changes
@@ -94,7 +98,10 @@ pub(super) mod function {
     ///       even though it might be that the respective objects aren't written to disk yet.
     ///     - Note that this tree may contain files with conflict markers as it will pick up the conflicting state visible on disk.
     /// * `index`
-    ///     - A representation of the non-conflicting portions of the index, without its meta-data.
+    ///     - A representation of the non-conflicting and changed portions of the index, without its meta-data.
+    ///     - may be empty if only conflicts exist.
+    /// * `index-conflicts`
+    ///     - `<entry-path>/[1,2,3]` - the blobs at their respective stages.
     #[instrument(skip(changes, _workspace_and_meta), err(Debug))]
     pub fn create_tree(
         head_tree_id: gix::Id<'_>,
@@ -105,13 +112,47 @@ pub(super) mod function {
         }: State,
         _workspace_and_meta: Option<(&but_graph::projection::Workspace, &impl RefMetadata)>,
     ) -> anyhow::Result<Outcome> {
+        // Assure this is a tree early.
+        let head_tree = head_tree_id.object()?.into_tree();
         let repo = head_tree_id.repo;
         let mut changes_to_apply: Vec<_> = changes
             .changes
             .iter()
             .filter(|c| selection.contains(&c.path))
             .map(|c| Ok(DiffSpec::from(c)))
             .collect();
+        changes_to_apply.extend(
+            changes
+                .ignored_changes
+                .iter()
+                .filter_map(|c| match &c.status_item {
+                    Some(gix::status::Item::IndexWorktree(
+                        gix::status::index_worktree::Item::Modification {
+                            status: EntryStatus::Conflict { .. },
+                            rela_path,
+                            ..
+                        },
+                    )) => Some(rela_path),
+                    _ => None,
+                })
+                .filter(|rela_path| selection.contains(rela_path.as_bstr()))
+                .map(|rela_path| {
+                    // Create a pretend-addition to pick up conflicted paths as well.
+                    Ok(DiffSpec::from(but_core::TreeChange {
+                        path: rela_path.to_owned(),
+                        status: but_core::TreeStatus::Addition {
+                            state: ChangeState {
+                                id: repo.object_hash().null(),
+                                // This field isn't relevant when entries are read from disk.
+                                kind: EntryKind::Tree,
+                            },
+                            is_untracked: true,
+                        },
+                        status_item: None,
+                    }))
+                }),
+        );
+
         let (new_tree, base_tree) = commit_engine::tree::apply_worktree_changes(
             head_tree_id.into(),
             repo,
@@ -138,19 +179,141 @@ pub(super) mod function {
             needs_head = true;
         }
 
+        let (index, index_conflicts) = snapshot_index(&mut edit, head_tree, changes, selection)?
+            .inspect(|(index, index_conflicts)| {
+                needs_head |= index_conflicts.is_some() && index.is_none();
+            })
+            .unwrap_or_default();
+
         if needs_head {
             edit.upsert("HEAD", EntryKind::Tree, head_tree_id)?;
         }
 
         Ok(Outcome {
             snapshot_tree: edit.write()?.into(),
-            head_tree: head_tree_id.into(),
+            head_tree: head_tree_id.detach(),
             worktree,
-            index: None,
-            index_conflicts: None,
+            index,
+            index_conflicts,
             workspace_references: None,
             head_references: None,
             metadata: None,
         })
     }
+
+    /// `snapshot_tree` is the tree into which our `index` and `index-conflicts` trees are written. These will also be returned
+    /// if they were written.
+    ///
+    /// `base_tree_id` is the tree from which a clean index can be created, and which we will edit to incorporate the
+    /// non-conflicting index changes.
+    fn snapshot_index(
+        snapshot_tree: &mut gix::object::tree::Editor,
+        base_tree: gix::Tree,
+        changes: but_core::WorktreeChanges,
+        selection: BTreeSet<BString>,
+    ) -> anyhow::Result<Option<(Option<gix::ObjectId>, Option<gix::ObjectId>)>> {
+        let mut conflicts = Vec::new();
+        let changes: Vec<_> = changes
+            .changes
+            .into_iter()
+            .filter_map(|c| c.status_item)
+            .chain(
+                changes
+                    .ignored_changes
+                    .into_iter()
+                    .filter_map(|c| c.status_item),
+            )
+            .filter_map(|item| match item {
+                gix::status::Item::IndexWorktree(
+                    gix::status::index_worktree::Item::Modification {
+                        status: EntryStatus::Conflict { entries, .. },
+                        rela_path,
+                        ..
+                    },
+                ) => {
+                    conflicts.push((rela_path, entries));
+                    None
+                }
+                gix::status::Item::TreeIndex(c) => Some(c),
+                _ => None,
+            })
+            .filter(|c| selection.iter().any(|path| path == c.location()))
+            .collect();
+
+        if changes.is_empty() && conflicts.is_empty() {
+            return Ok(None);
+        }
+
+        let mut base_tree_edit = base_tree.edit()?;
+        for change in changes {
+            match change {
+                Change::Deletion { location, .. } => {
+                    base_tree_edit.remove(location.as_bstr())?;
+                }
+                Change::Addition {
+                    location,
+                    entry_mode,
+                    id,
+                    ..
+                }
+                | Change::Modification {
+                    location,
+                    entry_mode,
+                    id,
+                    ..
+                } => {
+                    base_tree_edit.upsert(
+                        location.as_bstr(),
+                        entry_mode
+                            .to_tree_entry_mode()
+                            .with_context(|| format!("Could not convert the index entry {entry_mode:?} at '{location}' into a tree entry kind"))?
+                            .kind(),
+                        id.into_owned(),
+                    )?;
+                }
+                Change::Rewrite { .. } => {
+                    unreachable!("BUG: this must have been deactivated")
+                }
+            }
+        }
+
+        let index = base_tree_edit.write()?;
+        let index = (index != base_tree.id).then_some(index.detach());
+        if let Some(index) = index {
+            snapshot_tree.upsert("index", EntryKind::Tree, index)?;
+        }
+
+        let index_conflicts = if conflicts.is_empty() {
+            None
+        } else {
+            let mut root = snapshot_tree.cursor_at("index-conflicts")?;
+            for (rela_path, conflict_entries) in conflicts {
+                for (stage, entry) in conflict_entries
+                    .into_iter()
+                    .enumerate()
+                    .filter_map(|(idx, e)| e.map(|e| (idx + 1, e)))
+                {
+                    root.upsert(
+                        format!("{rela_path}/{stage}"),
+                        entry
+                            .mode
+                            .to_tree_entry_mode()
+                            .with_context(|| {
+                                format!(
+                                    "Could not convert the index entry {entry_mode:?} \
+                            at '{location}' into a tree entry kind",
+                                    entry_mode = entry.mode,
+                                    location = rela_path
+                                )
+                            })?
+                            .kind(),
+                        entry.id,
+                    )?;
+                }
+            }
+            root.write()?.detach().into()
+        };
+
+        Ok(Some((index, index_conflicts)))
+    }
 }