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

Author: Byron

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

@@ -5,7 +5,7 @@ pub use tree_changes::tree_changes;
 
 mod worktree;
 use crate::{ChangeState, ModeFlags, TreeChange, TreeStatus, TreeStatusKind};
-pub use worktree::worktree_changes;
+pub use worktree::{worktree_changes, worktree_changes_no_renames};
 
 /// conversion functions for use in the UI
 pub mod ui;

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 }

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,

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 .
+

crates/but-workspace/tests/workspace/snapshot/index_create_and_resolve.rs

@@ -0,0 +1,67 @@
+use crate::snapshot::args_for_worktree_changes;
+use crate::utils::{read_only_in_memory_scenario, visualize_index};
+use but_testsupport::visualize_tree;
+use but_workspace::snapshot;
+use gix::prelude::ObjectIdExt;
+
+#[test]
+fn unborn_added_to_index() -> anyhow::Result<()> {
+    let repo = read_only_in_memory_scenario("unborn-all-file-types-added-to-index")?;
+    let (head_tree_id, state, no_workspace_and_meta) = args_for_worktree_changes(&repo)?;
+
+    let out = snapshot::create_tree(head_tree_id, state, no_workspace_and_meta)?;
+    insta::assert_snapshot!(visualize_tree(out.snapshot_tree.attach(&repo)), @r#""#);
+    insta::assert_debug_snapshot!(out, @r"");
+
+    let res_out = snapshot::resolve_tree(
+        out.snapshot_tree.attach(&repo),
+        out.head_tree,
+        snapshot::resolve_tree::Options::default(),
+    )?;
+    let mut cherry_pick = res_out
+        .worktree_cherry_pick
+        .expect("a worktree change was applied");
+    assert_eq!(cherry_pick.tree.write()?, out.worktree.unwrap());
+    let index = res_out
+        .index
+        .expect("the index was altered with many added files");
+    insta::assert_snapshot!(visualize_index(&index), @r"");
+
+    assert!(res_out.metadata.is_none());
+    assert!(
+        res_out.workspace_references.is_none(),
+        "didn't ask to store this"
+    );
+    Ok(())
+}
+
+#[test]
+fn with_conflicts() -> anyhow::Result<()> {
+    let repo = read_only_in_memory_scenario("merge-with-two-branches-conflict")?;
+    let (head_tree_id, state, no_workspace_and_meta) = args_for_worktree_changes(&repo)?;
+
+    let out = snapshot::create_tree(head_tree_id, state, no_workspace_and_meta)?;
+    insta::assert_snapshot!(visualize_tree(out.snapshot_tree.attach(&repo)), @r#""#);
+    insta::assert_debug_snapshot!(out, @r"");
+
+    let res_out = snapshot::resolve_tree(
+        out.snapshot_tree.attach(&repo),
+        out.head_tree,
+        snapshot::resolve_tree::Options::default(),
+    )?;
+    let mut cherry_pick = res_out
+        .worktree_cherry_pick
+        .expect("a worktree change was applied");
+    assert_eq!(cherry_pick.tree.write()?, out.worktree.unwrap());
+    let index = res_out
+        .index
+        .expect("the index was altered with many added files");
+    insta::assert_snapshot!(visualize_index(&index), @r"");
+
+    assert!(res_out.metadata.is_none());
+    assert!(
+        res_out.workspace_references.is_none(),
+        "didn't ask to store this"
+    );
+    Ok(())
+}

crates/but-workspace/tests/workspace/snapshot/mod.rs

@@ -1 +1,36 @@
+mod index_create_and_resolve;
 mod worktree_create_and_resolve;
+
+mod utils {
+    use but_graph::VirtualBranchesTomlMetadata;
+    use but_workspace::snapshot;
+
+    /// Produce all args needed for creating a snapshot tree, and assure everything is selected.
+    #[expect(clippy::type_complexity)]
+    pub fn args_for_worktree_changes(
+        repo: &gix::Repository,
+    ) -> anyhow::Result<(
+        gix::Id<'_>,
+        snapshot::create_tree::State,
+        Option<(
+            &'static but_graph::projection::Workspace<'static>,
+            &'static VirtualBranchesTomlMetadata,
+        )>,
+    )> {
+        let changes = but_core::diff::worktree_changes_no_renames(repo)?;
+        let state = snapshot::create_tree::State {
+            selection: changes
+                .changes
+                .iter()
+                .map(|c| c.path.clone())
+                .chain(changes.ignored_changes.iter().map(|c| c.path.clone()))
+                .collect(),
+            changes,
+            head: false,
+        };
+        let head_tree_id = repo.head_tree_id_or_empty()?;
+
+        Ok((head_tree_id, state, None))
+    }
+}
+pub use utils::args_for_worktree_changes;

crates/but-workspace/tests/workspace/snapshot/worktree_create_and_resolve.rs

@@ -1,5 +1,5 @@
+use crate::snapshot::args_for_worktree_changes;
 use crate::utils::read_only_in_memory_scenario;
-use but_graph::VirtualBranchesTomlMetadata;
 use but_testsupport::visualize_tree;
 use but_workspace::snapshot;
 use gix::prelude::ObjectIdExt;
@@ -155,30 +155,3 @@ fn worktree_all_filetypes() -> anyhow::Result<()> {
     Ok(())
 }
 
-/// Produce all args needed for creating a snapshot tree, and assure everything is selected.
-#[expect(clippy::type_complexity)]
-fn args_for_worktree_changes(
-    repo: &gix::Repository,
-) -> anyhow::Result<(
-    gix::Id<'_>,
-    snapshot::create_tree::State,
-    Option<(
-        &'static but_graph::projection::Workspace<'static>,
-        &'static VirtualBranchesTomlMetadata,
-    )>,
-)> {
-    let changes = but_core::diff::worktree_changes(repo)?;
-    let state = snapshot::create_tree::State {
-        selection: changes
-            .changes
-            .iter()
-            .map(|c| c.path.clone())
-            .chain(changes.ignored_changes.iter().map(|c| c.path.clone()))
-            .collect(),
-        changes,
-        head: false,
-    };
-    let head_tree_id = repo.head_tree_id_or_empty()?;
-
-    Ok((head_tree_id, state, None))
-}