From: Junio C Hamano <gitster@pobox.com>
Date: Fri, 1 Jun 2018 06:06:40 +0000 (+0900)
Subject: Merge branch 'js/rebase-recreate-merge'
X-Git-Tag: v2.18.0-rc1~11
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/95dd4b2b14db912b482320c0a69518e77e7af19a?ds=inline;hp=-c

Merge branch 'js/rebase-recreate-merge'

Hotfixes.

* js/rebase-recreate-merge:
sequencer: ensure labels that are object IDs are rewritten
git-rebase--interactive: fix copy-paste mistake
---

95dd4b2b14db912b482320c0a69518e77e7af19a
diff --combined git-rebase--interactive.sh
index 0c92ac00fa,85a72b933e..06a7b79307
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@@ -81,8 -81,6 +81,8 @@@ rewritten_pending="$state_dir"/rewritte
  # and leaves CR at the end instead.
  cr=$(printf "\015")
  
 +empty_tree=$(git hash-object -t tree /dev/null)
 +
  strategy_args=${strategy:+--strategy=$strategy}
  test -n "$strategy_opts" &&
  eval '
@@@ -162,7 -160,7 +162,7 @@@ r, reword <commit> = use commit, but ed
  e, edit <commit> = use commit, but stop for amending
  s, squash <commit> = use commit, but meld into previous commit
  f, fixup <commit> = like \"squash\", but discard this commit's log message
- x, exec <commit> = run command (the rest of the line) using shell
+ x, exec <command> = run command (the rest of the line) using shell
  d, drop <commit> = remove commit
  l, label <label> = label current HEAD with a name
  t, reset <label> = reset HEAD to a label
@@@ -246,7 -244,7 +246,7 @@@ is_empty_commit() 
  		die "$(eval_gettext "\$sha1: not a commit that can be picked")"
  	}
  	ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null) ||
 -		ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904
 +		ptree=$empty_tree
  	test "$tree" = "$ptree"
  }
  
@@@ -896,8 -894,6 +896,8 @@@ init_revisions_and_shortrevisions () 
  	else
  		revisions=$onto...$orig_head
  		shortrevisions=$shorthead
 +		test -z "$squash_onto" ||
 +		echo "$squash_onto" >"$state_dir"/squash-onto
  	fi
  }
  
@@@ -952,7 -948,7 +952,7 @@@ EO
  	die "Could not skip unnecessary pick commands"
  
  	checkout_onto
 -	if test -z "$rebase_root" && test ! -d "$rewritten"
 +	if test ! -d "$rewritten"
  	then
  		require_clean_work_tree "rebase"
  		exec git rebase--helper ${force_rebase:+--no-ff} $allow_empty_message \
diff --combined sequencer.c
index 560fc9b67d,017adbe8e1..cca968043e
--- a/sequencer.c
+++ b/sequencer.c
@@@ -27,7 -27,6 +27,7 @@@
  #include "worktree.h"
  #include "oidmap.h"
  #include "oidset.h"
 +#include "alias.h"
  
  #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
  
@@@ -79,6 -78,13 +79,6 @@@ static GIT_PATH_FUNC(rebase_path_messag
   * previous commit and from the first squash/fixup commit are written
   * to it. The commit message for each subsequent squash/fixup commit
   * is appended to the file as it is processed.
 - *
 - * The first line of the file is of the form
 - *     # This is a combination of $count commits.
 - * where $count is the number of commits whose messages have been
 - * written to the file so far (including the initial "pick" commit).
 - * Each time that a commit message is processed, this line is read and
 - * updated. It is deleted just before the combined commit is made.
   */
  static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
  /*
@@@ -89,11 -95,6 +89,11 @@@
   * commit without opening the editor.)
   */
  static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
 +/*
 + * This file contains the list fixup/squash commands that have been
 + * accumulated into message-fixup or message-squash so far.
 + */
 +static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
  /*
   * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
   * GIT_AUTHOR_DATE that will be used for the commit that is currently
@@@ -124,12 -125,6 +124,12 @@@ static GIT_PATH_FUNC(rebase_path_rewrit
  static GIT_PATH_FUNC(rebase_path_rewritten_pending,
  	"rebase-merge/rewritten-pending")
  
 +/*
 + * The path of the file containig the OID of the "squash onto" commit, i.e.
 + * the dummy commit used for `reset [new root]`.
 + */
 +static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
 +
  /*
   * The path of the file listing refs that need to be deleted after the rebase
   * finishes. This is used by the `label` command to record the need for cleanup.
@@@ -284,7 -279,6 +284,7 @@@ int sequencer_remove_state(struct repla
  	for (i = 0; i < opts->xopts_nr; i++)
  		free(opts->xopts[i]);
  	free(opts->xopts);
 +	strbuf_release(&opts->current_fixups);
  
  	strbuf_reset(&buf);
  	strbuf_addstr(&buf, get_dir(opts));
@@@ -476,8 -470,7 +476,8 @@@ static int fast_forward_to(const struc
  	transaction = ref_transaction_begin(&err);
  	if (!transaction ||
  	    ref_transaction_update(transaction, "HEAD",
 -				   to, unborn ? &null_oid : from,
 +				   to, unborn && !is_rebase_i(opts) ?
 +				   &null_oid : from,
  				   0, sb.buf, &err) ||
  	    ref_transaction_commit(transaction, &err)) {
  		ref_transaction_free(transaction);
@@@ -536,8 -529,8 +536,8 @@@ static int do_recursive_merge(struct co
  	o.show_rename_progress = 1;
  
  	head_tree = parse_tree_indirect(head);
 -	next_tree = next ? next->tree : empty_tree();
 -	base_tree = base ? base->tree : empty_tree();
 +	next_tree = next ? get_commit_tree(next) : empty_tree();
 +	base_tree = base ? get_commit_tree(base) : empty_tree();
  
  	for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
  		parse_merge_opt(&o, *xopt);
@@@ -569,23 -562,9 +569,23 @@@
  	return !clean;
  }
  
 +static struct object_id *get_cache_tree_oid(void)
 +{
 +	if (!active_cache_tree)
 +		active_cache_tree = cache_tree();
 +
 +	if (!cache_tree_fully_valid(active_cache_tree))
 +		if (cache_tree_update(&the_index, 0)) {
 +			error(_("unable to update cache tree"));
 +			return NULL;
 +		}
 +
 +	return &active_cache_tree->oid;
 +}
 +
  static int is_index_unchanged(void)
  {
 -	struct object_id head_oid;
 +	struct object_id head_oid, *cache_tree_oid;
  	struct commit *head_commit;
  
  	if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
@@@ -604,10 -583,15 +604,10 @@@
  	if (parse_commit(head_commit))
  		return -1;
  
 -	if (!active_cache_tree)
 -		active_cache_tree = cache_tree();
 -
 -	if (!cache_tree_fully_valid(active_cache_tree))
 -		if (cache_tree_update(&the_index, 0))
 -			return error(_("unable to update cache tree"));
 +	if (!(cache_tree_oid = get_cache_tree_oid()))
 +		return -1;
  
 -	return !oidcmp(&active_cache_tree->oid,
 -		       &head_commit->tree->object.oid);
 +	return !oidcmp(cache_tree_oid, get_commit_tree_oid(head_commit));
  }
  
  static int write_author_script(const char *message)
@@@ -699,52 -683,6 +699,52 @@@ static char *get_author(const char *mes
  	return NULL;
  }
  
 +/* Read author-script and return an ident line (author <email> timestamp) */
 +static const char *read_author_ident(struct strbuf *buf)
 +{
 +	const char *keys[] = {
 +		"GIT_AUTHOR_NAME=", "GIT_AUTHOR_EMAIL=", "GIT_AUTHOR_DATE="
 +	};
 +	char *in, *out, *eol;
 +	int i = 0, len;
 +
 +	if (strbuf_read_file(buf, rebase_path_author_script(), 256) <= 0)
 +		return NULL;
 +
 +	/* dequote values and construct ident line in-place */
 +	for (in = out = buf->buf; i < 3 && in - buf->buf < buf->len; i++) {
 +		if (!skip_prefix(in, keys[i], (const char **)&in)) {
 +			warning("could not parse '%s' (looking for '%s'",
 +				rebase_path_author_script(), keys[i]);
 +			return NULL;
 +		}
 +
 +		eol = strchrnul(in, '\n');
 +		*eol = '\0';
 +		sq_dequote(in);
 +		len = strlen(in);
 +
 +		if (i > 0) /* separate values by spaces */
 +			*(out++) = ' ';
 +		if (i == 1) /* email needs to be surrounded by <...> */
 +			*(out++) = '<';
 +		memmove(out, in, len);
 +		out += len;
 +		if (i == 1) /* email needs to be surrounded by <...> */
 +			*(out++) = '>';
 +		in = eol + 1;
 +	}
 +
 +	if (i < 3) {
 +		warning("could not parse '%s' (looking for '%s')",
 +			rebase_path_author_script(), keys[i]);
 +		return NULL;
 +	}
 +
 +	buf->len = out - buf->buf;
 +	return buf->buf;
 +}
 +
  static const char staged_changes_advice[] =
  N_("you have staged changes in your working tree\n"
  "If these changes are meant to be squashed into the previous commit, run:\n"
@@@ -764,7 -702,6 +764,7 @@@
  #define AMEND_MSG   (1<<2)
  #define CLEANUP_MSG (1<<3)
  #define VERIFY_MSG  (1<<4)
 +#define CREATE_ROOT_COMMIT (1<<5)
  
  /*
   * If we are cherry-pick, and if the merge did not result in
@@@ -784,40 -721,6 +784,40 @@@ static int run_git_commit(const char *d
  	struct child_process cmd = CHILD_PROCESS_INIT;
  	const char *value;
  
 +	if (flags & CREATE_ROOT_COMMIT) {
 +		struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
 +		const char *author = is_rebase_i(opts) ?
 +			read_author_ident(&script) : NULL;
 +		struct object_id root_commit, *cache_tree_oid;
 +		int res = 0;
 +
 +		if (!defmsg)
 +			BUG("root commit without message");
 +
 +		if (!(cache_tree_oid = get_cache_tree_oid()))
 +			res = -1;
 +
 +		if (!res)
 +			res = strbuf_read_file(&msg, defmsg, 0);
 +
 +		if (res <= 0)
 +			res = error_errno(_("could not read '%s'"), defmsg);
 +		else
 +			res = commit_tree(msg.buf, msg.len, cache_tree_oid,
 +					  NULL, &root_commit, author,
 +					  opts->gpg_sign);
 +
 +		strbuf_release(&msg);
 +		strbuf_release(&script);
 +		if (!res) {
 +			update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
 +				   REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
 +			res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
 +					 UPDATE_REFS_MSG_ON_ERR);
 +		}
 +		return res < 0 ? error(_("writing root commit")) : 0;
 +	}
 +
  	cmd.git_cmd = 1;
  
  	if (is_rebase_i(opts)) {
@@@ -844,8 -747,6 +844,8 @@@
  		argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
  	if (defmsg)
  		argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
 +	else if (!(flags & EDIT_MSG))
 +		argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
  	if ((flags & CLEANUP_MSG))
  		argv_array_push(&cmd.args, "--cleanup=strip");
  	if ((flags & EDIT_MSG))
@@@ -1247,8 -1148,8 +1247,8 @@@ static int try_to_commit(struct strbuf 
  	}
  
  	if (!(flags & ALLOW_EMPTY) && !oidcmp(current_head ?
 -					      &current_head->tree->object.oid :
 -					      &empty_tree_oid, &tree)) {
 +					      get_commit_tree_oid(current_head) :
 +					      the_hash_algo->empty_tree, &tree)) {
  		res = 1; /* run 'git commit' to display error message */
  		goto out;
  	}
@@@ -1277,8 -1178,6 +1277,8 @@@
  		goto out;
  	}
  
 +	reset_ident_date();
 +
  	if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
  				 oid, author, opts->gpg_sign, extra)) {
  		res = error(_("failed to write commit object"));
@@@ -1308,8 -1207,7 +1308,8 @@@ static int do_commit(const char *msg_fi
  {
  	int res = 1;
  
 -	if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
 +	if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
 +	    !(flags & CREATE_ROOT_COMMIT)) {
  		struct object_id oid;
  		struct strbuf sb = STRBUF_INIT;
  
@@@ -1348,12 -1246,12 +1348,12 @@@ static int is_original_commit_empty(str
  		if (parse_commit(parent))
  			return error(_("could not parse parent commit %s"),
  				oid_to_hex(&parent->object.oid));
 -		ptree_oid = &parent->tree->object.oid;
 +		ptree_oid = get_commit_tree_oid(parent);
  	} else {
  		ptree_oid = the_hash_algo->empty_tree; /* commit is root */
  	}
  
 -	return !oidcmp(ptree_oid, &commit->tree->object.oid);
 +	return !oidcmp(ptree_oid, get_commit_tree_oid(commit));
  }
  
  /*
@@@ -1462,43 -1360,38 +1462,43 @@@ static int is_fixup(enum todo_command c
  	return command == TODO_FIXUP || command == TODO_SQUASH;
  }
  
 +/* Does this command create a (non-merge) commit? */
 +static int is_pick_or_similar(enum todo_command command)
 +{
 +	switch (command) {
 +	case TODO_PICK:
 +	case TODO_REVERT:
 +	case TODO_EDIT:
 +	case TODO_REWORD:
 +	case TODO_FIXUP:
 +	case TODO_SQUASH:
 +		return 1;
 +	default:
 +		return 0;
 +	}
 +}
 +
  static int update_squash_messages(enum todo_command command,
  		struct commit *commit, struct replay_opts *opts)
  {
  	struct strbuf buf = STRBUF_INIT;
 -	int count, res;
 +	int res;
  	const char *message, *body;
  
 -	if (file_exists(rebase_path_squash_msg())) {
 +	if (opts->current_fixup_count > 0) {
  		struct strbuf header = STRBUF_INIT;
 -		char *eol, *p;
 +		char *eol;
  
 -		if (strbuf_read_file(&buf, rebase_path_squash_msg(), 2048) <= 0)
 +		if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
  			return error(_("could not read '%s'"),
  				rebase_path_squash_msg());
  
 -		p = buf.buf + 1;
 -		eol = strchrnul(buf.buf, '\n');
 -		if (buf.buf[0] != comment_line_char ||
 -		    (p += strcspn(p, "0123456789\n")) == eol)
 -			return error(_("unexpected 1st line of squash message:"
 -				       "\n\n\t%.*s"),
 -				     (int)(eol - buf.buf), buf.buf);
 -		count = strtol(p, NULL, 10);
 -
 -		if (count < 1)
 -			return error(_("invalid 1st line of squash message:\n"
 -				       "\n\t%.*s"),
 -				     (int)(eol - buf.buf), buf.buf);
 +		eol = buf.buf[0] != comment_line_char ?
 +			buf.buf : strchrnul(buf.buf, '\n');
  
  		strbuf_addf(&header, "%c ", comment_line_char);
 -		strbuf_addf(&header,
 -			    _("This is a combination of %d commits."), ++count);
 +		strbuf_addf(&header, _("This is a combination of %d commits."),
 +			    opts->current_fixup_count + 2);
  		strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
  		strbuf_release(&header);
  	} else {
@@@ -1521,8 -1414,10 +1521,8 @@@
  				     rebase_path_fixup_msg());
  		}
  
 -		count = 2;
  		strbuf_addf(&buf, "%c ", comment_line_char);
 -		strbuf_addf(&buf, _("This is a combination of %d commits."),
 -			    count);
 +		strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
  		strbuf_addf(&buf, "\n%c ", comment_line_char);
  		strbuf_addstr(&buf, _("This is the 1st commit message:"));
  		strbuf_addstr(&buf, "\n\n");
@@@ -1539,14 -1434,13 +1539,14 @@@
  	if (command == TODO_SQUASH) {
  		unlink(rebase_path_fixup_msg());
  		strbuf_addf(&buf, "\n%c ", comment_line_char);
 -		strbuf_addf(&buf, _("This is the commit message #%d:"), count);
 +		strbuf_addf(&buf, _("This is the commit message #%d:"),
 +			    ++opts->current_fixup_count);
  		strbuf_addstr(&buf, "\n\n");
  		strbuf_addstr(&buf, body);
  	} else if (command == TODO_FIXUP) {
  		strbuf_addf(&buf, "\n%c ", comment_line_char);
  		strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
 -			    count);
 +			    ++opts->current_fixup_count);
  		strbuf_addstr(&buf, "\n\n");
  		strbuf_add_commented_lines(&buf, body, strlen(body));
  	} else
@@@ -1555,17 -1449,6 +1555,17 @@@
  
  	res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
  	strbuf_release(&buf);
 +
 +	if (!res) {
 +		strbuf_addf(&opts->current_fixups, "%s%s %s",
 +			    opts->current_fixups.len ? "\n" : "",
 +			    command_to_string(command),
 +			    oid_to_hex(&commit->object.oid));
 +		res = write_message(opts->current_fixups.buf,
 +				    opts->current_fixups.len,
 +				    rebase_path_current_fixups(), 0);
 +	}
 +
  	return res;
  }
  
@@@ -1631,16 -1514,9 +1631,16 @@@ static int do_pick_commit(enum todo_com
  			return error(_("your index file is unmerged."));
  	} else {
  		unborn = get_oid("HEAD", &head);
 -		if (unborn)
 +		/* Do we want to generate a root commit? */
 +		if (is_pick_or_similar(command) && opts->have_squash_onto &&
 +		    !oidcmp(&head, &opts->squash_onto)) {
 +			if (is_fixup(command))
 +				return error(_("cannot fixup root commit"));
 +			flags |= CREATE_ROOT_COMMIT;
 +			unborn = 1;
 +		} else if (unborn)
  			oidcpy(&head, the_hash_algo->empty_tree);
 -		if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD",
 +		if (index_differs_from(unborn ? empty_tree_oid_hex() : "HEAD",
  				       NULL, 0))
  			return error_dirty_index(opts);
  	}
@@@ -1835,9 -1711,6 +1835,9 @@@ fast_forward_edit
  	if (!res && final_fixup) {
  		unlink(rebase_path_fixup_msg());
  		unlink(rebase_path_squash_msg());
 +		unlink(rebase_path_current_fixups());
 +		strbuf_reset(&opts->current_fixups);
 +		opts->current_fixup_count = 0;
  	}
  
  leave:
@@@ -2254,22 -2127,6 +2254,22 @@@ static int read_populate_opts(struct re
  		read_strategy_opts(opts, &buf);
  		strbuf_release(&buf);
  
 +		if (read_oneliner(&opts->current_fixups,
 +				  rebase_path_current_fixups(), 1)) {
 +			const char *p = opts->current_fixups.buf;
 +			opts->current_fixup_count = 1;
 +			while ((p = strchr(p, '\n'))) {
 +				opts->current_fixup_count++;
 +				p++;
 +			}
 +		}
 +
 +		if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
 +			if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
 +				return error(_("unusable squash-onto"));
 +			opts->have_squash_onto = 1;
 +		}
 +
  		return 0;
  	}
  
@@@ -2614,9 -2471,10 +2614,9 @@@ static int error_with_patch(struct comm
  static int error_failed_squash(struct commit *commit,
  	struct replay_opts *opts, int subject_len, const char *subject)
  {
 -	if (rename(rebase_path_squash_msg(), rebase_path_message()))
 -		return error(_("could not rename '%s' to '%s'"),
 +	if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
 +		return error(_("could not copy '%s' to '%s'"),
  			rebase_path_squash_msg(), rebase_path_message());
 -	unlink(rebase_path_fixup_msg());
  	unlink(git_path_merge_msg());
  	if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
  		return error(_("could not copy '%s' to '%s'"),
@@@ -2708,7 -2566,7 +2708,7 @@@ static int safe_append(const char *file
  
  static int do_label(const char *name, int len)
  {
 -	struct ref_store *refs = get_main_ref_store();
 +	struct ref_store *refs = get_main_ref_store(the_repository);
  	struct ref_transaction *transaction;
  	struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
  	struct strbuf msg = STRBUF_INIT;
@@@ -2762,34 -2620,18 +2762,34 @@@ static int do_reset(const char *name, i
  	if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0)
  		return -1;
  
 -	/* Determine the length of the label */
 -	for (i = 0; i < len; i++)
 -		if (isspace(name[i]))
 -			len = i;
 -
 -	strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
 -	if (get_oid(ref_name.buf, &oid) &&
 -	    get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
 -		error(_("could not read '%s'"), ref_name.buf);
 -		rollback_lock_file(&lock);
 -		strbuf_release(&ref_name);
 -		return -1;
 +	if (len == 10 && !strncmp("[new root]", name, len)) {
 +		if (!opts->have_squash_onto) {
 +			const char *hex;
 +			if (commit_tree("", 0, the_hash_algo->empty_tree,
 +					NULL, &opts->squash_onto,
 +					NULL, NULL))
 +				return error(_("writing fake root commit"));
 +			opts->have_squash_onto = 1;
 +			hex = oid_to_hex(&opts->squash_onto);
 +			if (write_message(hex, strlen(hex),
 +					  rebase_path_squash_onto(), 0))
 +				return error(_("writing squash-onto"));
 +		}
 +		oidcpy(&oid, &opts->squash_onto);
 +	} else {
 +		/* Determine the length of the label */
 +		for (i = 0; i < len; i++)
 +			if (isspace(name[i]))
 +				len = i;
 +
 +		strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
 +		if (get_oid(ref_name.buf, &oid) &&
 +		    get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
 +			error(_("could not read '%s'"), ref_name.buf);
 +			rollback_lock_file(&lock);
 +			strbuf_release(&ref_name);
 +			return -1;
 +		}
  	}
  
  	memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
@@@ -2885,18 -2727,6 +2885,18 @@@ static int do_merge(struct commit *comm
  		goto leave_merge;
  	}
  
 +	if (opts->have_squash_onto &&
 +	    !oidcmp(&head_commit->object.oid, &opts->squash_onto)) {
 +		/*
 +		 * When the user tells us to "merge" something into a
 +		 * "[new root]", let's simply fast-forward to the merge head.
 +		 */
 +		rollback_lock_file(&lock);
 +		ret = fast_forward_to(&merge_commit->object.oid,
 +				       &head_commit->object.oid, 0, opts);
 +		goto leave_merge;
 +	}
 +
  	if (commit) {
  		const char *message = get_commit_buffer(commit, NULL);
  		const char *body;
@@@ -3404,16 -3234,19 +3404,16 @@@ static int continue_single_pick(void
  	return run_command_v_opt(argv, RUN_GIT_CMD);
  }
  
 -static int commit_staged_changes(struct replay_opts *opts)
 +static int commit_staged_changes(struct replay_opts *opts,
 +				 struct todo_list *todo_list)
  {
  	unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
 +	unsigned int final_fixup = 0, is_clean;
  
  	if (has_unstaged_changes(1))
  		return error(_("cannot rebase: You have unstaged changes."));
 -	if (!has_uncommitted_changes(0)) {
 -		const char *cherry_pick_head = git_path_cherry_pick_head();
  
 -		if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
 -			return error(_("could not remove CHERRY_PICK_HEAD"));
 -		return 0;
 -	}
 +	is_clean = !has_uncommitted_changes(0);
  
  	if (file_exists(rebase_path_amend())) {
  		struct strbuf rev = STRBUF_INIT;
@@@ -3426,107 -3259,19 +3426,107 @@@
  		if (get_oid_hex(rev.buf, &to_amend))
  			return error(_("invalid contents: '%s'"),
  				rebase_path_amend());
 -		if (oidcmp(&head, &to_amend))
 +		if (!is_clean && oidcmp(&head, &to_amend))
  			return error(_("\nYou have uncommitted changes in your "
  				       "working tree. Please, commit them\n"
  				       "first and then run 'git rebase "
  				       "--continue' again."));
 +		/*
 +		 * When skipping a failed fixup/squash, we need to edit the
 +		 * commit message, the current fixup list and count, and if it
 +		 * was the last fixup/squash in the chain, we need to clean up
 +		 * the commit message and if there was a squash, let the user
 +		 * edit it.
 +		 */
 +		if (is_clean && !oidcmp(&head, &to_amend) &&
 +		    opts->current_fixup_count > 0 &&
 +		    file_exists(rebase_path_stopped_sha())) {
 +			const char *p = opts->current_fixups.buf;
 +			int len = opts->current_fixups.len;
 +
 +			opts->current_fixup_count--;
 +			if (!len)
 +				BUG("Incorrect current_fixups:\n%s", p);
 +			while (len && p[len - 1] != '\n')
 +				len--;
 +			strbuf_setlen(&opts->current_fixups, len);
 +			if (write_message(p, len, rebase_path_current_fixups(),
 +					  0) < 0)
 +				return error(_("could not write file: '%s'"),
 +					     rebase_path_current_fixups());
 +
 +			/*
 +			 * If a fixup/squash in a fixup/squash chain failed, the
 +			 * commit message is already correct, no need to commit
 +			 * it again.
 +			 *
 +			 * Only if it is the final command in the fixup/squash
 +			 * chain, and only if the chain is longer than a single
 +			 * fixup/squash command (which was just skipped), do we
 +			 * actually need to re-commit with a cleaned up commit
 +			 * message.
 +			 */
 +			if (opts->current_fixup_count > 0 &&
 +			    !is_fixup(peek_command(todo_list, 0))) {
 +				final_fixup = 1;
 +				/*
 +				 * If there was not a single "squash" in the
 +				 * chain, we only need to clean up the commit
 +				 * message, no need to bother the user with
 +				 * opening the commit message in the editor.
 +				 */
 +				if (!starts_with(p, "squash ") &&
 +				    !strstr(p, "\nsquash "))
 +					flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
 +			} else if (is_fixup(peek_command(todo_list, 0))) {
 +				/*
 +				 * We need to update the squash message to skip
 +				 * the latest commit message.
 +				 */
 +				struct commit *commit;
 +				const char *path = rebase_path_squash_msg();
 +
 +				if (parse_head(&commit) ||
 +				    !(p = get_commit_buffer(commit, NULL)) ||
 +				    write_message(p, strlen(p), path, 0)) {
 +					unuse_commit_buffer(commit, p);
 +					return error(_("could not write file: "
 +						       "'%s'"), path);
 +				}
 +				unuse_commit_buffer(commit, p);
 +			}
 +		}
  
  		strbuf_release(&rev);
  		flags |= AMEND_MSG;
  	}
  
 -	if (run_git_commit(rebase_path_message(), opts, flags))
 +	if (is_clean) {
 +		const char *cherry_pick_head = git_path_cherry_pick_head();
 +
 +		if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
 +			return error(_("could not remove CHERRY_PICK_HEAD"));
 +		if (!final_fixup)
 +			return 0;
 +	}
 +
 +	if (run_git_commit(final_fixup ? NULL : rebase_path_message(),
 +			   opts, flags))
  		return error(_("could not commit staged changes."));
  	unlink(rebase_path_amend());
 +	if (final_fixup) {
 +		unlink(rebase_path_fixup_msg());
 +		unlink(rebase_path_squash_msg());
 +	}
 +	if (opts->current_fixup_count > 0) {
 +		/*
 +		 * Whether final fixup or not, we just cleaned up the commit
 +		 * message...
 +		 */
 +		unlink(rebase_path_current_fixups());
 +		strbuf_reset(&opts->current_fixups);
 +		opts->current_fixup_count = 0;
 +	}
  	return 0;
  }
  
@@@ -3538,16 -3283,14 +3538,16 @@@ int sequencer_continue(struct replay_op
  	if (read_and_refresh_cache(opts))
  		return -1;
  
 +	if (read_populate_opts(opts))
 +		return -1;
  	if (is_rebase_i(opts)) {
 -		if (commit_staged_changes(opts))
 +		if ((res = read_populate_todo(&todo_list, opts)))
 +			goto release_todo_list;
 +		if (commit_staged_changes(opts, &todo_list))
  			return -1;
  	} else if (!file_exists(get_todo_path(opts)))
  		return continue_single_pick();
 -	if (read_populate_opts(opts))
 -		return -1;
 -	if ((res = read_populate_todo(&todo_list, opts)))
 +	else if ((res = read_populate_todo(&todo_list, opts)))
  		goto release_todo_list;
  
  	if (!is_rebase_i(opts)) {
@@@ -3606,8 -3349,7 +3606,8 @@@ int sequencer_pick_revisions(struct rep
  
  		if (!get_oid(name, &oid)) {
  			if (!lookup_commit_reference_gently(&oid, 1)) {
 -				enum object_type type = oid_object_info(&oid,
 +				enum object_type type = oid_object_info(the_repository,
 +									&oid,
  									NULL);
  				return error(_("%s: can't cherry-pick a %s"),
  					name, type_name(type));
@@@ -3792,7 -3534,7 +3792,7 @@@ static const char *label_oid(struct obj
  				p[i] = save;
  			}
  		}
- 	} else if (((len = strlen(label)) == GIT_SHA1_RAWSZ &&
+ 	} else if (((len = strlen(label)) == the_hash_algo->hexsz &&
  		    !get_oid_hex(label, &dummy)) ||
  		   (len == 1 && *label == '#') ||
  		   hashmap_get_from_hash(&state->labels,
@@@ -4006,8 -3748,7 +4006,8 @@@ static int make_script_with_merges(stru
  		}
  
  		if (!commit)
 -			fprintf(out, "%s onto\n", cmd_reset);
 +			fprintf(out, "%s %s\n", cmd_reset,
 +				rebase_cousins ? "onto" : "[new root]");
  		else {
  			const char *to = NULL;
  
diff --combined t/t3430-rebase-merges.sh
index ce6de6f491,472ad9463c..2608e5483d
--- a/t/t3430-rebase-merges.sh
+++ b/t/t3430-rebase-merges.sh
@@@ -70,6 -70,7 +70,7 @@@ test_expect_success 'create completely 
  	merge -C H second
  	merge onebranch # Merge the topic branch '\''onebranch'\''
  	EOF
+ 	cp script-from-scratch script-from-scratch-orig &&
  	test_config sequence.editor \""$PWD"/replace-editor.sh\" &&
  	test_tick &&
  	git rebase -i -r A &&
@@@ -241,76 -242,20 +242,92 @@@ test_expect_success 'refuse to merge an
  	test_cmp_rev HEAD $before
  '
  
 +test_expect_success 'root commits' '
 +	git checkout --orphan unrelated &&
 +	(GIT_AUTHOR_NAME="Parsnip" GIT_AUTHOR_EMAIL="root@example.com" \
 +	 test_commit second-root) &&
 +	test_commit third-root &&
 +	cat >script-from-scratch <<-\EOF &&
 +	pick third-root
 +	label first-branch
 +	reset [new root]
 +	pick second-root
 +	merge first-branch # Merge the 3rd root
 +	EOF
 +	test_config sequence.editor \""$PWD"/replace-editor.sh\" &&
 +	test_tick &&
 +	git rebase -i --force --root -r &&
 +	test "Parsnip" = "$(git show -s --format=%an HEAD^)" &&
 +	test $(git rev-parse second-root^0) != $(git rev-parse HEAD^) &&
 +	test $(git rev-parse second-root:second-root.t) = \
 +		$(git rev-parse HEAD^:second-root.t) &&
 +	test_cmp_graph HEAD <<-\EOF &&
 +	*   Merge the 3rd root
 +	|\
 +	| * third-root
 +	* second-root
 +	EOF
 +
 +	: fast forward if possible &&
 +	before="$(git rev-parse --verify HEAD)" &&
 +	test_might_fail git config --unset sequence.editor &&
 +	test_tick &&
 +	git rebase -i --root -r &&
 +	test_cmp_rev HEAD $before
 +'
 +
 +test_expect_success 'a "merge" into a root commit is a fast-forward' '
 +	head=$(git rev-parse HEAD) &&
 +	cat >script-from-scratch <<-EOF &&
 +	reset [new root]
 +	merge $head
 +	EOF
 +	test_config sequence.editor \""$PWD"/replace-editor.sh\" &&
 +	test_tick &&
 +	git rebase -i -r HEAD^ &&
 +	test_cmp_rev HEAD $head
 +'
 +
 +test_expect_success 'A root commit can be a cousin, treat it that way' '
 +	git checkout --orphan khnum &&
 +	test_commit yama &&
 +	git checkout -b asherah master &&
 +	test_commit shamkat &&
 +	git merge --allow-unrelated-histories khnum &&
 +	test_tick &&
 +	git rebase -f -r HEAD^ &&
 +	! test_cmp_rev HEAD^2 khnum &&
 +	test_cmp_graph HEAD^.. <<-\EOF &&
 +	*   Merge branch '\''khnum'\'' into asherah
 +	|\
 +	| * yama
 +	o shamkat
 +	EOF
 +	test_tick &&
 +	git rebase --rebase-merges=rebase-cousins HEAD^ &&
 +	test_cmp_graph HEAD^.. <<-\EOF
 +	*   Merge branch '\''khnum'\'' into asherah
 +	|\
 +	| * yama
 +	|/
 +	o shamkat
 +	EOF
 +'
 +
+ test_expect_success 'labels that are object IDs are rewritten' '
+ 	git checkout -b third B &&
+ 	test_tick &&
+ 	test_commit I &&
+ 	third=$(git rev-parse HEAD) &&
+ 	git checkout -b labels master &&
+ 	git merge --no-commit third &&
+ 	test_tick &&
+ 	git commit -m "Merge commit '\''$third'\'' into labels" &&
+ 	cp script-from-scratch-orig script-from-scratch &&
+ 	test_config sequence.editor \""$PWD"/replace-editor.sh\" &&
+ 	test_tick &&
+ 	git rebase -i -r A &&
+ 	! grep "^label $third$" .git/ORIGINAL-TODO
+ '
+ 
  test_done