From: Patrick Steinhardt Date: Wed, 10 Jun 2026 08:52:20 GMT Subject: [PATCH v4 00/10] builtin/history: introduce "drop" subcommand Message-ID: <20260610-b4-pks-history-drop-v4-0-70d5f0ae8c25@pks.im> In-Reply-To: <20260601-b4-pks-history-drop-v1-0-643e32340d55@pks.im> Hi, this small patch series introduces the new "drop" subcommand for git-history(1). As a reader might guess, the command does exactly that: given a commit, it will drop that commit from the commit history and replay descendant branches on top of it. Changes in v4: - Remove the `SKIP_REF_UPDATES` flag in favor of a new `UPDATE_HEAD` flag, as suggested by Phillip. - Rename `reset_head()` to `reset_working_tree()`. This better matches the new scope of the function, and it helps us to catch any in-flight patches that would now have to set the `UPDATE_HEAD` flag. - Link to v3: https://patch.msgid.link/20260608-b4-pks-history-drop-v3-0-84ca8e43e937@pks.im Changes in v3: - Fix commit message typos. - Make `update_orig_head` and `skip_ref_updates` mutually exclusive. - Use fancy revisions to specify the commit to drop in the example section. - Detect conflicting changes in the index/working tree in dry-run mode. - Consistently use a subshell. - Rename `RESET_HEAD_ORIG_HEAD` to `RESET_HEAD_UPDATE_ORIG_HEAD`. - - Link to v2: https://patch.msgid.link/20260603-b4-pks-history-drop-v2-0-742cb5b5176d@pks.im Changes in v2: - Reworked `update_worktree()` to use `reset_head()`, which required a bunch of changes to `reset_head()`. - Consistently mention the commit that cannot be dropped as part of error messages. - Adapt error message to not use backticks anymore. - Drop redundant "--graph" flag in a test helper. - Link to v1: https://patch.msgid.link/20260601-b4-pks-history-drop-v1-0-643e32340d55@pks.im Thanks! Patrick --- Patrick Steinhardt (10): read-cache: split out function to drop unmerged entries to stage 0 reset: drop `USE_THE_REPOSITORY_VARIABLE` reset: rename `reset_head()` reset: modernize flags passed to `reset_working_tree()` reset: introduce dry-run mode reset: introduce ability to skip updating HEAD reset: allow the caller to specify the current HEAD object reset: stop assuming that the caller passes in a clean index builtin/history: split handling of ref updates into two phases builtin/history: implement "drop" subcommand Documentation/git-history.adoc | 38 ++- builtin/history.c | 288 +++++++++++++++++++--- builtin/rebase.c | 41 ++-- read-cache-ll.h | 1 + read-cache.c | 12 +- reset.c | 99 +++++--- reset.h | 51 ++-- sequencer.c | 17 +- t/meson.build | 1 + t/t3454-history-drop.sh | 537 +++++++++++++++++++++++++++++++++++++++++ 10 files changed, 968 insertions(+), 117 deletions(-) Range-diff versus v3: 1: e9291b8592 = 1: 63c1a10ca0 read-cache: split out function to drop unmerged entries to stage 0 2: 6ae06725ca = 2: b83e2124e8 reset: drop `USE_THE_REPOSITORY_VARIABLE` 3: 53bf10c527 < -: ---------- reset: modernize flags passed to `reset_head()` -: ---------- > 3: 0488effe71 reset: rename `reset_head()` -: ---------- > 4: 364e71ee9c reset: modernize flags passed to `reset_working_tree()` 4: b8e5464d06 ! 5: 0fa45bd263 reset: introduce dry-run mode @@ Metadata ## Commit message ## reset: introduce dry-run mode - In a subsequent commit we'll add another caller to `reset_head()` that - wants to perform a dry-run check of whether it would be possible to + In a subsequent commit we'll add another caller to `reset_working_tree()` + that wants to perform a dry-run check of whether it would be possible to update the index and working tree when moving to a new commit. Introduce a new flag that lets the caller perform this operation. Signed-off-by: Patrick Steinhardt ## reset.c ## -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) - unsigned reset_hard = opts->flags & RESET_HEAD_HARD; - unsigned refs_only = opts->flags & RESET_HEAD_REFS_ONLY; - unsigned update_orig_head = opts->flags & RESET_HEAD_UPDATE_ORIG_HEAD; -+ unsigned dry_run = opts->flags & RESET_HEAD_DRY_RUN; +@@ reset.c: int reset_working_tree(struct repository *r, + unsigned reset_hard = opts->flags & RESET_WORKING_TREE_HARD; + unsigned refs_only = opts->flags & RESET_WORKING_TREE_REFS_ONLY; + unsigned update_orig_head = opts->flags & RESET_WORKING_TREE_UPDATE_ORIG_HEAD; ++ unsigned dry_run = opts->flags & RESET_WORKING_TREE_DRY_RUN; struct object_id *head = NULL, head_oid; struct tree_desc desc[2] = { { NULL }, { NULL } }; struct lock_file lock = LOCK_INIT; @@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts const char *action; int ret = 0, nr = 0; -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) +@@ reset.c: int reset_working_tree(struct repository *r, if (opts->branch_msg && !opts->branch) BUG("branch reflog message given without a branch"); @@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts ret = -1; goto leave_reset_head; } -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) +@@ reset.c: int reset_working_tree(struct repository *r, if (!oid) oid = &head_oid; @@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts unpack_tree_opts.merge = 1; unpack_tree_opts.preserve_ignored = 0; /* FIXME: !overwrite_ignore */ unpack_tree_opts.skip_cache_tree_update = 1; -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) +@@ reset.c: int reset_working_tree(struct repository *r, if (reset_hard) unpack_tree_opts.reset = UNPACK_RESET_PROTECT_UNTRACKED; @@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts if (!reset_hard && !fill_tree_descriptor(r, &desc[nr++], &head_oid)) { ret = error(_("failed to find tree of %s"), oid_to_hex(&head_oid)); -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) +@@ reset.c: int reset_working_tree(struct repository *r, goto leave_reset_head; } @@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts tree = repo_parse_tree_indirect(r, oid); if (!tree) { ret = error(_("unable to read tree (%s)"), oid_to_hex(oid)); -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) +@@ reset.c: int reset_working_tree(struct repository *r, leave_reset_head: rollback_lock_file(&lock); clear_unpack_trees_porcelain(&unpack_tree_opts); @@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts return ret; ## reset.h ## -@@ reset.h: enum reset_head_flags { +@@ reset.h: enum reset_working_tree_flags { /* Update ORIG_HEAD as well as HEAD */ - RESET_HEAD_UPDATE_ORIG_HEAD = (1 << 4), + RESET_WORKING_TREE_UPDATE_ORIG_HEAD = (1 << 4), + + /* + * Perform a dry-run by performing the operation without updating + * any user-visible state. + */ -+ RESET_HEAD_DRY_RUN = (1 << 5), ++ RESET_WORKING_TREE_DRY_RUN = (1 << 5), }; - struct reset_head_opts { + struct reset_working_tree_options { 5: bbb8b98f8e < -: ---------- reset: introduce ability to skip reference updates -: ---------- > 6: 4f844adaa7 reset: introduce ability to skip updating HEAD 6: 24cccf728f ! 7: 28e7dd039e reset: allow the caller to specify the current HEAD object @@ Metadata ## Commit message ## reset: allow the caller to specify the current HEAD object - When calling `reset_head()` we automatically derive the commit that the - callers wants to move from by reading the HEAD commit. Some callers may - already have resolved it, or they may want to move from a different - commit that doesn't match HEAD. + When calling `reset_working_tree()` we automatically derive the commit + that the callers wants to move from by reading the HEAD commit. Some + callers may already have resolved it, or they may want to move from a + different commit that doesn't match HEAD. Introduce a new `oid_from` option that lets the caller specify the commit. @@ Commit message Signed-off-by: Patrick Steinhardt ## reset.c ## -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) +@@ reset.c: int reset_working_tree(struct repository *r, goto leave_reset_head; } @@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts ret = error(_("could not determine HEAD revision")); ## reset.h ## -@@ reset.h: struct reset_head_opts { +@@ reset.h: struct reset_working_tree_options { * The commit to checkout/reset to. Defaults to HEAD. */ const struct object_id *oid; 7: 4b79437a50 ! 8: 6b590da34e reset: stop assuming that the caller passes in a clean index @@ Commit message reset: stop assuming that the caller passes in a clean index In 652bd0211d (rebase: use 'skip_cache_tree_update' option, 2022-11-10), - we updated `reset_head()` to stop updating the index tree cache. This - was done as a performance optimization: the function is only called by - "sequencer.c" and "rebase.c", both of which assume a clean index before - they perform their operation, so we know that the end result will be a - clean index, too. Consequently, we can skip recomputing the cache as we - can instead use `prime_cache_tree()` directly. + we updated `reset_working_tree()` to stop updating the index tree cache. + This was done as a performance optimization: the function is only called + by "sequencer.c" and "rebase.c", both of which assume a clean index + before they perform their operation, so we know that the end result will + be a clean index, too. Consequently, we can skip recomputing the cache + as we can instead use `prime_cache_tree()` directly. In a subsequent commit we're about to add a new caller though where the assumption doesn't hold anymore: the index may be dirty before calling - `reset_head()`, and consequently we cannot prime the cache with a given - tree anymore as the index and tree will mismatch. + `reset_working_tree()`, and consequently we cannot prime the cache with + a given tree anymore as the index and tree will mismatch. Adapt the logic so that we only skip the cache tree update in case we're doing a hard reset. While we could introduce logic that only skips the @@ Commit message Signed-off-by: Patrick Steinhardt ## reset.c ## -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) +@@ reset.c: int reset_working_tree(struct repository *r, unpack_tree_opts.dry_run = dry_run; unpack_tree_opts.merge = 1; unpack_tree_opts.preserve_ignored = 0; /* FIXME: !overwrite_ignore */ @@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts if (!reset_hard && !fill_tree_descriptor(r, &desc[nr++], &head_oid)) { ret = error(_("failed to find tree of %s"), -@@ reset.c: int reset_head(struct repository *r, const struct reset_head_opts *opts) +@@ reset.c: int reset_working_tree(struct repository *r, goto leave_reset_head; } 8: d01c7ffb29 = 9: fddadbf87f builtin/history: split handling of ref updates into two phases 9: c75925f7ed ! 10: cb09216db3 builtin/history: implement "drop" subcommand @@ builtin/history.c: static int cmd_history_split(int argc, + const struct commit *new_head, + bool dry_run) +{ -+ struct reset_head_opts opts = { ++ struct reset_working_tree_options opts = { + .oid_from = &old_head->object.oid, + .oid = &new_head->object.oid, -+ .flags = RESET_HEAD_SKIP_REF_UPDATES, + }; + if (dry_run) -+ opts.flags |= RESET_HEAD_DRY_RUN; -+ return reset_head(repo, &opts); ++ opts.flags |= RESET_WORKING_TREE_DRY_RUN; ++ return reset_working_tree(repo, &opts); +} + +static int find_head_tree_change(struct repository *repo, --- base-commit: 1666c1265231b0bc5f613fbbf3f0a9896cdef76e change-id: 20260601-b4-pks-history-drop-28f6c6399e7b