Detect and reject individual no-effect changes after cherry-pick

When committing a mix of changes to a branch, some changes may have no
effect on the target tree — for example, deleting a file that only exists
in another stack's workspace tree but not in this branch. Previously,
these no-op changes were silently dropped: the commit succeeded without
the change, and the caller received no rejection feedback.

The root cause was that the post-cherry-pick check only compared the
entire result tree against the target tree. If at least one change was
effective, the aggregate trees would differ and all changes appeared to
succeed — even those that individually had no effect.

Now, after the cherry-pick, each change is checked individually by
comparing its path entry between the target tree and the result tree.
Changes where the entry is identical (or both absent) are rejected as
NoEffectiveChanges, giving the caller per-change feedback.

A regression test with a two-stack fixture verifies that committing a
file deletion from another stack alongside a valid modification correctly
rejects the deletion while still producing a commit for the modification.

Author: mtsgrd

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

@@ -153,6 +153,35 @@ pub fn create_tree(
                 }
                 tree_with_changes = merge_result.tree.write()?.detach();
             }
+            // After the cherry-pick, some changes may have had no effect on the target tree
+            // (e.g. deleting a file that only exists in another stack's tree, not in this
+            // branch). Check each change individually by comparing its path entry between
+            // the target tree and the result tree — if they match, the change was a no-op.
+            if needs_cherry_pick {
+                let target = target_tree.attach(repo).object()?.peel_to_tree()?;
+                let result = tree_with_changes.attach(repo).object()?.peel_to_tree()?;
+                for possible_change in changes.iter_mut() {
+                    let spec = match possible_change {
+                        Ok(spec) => spec,
+                        Err(_) => continue,
+                    };
+                    let target_entry = target.lookup_entry(spec.path.as_bstr().split_str("/"))?;
+                    let result_entry = result.lookup_entry(spec.path.as_bstr().split_str("/"))?;
+                    if target_entry.map(|e| e.object_id()) == result_entry.map(|e| e.object_id()) {
+                        into_err_spec(possible_change, RejectionReason::NoEffectiveChanges);
+                    }
+                }
+            }
+            // If every change was individually rejected, there is nothing to commit —
+            // unless some were cherry-pick conflicts, in which case we still create a
+            // commit so the user can see and resolve the conflicts.
+            if changes.iter().all(|c| c.is_err())
+                && !changes
+                    .iter()
+                    .any(|c| matches!(c, Err((RejectionReason::CherryPickMergeConflict, _))))
+            {
+                break 'retry (None, None);
+            }
             break 'retry (
                 Some(tree_with_changes),
                 Some(tree_with_changes_without_cherry_pick),

crates/but-workspace/tests/fixtures/scenario/two-stacks-with-extra-file.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+set -eu -o pipefail
+
+source "${BASH_SOURCE[0]%/*}/shared.sh"
+
+### General Description
+
+# A workspace commit with two stacks.
+# Stack A modifies `file` (prepends lines).
+# Stack B creates `new-file`.
+git init
+
+seq 50 60 >file && git add . && git commit -m "base" && git tag base
+setup_target_to_match_main
+
+git branch B
+
+git checkout -b A
+{ seq 10; seq 50 60; } >file && git add . && git commit -m "A: 10 lines on top of file"
+
+git checkout B
+seq 10 >new-file && git add . && git commit -m "B: new file with 10 lines"
+
+create_workspace_commit_once A B

crates/but-workspace/tests/workspace/commit_engine/new_commit.rs

@@ -1236,6 +1236,52 @@ fn validate_no_change_on_noop() -> anyhow::Result<()> {
     Ok(())
 }
 
+/// When committing a deletion of a file that only exists in another stack's tree
+/// alongside a valid change, the deletion should be rejected as `NoEffectiveChanges`
+/// while the valid change still produces a commit.
+#[test]
+fn deletion_of_file_from_other_stack_is_rejected_per_change() -> anyhow::Result<()> {
+    let (repo, _tmp) = writable_scenario("two-stacks-with-extra-file");
+
+    // Delete `new-file` which only exists in stack B's tree, not in A.
+    let new_file_path = repo.workdir_path("new-file").expect("non-bare");
+    std::fs::remove_file(&new_file_path)?;
+
+    // Also modify `file` which does exist in stack A's tree.
+    write_sequence(&repo, "file", [(1, 5), (50, 60)])?;
+
+    let parent_commit = repo.rev_parse_single("A")?;
+    let outcome = commit_engine::create_commit(
+        &repo,
+        Destination::NewCommit {
+            parent_commit_id: Some(parent_commit.into()),
+            message: "modify file and delete new-file on stack A".into(),
+            stack_segment: None,
+        },
+        vec![diff_spec(None, "file", []), diff_spec(None, "new-file", [])],
+        CONTEXT_LINES,
+    )?;
+
+    assert!(
+        outcome.new_commit.is_some(),
+        "a commit is created because the file modification is valid"
+    );
+    insta::assert_debug_snapshot!(outcome.rejected_specs, @r#"
+    [
+        (
+            NoEffectiveChanges,
+            DiffSpec {
+                previous_path: None,
+                path: "new-file",
+                hunk_headers: [],
+            },
+        ),
+    ]
+    "#);
+
+    Ok(())
+}
+
 const UI_CONTEXT_LINES: u32 = 3;
 
 mod utils {