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/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 anyhow::{Context, bail};
+    use bstr::{BString, ByteSlice};
     use but_core::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
@@ -105,6 +109,8 @@ pub(super) mod function {
         }: State,
         _workspace_and_meta: Option<(&but_graph::projection::Workspace, &impl RefMetadata)>,
     ) -> anyhow::Result<Outcome> {
+        // Assure this is a tree.
+        let head_tree = head_tree_id.object()?.into_tree();
         let repo = head_tree_id.repo;
         let mut changes_to_apply: Vec<_> = changes
             .changes
@@ -138,19 +144,142 @@ pub(super) mod function {
             needs_head = true;
         }
 
+        let (index, index_conflicts) = snapshot_index(&mut edit, head_tree, changes, selection)?
+            .inspect(|_| {
+                needs_head = true;
+            })
+            .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 stage in 1..=3 {
+                for (rela_path, conflict_at_stage) in
+                    conflicts.iter_mut().filter_map(|(rela_path, stages)| {
+                        #[allow(clippy::indexing_slicing)]
+                        stages[stage - 1].take().map(|e| (rela_path, e))
+                    })
+                {
+                    root.upsert(
+                        format!("{stage}/{rela_path}"),
+                        conflict_at_stage
+                            .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 = conflict_at_stage.mode,
+                                    location = rela_path
+                                )
+                            })?
+                            .kind(),
+                        conflict_at_stage.id,
+                    )?;
+                }
+            }
+            Some(root.write()?.detach())
+        };
+
+        Ok(Some((index, index_conflicts)))
+    }
 }

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

@@ -6,6 +6,7 @@ pub struct Outcome<'repo> {
     /// It's `None` if the was no worktree change.
     pub worktree_cherry_pick: Option<gix::merge::tree::Outcome<'repo>>,
     /// If an index was stored in the snapshot, this is the reconstructed index, including conflicts.
+    /// Note that it has no information from disk whatsoever and should not be written like that.
     ///
     /// It's `None` if there were no index-only changes.
     pub index: Option<gix::index::State>,

crates/but-workspace/tests/fixtures/scenario/unborn-all-file-types-added-to-index.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+### Description
+# A newly initialized git repository with an executable, a normal file, a symlink and a fifo, added to the index.
+set -eu -o pipefail
+
+git init
+echo content > untracked
+echo exe > untracked-exe && chmod +x untracked-exe
+ln -s untracked link
+mkdir dir
+mkfifo dir/fifo-should-be-ignored
+
+git add .
+