kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'en/no-amend-during-conflicts' into jch 

Teach 'am', 'revert', and 'rebase' that running 'commit --amend' or a
partial 'commit <paths>' makes no sense during operations that stop
and return control to the user to resolve conflicts left in the
working tree, just like 'cherry-pick' and 'merge' do.

* en/no-amend-during-conflicts:
  commit: refuse partial commits during conflict resolution
  commit: refuse to amend during conflict resolution
  commit: reword the empty-commit rebase amend error
  commit: allow a partial commit when a rebase pick becomes empty
  commit: clarify FROM_REBASE_PICK and is_from_rebase() names
jch
Junio C Hamano 2026-08-31 11:12:03 -07:00
parent edcfdf8463 c1eb66fde0
commit 834df6c69b
7 changed files with 299 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
builtin/commit.c
View File

@ -515,13 +515,25 @@ static const char *prepare_index(const char **argv, const char *prefix,
*/
commit_style = COMMIT_PARTIAL;

if (whence != FROM_COMMIT) {
if (whence == FROM_MERGE)
die(_("cannot do a partial commit during a merge."));
else if (is_from_cherry_pick(whence))
die(_("cannot do a partial commit during a cherry-pick."));
else if (is_from_rebase(whence))
die(_("cannot do a partial commit during a rebase."));
switch (sequencer_ongoing_operation(the_repository, whence)) {
case ONGOING_NONE:
break;
case ONGOING_MERGE:
die(_("cannot do a partial commit during a merge."));
case ONGOING_CHERRY_PICK:
die(_("cannot do a partial commit during a cherry-pick."));
case ONGOING_REBASE_EMPTY:
/*
* A pick that became empty is not a conflict, and creating
* a new commit (partial or not) poses no problem.
*/
break;
case ONGOING_REVERT:
die(_("cannot do a partial commit during a revert."));
case ONGOING_AM:
die(_("cannot do a partial commit during an am session."));
case ONGOING_REBASE_CONFLICT:
die(_("cannot do a partial commit while resolving conflicts during a rebase."));
}

if (list_paths(&partial, !current_head ? NULL : "HEAD", &pathspec))
@ -893,7 +905,7 @@ static int prepare_to_commit(const char *index_file, const char *prefix,
*/
else if (whence == FROM_MERGE)
hook_arg1 = "merge";
else if (is_from_cherry_pick(whence) || whence == FROM_REBASE_PICK) {
else if (is_from_cherry_pick(whence) || is_from_rebase_empty(whence)) {
hook_arg1 = "commit";
hook_arg2 = "CHERRY_PICK_HEAD";
}
@ -1086,7 +1098,7 @@ static int prepare_to_commit(const char *index_file, const char *prefix,
if (amend)
fputs(_(empty_amend_advice), stderr);
else if (is_from_cherry_pick(whence) ||
whence == FROM_REBASE_PICK) {
is_from_rebase_empty(whence)) {
fputs(_(empty_cherry_pick_advice), stderr);
if (whence == FROM_CHERRY_PICK_SINGLE)
fputs(_(empty_cherry_pick_advice_single), stderr);
@ -1326,15 +1338,30 @@ static int parse_and_validate_options(int argc, const char *argv[],
use_editor = 0;

/* Sanity check options */
if (amend && !current_head)
die(_("You have nothing to amend."));
if (amend && whence != FROM_COMMIT) {
if (whence == FROM_MERGE)
if (amend) {
if (!current_head)
die(_("You have nothing to amend."));
/*
* Refuse to amend in the middle of any operation that is
* meant to record its result as a new commit on top of HEAD
* rather than by rewriting HEAD.
*/
switch (sequencer_ongoing_operation(s->repo, whence)) {
case ONGOING_NONE:
break;
case ONGOING_MERGE:
die(_("You are in the middle of a merge -- cannot amend."));
else if (is_from_cherry_pick(whence))
case ONGOING_CHERRY_PICK:
die(_("You are in the middle of a cherry-pick -- cannot amend."));
else if (whence == FROM_REBASE_PICK)
die(_("You are in the middle of a rebase -- cannot amend."));
case ONGOING_REBASE_EMPTY:
die(_("The now-empty commit has been dropped -- cannot amend."));
case ONGOING_REVERT:
die(_("You are in the middle of a revert -- cannot amend."));
case ONGOING_AM:
die(_("You are in the middle of an am session -- cannot amend."));
case ONGOING_REBASE_CONFLICT:
die(_("You are resolving conflicts during a rebase -- cannot amend."));
}
}
if (fixup_message && squash_message)
die(_("options '%s' and '%s' cannot be used together"), "--squash", "--fixup");
@ -1353,7 +1380,7 @@ static int parse_and_validate_options(int argc, const char *argv[],
if (amend && !use_message && !fixup_message)
use_message = "HEAD";
if (!use_message && !is_from_cherry_pick(whence) &&
!is_from_rebase(whence) && renew_authorship)
!is_from_rebase_empty(whence) && renew_authorship)
die(_("--reset-author can be used only with -C, -c or --amend."));
if (use_message) {
use_message_buffer = read_commit_message(use_message);
@ -1362,7 +1389,7 @@ static int parse_and_validate_options(int argc, const char *argv[],
author_message_buffer = use_message_buffer;
}
}
if ((is_from_cherry_pick(whence) || whence == FROM_REBASE_PICK) &&
if ((is_from_cherry_pick(whence) || is_from_rebase_empty(whence)) &&
!renew_authorship) {
author_message = "CHERRY_PICK_HEAD";
author_message_buffer = read_commit_message(author_message);
@ -1887,7 +1914,7 @@ int cmd_commit(int argc,
if (!reflog_msg)
reflog_msg = is_from_cherry_pick(whence)
? "commit (cherry-pick)"
: is_from_rebase(whence)
: is_from_rebase_empty(whence)
? "commit (rebase)"
: "commit";
commit_list_insert(current_head, &parents);

59
sequencer.c
View File

@ -142,6 +142,13 @@ static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
* command is processed, this file is deleted.
*/
static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
/*
* The apply ("am") backend keeps its state in the rebase-apply directory;
* the "applying" file within it marks a plain `git am` (as opposed to an
* apply-based rebase).
*/
static GIT_PATH_FUNC(apply_dir, "rebase-apply")
static GIT_PATH_FUNC(apply_path_applying, "rebase-apply/applying")
/*
* When we stop at a given patch via the "edit" command, this file contains
* the commit object name of the corresponding patch.
@ -6957,7 +6964,7 @@ int sequencer_determine_whence(struct repository *r, enum commit_whence *whence)
!repo_get_oid(r, "REBASE_HEAD", &rebase_head) &&
!repo_get_oid(r, "CHERRY_PICK_HEAD", &cherry_pick_head) &&
oideq(&rebase_head, &cherry_pick_head))
*whence = FROM_REBASE_PICK;
*whence = FROM_REBASE_EMPTY;
else
*whence = FROM_CHERRY_PICK_SINGLE;

@ -6967,6 +6974,56 @@ int sequencer_determine_whence(struct repository *r, enum commit_whence *whence)
return 0;
}

enum ongoing_operation sequencer_ongoing_operation(struct repository *r,
enum commit_whence whence)
{
/*
* The merge, cherry-pick, and (empty) rebase-pick stops are already
* distinguished by 'whence'.
*/
switch (whence) {
case FROM_MERGE:
return ONGOING_MERGE;
case FROM_CHERRY_PICK_SINGLE:
case FROM_CHERRY_PICK_MULTI:
return ONGOING_CHERRY_PICK;
case FROM_REBASE_EMPTY:
return ONGOING_REBASE_EMPTY;
case FROM_COMMIT:
break;
}

/*
* 'whence' is FROM_COMMIT, but we may still be in the middle of an
* operation that records its result on top of HEAD; detect those
* from their on-disk state.
*/

/* In the middle of a revert? */
if (refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD"))
return ONGOING_REVERT;

/* In the middle of an `am`? */
if (file_exists(apply_path_applying()))
return ONGOING_AM;

/*
* In the middle of a rebase that stopped for conflict resolution?
* The apply backend only ever stops for conflicts, so the presence
* of its state directory is enough. The merge backend writes
* stopped-sha whenever it hands control back to the user, but omits
* `amend` unless it stopped with HEAD already pointing at the commit
* to be amended (a clean edit/reword stop); its absence therefore
* marks a conflicted stop.
*/
if (file_exists(apply_dir()) ||
(file_exists(rebase_path_stopped_sha()) &&
!file_exists(rebase_path_amend())))
return ONGOING_REBASE_CONFLICT;

return ONGOING_NONE;
}

int sequencer_get_update_refs_state(const char *wt_dir,
struct string_list *refs)
{

24
sequencer.h
View File

@ -277,6 +277,30 @@ int sequencer_get_last_command(struct repository* r,
enum replay_action *action);
int sequencer_determine_whence(struct repository *r, enum commit_whence *whence);

/*
* An in-progress operation that records its result (often a conflict
* resolution) as a new commit on top of HEAD. Some ways of invoking
* "git commit" -- amending HEAD, or a partial commit -- are almost
* always a mistake during such an operation.
*/
enum ongoing_operation {
ONGOING_NONE = 0,
ONGOING_MERGE,
ONGOING_CHERRY_PICK,
ONGOING_REBASE_EMPTY,
ONGOING_REVERT,
ONGOING_AM,
ONGOING_REBASE_CONFLICT
};

/*
* Return which in-progress operation, if any, is underway; see enum
* ongoing_operation. 'whence' is the origin already computed for the
* pending commit.
*/
enum ongoing_operation sequencer_ongoing_operation(struct repository *r,
enum commit_whence whence);

/**
* Append the set of ref-OID pairs that are currently stored for the 'git
* rebase --update-refs' feature if such a rebase is currently happening.

128
t/t3404-rebase-interactive.sh
View File

@ -1858,7 +1858,7 @@ test_expect_success 'post-commit hook is called' '
test_cmp expect actual
'

test_expect_success 'correct error message for partial commit after empty pick' '
test_expect_success 'partial commit is allowed when a rebase pick becomes empty' '
test_when_finished "git rebase --abort" &&
(
set_fake_editor &&
@ -1867,8 +1867,7 @@ test_expect_success 'correct error message for partial commit after empty pick'
test_must_fail git rebase -i A D
) &&
echo x >file1 &&
test_must_fail git commit file1 2>err &&
test_grep "cannot do a partial commit during a rebase." err
git commit file1
'

test_expect_success 'correct error message for commit --amend after empty pick' '
@ -1881,7 +1880,128 @@ test_expect_success 'correct error message for commit --amend after empty pick'
) &&
echo x>file1 &&
test_must_fail git commit -a --amend 2>err &&
test_grep "middle of a rebase -- cannot amend." err
test_grep "now-empty commit has been dropped -- cannot amend." err
'

test_expect_success 'commit --amend is refused at a rebase conflict stop' '
test_when_finished "git rebase --abort" &&
git checkout --detach conflict-branch &&
(
set_fake_editor &&
FAKE_LINES="1 3" &&
export FAKE_LINES &&
test_must_fail git rebase -i A
) &&
test_path_is_file .git/rebase-merge/patch &&
test_path_is_missing .git/rebase-merge/amend &&
echo resolved >conflict &&
git add conflict &&
test_must_fail git commit --amend --no-edit 2>err &&
test_grep "You are resolving conflicts during a rebase -- cannot amend" err
'

test_expect_success 'commit --amend is refused when an "edit" pick conflicts' '
test_when_finished "git rebase --abort" &&
git checkout --detach conflict-branch &&
(
set_fake_editor &&
FAKE_LINES="1 edit 3" &&
export FAKE_LINES &&
test_must_fail git rebase -i A
) &&
test_path_is_file .git/rebase-merge/patch &&
test_path_is_missing .git/rebase-merge/amend &&
echo resolved >conflict &&
git add conflict &&
test_must_fail git commit --amend --no-edit 2>err &&
test_grep "You are resolving conflicts during a rebase -- cannot amend" err
'

test_expect_success 'commit --amend is allowed at a rebase edit stop' '
test_when_finished "git rebase --abort" &&
git checkout --detach no-conflict-branch &&
(
set_fake_editor &&
FAKE_LINES="edit 1 2 3 4" &&
export FAKE_LINES &&
git rebase -i A
) &&
test_path_is_file .git/rebase-merge/amend &&
echo tweak >fileJ &&
git add fileJ &&
git commit --amend --no-edit
'

test_expect_success 'commit --amend is allowed at a rebase break stop' '
test_when_finished "git rebase --abort" &&
git checkout --detach no-conflict-branch &&
(
set_fake_editor &&
FAKE_LINES="break 1 2 3 4" &&
export FAKE_LINES &&
git rebase -i A
) &&
test_must_fail git rev-parse --verify REBASE_HEAD &&
echo tweak >fileJ &&
git add fileJ &&
git commit --amend --no-edit
'

test_expect_success 'commit --amend is refused at an apply-backend conflict stop' '
test_when_finished "rm -rf apply-backend" &&
test_create_repo apply-backend &&
(
cd apply-backend &&
test_commit base file &&
git branch -M mainline &&
test_commit upstream file upstream &&
git checkout -b side mainline~1 &&
test_commit conflicting file side &&
test_commit unrelated other &&
test_must_fail git rebase --apply mainline &&
# the apply backend only ever stops for conflicts, and
# leaves HEAD on the previously-applied commit
test_path_is_dir .git/rebase-apply &&
test_path_is_missing .git/rebase-apply/applying &&
echo resolved >file &&
git add file &&
test_must_fail git commit --amend --no-edit 2>err &&
test_grep "You are resolving conflicts during a rebase -- cannot amend" err
)
'

test_expect_success 'partial commit is refused at a rebase conflict stop' '
test_when_finished "git rebase --abort" &&
git checkout --detach conflict-branch &&
(
set_fake_editor &&
FAKE_LINES="1 3" &&
export FAKE_LINES &&
test_must_fail git rebase -i A
) &&
echo resolved >conflict &&
git add conflict &&
test_must_fail git commit conflict 2>err &&
test_grep "cannot do a partial commit while resolving conflicts during a rebase." err
'

test_expect_success 'partial commit is refused at an apply-backend conflict stop' '
test_when_finished "rm -rf apply-backend" &&
test_create_repo apply-backend &&
(
cd apply-backend &&
test_commit base file &&
git branch -M mainline &&
test_commit upstream file upstream &&
git checkout -b side mainline~1 &&
test_commit conflicting file side &&
test_commit unrelated other &&
test_must_fail git rebase --apply mainline &&
echo resolved >file &&
git add file &&
test_must_fail git commit file 2>err &&
test_grep "cannot do a partial commit while resolving conflicts during a rebase." err
)
'

test_expect_success 'todo has correct onto hash' '

22
t/t3507-cherry-pick-conflict.sh
View File

@ -364,6 +364,28 @@ test_expect_success 'failed revert sets REVERT_HEAD' '
test_cmp_rev picked REVERT_HEAD
'

test_expect_success 'commit --amend of revert fails' '
pristine_detach initial &&

test_must_fail git revert picked &&
echo resolved >foo &&
git add foo &&
test_must_fail git commit --amend 2>err &&

test_grep "in the middle of a revert -- cannot amend." err
'

test_expect_success 'partial commit during a revert fails' '
pristine_detach initial &&

test_must_fail git revert picked &&
echo resolved >foo &&
git add foo &&
test_must_fail git commit foo 2>err &&

test_grep "cannot do a partial commit during a revert." err
'

test_expect_success 'successful revert does not set REVERT_HEAD' '
pristine_detach base &&
git revert base &&

22
t/t4151-am-abort.sh
View File

@ -63,6 +63,28 @@ do

done

test_expect_success 'commit --amend during a failed am fails' '
git reset --hard initial &&
cp file-2-expect file-2 &&
test_must_fail git am 000[1245]-*.patch &&
echo resolved >file-1 &&
git add file-1 &&
test_must_fail git commit --amend 2>err &&
test_grep "in the middle of an am session -- cannot amend." err &&
git am --abort
'

test_expect_success 'partial commit during a failed am fails' '
git reset --hard initial &&
cp file-2-expect file-2 &&
test_must_fail git am 000[1245]-*.patch &&
echo resolved >file-1 &&
git add file-1 &&
test_must_fail git commit file-1 2>err &&
test_grep "cannot do a partial commit during an am session." err &&
git am --abort
'

test_expect_success 'am -3 --skip removes otherfile-4' '
git reset --hard initial &&
test_must_fail git am -3 0003-*.patch &&

6
wt-status.h
View File

@ -41,7 +41,7 @@ enum commit_whence {
FROM_MERGE, /* commit came from merge */
FROM_CHERRY_PICK_SINGLE, /* commit came from cherry-pick */
FROM_CHERRY_PICK_MULTI, /* commit came from a sequence of cherry-picks */
FROM_REBASE_PICK /* commit came from a pick/reword/edit */
FROM_REBASE_EMPTY /* rebase applied a pick that became empty */
};

static inline int is_from_cherry_pick(enum commit_whence whence)
@ -50,9 +50,9 @@ static inline int is_from_cherry_pick(enum commit_whence whence)
whence == FROM_CHERRY_PICK_MULTI;
}

static inline int is_from_rebase(enum commit_whence whence)
static inline int is_from_rebase_empty(enum commit_whence whence)
{
return whence == FROM_REBASE_PICK;
return whence == FROM_REBASE_EMPTY;
}

struct wt_status_change_data {