rebase: don't use rebased node as dirstate p2 (BC)

When rebasing a node, we currently use the rebased node as p2 in the
dirstate until just before we commit it (we then change to the desired
parents). This p2 is visible to the user when the rebase gets
interrupted because of merge conflicts. That can be useful to the user
as a reminder of which commit is currently being rebased, but I
believe it's incorrect for a few reasons:

 * I think the dirstate parents should be the ones that will be set
   when the commit is created.

 * I think having two parents means that you're merging those two
   commits, but when rebasing, you're generally grafting, not merging.

 * When rebasing a merge commit, we should use the two desired parents
   as dirstate parents (and we clearly can't have the rebased node as
   a third dirstate parent).

 * `hg graft` (and `hg update --merge`) sets only one parent and `hg
   rebase` should be consistent with that.

I realize that this is a somewhat large user-visible change, but I
think it's worth it because it will simplify things quite a bit.

Differential Revision: https://phab.mercurial-scm.org/D7827

hgext/rebase.py

@@ -1,2251 +1,2249 b''
 # rebase.py - rebasing feature for mercurial
 #
 # Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''command to move sets of revisions to a different ancestor
 
 This extension lets you rebase changesets in an existing Mercurial
 repository.
 
 For more information:
 https://mercurial-scm.org/wiki/RebaseExtension
 '''
 
 from __future__ import absolute_import
 
 import errno
 import os
 
 from mercurial.i18n import _
 from mercurial.node import (
     nullrev,
     short,
 )
 from mercurial.pycompat import open
 from mercurial import (
     bookmarks,
     cmdutil,
     commands,
     copies,
     destutil,
     dirstateguard,
     error,
     extensions,
     hg,
     merge as mergemod,
     mergeutil,
     node as nodemod,
     obsolete,
     obsutil,
     patch,
     phases,
     pycompat,
     registrar,
     repair,
     revset,
     revsetlang,
     rewriteutil,
     scmutil,
     smartset,
     state as statemod,
     util,
 )
 
 # The following constants are used throughout the rebase module. The ordering of
 # their values must be maintained.
 
 # Indicates that a revision needs to be rebased
 revtodo = -1
 revtodostr = b'-1'
 
 # legacy revstates no longer needed in current code
 # -2: nullmerge, -3: revignored, -4: revprecursor, -5: revpruned
 legacystates = {b'-2', b'-3', b'-4', b'-5'}
 
 cmdtable = {}
 command = registrar.command(cmdtable)
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 
 def _nothingtorebase():
     return 1
 
 
 def _savegraft(ctx, extra):
     s = ctx.extra().get(b'source', None)
     if s is not None:
         extra[b'source'] = s
     s = ctx.extra().get(b'intermediate-source', None)
     if s is not None:
         extra[b'intermediate-source'] = s
 
 
 def _savebranch(ctx, extra):
     extra[b'branch'] = ctx.branch()
 
 
 def _destrebase(repo, sourceset, destspace=None):
     """small wrapper around destmerge to pass the right extra args
 
     Please wrap destutil.destmerge instead."""
     return destutil.destmerge(
         repo,
         action=b'rebase',
         sourceset=sourceset,
         onheadcheck=False,
         destspace=destspace,
     )
 
 
 revsetpredicate = registrar.revsetpredicate()
 
 
 @revsetpredicate(b'_destrebase')
 def _revsetdestrebase(repo, subset, x):
     # ``_rebasedefaultdest()``
 
     # default destination for rebase.
     # # XXX: Currently private because I expect the signature to change.
     # # XXX: - bailing out in case of ambiguity vs returning all data.
     # i18n: "_rebasedefaultdest" is a keyword
     sourceset = None
     if x is not None:
         sourceset = revset.getset(repo, smartset.fullreposet(repo), x)
     return subset & smartset.baseset([_destrebase(repo, sourceset)])
 
 
 @revsetpredicate(b'_destautoorphanrebase')
 def _revsetdestautoorphanrebase(repo, subset, x):
     # ``_destautoorphanrebase()``
 
     # automatic rebase destination for a single orphan revision.
     unfi = repo.unfiltered()
     obsoleted = unfi.revs(b'obsolete()')
 
     src = revset.getset(repo, subset, x).first()
 
     # Empty src or already obsoleted - Do not return a destination
     if not src or src in obsoleted:
         return smartset.baseset()
     dests = destutil.orphanpossibledestination(repo, src)
     if len(dests) > 1:
         raise error.Abort(
             _(b"ambiguous automatic rebase: %r could end up on any of %r")
             % (src, dests)
         )
     # We have zero or one destination, so we can just return here.
     return smartset.baseset(dests)
 
 
 def _ctxdesc(ctx):
     """short description for a context"""
     desc = b'%d:%s "%s"' % (
         ctx.rev(),
         ctx,
         ctx.description().split(b'\n', 1)[0],
     )
     repo = ctx.repo()
     names = []
     for nsname, ns in pycompat.iteritems(repo.names):
         if nsname == b'branches':
             continue
         names.extend(ns.names(repo, ctx.node()))
     if names:
         desc += b' (%s)' % b' '.join(names)
     return desc
 
 
 class rebaseruntime(object):
     """This class is a container for rebase runtime state"""
 
     def __init__(self, repo, ui, inmemory=False, opts=None):
         if opts is None:
             opts = {}
 
         # prepared: whether we have rebasestate prepared or not. Currently it
         # decides whether "self.repo" is unfiltered or not.
         # The rebasestate has explicit hash to hash instructions not depending
         # on visibility. If rebasestate exists (in-memory or on-disk), use
         # unfiltered repo to avoid visibility issues.
         # Before knowing rebasestate (i.e. when starting a new rebase (not
         # --continue or --abort)), the original repo should be used so
         # visibility-dependent revsets are correct.
         self.prepared = False
         self.resume = False
         self._repo = repo
 
         self.ui = ui
         self.opts = opts
         self.originalwd = None
         self.external = nullrev
         # Mapping between the old revision id and either what is the new rebased
         # revision or what needs to be done with the old revision. The state
         # dict will be what contains most of the rebase progress state.
         self.state = {}
         self.activebookmark = None
         self.destmap = {}
         self.skipped = set()
 
         self.collapsef = opts.get(b'collapse', False)
         self.collapsemsg = cmdutil.logmessage(ui, opts)
         self.date = opts.get(b'date', None)
 
         e = opts.get(b'extrafn')  # internal, used by e.g. hgsubversion
         self.extrafns = [_savegraft]
         if e:
             self.extrafns = [e]
 
         self.backupf = ui.configbool(b'rewrite', b'backup-bundle')
         self.keepf = opts.get(b'keep', False)
         self.keepbranchesf = opts.get(b'keepbranches', False)
         self.obsoletenotrebased = {}
         self.obsoletewithoutsuccessorindestination = set()
         self.inmemory = inmemory
         self.stateobj = statemod.cmdstate(repo, b'rebasestate')
 
     @property
     def repo(self):
         if self.prepared:
             return self._repo.unfiltered()
         else:
             return self._repo
 
     def storestatus(self, tr=None):
         """Store the current status to allow recovery"""
         if tr:
             tr.addfilegenerator(
                 b'rebasestate',
                 (b'rebasestate',),
                 self._writestatus,
                 location=b'plain',
             )
         else:
             with self.repo.vfs(b"rebasestate", b"w") as f:
                 self._writestatus(f)
 
     def _writestatus(self, f):
         repo = self.repo
         assert repo.filtername is None
         f.write(repo[self.originalwd].hex() + b'\n')
         # was "dest". we now write dest per src root below.
         f.write(b'\n')
         f.write(repo[self.external].hex() + b'\n')
         f.write(b'%d\n' % int(self.collapsef))
         f.write(b'%d\n' % int(self.keepf))
         f.write(b'%d\n' % int(self.keepbranchesf))
         f.write(b'%s\n' % (self.activebookmark or b''))
         destmap = self.destmap
         for d, v in pycompat.iteritems(self.state):
             oldrev = repo[d].hex()
             if v >= 0:
                 newrev = repo[v].hex()
             else:
                 newrev = b"%d" % v
             destnode = repo[destmap[d]].hex()
             f.write(b"%s:%s:%s\n" % (oldrev, newrev, destnode))
         repo.ui.debug(b'rebase status stored\n')
 
     def restorestatus(self):
         """Restore a previously stored status"""
         if not self.stateobj.exists():
             cmdutil.wrongtooltocontinue(self.repo, _(b'rebase'))
 
         data = self._read()
         self.repo.ui.debug(b'rebase status resumed\n')
 
         self.originalwd = data[b'originalwd']
         self.destmap = data[b'destmap']
         self.state = data[b'state']
         self.skipped = data[b'skipped']
         self.collapsef = data[b'collapse']
         self.keepf = data[b'keep']
         self.keepbranchesf = data[b'keepbranches']
         self.external = data[b'external']
         self.activebookmark = data[b'activebookmark']
 
     def _read(self):
         self.prepared = True
         repo = self.repo
         assert repo.filtername is None
         data = {
             b'keepbranches': None,
             b'collapse': None,
             b'activebookmark': None,
             b'external': nullrev,
             b'keep': None,
             b'originalwd': None,
         }
         legacydest = None
         state = {}
         destmap = {}
 
         if True:
             f = repo.vfs(b"rebasestate")
             for i, l in enumerate(f.read().splitlines()):
                 if i == 0:
                     data[b'originalwd'] = repo[l].rev()
                 elif i == 1:
                     # this line should be empty in newer version. but legacy
                     # clients may still use it
                     if l:
                         legacydest = repo[l].rev()
                 elif i == 2:
                     data[b'external'] = repo[l].rev()
                 elif i == 3:
                     data[b'collapse'] = bool(int(l))
                 elif i == 4:
                     data[b'keep'] = bool(int(l))
                 elif i == 5:
                     data[b'keepbranches'] = bool(int(l))
                 elif i == 6 and not (len(l) == 81 and b':' in l):
                     # line 6 is a recent addition, so for backwards
                     # compatibility check that the line doesn't look like the
                     # oldrev:newrev lines
                     data[b'activebookmark'] = l
                 else:
                     args = l.split(b':')
                     oldrev = repo[args[0]].rev()
                     newrev = args[1]
                     if newrev in legacystates:
                         continue
                     if len(args) > 2:
                         destrev = repo[args[2]].rev()
                     else:
                         destrev = legacydest
                     destmap[oldrev] = destrev
                     if newrev == revtodostr:
                         state[oldrev] = revtodo
                         # Legacy compat special case
                     else:
                         state[oldrev] = repo[newrev].rev()
 
         if data[b'keepbranches'] is None:
             raise error.Abort(_(b'.hg/rebasestate is incomplete'))
 
         data[b'destmap'] = destmap
         data[b'state'] = state
         skipped = set()
         # recompute the set of skipped revs
         if not data[b'collapse']:
             seen = set(destmap.values())
             for old, new in sorted(state.items()):
                 if new != revtodo and new in seen:
                     skipped.add(old)
                 seen.add(new)
         data[b'skipped'] = skipped
         repo.ui.debug(
             b'computed skipped revs: %s\n'
             % (b' '.join(b'%d' % r for r in sorted(skipped)) or b'')
         )
 
         return data
 
     def _handleskippingobsolete(self, obsoleterevs, destmap):
         """Compute structures necessary for skipping obsolete revisions
 
         obsoleterevs:   iterable of all obsolete revisions in rebaseset
         destmap:        {srcrev: destrev} destination revisions
         """
         self.obsoletenotrebased = {}
         if not self.ui.configbool(b'experimental', b'rebaseskipobsolete'):
             return
         obsoleteset = set(obsoleterevs)
         (
             self.obsoletenotrebased,
             self.obsoletewithoutsuccessorindestination,
             obsoleteextinctsuccessors,
         ) = _computeobsoletenotrebased(self.repo, obsoleteset, destmap)
         skippedset = set(self.obsoletenotrebased)
         skippedset.update(self.obsoletewithoutsuccessorindestination)
         skippedset.update(obsoleteextinctsuccessors)
         _checkobsrebase(self.repo, self.ui, obsoleteset, skippedset)
 
     def _prepareabortorcontinue(self, isabort, backup=True, suppwarns=False):
         self.resume = True
         try:
             self.restorestatus()
             self.collapsemsg = restorecollapsemsg(self.repo, isabort)
         except error.RepoLookupError:
             if isabort:
                 clearstatus(self.repo)
                 clearcollapsemsg(self.repo)
                 self.repo.ui.warn(
                     _(
                         b'rebase aborted (no revision is removed,'
                         b' only broken state is cleared)\n'
                     )
                 )
                 return 0
             else:
                 msg = _(b'cannot continue inconsistent rebase')
                 hint = _(b'use "hg rebase --abort" to clear broken state')
                 raise error.Abort(msg, hint=hint)
 
         if isabort:
             backup = backup and self.backupf
             return self._abort(backup=backup, suppwarns=suppwarns)
 
     def _preparenewrebase(self, destmap):
         if not destmap:
             return _nothingtorebase()
 
         rebaseset = destmap.keys()
         if not self.keepf:
             try:
                 rewriteutil.precheck(self.repo, rebaseset, action=b'rebase')
             except error.Abort as e:
                 if e.hint is None:
                     e.hint = _(b'use --keep to keep original changesets')
                 raise e
 
         result = buildstate(self.repo, destmap, self.collapsef)
 
         if not result:
             # Empty state built, nothing to rebase
             self.ui.status(_(b'nothing to rebase\n'))
             return _nothingtorebase()
 
         (self.originalwd, self.destmap, self.state) = result
         if self.collapsef:
             dests = set(self.destmap.values())
             if len(dests) != 1:
                 raise error.Abort(
                     _(b'--collapse does not work with multiple destinations')
                 )
             destrev = next(iter(dests))
             destancestors = self.repo.changelog.ancestors(
                 [destrev], inclusive=True
             )
             self.external = externalparent(self.repo, self.state, destancestors)
 
         for destrev in sorted(set(destmap.values())):
             dest = self.repo[destrev]
             if dest.closesbranch() and not self.keepbranchesf:
                 self.ui.status(_(b'reopening closed branch head %s\n') % dest)
 
         self.prepared = True
 
     def _assignworkingcopy(self):
         if self.inmemory:
             from mercurial.context import overlayworkingctx
 
             self.wctx = overlayworkingctx(self.repo)
             self.repo.ui.debug(b"rebasing in-memory\n")
         else:
             self.wctx = self.repo[None]
             self.repo.ui.debug(b"rebasing on disk\n")
         self.repo.ui.log(
             b"rebase",
             b"using in-memory rebase: %r\n",
             self.inmemory,
             rebase_imm_used=self.inmemory,
         )
 
     def _performrebase(self, tr):
         self._assignworkingcopy()
         repo, ui = self.repo, self.ui
         if self.keepbranchesf:
             # insert _savebranch at the start of extrafns so if
             # there's a user-provided extrafn it can clobber branch if
             # desired
             self.extrafns.insert(0, _savebranch)
             if self.collapsef:
                 branches = set()
                 for rev in self.state:
                     branches.add(repo[rev].branch())
                     if len(branches) > 1:
                         raise error.Abort(
                             _(b'cannot collapse multiple named branches')
                         )
 
         # Calculate self.obsoletenotrebased
         obsrevs = _filterobsoleterevs(self.repo, self.state)
         self._handleskippingobsolete(obsrevs, self.destmap)
 
         # Keep track of the active bookmarks in order to reset them later
         self.activebookmark = self.activebookmark or repo._activebookmark
         if self.activebookmark:
             bookmarks.deactivate(repo)
 
         # Store the state before we begin so users can run 'hg rebase --abort'
         # if we fail before the transaction closes.
         self.storestatus()
         if tr:
             # When using single transaction, store state when transaction
             # commits.
             self.storestatus(tr)
 
         cands = [k for k, v in pycompat.iteritems(self.state) if v == revtodo]
         p = repo.ui.makeprogress(
             _(b"rebasing"), unit=_(b'changesets'), total=len(cands)
         )
 
         def progress(ctx):
             p.increment(item=(b"%d:%s" % (ctx.rev(), ctx)))
 
         allowdivergence = self.ui.configbool(
             b'experimental', b'evolution.allowdivergence'
         )
         for subset in sortsource(self.destmap):
             sortedrevs = self.repo.revs(b'sort(%ld, -topo)', subset)
             if not allowdivergence:
                 sortedrevs -= self.repo.revs(
                     b'descendants(%ld) and not %ld',
                     self.obsoletewithoutsuccessorindestination,
                     self.obsoletewithoutsuccessorindestination,
                 )
             for rev in sortedrevs:
                 self._rebasenode(tr, rev, allowdivergence, progress)
         p.complete()
         ui.note(_(b'rebase merging completed\n'))
 
     def _concludenode(self, rev, p1, p2, editor, commitmsg=None):
         '''Commit the wd changes with parents p1 and p2.
 
         Reuse commit info from rev but also store useful information in extra.
         Return node of committed revision.'''
         repo = self.repo
         ctx = repo[rev]
         if commitmsg is None:
             commitmsg = ctx.description()
         date = self.date
         if date is None:
             date = ctx.date()
         extra = {b'rebase_source': ctx.hex()}
         for c in self.extrafns:
             c(ctx, extra)
         keepbranch = self.keepbranchesf and repo[p1].branch() != ctx.branch()
         destphase = max(ctx.phase(), phases.draft)
         overrides = {(b'phases', b'new-commit'): destphase}
         if keepbranch:
             overrides[(b'ui', b'allowemptycommit')] = True
         with repo.ui.configoverride(overrides, b'rebase'):
             if self.inmemory:
                 newnode = commitmemorynode(
                     repo,
                     p1,
                     p2,
                     wctx=self.wctx,
                     extra=extra,
                     commitmsg=commitmsg,
                     editor=editor,
                     user=ctx.user(),
                     date=date,
                 )
                 mergemod.mergestate.clean(repo)
             else:
                 newnode = commitnode(
                     repo,
                     p1,
                     p2,
                     extra=extra,
                     commitmsg=commitmsg,
                     editor=editor,
                     user=ctx.user(),
                     date=date,
                 )
 
             if newnode is None:
                 # If it ended up being a no-op commit, then the normal
                 # merge state clean-up path doesn't happen, so do it
                 # here. Fix issue5494
                 mergemod.mergestate.clean(repo)
             return newnode
 
     def _rebasenode(self, tr, rev, allowdivergence, progressfn):
         repo, ui, opts = self.repo, self.ui, self.opts
         dest = self.destmap[rev]
         ctx = repo[rev]
         desc = _ctxdesc(ctx)
         if self.state[rev] == rev:
             ui.status(_(b'already rebased %s\n') % desc)
         elif (
             not allowdivergence
             and rev in self.obsoletewithoutsuccessorindestination
         ):
             msg = (
                 _(
                     b'note: not rebasing %s and its descendants as '
                     b'this would cause divergence\n'
                 )
                 % desc
             )
             repo.ui.status(msg)
             self.skipped.add(rev)
         elif rev in self.obsoletenotrebased:
             succ = self.obsoletenotrebased[rev]
             if succ is None:
                 msg = _(b'note: not rebasing %s, it has no successor\n') % desc
             else:
                 succdesc = _ctxdesc(repo[succ])
                 msg = _(
                     b'note: not rebasing %s, already in destination as %s\n'
                 ) % (desc, succdesc)
             repo.ui.status(msg)
             # Make clearrebased aware state[rev] is not a true successor
             self.skipped.add(rev)
             # Record rev as moved to its desired destination in self.state.
             # This helps bookmark and working parent movement.
             dest = max(
                 adjustdest(repo, rev, self.destmap, self.state, self.skipped)
             )
             self.state[rev] = dest
         elif self.state[rev] == revtodo:
             ui.status(_(b'rebasing %s\n') % desc)
             progressfn(ctx)
             p1, p2, base = defineparents(
                 repo,
                 rev,
                 self.destmap,
                 self.state,
                 self.skipped,
                 self.obsoletenotrebased,
             )
             if self.resume and self.wctx.p1().rev() == p1:
                 repo.ui.debug(b'resuming interrupted rebase\n')
                 self.resume = False
             else:
                 overrides = {(b'ui', b'forcemerge'): opts.get(b'tool', b'')}
                 with ui.configoverride(overrides, b'rebase'):
                     stats = rebasenode(
                         repo,
                         rev,
                         p1,
+                        p2,
                         base,
                         self.collapsef,
                         dest,
                         wctx=self.wctx,
                     )
                     if stats.unresolvedcount > 0:
                         if self.inmemory:
                             raise error.InMemoryMergeConflictsError()
                         else:
                             raise error.InterventionRequired(
                                 _(
                                     b'unresolved conflicts (see hg '
                                     b'resolve, then hg rebase --continue)'
                                 )
                             )
             if not self.collapsef:
                 merging = p2 != nullrev
                 editform = cmdutil.mergeeditform(merging, b'rebase')
                 editor = cmdutil.getcommiteditor(
                     editform=editform, **pycompat.strkwargs(opts)
                 )
                 newnode = self._concludenode(rev, p1, p2, editor)
             else:
                 # Skip commit if we are collapsing
-                if self.inmemory:
-                    self.wctx.setbase(repo[p1])
-                else:
-                    repo.setparents(repo[p1].node())
                 newnode = None
             # Update the state
             if newnode is not None:
                 self.state[rev] = repo[newnode].rev()
                 ui.debug(b'rebased as %s\n' % short(newnode))
             else:
                 if not self.collapsef:
                     ui.warn(
                         _(
                             b'note: not rebasing %s, its destination already '
                             b'has all its changes\n'
                         )
                         % desc
                     )
                     self.skipped.add(rev)
                 self.state[rev] = p1
                 ui.debug(b'next revision set to %d\n' % p1)
         else:
             ui.status(
                 _(b'already rebased %s as %s\n') % (desc, repo[self.state[rev]])
             )
         if not tr:
             # When not using single transaction, store state after each
             # commit is completely done. On InterventionRequired, we thus
             # won't store the status. Instead, we'll hit the "len(parents) == 2"
             # case and realize that the commit was in progress.
             self.storestatus()
 
     def _finishrebase(self):
         repo, ui, opts = self.repo, self.ui, self.opts
         fm = ui.formatter(b'rebase', opts)
         fm.startitem()
         if self.collapsef:
             p1, p2, _base = defineparents(
                 repo,
                 min(self.state),
                 self.destmap,
                 self.state,
                 self.skipped,
                 self.obsoletenotrebased,
             )
             editopt = opts.get(b'edit')
             editform = b'rebase.collapse'
             if self.collapsemsg:
                 commitmsg = self.collapsemsg
             else:
                 commitmsg = b'Collapsed revision'
                 for rebased in sorted(self.state):
                     if rebased not in self.skipped:
                         commitmsg += b'\n* %s' % repo[rebased].description()
                 editopt = True
             editor = cmdutil.getcommiteditor(edit=editopt, editform=editform)
             revtoreuse = max(self.state)
 
             newnode = self._concludenode(
                 revtoreuse, p1, self.external, editor, commitmsg=commitmsg
             )
 
             if newnode is not None:
                 newrev = repo[newnode].rev()
                 for oldrev in self.state:
                     self.state[oldrev] = newrev
 
         if b'qtip' in repo.tags():
             updatemq(repo, self.state, self.skipped, **pycompat.strkwargs(opts))
 
         # restore original working directory
         # (we do this before stripping)
         newwd = self.state.get(self.originalwd, self.originalwd)
         if newwd < 0:
             # original directory is a parent of rebase set root or ignored
             newwd = self.originalwd
         if newwd not in [c.rev() for c in repo[None].parents()]:
             ui.note(_(b"update back to initial working directory parent\n"))
             hg.updaterepo(repo, newwd, overwrite=False)
 
         collapsedas = None
         if self.collapsef and not self.keepf:
             collapsedas = newnode
         clearrebased(
             ui,
             repo,
             self.destmap,
             self.state,
             self.skipped,
             collapsedas,
             self.keepf,
             fm=fm,
             backup=self.backupf,
         )
 
         clearstatus(repo)
         clearcollapsemsg(repo)
 
         ui.note(_(b"rebase completed\n"))
         util.unlinkpath(repo.sjoin(b'undo'), ignoremissing=True)
         if self.skipped:
             skippedlen = len(self.skipped)
             ui.note(_(b"%d revisions have been skipped\n") % skippedlen)
         fm.end()
 
         if (
             self.activebookmark
             and self.activebookmark in repo._bookmarks
             and repo[b'.'].node() == repo._bookmarks[self.activebookmark]
         ):
             bookmarks.activate(repo, self.activebookmark)
 
     def _abort(self, backup=True, suppwarns=False):
         '''Restore the repository to its original state.'''
 
         repo = self.repo
         try:
             # If the first commits in the rebased set get skipped during the
             # rebase, their values within the state mapping will be the dest
             # rev id. The rebased list must must not contain the dest rev
             # (issue4896)
             rebased = [
                 s
                 for r, s in self.state.items()
                 if s >= 0 and s != r and s != self.destmap[r]
             ]
             immutable = [d for d in rebased if not repo[d].mutable()]
             cleanup = True
             if immutable:
                 repo.ui.warn(
                     _(b"warning: can't clean up public changesets %s\n")
                     % b', '.join(bytes(repo[r]) for r in immutable),
                     hint=_(b"see 'hg help phases' for details"),
                 )
                 cleanup = False
 
             descendants = set()
             if rebased:
                 descendants = set(repo.changelog.descendants(rebased))
             if descendants - set(rebased):
                 repo.ui.warn(
                     _(
                         b"warning: new changesets detected on "
                         b"destination branch, can't strip\n"
                     )
                 )
                 cleanup = False
 
             if cleanup:
                 if rebased:
                     strippoints = [
                         c.node() for c in repo.set(b'roots(%ld)', rebased)
                     ]
 
                 updateifonnodes = set(rebased)
                 updateifonnodes.update(self.destmap.values())
                 updateifonnodes.add(self.originalwd)
                 shouldupdate = repo[b'.'].rev() in updateifonnodes
 
                 # Update away from the rebase if necessary
                 if shouldupdate:
                     mergemod.clean_update(repo[self.originalwd])
 
                 # Strip from the first rebased revision
                 if rebased:
                     repair.strip(repo.ui, repo, strippoints, backup=backup)
 
             if self.activebookmark and self.activebookmark in repo._bookmarks:
                 bookmarks.activate(repo, self.activebookmark)
 
         finally:
             clearstatus(repo)
             clearcollapsemsg(repo)
             if not suppwarns:
                 repo.ui.warn(_(b'rebase aborted\n'))
         return 0
 
 
 @command(
     b'rebase',
     [
         (
             b's',
             b'source',
             b'',
             _(b'rebase the specified changeset and descendants'),
             _(b'REV'),
         ),
         (
             b'b',
             b'base',
             b'',
             _(b'rebase everything from branching point of specified changeset'),
             _(b'REV'),
         ),
         (b'r', b'rev', [], _(b'rebase these revisions'), _(b'REV')),
         (
             b'd',
             b'dest',
             b'',
             _(b'rebase onto the specified changeset'),
             _(b'REV'),
         ),
         (b'', b'collapse', False, _(b'collapse the rebased changesets')),
         (
             b'm',
             b'message',
             b'',
             _(b'use text as collapse commit message'),
             _(b'TEXT'),
         ),
         (b'e', b'edit', False, _(b'invoke editor on commit messages')),
         (
             b'l',
             b'logfile',
             b'',
             _(b'read collapse commit message from file'),
             _(b'FILE'),
         ),
         (b'k', b'keep', False, _(b'keep original changesets')),
         (b'', b'keepbranches', False, _(b'keep original branch names')),
         (b'D', b'detach', False, _(b'(DEPRECATED)')),
         (b'i', b'interactive', False, _(b'(DEPRECATED)')),
         (b't', b'tool', b'', _(b'specify merge tool')),
         (b'', b'stop', False, _(b'stop interrupted rebase')),
         (b'c', b'continue', False, _(b'continue an interrupted rebase')),
         (b'a', b'abort', False, _(b'abort an interrupted rebase')),
         (
             b'',
             b'auto-orphans',
             b'',
             _(
                 b'automatically rebase orphan revisions '
                 b'in the specified revset (EXPERIMENTAL)'
             ),
         ),
     ]
     + cmdutil.dryrunopts
     + cmdutil.formatteropts
     + cmdutil.confirmopts,
     _(b'[-s REV | -b REV] [-d REV] [OPTION]'),
     helpcategory=command.CATEGORY_CHANGE_MANAGEMENT,
 )
 def rebase(ui, repo, **opts):
     """move changeset (and descendants) to a different branch
 
     Rebase uses repeated merging to graft changesets from one part of
     history (the source) onto another (the destination). This can be
     useful for linearizing *local* changes relative to a master
     development tree.
 
     Published commits cannot be rebased (see :hg:`help phases`).
     To copy commits, see :hg:`help graft`.
 
     If you don't specify a destination changeset (``-d/--dest``), rebase
     will use the same logic as :hg:`merge` to pick a destination.  if
     the current branch contains exactly one other head, the other head
     is merged with by default.  Otherwise, an explicit revision with
     which to merge with must be provided.  (destination changeset is not
     modified by rebasing, but new changesets are added as its
     descendants.)
 
     Here are the ways to select changesets:
 
       1. Explicitly select them using ``--rev``.
 
       2. Use ``--source`` to select a root changeset and include all of its
          descendants.
 
       3. Use ``--base`` to select a changeset; rebase will find ancestors
          and their descendants which are not also ancestors of the destination.
 
       4. If you do not specify any of ``--rev``, ``--source``, or ``--base``,
          rebase will use ``--base .`` as above.
 
     If ``--source`` or ``--rev`` is used, special names ``SRC`` and ``ALLSRC``
     can be used in ``--dest``. Destination would be calculated per source
     revision with ``SRC`` substituted by that single source revision and
     ``ALLSRC`` substituted by all source revisions.
 
     Rebase will destroy original changesets unless you use ``--keep``.
     It will also move your bookmarks (even if you do).
 
     Some changesets may be dropped if they do not contribute changes
     (e.g. merges from the destination branch).
 
     Unlike ``merge``, rebase will do nothing if you are at the branch tip of
     a named branch with two heads. You will need to explicitly specify source
     and/or destination.
 
     If you need to use a tool to automate merge/conflict decisions, you
     can specify one with ``--tool``, see :hg:`help merge-tools`.
     As a caveat: the tool will not be used to mediate when a file was
     deleted, there is no hook presently available for this.
 
     If a rebase is interrupted to manually resolve a conflict, it can be
     continued with --continue/-c, aborted with --abort/-a, or stopped with
     --stop.
 
     .. container:: verbose
 
       Examples:
 
       - move "local changes" (current commit back to branching point)
         to the current branch tip after a pull::
 
           hg rebase
 
       - move a single changeset to the stable branch::
 
           hg rebase -r 5f493448 -d stable
 
       - splice a commit and all its descendants onto another part of history::
 
           hg rebase --source c0c3 --dest 4cf9
 
       - rebase everything on a branch marked by a bookmark onto the
         default branch::
 
           hg rebase --base myfeature --dest default
 
       - collapse a sequence of changes into a single commit::
 
           hg rebase --collapse -r 1520:1525 -d .
 
       - move a named branch while preserving its name::
 
           hg rebase -r "branch(featureX)" -d 1.3 --keepbranches
 
       - stabilize orphaned changesets so history looks linear::
 
           hg rebase -r 'orphan()-obsolete()'\
  -d 'first(max((successors(max(roots(ALLSRC) & ::SRC)^)-obsolete())::) +\
  max(::((roots(ALLSRC) & ::SRC)^)-obsolete()))'
 
     Configuration Options:
 
     You can make rebase require a destination if you set the following config
     option::
 
       [commands]
       rebase.requiredest = True
 
     By default, rebase will close the transaction after each commit. For
     performance purposes, you can configure rebase to use a single transaction
     across the entire rebase. WARNING: This setting introduces a significant
     risk of losing the work you've done in a rebase if the rebase aborts
     unexpectedly::
 
       [rebase]
       singletransaction = True
 
     By default, rebase writes to the working copy, but you can configure it to
     run in-memory for better performance. When the rebase is not moving the
     parent(s) of the working copy (AKA the "currently checked out changesets"),
     this may also allow it to run even if the working copy is dirty::
 
       [rebase]
       experimental.inmemory = True
 
     Return Values:
 
     Returns 0 on success, 1 if nothing to rebase or there are
     unresolved conflicts.
 
     """
     opts = pycompat.byteskwargs(opts)
     inmemory = ui.configbool(b'rebase', b'experimental.inmemory')
     action = cmdutil.check_at_most_one_arg(opts, b'abort', b'stop', b'continue')
     if action:
         cmdutil.check_incompatible_arguments(
             opts, action, [b'confirm', b'dry_run']
         )
         cmdutil.check_incompatible_arguments(
             opts, action, [b'rev', b'source', b'base', b'dest']
         )
     cmdutil.check_at_most_one_arg(opts, b'confirm', b'dry_run')
     cmdutil.check_at_most_one_arg(opts, b'rev', b'source', b'base')
 
     if action or repo.currenttransaction() is not None:
         # in-memory rebase is not compatible with resuming rebases.
         # (Or if it is run within a transaction, since the restart logic can
         # fail the entire transaction.)
         inmemory = False
 
     if opts.get(b'auto_orphans'):
         disallowed_opts = set(opts) - {b'auto_orphans'}
         cmdutil.check_incompatible_arguments(
             opts, b'auto_orphans', disallowed_opts
         )
 
         userrevs = list(repo.revs(opts.get(b'auto_orphans')))
         opts[b'rev'] = [revsetlang.formatspec(b'%ld and orphan()', userrevs)]
         opts[b'dest'] = b'_destautoorphanrebase(SRC)'
 
     if opts.get(b'dry_run') or opts.get(b'confirm'):
         return _dryrunrebase(ui, repo, action, opts)
     elif action == b'stop':
         rbsrt = rebaseruntime(repo, ui)
         with repo.wlock(), repo.lock():
             rbsrt.restorestatus()
             if rbsrt.collapsef:
                 raise error.Abort(_(b"cannot stop in --collapse session"))
             allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
             if not (rbsrt.keepf or allowunstable):
                 raise error.Abort(
                     _(
                         b"cannot remove original changesets with"
                         b" unrebased descendants"
                     ),
                     hint=_(
                         b'either enable obsmarkers to allow unstable '
                         b'revisions or use --keep to keep original '
                         b'changesets'
                     ),
                 )
             # update to the current working revision
             # to clear interrupted merge
             hg.updaterepo(repo, rbsrt.originalwd, overwrite=True)
             rbsrt._finishrebase()
             return 0
     elif inmemory:
         try:
             # in-memory merge doesn't support conflicts, so if we hit any, abort
             # and re-run as an on-disk merge.
             overrides = {(b'rebase', b'singletransaction'): True}
             with ui.configoverride(overrides, b'rebase'):
                 return _dorebase(ui, repo, action, opts, inmemory=inmemory)
         except error.InMemoryMergeConflictsError:
             ui.warn(
                 _(
                     b'hit merge conflicts; re-running rebase without in-memory'
                     b' merge\n'
                 )
             )
             # TODO: Make in-memory merge not use the on-disk merge state, so
             # we don't have to clean it here
             mergemod.mergestate.clean(repo)
             clearstatus(repo)
             clearcollapsemsg(repo)
             return _dorebase(ui, repo, action, opts, inmemory=False)
     else:
         return _dorebase(ui, repo, action, opts)
 
 
 def _dryrunrebase(ui, repo, action, opts):
     rbsrt = rebaseruntime(repo, ui, inmemory=True, opts=opts)
     confirm = opts.get(b'confirm')
     if confirm:
         ui.status(_(b'starting in-memory rebase\n'))
     else:
         ui.status(
             _(b'starting dry-run rebase; repository will not be changed\n')
         )
     with repo.wlock(), repo.lock():
         needsabort = True
         try:
             overrides = {(b'rebase', b'singletransaction'): True}
             with ui.configoverride(overrides, b'rebase'):
                 _origrebase(
                     ui,
                     repo,
                     action,
                     opts,
                     rbsrt,
                     inmemory=True,
                     leaveunfinished=True,
                 )
         except error.InMemoryMergeConflictsError:
             ui.status(_(b'hit a merge conflict\n'))
             return 1
         except error.Abort:
             needsabort = False
             raise
         else:
             if confirm:
                 ui.status(_(b'rebase completed successfully\n'))
                 if not ui.promptchoice(_(b'apply changes (yn)?$$ &Yes $$ &No')):
                     # finish unfinished rebase
                     rbsrt._finishrebase()
                 else:
                     rbsrt._prepareabortorcontinue(
                         isabort=True, backup=False, suppwarns=True
                     )
                 needsabort = False
             else:
                 ui.status(
                     _(
                         b'dry-run rebase completed successfully; run without'
                         b' -n/--dry-run to perform this rebase\n'
                     )
                 )
             return 0
         finally:
             if needsabort:
                 # no need to store backup in case of dryrun
                 rbsrt._prepareabortorcontinue(
                     isabort=True, backup=False, suppwarns=True
                 )
 
 
 def _dorebase(ui, repo, action, opts, inmemory=False):
     rbsrt = rebaseruntime(repo, ui, inmemory, opts)
     return _origrebase(ui, repo, action, opts, rbsrt, inmemory=inmemory)
 
 
 def _origrebase(
     ui, repo, action, opts, rbsrt, inmemory=False, leaveunfinished=False
 ):
     assert action != b'stop'
     with repo.wlock(), repo.lock():
         if opts.get(b'interactive'):
             try:
                 if extensions.find(b'histedit'):
                     enablehistedit = b''
             except KeyError:
                 enablehistedit = b" --config extensions.histedit="
             help = b"hg%s help -e histedit" % enablehistedit
             msg = (
                 _(
                     b"interactive history editing is supported by the "
                     b"'histedit' extension (see \"%s\")"
                 )
                 % help
             )
             raise error.Abort(msg)
 
         if rbsrt.collapsemsg and not rbsrt.collapsef:
             raise error.Abort(_(b'message can only be specified with collapse'))
 
         if action:
             if rbsrt.collapsef:
                 raise error.Abort(
                     _(b'cannot use collapse with continue or abort')
                 )
             if action == b'abort' and opts.get(b'tool', False):
                 ui.warn(_(b'tool option will be ignored\n'))
             if action == b'continue':
                 ms = mergemod.mergestate.read(repo)
                 mergeutil.checkunresolved(ms)
 
             retcode = rbsrt._prepareabortorcontinue(
                 isabort=(action == b'abort')
             )
             if retcode is not None:
                 return retcode
         else:
             # search default destination in this space
             # used in the 'hg pull --rebase' case, see issue 5214.
             destspace = opts.get(b'_destspace')
             destmap = _definedestmap(
                 ui,
                 repo,
                 inmemory,
                 opts.get(b'dest', None),
                 opts.get(b'source', None),
                 opts.get(b'base', None),
                 opts.get(b'rev', []),
                 destspace=destspace,
             )
             retcode = rbsrt._preparenewrebase(destmap)
             if retcode is not None:
                 return retcode
             storecollapsemsg(repo, rbsrt.collapsemsg)
 
         tr = None
 
         singletr = ui.configbool(b'rebase', b'singletransaction')
         if singletr:
             tr = repo.transaction(b'rebase')
 
         # If `rebase.singletransaction` is enabled, wrap the entire operation in
         # one transaction here. Otherwise, transactions are obtained when
         # committing each node, which is slower but allows partial success.
         with util.acceptintervention(tr):
             # Same logic for the dirstate guard, except we don't create one when
             # rebasing in-memory (it's not needed).
             dsguard = None
             if singletr and not inmemory:
                 dsguard = dirstateguard.dirstateguard(repo, b'rebase')
             with util.acceptintervention(dsguard):
                 rbsrt._performrebase(tr)
                 if not leaveunfinished:
                     rbsrt._finishrebase()
 
 
 def _definedestmap(
     ui,
     repo,
     inmemory,
     destf=None,
     srcf=None,
     basef=None,
     revf=None,
     destspace=None,
 ):
     """use revisions argument to define destmap {srcrev: destrev}"""
     if revf is None:
         revf = []
 
     # destspace is here to work around issues with `hg pull --rebase` see
     # issue5214 for details
 
     cmdutil.checkunfinished(repo)
     if not inmemory:
         cmdutil.bailifchanged(repo)
 
     if ui.configbool(b'commands', b'rebase.requiredest') and not destf:
         raise error.Abort(
             _(b'you must specify a destination'),
             hint=_(b'use: hg rebase -d REV'),
         )
 
     dest = None
 
     if revf:
         rebaseset = scmutil.revrange(repo, revf)
         if not rebaseset:
             ui.status(_(b'empty "rev" revision set - nothing to rebase\n'))
             return None
     elif srcf:
         src = scmutil.revrange(repo, [srcf])
         if not src:
             ui.status(_(b'empty "source" revision set - nothing to rebase\n'))
             return None
         rebaseset = repo.revs(b'(%ld)::', src) or src
     else:
         base = scmutil.revrange(repo, [basef or b'.'])
         if not base:
             ui.status(
                 _(b'empty "base" revision set - ' b"can't compute rebase set\n")
             )
             return None
         if destf:
             # --base does not support multiple destinations
             dest = scmutil.revsingle(repo, destf)
         else:
             dest = repo[_destrebase(repo, base, destspace=destspace)]
             destf = bytes(dest)
 
         roots = []  # selected children of branching points
         bpbase = {}  # {branchingpoint: [origbase]}
         for b in base:  # group bases by branching points
             bp = repo.revs(b'ancestor(%d, %d)', b, dest.rev()).first()
             bpbase[bp] = bpbase.get(bp, []) + [b]
         if None in bpbase:
             # emulate the old behavior, showing "nothing to rebase" (a better
             # behavior may be abort with "cannot find branching point" error)
             bpbase.clear()
         for bp, bs in pycompat.iteritems(bpbase):  # calculate roots
             roots += list(repo.revs(b'children(%d) & ancestors(%ld)', bp, bs))
 
         rebaseset = repo.revs(b'%ld::', roots)
 
         if not rebaseset:
             # transform to list because smartsets are not comparable to
             # lists. This should be improved to honor laziness of
             # smartset.
             if list(base) == [dest.rev()]:
                 if basef:
                     ui.status(
                         _(
                             b'nothing to rebase - %s is both "base"'
                             b' and destination\n'
                         )
                         % dest
                     )
                 else:
                     ui.status(
                         _(
                             b'nothing to rebase - working directory '
                             b'parent is also destination\n'
                         )
                     )
             elif not repo.revs(b'%ld - ::%d', base, dest.rev()):
                 if basef:
                     ui.status(
                         _(
                             b'nothing to rebase - "base" %s is '
                             b'already an ancestor of destination '
                             b'%s\n'
                         )
                         % (b'+'.join(bytes(repo[r]) for r in base), dest)
                     )
                 else:
                     ui.status(
                         _(
                             b'nothing to rebase - working '
                             b'directory parent is already an '
                             b'ancestor of destination %s\n'
                         )
                         % dest
                     )
             else:  # can it happen?
                 ui.status(
                     _(b'nothing to rebase from %s to %s\n')
                     % (b'+'.join(bytes(repo[r]) for r in base), dest)
                 )
             return None
 
     if nodemod.wdirrev in rebaseset:
         raise error.Abort(_(b'cannot rebase the working copy'))
     rebasingwcp = repo[b'.'].rev() in rebaseset
     ui.log(
         b"rebase",
         b"rebasing working copy parent: %r\n",
         rebasingwcp,
         rebase_rebasing_wcp=rebasingwcp,
     )
     if inmemory and rebasingwcp:
         # Check these since we did not before.
         cmdutil.checkunfinished(repo)
         cmdutil.bailifchanged(repo)
 
     if not destf:
         dest = repo[_destrebase(repo, rebaseset, destspace=destspace)]
         destf = bytes(dest)
 
     allsrc = revsetlang.formatspec(b'%ld', rebaseset)
     alias = {b'ALLSRC': allsrc}
 
     if dest is None:
         try:
             # fast path: try to resolve dest without SRC alias
             dest = scmutil.revsingle(repo, destf, localalias=alias)
         except error.RepoLookupError:
             # multi-dest path: resolve dest for each SRC separately
             destmap = {}
             for r in rebaseset:
                 alias[b'SRC'] = revsetlang.formatspec(b'%d', r)
                 # use repo.anyrevs instead of scmutil.revsingle because we
                 # don't want to abort if destset is empty.
                 destset = repo.anyrevs([destf], user=True, localalias=alias)
                 size = len(destset)
                 if size == 1:
                     destmap[r] = destset.first()
                 elif size == 0:
                     ui.note(_(b'skipping %s - empty destination\n') % repo[r])
                 else:
                     raise error.Abort(
                         _(b'rebase destination for %s is not unique') % repo[r]
                     )
 
     if dest is not None:
         # single-dest case: assign dest to each rev in rebaseset
         destrev = dest.rev()
         destmap = {r: destrev for r in rebaseset}  # {srcrev: destrev}
 
     if not destmap:
         ui.status(_(b'nothing to rebase - empty destination\n'))
         return None
 
     return destmap
 
 
 def externalparent(repo, state, destancestors):
     """Return the revision that should be used as the second parent
     when the revisions in state is collapsed on top of destancestors.
     Abort if there is more than one parent.
     """
     parents = set()
     source = min(state)
     for rev in state:
         if rev == source:
             continue
         for p in repo[rev].parents():
             if p.rev() not in state and p.rev() not in destancestors:
                 parents.add(p.rev())
     if not parents:
         return nullrev
     if len(parents) == 1:
         return parents.pop()
     raise error.Abort(
         _(
             b'unable to collapse on top of %d, there is more '
             b'than one external parent: %s'
         )
         % (max(destancestors), b', '.join(b"%d" % p for p in sorted(parents)))
     )
 
 
 def commitmemorynode(repo, p1, p2, wctx, editor, extra, user, date, commitmsg):
     '''Commit the memory changes with parents p1 and p2.
     Return node of committed revision.'''
     # Replicates the empty check in ``repo.commit``.
     if wctx.isempty() and not repo.ui.configbool(b'ui', b'allowemptycommit'):
         return None
 
     # By convention, ``extra['branch']`` (set by extrafn) clobbers
     # ``branch`` (used when passing ``--keepbranches``).
     branch = None
     if b'branch' in extra:
         branch = extra[b'branch']
 
     wctx.setparents(repo[p1].node(), repo[p2].node())
     memctx = wctx.tomemctx(
         commitmsg,
         date=date,
         extra=extra,
         user=user,
         branch=branch,
         editor=editor,
     )
     commitres = repo.commitctx(memctx)
     wctx.clean()  # Might be reused
     return commitres
 
 
 def commitnode(repo, p1, p2, editor, extra, user, date, commitmsg):
     '''Commit the wd changes with parents p1 and p2.
     Return node of committed revision.'''
     dsguard = util.nullcontextmanager()
     if not repo.ui.configbool(b'rebase', b'singletransaction'):
         dsguard = dirstateguard.dirstateguard(repo, b'rebase')
     with dsguard:
         repo.setparents(repo[p1].node(), repo[p2].node())
 
         # Commit might fail if unresolved files exist
         newnode = repo.commit(
             text=commitmsg, user=user, date=date, extra=extra, editor=editor
         )
 
         repo.dirstate.setbranch(repo[newnode].branch())
         return newnode
 
 
-def rebasenode(repo, rev, p1, base, collapse, dest, wctx):
+def rebasenode(repo, rev, p1, p2, base, collapse, dest, wctx):
     """Rebase a single revision rev on top of p1 using base as merge ancestor"""
     # Merge phase
     # Update to destination and merge it with local
     p1ctx = repo[p1]
     if wctx.isinmemory():
         wctx.setbase(p1ctx)
     else:
         if repo[b'.'].rev() != p1:
             repo.ui.debug(b" update to %d:%s\n" % (p1, p1ctx))
             mergemod.clean_update(p1ctx)
         else:
             repo.ui.debug(b" already in destination\n")
         # This is, alas, necessary to invalidate workingctx's manifest cache,
         # as well as other data we litter on it in other places.
         wctx = repo[None]
         repo.dirstate.write(repo.currenttransaction())
     ctx = repo[rev]
     repo.ui.debug(b" merge against %d:%s\n" % (rev, ctx))
     if base is not None:
         repo.ui.debug(b"   detach base %d:%s\n" % (base, repo[base]))
 
     # See explanation in merge.graft()
     mergeancestor = repo.changelog.isancestor(p1ctx.node(), ctx.node())
     stats = mergemod.update(
         repo,
         rev,
         branchmerge=True,
         force=True,
         ancestor=base,
         mergeancestor=mergeancestor,
         labels=[b'dest', b'source'],
         wc=wctx,
     )
+    wctx.setparents(p1ctx.node(), repo[p2].node())
     if collapse:
         copies.graftcopies(wctx, ctx, repo[dest])
     else:
         # If we're not using --collapse, we need to
         # duplicate copies between the revision we're
         # rebasing and its first parent.
         copies.graftcopies(wctx, ctx, ctx.p1())
     return stats
 
 
 def adjustdest(repo, rev, destmap, state, skipped):
     r"""adjust rebase destination given the current rebase state
 
     rev is what is being rebased. Return a list of two revs, which are the
     adjusted destinations for rev's p1 and p2, respectively. If a parent is
     nullrev, return dest without adjustment for it.
 
     For example, when doing rebasing B+E to F, C to G, rebase will first move B
     to B1, and E's destination will be adjusted from F to B1.
 
         B1 <- written during rebasing B
         |
         F <- original destination of B, E
         |
         | E <- rev, which is being rebased
         | |
         | D <- prev, one parent of rev being checked
         | |
         | x <- skipped, ex. no successor or successor in (::dest)
         | |
         | C <- rebased as C', different destination
         | |
         | B <- rebased as B1     C'
         |/                       |
         A                        G <- destination of C, different
 
     Another example about merge changeset, rebase -r C+G+H -d K, rebase will
     first move C to C1, G to G1, and when it's checking H, the adjusted
     destinations will be [C1, G1].
 
             H       C1 G1
            /|       | /
           F G       |/
         K | |  ->   K
         | C D       |
         | |/        |
         | B         | ...
         |/          |/
         A           A
 
     Besides, adjust dest according to existing rebase information. For example,
 
       B C D    B needs to be rebased on top of C, C needs to be rebased on top
        \|/     of D. We will rebase C first.
         A
 
           C'   After rebasing C, when considering B's destination, use C'
           |    instead of the original C.
       B   D
        \ /
         A
     """
     # pick already rebased revs with same dest from state as interesting source
     dest = destmap[rev]
     source = [
         s
         for s, d in state.items()
         if d > 0 and destmap[s] == dest and s not in skipped
     ]
 
     result = []
     for prev in repo.changelog.parentrevs(rev):
         adjusted = dest
         if prev != nullrev:
             candidate = repo.revs(b'max(%ld and (::%d))', source, prev).first()
             if candidate is not None:
                 adjusted = state[candidate]
         if adjusted == dest and dest in state:
             adjusted = state[dest]
             if adjusted == revtodo:
                 # sortsource should produce an order that makes this impossible
                 raise error.ProgrammingError(
                     b'rev %d should be rebased already at this time' % dest
                 )
         result.append(adjusted)
     return result
 
 
 def _checkobsrebase(repo, ui, rebaseobsrevs, rebaseobsskipped):
     """
     Abort if rebase will create divergence or rebase is noop because of markers
 
     `rebaseobsrevs`: set of obsolete revision in source
     `rebaseobsskipped`: set of revisions from source skipped because they have
     successors in destination or no non-obsolete successor.
     """
     # Obsolete node with successors not in dest leads to divergence
     divergenceok = ui.configbool(b'experimental', b'evolution.allowdivergence')
     divergencebasecandidates = rebaseobsrevs - rebaseobsskipped
 
     if divergencebasecandidates and not divergenceok:
         divhashes = (bytes(repo[r]) for r in divergencebasecandidates)
         msg = _(b"this rebase will cause divergences from: %s")
         h = _(
             b"to force the rebase please set "
             b"experimental.evolution.allowdivergence=True"
         )
         raise error.Abort(msg % (b",".join(divhashes),), hint=h)
 
 
 def successorrevs(unfi, rev):
     """yield revision numbers for successors of rev"""
     assert unfi.filtername is None
     get_rev = unfi.changelog.index.get_rev
     for s in obsutil.allsuccessors(unfi.obsstore, [unfi[rev].node()]):
         r = get_rev(s)
         if r is not None:
             yield r
 
 
 def defineparents(repo, rev, destmap, state, skipped, obsskipped):
     """Return new parents and optionally a merge base for rev being rebased
 
     The destination specified by "dest" cannot always be used directly because
     previously rebase result could affect destination. For example,
 
           D E    rebase -r C+D+E -d B
           |/     C will be rebased to C'
         B C      D's new destination will be C' instead of B
         |/       E's new destination will be C' instead of B
         A
 
     The new parents of a merge is slightly more complicated. See the comment
     block below.
     """
     # use unfiltered changelog since successorrevs may return filtered nodes
     assert repo.filtername is None
     cl = repo.changelog
     isancestor = cl.isancestorrev
 
     dest = destmap[rev]
     oldps = repo.changelog.parentrevs(rev)  # old parents
     newps = [nullrev, nullrev]  # new parents
     dests = adjustdest(repo, rev, destmap, state, skipped)
     bases = list(oldps)  # merge base candidates, initially just old parents
 
     if all(r == nullrev for r in oldps[1:]):
         # For non-merge changeset, just move p to adjusted dest as requested.
         newps[0] = dests[0]
     else:
         # For merge changeset, if we move p to dests[i] unconditionally, both
         # parents may change and the end result looks like "the merge loses a
         # parent", which is a surprise. This is a limit because "--dest" only
         # accepts one dest per src.
         #
         # Therefore, only move p with reasonable conditions (in this order):
         #   1. use dest, if dest is a descendent of (p or one of p's successors)
         #   2. use p's rebased result, if p is rebased (state[p] > 0)
         #
         # Comparing with adjustdest, the logic here does some additional work:
         #   1. decide which parents will not be moved towards dest
         #   2. if the above decision is "no", should a parent still be moved
         #      because it was rebased?
         #
         # For example:
         #
         #     C    # "rebase -r C -d D" is an error since none of the parents
         #    /|    # can be moved. "rebase -r B+C -d D" will move C's parent
         #   A B D  # B (using rule "2."), since B will be rebased.
         #
         # The loop tries to be not rely on the fact that a Mercurial node has
         # at most 2 parents.
         for i, p in enumerate(oldps):
             np = p  # new parent
             if any(isancestor(x, dests[i]) for x in successorrevs(repo, p)):
                 np = dests[i]
             elif p in state and state[p] > 0:
                 np = state[p]
 
             # If one parent becomes an ancestor of the other, drop the ancestor
             for j, x in enumerate(newps[:i]):
                 if x == nullrev:
                     continue
                 if isancestor(np, x):  # CASE-1
                     np = nullrev
                 elif isancestor(x, np):  # CASE-2
                     newps[j] = np
                     np = nullrev
                     # New parents forming an ancestor relationship does not
                     # mean the old parents have a similar relationship. Do not
                     # set bases[x] to nullrev.
                     bases[j], bases[i] = bases[i], bases[j]
 
             newps[i] = np
 
         # "rebasenode" updates to new p1, and the old p1 will be used as merge
         # base. If only p2 changes, merging using unchanged p1 as merge base is
         # suboptimal. Therefore swap parents to make the merge sane.
         if newps[1] != nullrev and oldps[0] == newps[0]:
             assert len(newps) == 2 and len(oldps) == 2
             newps.reverse()
             bases.reverse()
 
         # No parent change might be an error because we fail to make rev a
         # descendent of requested dest. This can happen, for example:
         #
         #     C    # rebase -r C -d D
         #    /|    # None of A and B will be changed to D and rebase fails.
         #   A B D
         if set(newps) == set(oldps) and dest not in newps:
             raise error.Abort(
                 _(
                     b'cannot rebase %d:%s without '
                     b'moving at least one of its parents'
                 )
                 % (rev, repo[rev])
             )
 
     # Source should not be ancestor of dest. The check here guarantees it's
     # impossible. With multi-dest, the initial check does not cover complex
     # cases since we don't have abstractions to dry-run rebase cheaply.
     if any(p != nullrev and isancestor(rev, p) for p in newps):
         raise error.Abort(_(b'source is ancestor of destination'))
 
     # Check if the merge will contain unwanted changes. That may happen if
     # there are multiple special (non-changelog ancestor) merge bases, which
     # cannot be handled well by the 3-way merge algorithm. For example:
     #
     #     F
     #    /|
     #   D E  # "rebase -r D+E+F -d Z", when rebasing F, if "D" was chosen
     #   | |  # as merge base, the difference between D and F will include
     #   B C  # C, so the rebased F will contain C surprisingly. If "E" was
     #   |/   #  chosen, the rebased F will contain B.
     #   A Z
     #
     # But our merge base candidates (D and E in above case) could still be
     # better than the default (ancestor(F, Z) == null). Therefore still
     # pick one (so choose p1 above).
     if sum(1 for b in set(bases) if b != nullrev and b not in newps) > 1:
         unwanted = [None, None]  # unwanted[i]: unwanted revs if choose bases[i]
         for i, base in enumerate(bases):
             if base == nullrev or base in newps:
                 continue
             # Revisions in the side (not chosen as merge base) branch that
             # might contain "surprising" contents
             other_bases = set(bases) - {base}
             siderevs = list(
                 repo.revs(b'(%ld %% (%d+%d))', other_bases, base, dest)
             )
 
             # If those revisions are covered by rebaseset, the result is good.
             # A merge in rebaseset would be considered to cover its ancestors.
             if siderevs:
                 rebaseset = [
                     r for r, d in state.items() if d > 0 and r not in obsskipped
                 ]
                 merges = [
                     r for r in rebaseset if cl.parentrevs(r)[1] != nullrev
                 ]
                 unwanted[i] = list(
                     repo.revs(
                         b'%ld - (::%ld) - %ld', siderevs, merges, rebaseset
                     )
                 )
 
         if any(revs is not None for revs in unwanted):
             # Choose a merge base that has a minimal number of unwanted revs.
             l, i = min(
                 (len(revs), i)
                 for i, revs in enumerate(unwanted)
                 if revs is not None
             )
 
             # The merge will include unwanted revisions. Abort now. Revisit this if
             # we have a more advanced merge algorithm that handles multiple bases.
             if l > 0:
                 unwanteddesc = _(b' or ').join(
                     (
                         b', '.join(b'%d:%s' % (r, repo[r]) for r in revs)
                         for revs in unwanted
                         if revs is not None
                     )
                 )
                 raise error.Abort(
                     _(b'rebasing %d:%s will include unwanted changes from %s')
                     % (rev, repo[rev], unwanteddesc)
                 )
 
             # newps[0] should match merge base if possible. Currently, if newps[i]
             # is nullrev, the only case is newps[i] and newps[j] (j < i), one is
             # the other's ancestor. In that case, it's fine to not swap newps here.
             # (see CASE-1 and CASE-2 above)
             if i != 0:
                 if newps[i] != nullrev:
                     newps[0], newps[i] = newps[i], newps[0]
                 bases[0], bases[i] = bases[i], bases[0]
 
     # "rebasenode" updates to new p1, use the corresponding merge base.
     base = bases[0]
 
     repo.ui.debug(b" future parents are %d and %d\n" % tuple(newps))
 
     return newps[0], newps[1], base
 
 
 def isagitpatch(repo, patchname):
     """Return true if the given patch is in git format"""
     mqpatch = os.path.join(repo.mq.path, patchname)
     for line in patch.linereader(open(mqpatch, b'rb')):
         if line.startswith(b'diff --git'):
             return True
     return False
 
 
 def updatemq(repo, state, skipped, **opts):
     """Update rebased mq patches - finalize and then import them"""
     mqrebase = {}
     mq = repo.mq
     original_series = mq.fullseries[:]
     skippedpatches = set()
 
     for p in mq.applied:
         rev = repo[p.node].rev()
         if rev in state:
             repo.ui.debug(
                 b'revision %d is an mq patch (%s), finalize it.\n'
                 % (rev, p.name)
             )
             mqrebase[rev] = (p.name, isagitpatch(repo, p.name))
         else:
             # Applied but not rebased, not sure this should happen
             skippedpatches.add(p.name)
 
     if mqrebase:
         mq.finish(repo, mqrebase.keys())
 
         # We must start import from the newest revision
         for rev in sorted(mqrebase, reverse=True):
             if rev not in skipped:
                 name, isgit = mqrebase[rev]
                 repo.ui.note(
                     _(b'updating mq patch %s to %d:%s\n')
                     % (name, state[rev], repo[state[rev]])
                 )
                 mq.qimport(
                     repo,
                     (),
                     patchname=name,
                     git=isgit,
                     rev=[b"%d" % state[rev]],
                 )
             else:
                 # Rebased and skipped
                 skippedpatches.add(mqrebase[rev][0])
 
         # Patches were either applied and rebased and imported in
         # order, applied and removed or unapplied. Discard the removed
         # ones while preserving the original series order and guards.
         newseries = [
             s
             for s in original_series
             if mq.guard_re.split(s, 1)[0] not in skippedpatches
         ]
         mq.fullseries[:] = newseries
         mq.seriesdirty = True
         mq.savedirty()
 
 
 def storecollapsemsg(repo, collapsemsg):
     """Store the collapse message to allow recovery"""
     collapsemsg = collapsemsg or b''
     f = repo.vfs(b"last-message.txt", b"w")
     f.write(b"%s\n" % collapsemsg)
     f.close()
 
 
 def clearcollapsemsg(repo):
     """Remove collapse message file"""
     repo.vfs.unlinkpath(b"last-message.txt", ignoremissing=True)
 
 
 def restorecollapsemsg(repo, isabort):
     """Restore previously stored collapse message"""
     try:
         f = repo.vfs(b"last-message.txt")
         collapsemsg = f.readline().strip()
         f.close()
     except IOError as err:
         if err.errno != errno.ENOENT:
             raise
         if isabort:
             # Oh well, just abort like normal
             collapsemsg = b''
         else:
             raise error.Abort(_(b'missing .hg/last-message.txt for rebase'))
     return collapsemsg
 
 
 def clearstatus(repo):
     """Remove the status files"""
     # Make sure the active transaction won't write the state file
     tr = repo.currenttransaction()
     if tr:
         tr.removefilegenerator(b'rebasestate')
     repo.vfs.unlinkpath(b"rebasestate", ignoremissing=True)
 
 
 def sortsource(destmap):
     """yield source revisions in an order that we only rebase things once
 
     If source and destination overlaps, we should filter out revisions
     depending on other revisions which hasn't been rebased yet.
 
     Yield a sorted list of revisions each time.
 
     For example, when rebasing A to B, B to C. This function yields [B], then
     [A], indicating B needs to be rebased first.
 
     Raise if there is a cycle so the rebase is impossible.
     """
     srcset = set(destmap)
     while srcset:
         srclist = sorted(srcset)
         result = []
         for r in srclist:
             if destmap[r] not in srcset:
                 result.append(r)
         if not result:
             raise error.Abort(_(b'source and destination form a cycle'))
         srcset -= set(result)
         yield result
 
 
 def buildstate(repo, destmap, collapse):
     '''Define which revisions are going to be rebased and where
 
     repo: repo
     destmap: {srcrev: destrev}
     '''
     rebaseset = destmap.keys()
     originalwd = repo[b'.'].rev()
 
     # This check isn't strictly necessary, since mq detects commits over an
     # applied patch. But it prevents messing up the working directory when
     # a partially completed rebase is blocked by mq.
     if b'qtip' in repo.tags():
         mqapplied = set(repo[s.node].rev() for s in repo.mq.applied)
         if set(destmap.values()) & mqapplied:
             raise error.Abort(_(b'cannot rebase onto an applied mq patch'))
 
     # Get "cycle" error early by exhausting the generator.
     sortedsrc = list(sortsource(destmap))  # a list of sorted revs
     if not sortedsrc:
         raise error.Abort(_(b'no matching revisions'))
 
     # Only check the first batch of revisions to rebase not depending on other
     # rebaseset. This means "source is ancestor of destination" for the second
     # (and following) batches of revisions are not checked here. We rely on
     # "defineparents" to do that check.
     roots = list(repo.set(b'roots(%ld)', sortedsrc[0]))
     if not roots:
         raise error.Abort(_(b'no matching revisions'))
 
     def revof(r):
         return r.rev()
 
     roots = sorted(roots, key=revof)
     state = dict.fromkeys(rebaseset, revtodo)
     emptyrebase = len(sortedsrc) == 1
     for root in roots:
         dest = repo[destmap[root.rev()]]
         commonbase = root.ancestor(dest)
         if commonbase == root:
             raise error.Abort(_(b'source is ancestor of destination'))
         if commonbase == dest:
             wctx = repo[None]
             if dest == wctx.p1():
                 # when rebasing to '.', it will use the current wd branch name
                 samebranch = root.branch() == wctx.branch()
             else:
                 samebranch = root.branch() == dest.branch()
             if not collapse and samebranch and dest in root.parents():
                 # mark the revision as done by setting its new revision
                 # equal to its old (current) revisions
                 state[root.rev()] = root.rev()
                 repo.ui.debug(b'source is a child of destination\n')
                 continue
 
         emptyrebase = False
         repo.ui.debug(b'rebase onto %s starting from %s\n' % (dest, root))
     if emptyrebase:
         return None
     for rev in sorted(state):
         parents = [p for p in repo.changelog.parentrevs(rev) if p != nullrev]
         # if all parents of this revision are done, then so is this revision
         if parents and all((state.get(p) == p for p in parents)):
             state[rev] = rev
     return originalwd, destmap, state
 
 
 def clearrebased(
     ui,
     repo,
     destmap,
     state,
     skipped,
     collapsedas=None,
     keepf=False,
     fm=None,
     backup=True,
 ):
     """dispose of rebased revision at the end of the rebase
 
     If `collapsedas` is not None, the rebase was a collapse whose result if the
     `collapsedas` node.
 
     If `keepf` is not True, the rebase has --keep set and no nodes should be
     removed (but bookmarks still need to be moved).
 
     If `backup` is False, no backup will be stored when stripping rebased
     revisions.
     """
     tonode = repo.changelog.node
     replacements = {}
     moves = {}
     stripcleanup = not obsolete.isenabled(repo, obsolete.createmarkersopt)
 
     collapsednodes = []
     for rev, newrev in sorted(state.items()):
         if newrev >= 0 and newrev != rev:
             oldnode = tonode(rev)
             newnode = collapsedas or tonode(newrev)
             moves[oldnode] = newnode
             succs = None
             if rev in skipped:
                 if stripcleanup or not repo[rev].obsolete():
                     succs = ()
             elif collapsedas:
                 collapsednodes.append(oldnode)
             else:
                 succs = (newnode,)
             if succs is not None:
                 replacements[(oldnode,)] = succs
     if collapsednodes:
         replacements[tuple(collapsednodes)] = (collapsedas,)
     if fm:
         hf = fm.hexfunc
         fl = fm.formatlist
         fd = fm.formatdict
         changes = {}
         for oldns, newn in pycompat.iteritems(replacements):
             for oldn in oldns:
                 changes[hf(oldn)] = fl([hf(n) for n in newn], name=b'node')
         nodechanges = fd(changes, key=b"oldnode", value=b"newnodes")
         fm.data(nodechanges=nodechanges)
     if keepf:
         replacements = {}
     scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup)
 
 
 def pullrebase(orig, ui, repo, *args, **opts):
     """Call rebase after pull if the latter has been invoked with --rebase"""
     if opts.get('rebase'):
         if ui.configbool(b'commands', b'rebase.requiredest'):
             msg = _(b'rebase destination required by configuration')
             hint = _(b'use hg pull followed by hg rebase -d DEST')
             raise error.Abort(msg, hint=hint)
 
         with repo.wlock(), repo.lock():
             if opts.get('update'):
                 del opts['update']
                 ui.debug(
                     b'--update and --rebase are not compatible, ignoring '
                     b'the update flag\n'
                 )
 
             cmdutil.checkunfinished(repo, skipmerge=True)
             cmdutil.bailifchanged(
                 repo,
                 hint=_(
                     b'cannot pull with rebase: '
                     b'please commit or shelve your changes first'
                 ),
             )
 
             revsprepull = len(repo)
             origpostincoming = commands.postincoming
 
             def _dummy(*args, **kwargs):
                 pass
 
             commands.postincoming = _dummy
             try:
                 ret = orig(ui, repo, *args, **opts)
             finally:
                 commands.postincoming = origpostincoming
             revspostpull = len(repo)
             if revspostpull > revsprepull:
                 # --rev option from pull conflict with rebase own --rev
                 # dropping it
                 if 'rev' in opts:
                     del opts['rev']
                 # positional argument from pull conflicts with rebase's own
                 # --source.
                 if 'source' in opts:
                     del opts['source']
                 # revsprepull is the len of the repo, not revnum of tip.
                 destspace = list(repo.changelog.revs(start=revsprepull))
                 opts['_destspace'] = destspace
                 try:
                     rebase(ui, repo, **opts)
                 except error.NoMergeDestAbort:
                     # we can maybe update instead
                     rev, _a, _b = destutil.destupdate(repo)
                     if rev == repo[b'.'].rev():
                         ui.status(_(b'nothing to rebase\n'))
                     else:
                         ui.status(_(b'nothing to rebase - updating instead\n'))
                         # not passing argument to get the bare update behavior
                         # with warning and trumpets
                         commands.update(ui, repo)
     else:
         if opts.get('tool'):
             raise error.Abort(_(b'--tool can only be used with --rebase'))
         ret = orig(ui, repo, *args, **opts)
 
     return ret
 
 
 def _filterobsoleterevs(repo, revs):
     """returns a set of the obsolete revisions in revs"""
     return set(r for r in revs if repo[r].obsolete())
 
 
 def _computeobsoletenotrebased(repo, rebaseobsrevs, destmap):
     """Return (obsoletenotrebased, obsoletewithoutsuccessorindestination).
 
     `obsoletenotrebased` is a mapping mapping obsolete => successor for all
     obsolete nodes to be rebased given in `rebaseobsrevs`.
 
     `obsoletewithoutsuccessorindestination` is a set with obsolete revisions
     without a successor in destination.
 
     `obsoleteextinctsuccessors` is a set of obsolete revisions with only
     obsolete successors.
     """
     obsoletenotrebased = {}
     obsoletewithoutsuccessorindestination = set()
     obsoleteextinctsuccessors = set()
 
     assert repo.filtername is None
     cl = repo.changelog
     get_rev = cl.index.get_rev
     extinctrevs = set(repo.revs(b'extinct()'))
     for srcrev in rebaseobsrevs:
         srcnode = cl.node(srcrev)
         # XXX: more advanced APIs are required to handle split correctly
         successors = set(obsutil.allsuccessors(repo.obsstore, [srcnode]))
         # obsutil.allsuccessors includes node itself
         successors.remove(srcnode)
         succrevs = {get_rev(s) for s in successors}
         succrevs.discard(None)
         if succrevs.issubset(extinctrevs):
             # all successors are extinct
             obsoleteextinctsuccessors.add(srcrev)
         if not successors:
             # no successor
             obsoletenotrebased[srcrev] = None
         else:
             dstrev = destmap[srcrev]
             for succrev in succrevs:
                 if cl.isancestorrev(succrev, dstrev):
                     obsoletenotrebased[srcrev] = succrev
                     break
             else:
                 # If 'srcrev' has a successor in rebase set but none in
                 # destination (which would be catched above), we shall skip it
                 # and its descendants to avoid divergence.
                 if srcrev in extinctrevs or any(s in destmap for s in succrevs):
                     obsoletewithoutsuccessorindestination.add(srcrev)
 
     return (
         obsoletenotrebased,
         obsoletewithoutsuccessorindestination,
         obsoleteextinctsuccessors,
     )
 
 
 def abortrebase(ui, repo):
     with repo.wlock(), repo.lock():
         rbsrt = rebaseruntime(repo, ui)
         rbsrt._prepareabortorcontinue(isabort=True)
 
 
 def continuerebase(ui, repo):
     with repo.wlock(), repo.lock():
         rbsrt = rebaseruntime(repo, ui)
         ms = mergemod.mergestate.read(repo)
         mergeutil.checkunresolved(ms)
         retcode = rbsrt._prepareabortorcontinue(isabort=False)
         if retcode is not None:
             return retcode
         rbsrt._performrebase(None)
         rbsrt._finishrebase()
 
 
 def summaryhook(ui, repo):
     if not repo.vfs.exists(b'rebasestate'):
         return
     try:
         rbsrt = rebaseruntime(repo, ui, {})
         rbsrt.restorestatus()
         state = rbsrt.state
     except error.RepoLookupError:
         # i18n: column positioning for "hg summary"
         msg = _(b'rebase: (use "hg rebase --abort" to clear broken state)\n')
         ui.write(msg)
         return
     numrebased = len([i for i in pycompat.itervalues(state) if i >= 0])
     # i18n: column positioning for "hg summary"
     ui.write(
         _(b'rebase: %s, %s (rebase --continue)\n')
         % (
             ui.label(_(b'%d rebased'), b'rebase.rebased') % numrebased,
             ui.label(_(b'%d remaining'), b'rebase.remaining')
             % (len(state) - numrebased),
         )
     )
 
 
 def uisetup(ui):
     # Replace pull with a decorator to provide --rebase option
     entry = extensions.wrapcommand(commands.table, b'pull', pullrebase)
     entry[1].append(
         (b'', b'rebase', None, _(b"rebase working directory to branch head"))
     )
     entry[1].append((b't', b'tool', b'', _(b"specify merge tool for rebase")))
     cmdutil.summaryhooks.add(b'rebase', summaryhook)
     statemod.addunfinished(
         b'rebase',
         fname=b'rebasestate',
         stopflag=True,
         continueflag=True,
         abortfunc=abortrebase,
         continuefunc=continuerebase,
     )

relnotes/next

@@ -1,34 +1,39 b''
 == New Features ==
 
  * `hg purge`/`hg clean` can now delete ignored files instead of
    untracked files, with the new -i flag.
 
  * `hg log` now defaults to using an '%' symbol for commits involved
     in unresolved merge conflicts. That includes unresolved conflicts
     caused by e.g. `hg update --merge` and `hg graft`. '@' still takes
     precedence, so what used to be marked '@' still is.
 
  * New `conflictlocal()` and `conflictother()` revsets return the
    commits that are being merged, when there are conflicts. Also works
    for conflicts caused by e.g. `hg graft`.
 
 
 == New Experimental Features ==
 
 
 == Bug Fixes  ==
 
 
 == Backwards Compatibility Changes ==
 
+ * When `hg rebase` pauses for merge conflict resolution, the working
+   copy will no longer have the rebased node as a second parent. You
+   can use the new `conflictparents()` revset for finding the other
+   parent during a conflict.
+
 
 == Internal API Changes ==
 
  * The deprecated `ui.progress()` has now been deleted. Please use
    `ui.makeprogress()` instead.
 
  * `hg.merge()` has lost its `abort` argument. Please call
    `hg.abortmerge()` directly instead.
 
  * The `*others` argument of `cmdutil.check_incompatible_arguments()`
    changed from being varargs argument to being a single collection.

tests/test-rebase-abort.t

@@ -1,525 +1,525 b''
 #testcases abortcommand abortflag
 #testcases continuecommand continueflag
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}:{phase} '{desc}' {branches}\n"
   > EOF
 
 #if abortflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > abort = rebase --abort
   > EOF
 #endif
 
 #if continueflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > continue = rebase --continue
   > EOF
 #endif
 
   $ hg init a
   $ cd a
 
   $ touch .hg/rebasestate
   $ hg sum
   parent: -1:000000000000 tip (empty repository)
   branch: default
   commit: (clean)
   update: (current)
   abort: .hg/rebasestate is incomplete
   [255]
   $ rm .hg/rebasestate
 
   $ echo c1 > common
   $ hg add common
   $ hg ci -m C1
 
   $ echo c2 >> common
   $ hg ci -m C2
 
   $ echo c3 >> common
   $ hg ci -m C3
 
   $ hg up -q -C 1
 
   $ echo l1 >> extra
   $ hg add extra
   $ hg ci -m L1
   created new head
 
   $ sed -e 's/c2/l2/' common > common.new
   $ mv common.new common
   $ hg ci -m L2
 
   $ hg phase --force --secret 2
 
   $ hg tglog
   @  4:draft 'L2'
   |
   o  3:draft 'L1'
   |
   | o  2:secret 'C3'
   |/
   o  1:draft 'C2'
   |
   o  0:draft 'C1'
   
 
 Conflicting rebase:
 
   $ hg rebase -s 3 -d 2
   rebasing 3:3163e20567cc "L1"
   rebasing 4:46f0b057b5c0 "L2" (tip)
   merging common
   warning: conflicts while merging common! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
 Insert unsupported advisory merge record:
 
   $ hg --config extensions.fakemergerecord=$TESTDIR/fakemergerecord.py fakemergerecord -x
   $ hg debugmergestate
   * version 2 records
   local: 3e046f2ecedb793b97ed32108086edd1a162f8bc
   other: 46f0b057b5c061d276b91491c22151f78698abd2
   labels:
     local: dest
     other: source
   unrecognized entry: x	advisory record
   file extras: common (ancestorlinknode = 3163e20567cc93074fbb7a53c8b93312e59dbf2c)
   file: common (record type "F", state "u", hash 94c8c21d08740f5da9eaa38d1f175c592692f0d1)
     local path: common (flags "")
     ancestor path: common (node de0a666fdd9c1a0b0698b90d85064d8bd34f74b6)
     other path: common (node 2f6411de53677f6f1048fef5bf888d67a342e0a5)
   $ hg resolve -l
   U common
 
 Insert unsupported mandatory merge record:
 
   $ hg --config extensions.fakemergerecord=$TESTDIR/fakemergerecord.py fakemergerecord -X
   $ hg debugmergestate
   * version 2 records
   local: 3e046f2ecedb793b97ed32108086edd1a162f8bc
   other: 46f0b057b5c061d276b91491c22151f78698abd2
   labels:
     local: dest
     other: source
   file extras: common (ancestorlinknode = 3163e20567cc93074fbb7a53c8b93312e59dbf2c)
   file: common (record type "F", state "u", hash 94c8c21d08740f5da9eaa38d1f175c592692f0d1)
     local path: common (flags "")
     ancestor path: common (node de0a666fdd9c1a0b0698b90d85064d8bd34f74b6)
     other path: common (node 2f6411de53677f6f1048fef5bf888d67a342e0a5)
   unrecognized entry: X	mandatory record
   $ hg resolve -l
   abort: unsupported merge state records: X
   (see https://mercurial-scm.org/wiki/MergeStateRecords for more information)
   [255]
   $ hg resolve -ma
   abort: unsupported merge state records: X
   (see https://mercurial-scm.org/wiki/MergeStateRecords for more information)
   [255]
 
 Abort (should clear out unsupported merge state):
 
 #if abortcommand
 when in dry-run mode
   $ hg abort --dry-run
   rebase in progress, will be aborted
 #endif
 
   $ hg abort
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/3e046f2ecedb-6beef7d5-backup.hg
   rebase aborted
   $ hg debugmergestate
   no merge state found
 
   $ hg tglog
   @  4:draft 'L2'
   |
   o  3:draft 'L1'
   |
   | o  2:secret 'C3'
   |/
   o  1:draft 'C2'
   |
   o  0:draft 'C1'
   
 Test safety for inconsistent rebase state, which may be created (and
 forgotten) by Mercurial earlier than 2.7. This emulates Mercurial
 earlier than 2.7 by renaming ".hg/rebasestate" temporarily.
 
   $ hg rebase -s 3 -d 2
   rebasing 3:3163e20567cc "L1"
   rebasing 4:46f0b057b5c0 "L2" (tip)
   merging common
   warning: conflicts while merging common! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ mv .hg/rebasestate .hg/rebasestate.back
   $ hg update --quiet --clean 2
   $ hg --config extensions.mq= strip --quiet "destination()"
   $ mv .hg/rebasestate.back .hg/rebasestate
 
   $ hg continue
   abort: cannot continue inconsistent rebase
   (use "hg rebase --abort" to clear broken state)
   [255]
   $ hg summary | grep '^rebase: '
   rebase: (use "hg rebase --abort" to clear broken state)
   $ hg abort
   rebase aborted (no revision is removed, only broken state is cleared)
 
   $ cd ..
 
 
 Construct new repo:
 
   $ hg init b
   $ cd b
 
   $ echo a > a
   $ hg ci -Am A
   adding a
 
   $ echo b > b
   $ hg ci -Am B
   adding b
 
   $ echo c > c
   $ hg ci -Am C
   adding c
 
   $ hg up -q 0
 
   $ echo b > b
   $ hg ci -Am 'B bis'
   adding b
   created new head
 
   $ echo c1 > c
   $ hg ci -Am C1
   adding c
 
   $ hg phase --force --secret 1
   $ hg phase --public 1
 
 Rebase and abort without generating new changesets:
 
   $ hg tglog
   @  4:draft 'C1'
   |
   o  3:draft 'B bis'
   |
   | o  2:secret 'C'
   | |
   | o  1:public 'B'
   |/
   o  0:public 'A'
   
   $ hg rebase -b 4 -d 2
   rebasing 3:a6484957d6b9 "B bis"
   note: not rebasing 3:a6484957d6b9 "B bis", its destination already has all its changes
   rebasing 4:145842775fec "C1" (tip)
   merging c
   warning: conflicts while merging c! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ hg tglog
-  @  4:draft 'C1'
+  %  4:draft 'C1'
   |
   o  3:draft 'B bis'
   |
   | @  2:secret 'C'
   | |
   | o  1:public 'B'
   |/
   o  0:public 'A'
   
   $ hg rebase -a
   rebase aborted
 
   $ hg tglog
   @  4:draft 'C1'
   |
   o  3:draft 'B bis'
   |
   | o  2:secret 'C'
   | |
   | o  1:public 'B'
   |/
   o  0:public 'A'
   
 
   $ cd ..
 
 rebase abort should not leave working copy in a merge state if tip-1 is public
 (issue4082)
 
   $ hg init abortpublic
   $ cd abortpublic
   $ echo a > a && hg ci -Aqm a
   $ hg book master
   $ hg book foo
   $ echo b > b && hg ci -Aqm b
   $ hg up -q master
   $ echo c > c && hg ci -Aqm c
   $ hg phase -p -r .
   $ hg up -q foo
   $ echo C > c && hg ci -Aqm C
   $ hg log -G --template "{rev} {desc} {bookmarks}"
   @  3 C foo
   |
   | o  2 c master
   | |
   o |  1 b
   |/
   o  0 a
   
 
   $ hg rebase -d master -r foo
   rebasing 3:6c0f977a22d8 "C" (foo tip)
   merging c
   warning: conflicts while merging c! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg abort
   rebase aborted
   $ hg log -G --template "{rev} {desc} {bookmarks}"
   @  3 C foo
   |
   | o  2 c master
   | |
   o |  1 b
   |/
   o  0 a
   
   $ cd ..
 
 Make sure we don't clobber changes in the working directory when the
 user has somehow managed to update to a different revision (issue4009)
 
   $ hg init noupdate
   $ cd noupdate
   $ hg book @
   $ echo original > a
   $ hg add a
   $ hg commit -m a
   $ echo x > b
   $ hg add b
   $ hg commit -m b1
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (leaving bookmark @)
   $ hg book foo
   $ echo y > b
   $ hg add b
   $ hg commit -m b2
   created new head
 
   $ hg rebase -d @ -b foo --tool=internal:fail
   rebasing 2:070cf4580bb5 "b2" (foo tip)
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ mv .hg/rebasestate ./ # so we're allowed to hg up like in mercurial <2.6.3
   $ hg up -C 0            # user does other stuff in the repo
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ mv rebasestate .hg/   # user upgrades to 2.7
 
   $ echo new > a
   $ hg up 1               # user gets an error saying to run hg rebase --abort
   abort: rebase in progress
   (use 'hg rebase --continue' or 'hg rebase --abort')
   [255]
 
   $ cat a
   new
   $ hg abort
   rebase aborted
   $ cat a
   new
 
   $ cd ..
 
 test aborting an interrupted series (issue5084)
   $ hg init interrupted
   $ cd interrupted
   $ touch base
   $ hg add base
   $ hg commit -m base
   $ touch a
   $ hg add a
   $ hg commit -m a
   $ echo 1 > a
   $ hg commit -m 1
   $ touch b
   $ hg add b
   $ hg commit -m b
   $ echo 2 >> a
   $ hg commit -m c
   $ touch d
   $ hg add d
   $ hg commit -m d
   $ hg co -q 1
   $ hg rm a
   $ hg commit -m no-a
   created new head
   $ hg co 0
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -G --template "{rev} {desc} {bookmarks}"
   o  6 no-a
   |
   | o  5 d
   | |
   | o  4 c
   | |
   | o  3 b
   | |
   | o  2 1
   |/
   o  1 a
   |
   @  0 base
   
   $ hg --config extensions.n=$TESTDIR/failfilemerge.py rebase -s 3 -d tip
   rebasing 3:3a71550954f1 "b"
   rebasing 4:e80b69427d80 "c"
   abort: ^C
   [255]
 
 New operations are blocked with the correct state message
 
   $ find .hg -name '*state' -prune | sort
   .hg/dirstate
   .hg/merge/state
   .hg/rebasestate
   .hg/undo.backup.dirstate
   .hg/undo.dirstate
   .hg/updatestate
 
   $ hg rebase -s 3 -d tip
   abort: rebase in progress
   (use 'hg rebase --continue' or 'hg rebase --abort')
   [255]
   $ hg up .
   abort: rebase in progress
   (use 'hg rebase --continue' or 'hg rebase --abort')
   [255]
   $ hg up -C .
   abort: rebase in progress
   (use 'hg rebase --continue' or 'hg rebase --abort')
   [255]
 
   $ hg graft 3
   abort: rebase in progress
   (use 'hg rebase --continue' or 'hg rebase --abort')
   [255]
 
   $ hg abort
   saved backup bundle to $TESTTMP/interrupted/.hg/strip-backup/3d8812cf300d-93041a90-backup.hg
   rebase aborted
   $ hg log -G --template "{rev} {desc} {bookmarks}"
   o  6 no-a
   |
   | o  5 d
   | |
   | o  4 c
   | |
   | o  3 b
   | |
   | o  2 1
   |/
   o  1 a
   |
   @  0 base
   
   $ hg summary
   parent: 0:df4f53cec30a 
    base
   branch: default
   commit: (clean)
   update: 6 new changesets (update)
   phases: 7 draft
 
   $ cd ..
 On the other hand, make sure we *do* clobber changes whenever we
 haven't somehow managed to update the repo to a different revision
 during a rebase (issue4661)
 
   $ hg ini yesupdate
   $ cd yesupdate
   $ echo "initial data" > foo.txt
   $ hg add
   adding foo.txt
   $ hg ci -m "initial checkin"
   $ echo "change 1" > foo.txt
   $ hg ci -m "change 1"
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo "conflicting change 1" > foo.txt
   $ hg ci -m "conflicting 1"
   created new head
   $ echo "conflicting change 2" > foo.txt
   $ hg ci -m "conflicting 2"
 
   $ hg rebase -d 1 --tool 'internal:fail'
   rebasing 2:e4ea5cdc9789 "conflicting 1"
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg abort
   rebase aborted
   $ hg summary
   parent: 3:b16646383533 tip
    conflicting 2
   branch: default
   commit: (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 4 draft
   $ cd ..
 
 test aborting a rebase succeeds after rebasing with skipped commits onto a
 public changeset (issue4896)
 
   $ hg init succeedonpublic
   $ cd succeedonpublic
   $ echo 'content' > root
   $ hg commit -A -m 'root' -q
 
 set up public branch
   $ echo 'content' > disappear
   $ hg commit -A -m 'disappear public' -q
 commit will cause merge conflict on rebase
   $ echo '' > root
   $ hg commit -m 'remove content public' -q
   $ hg phase --public
 
 setup the draft branch that will be rebased onto public commit
   $ hg up -r 0 -q
   $ echo 'content' > disappear
 commit will disappear
   $ hg commit -A -m 'disappear draft' -q
   $ echo 'addedcontADDEDentadded' > root
 commit will cause merge conflict on rebase
   $ hg commit -m 'add content draft' -q
 
   $ hg rebase -d 'public()' --tool :merge -q
   note: not rebasing 3:0682fd3dabf5 "disappear draft", its destination already has all its changes
   warning: conflicts while merging root! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg abort
   rebase aborted
   $ cd ..
 

tests/test-rebase-collapse.t

@@ -1,776 +1,776 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > mq=
   > drawdag=$TESTDIR/drawdag.py
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: {node|short} '{desc}' {branches}\n"
   > tglogp = log -G --template "{rev}: {node|short} {phase} '{desc}' {branches}\n"
   > EOF
 
 Highest phase of source commits is used:
 
   $ hg init phase
   $ cd phase
   $ hg debugdrawdag << 'EOF'
   >   D
   >   |
   > F C
   > | |
   > E B
   > |/
   > A
   > EOF
 
   $ hg phase --force --secret D
 
   $ cat > $TESTTMP/editor.sh <<EOF
   > echo "==== before editing"
   > cat \$1
   > echo "===="
   > echo "edited manually" >> \$1
   > EOF
   $ HGEDITOR="sh $TESTTMP/editor.sh" hg rebase --collapse --keepbranches -e --source B --dest F
   rebasing 1:112478962961 "B" (B)
   rebasing 3:26805aba1e60 "C" (C)
   rebasing 5:f585351a92f8 "D" (D tip)
   ==== before editing
   Collapsed revision
   * B
   * C
   * D
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added B
   HG: added C
   HG: added D
   ====
   saved backup bundle to $TESTTMP/phase/.hg/strip-backup/112478962961-cb2a9b47-rebase.hg
 
   $ hg tglogp
   o  3: 92fa5f5fe108 secret 'Collapsed revision
   |  * B
   |  * C
   |  * D
   |
   |
   |  edited manually'
   o  2: 64a8289d2492 draft 'F'
   |
   o  1: 7fb047a69f22 draft 'E'
   |
   o  0: 426bada5c675 draft 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
   E
   F
 
   $ cd ..
 
 
 Merge gets linearized:
 
   $ hg init linearized-merge
   $ cd linearized-merge
 
   $ hg debugdrawdag << 'EOF'
   > F D
   > |/|
   > C B
   > |/
   > A
   > EOF
 
   $ hg phase --force --secret D
   $ hg rebase --source B --collapse --dest F
   rebasing 1:112478962961 "B" (B)
   rebasing 3:4e4f9194f9f1 "D" (D)
   saved backup bundle to $TESTTMP/linearized-merge/.hg/strip-backup/112478962961-e389075b-rebase.hg
 
   $ hg tglog
   o  3: 5bdc08b7da2b 'Collapsed revision
   |  * B
   |  * D'
   o  2: afc707c82df0 'F'
   |
   o  1: dc0947a82db8 'C'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   F
 
   $ cd ..
 
 Custom message:
 
   $ hg init message
   $ cd message
 
   $ hg debugdrawdag << 'EOF'
   >   C
   >   |
   > D B
   > |/
   > A
   > EOF
 
 
   $ hg rebase --base B -m 'custom message'
   abort: message can only be specified with collapse
   [255]
 
   $ cat > $TESTTMP/checkeditform.sh <<EOF
   > env | grep HGEDITFORM
   > true
   > EOF
   $ HGEDITOR="sh $TESTTMP/checkeditform.sh" hg rebase --source B --collapse -m 'custom message' -e --dest D
   rebasing 1:112478962961 "B" (B)
   rebasing 3:26805aba1e60 "C" (C tip)
   HGEDITFORM=rebase.collapse
   saved backup bundle to $TESTTMP/message/.hg/strip-backup/112478962961-f4131707-rebase.hg
 
   $ hg tglog
   o  2: 2f197b9a08f3 'custom message'
   |
   o  1: b18e25de2cf5 'D'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
 
   $ cd ..
 
 Rebase and collapse - more than one external (fail):
 
   $ hg init multiple-external-parents
   $ cd multiple-external-parents
 
   $ hg debugdrawdag << 'EOF'
   >   G
   >   |\
   >   | F
   >   | |
   >   D E
   >   |\|
   > H C B
   >  \|/
   >   A
   > EOF
 
   $ hg rebase -s C --dest H --collapse
   abort: unable to collapse on top of 3, there is more than one external parent: 1, 6
   [255]
 
 Rebase and collapse - E onto H:
 
   $ hg rebase -s E --dest I --collapse # root (E) is not a merge
   abort: unknown revision 'I'!
   [255]
 
   $ hg tglog
   o    7: 64e264db77f0 'G'
   |\
   | o  6: 11abe3fb10b8 'F'
   | |
   | o  5: 49cb92066bfd 'E'
   | |
   o |  4: 4e4f9194f9f1 'D'
   |\|
   | | o  3: 575c4b5ec114 'H'
   | | |
   o---+  2: dc0947a82db8 'C'
    / /
   o /  1: 112478962961 'B'
   |/
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   E
   F
 
   $ cd ..
 
 
 
 
 Test that branchheads cache is updated correctly when doing a strip in which
 the parent of the ancestor node to be stripped does not become a head and also,
 the parent of a node that is a child of the node stripped becomes a head (node
 3). The code is now much simpler and we could just test a simpler scenario
 We keep it the test this way in case new complexity is injected.
 
 Create repo b:
 
   $ hg init branch-heads
   $ cd branch-heads
 
   $ hg debugdrawdag << 'EOF'
   >   G
   >   |\
   >   | F
   >   | |
   >   D E
   >   |\|
   > H C B
   >  \|/
   >   A
   > EOF
 
   $ hg heads --template="{rev}:{node} {branch}\n"
   7:64e264db77f061f16d9132b70c5a58e2461fb630 default
   3:575c4b5ec114d64b681d33f8792853568bfb2b2c default
 
   $ cat $TESTTMP/branch-heads/.hg/cache/branch2-served
   64e264db77f061f16d9132b70c5a58e2461fb630 7
   575c4b5ec114d64b681d33f8792853568bfb2b2c o default
   64e264db77f061f16d9132b70c5a58e2461fb630 o default
 
   $ hg strip 4
   saved backup bundle to $TESTTMP/branch-heads/.hg/strip-backup/4e4f9194f9f1-5ec4b5e6-backup.hg
 
   $ cat $TESTTMP/branch-heads/.hg/cache/branch2-served
   11abe3fb10b8689b560681094b17fe161871d043 5
   dc0947a82db884575bb76ea10ac97b08536bfa03 o default
   575c4b5ec114d64b681d33f8792853568bfb2b2c o default
   11abe3fb10b8689b560681094b17fe161871d043 o default
 
   $ hg heads --template="{rev}:{node} {branch}\n"
   5:11abe3fb10b8689b560681094b17fe161871d043 default
   3:575c4b5ec114d64b681d33f8792853568bfb2b2c default
   2:dc0947a82db884575bb76ea10ac97b08536bfa03 default
 
   $ cd ..
 
 
 
 Preserves external parent
 
   $ hg init external-parent
   $ cd external-parent
 
   $ hg debugdrawdag << 'EOF'
   >   H
   >   |\
   >   | G
   >   | |
   >   | F # F/E = F\n
   >   | |
   >   D E # D/D = D\n
   >   |\|
   > I C B
   >  \|/
   >   A
   > EOF
 
   $ hg rebase -s F --dest I --collapse # root (F) is not a merge
   rebasing 6:c82b08f646f1 "F" (F)
   file 'E' was deleted in local [dest] but was modified in other [source].
   You can use (c)hanged version, leave (d)eleted, or leave (u)nresolved.
   What do you want to do? u
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ echo F > E
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase -c
   rebasing 6:c82b08f646f1 "F" (F)
   rebasing 7:a6db7fa104e1 "G" (G)
   rebasing 8:e1d201b72d91 "H" (H tip)
   saved backup bundle to $TESTTMP/external-parent/.hg/strip-backup/c82b08f646f1-f2721fbf-rebase.hg
 
   $ hg tglog
   o    6: 681daa3e686d 'Collapsed revision
   |\   * F
   | |  * G
   | |  * H'
   | | o  5: 49cb92066bfd 'E'
   | | |
   | o |  4: 09143c0bf13e 'D'
   | |\|
   o | |  3: 08ebfeb61bac 'I'
   | | |
   | o |  2: dc0947a82db8 'C'
   |/ /
   | o  1: 112478962961 'B'
   |/
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   C
   D
   E
   F
   G
   I
 
   $ hg up tip -q
   $ cat E
   F
 
   $ cd ..
 
 Rebasing from multiple bases:
 
   $ hg init multiple-bases
   $ cd multiple-bases
   $ hg debugdrawdag << 'EOF'
   >   C B
   > D |/
   > |/
   > A
   > EOF
   $ hg rebase --collapse -r 'B+C' -d D
   rebasing 1:fc2b737bb2e5 "B" (B)
   rebasing 2:dc0947a82db8 "C" (C)
   saved backup bundle to $TESTTMP/multiple-bases/.hg/strip-backup/dc0947a82db8-b0c1a7ea-rebase.hg
   $ hg tglog
   o  2: 2127ae44d291 'Collapsed revision
   |  * B
   |  * C'
   o  1: b18e25de2cf5 'D'
   |
   o  0: 426bada5c675 'A'
   
   $ cd ..
 
 With non-contiguous commits:
 
   $ hg init non-contiguous
   $ cd non-contiguous
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > evolution=all
   > EOF
 
   $ hg debugdrawdag << 'EOF'
   > F
   > |
   > E
   > |
   > D
   > |
   > C
   > |
   > B G
   > |/
   > A
   > EOF
 
 BROKEN: should be allowed
   $ hg rebase --collapse -r 'B+D+F' -d G
   abort: unable to collapse on top of 2, there is more than one external parent: 3, 5
   [255]
   $ cd ..
 
 
   $ hg init multiple-external-parents-2
   $ cd multiple-external-parents-2
   $ hg debugdrawdag << 'EOF'
   > D       G
   > |\     /|
   > B C   E F
   >  \|   |/
   >   \ H /
   >    \|/
   >     A
   > EOF
 
   $ hg rebase --collapse -d H -s 'B+F'
   abort: unable to collapse on top of 5, there is more than one external parent: 1, 3
   [255]
   $ cd ..
 
 With internal merge:
 
   $ hg init internal-merge
   $ cd internal-merge
 
   $ hg debugdrawdag << 'EOF'
   >   E
   >   |\
   >   C D
   >   |/
   > F B
   > |/
   > A
   > EOF
 
 
   $ hg rebase -s B --collapse --dest F
   rebasing 1:112478962961 "B" (B)
   rebasing 3:26805aba1e60 "C" (C)
   rebasing 4:be0ef73c17ad "D" (D)
   rebasing 5:02c4367d6973 "E" (E tip)
   saved backup bundle to $TESTTMP/internal-merge/.hg/strip-backup/112478962961-1dfb057b-rebase.hg
 
   $ hg tglog
   o  2: c0512a1797b0 'Collapsed revision
   |  * B
   |  * C
   |  * D
   |  * E'
   o  1: 8908a377a434 'F'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
   F
   $ cd ..
 
 Interactions between collapse and keepbranches
   $ hg init e
   $ cd e
   $ echo 'a' > a
   $ hg ci -Am 'A'
   adding a
 
   $ hg branch 'one'
   marked working directory as branch one
   (branches are permanent and global, did you want a bookmark?)
   $ echo 'b' > b
   $ hg ci -Am 'B'
   adding b
 
   $ hg branch 'two'
   marked working directory as branch two
   $ echo 'c' > c
   $ hg ci -Am 'C'
   adding c
 
   $ hg up -q 0
   $ echo 'd' > d
   $ hg ci -Am 'D'
   adding d
 
   $ hg tglog
   @  3: 41acb9dca9eb 'D'
   |
   | o  2: 8ac4a08debf1 'C' two
   | |
   | o  1: 1ba175478953 'B' one
   |/
   o  0: 1994f17a630e 'A'
   
   $ hg rebase --keepbranches --collapse -s 1 -d 3
   abort: cannot collapse multiple named branches
   [255]
 
   $ cd ..
 
 Rebase, collapse and copies
 
   $ hg init copies
   $ cd copies
   $ hg unbundle "$TESTDIR/bundles/renames.hg"
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 11 changes to 7 files (+1 heads)
   new changesets f447d5abf5ea:338e84e2e558 (4 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up -q tip
   $ hg tglog
   @  3: 338e84e2e558 'move2'
   |
   o  2: 6e7340ee38c0 'move1'
   |
   | o  1: 1352765a01d4 'change'
   |/
   o  0: f447d5abf5ea 'add'
   
   $ hg rebase --collapse -d 1
   rebasing 2:6e7340ee38c0 "move1"
   merging a and d to d
   merging b and e to e
   merging c and f to f
   rebasing 3:338e84e2e558 "move2" (tip)
   merging f and c to c
   merging e and g to g
   saved backup bundle to $TESTTMP/copies/.hg/strip-backup/6e7340ee38c0-ef8ef003-rebase.hg
   $ hg st
   $ hg st --copies --change tip
   A d
     a
   A g
     b
   R b
   $ hg up tip -q
   $ cat c
   c
   c
   $ cat d
   a
   a
   $ cat g
   b
   b
   $ hg log -r . --template "{file_copies}\n"
   d (a)g (b)
 
 Test collapsing a middle revision in-place
 
   $ hg tglog
   @  2: 64b456429f67 'Collapsed revision
   |  * move1
   |  * move2'
   o  1: 1352765a01d4 'change'
   |
   o  0: f447d5abf5ea 'add'
   
   $ hg rebase --collapse -r 1 -d 0
   abort: cannot rebase changeset with children
   (use --keep to keep original changesets)
   [255]
 
 Test collapsing in place
 
   $ hg rebase --collapse -b . -d 0
   rebasing 1:1352765a01d4 "change"
   rebasing 2:64b456429f67 "Collapsed revision" (tip)
   saved backup bundle to $TESTTMP/copies/.hg/strip-backup/1352765a01d4-45a352ea-rebase.hg
   $ hg st --change tip --copies
   M a
   M c
   A d
     a
   A g
     b
   R b
   $ hg up tip -q
   $ cat a
   a
   a
   $ cat c
   c
   c
   $ cat d
   a
   a
   $ cat g
   b
   b
   $ cd ..
 
 
 Test stripping a revision with another child
 
   $ hg init f
   $ cd f
 
   $ hg debugdrawdag << 'EOF'
   > C B
   > |/
   > A
   > EOF
 
   $ hg heads --template="{rev}:{node} {branch}: {desc}\n"
   2:dc0947a82db884575bb76ea10ac97b08536bfa03 default: C
   1:112478962961147124edd43549aedd1a335e44bf default: B
 
   $ hg strip C
   saved backup bundle to $TESTTMP/f/.hg/strip-backup/dc0947a82db8-d21b92a4-backup.hg
 
   $ hg tglog
   o  1: 112478962961 'B'
   |
   o  0: 426bada5c675 'A'
   
 
 
   $ hg heads --template="{rev}:{node} {branch}: {desc}\n"
   1:112478962961147124edd43549aedd1a335e44bf default: B
 
   $ cd ..
 
 Test collapsing changes that add then remove a file
 
   $ hg init collapseaddremove
   $ cd collapseaddremove
 
   $ touch base
   $ hg commit -Am base
   adding base
   $ touch a
   $ hg commit -Am a
   adding a
   $ hg rm a
   $ touch b
   $ hg commit -Am b
   adding b
   $ hg book foo
   $ hg rebase -d 0 -r "1::2" --collapse -m collapsed
   rebasing 1:6d8d9f24eec3 "a"
   rebasing 2:1cc73eca5ecc "b" (foo tip)
   saved backup bundle to $TESTTMP/collapseaddremove/.hg/strip-backup/6d8d9f24eec3-77d3b6e2-rebase.hg
   $ hg log -G --template "{rev}: '{desc}' {bookmarks}"
   @  1: 'collapsed' foo
   |
   o  0: 'base'
   
   $ hg manifest --rev tip
   b
   base
 
   $ cd ..
 
 Test that rebase --collapse will remember message after
 running into merge conflict and invoking rebase --continue.
 
   $ hg init collapse_remember_message
   $ cd collapse_remember_message
   $ hg debugdrawdag << 'EOF'
   > C B # B/A = B\n
   > |/  # C/A = C\n
   > A
   > EOF
   $ hg rebase --collapse -m "new message" -b B -d C
   rebasing 1:81e5401e4d37 "B" (B)
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ rm A.orig
   $ hg resolve --mark A
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 1:81e5401e4d37 "B" (B)
   saved backup bundle to $TESTTMP/collapse_remember_message/.hg/strip-backup/81e5401e4d37-96c3dd30-rebase.hg
   $ hg log
   changeset:   2:17186933e123
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     new message
   
   changeset:   1:043039e9df84
   tag:         C
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     C
   
   changeset:   0:426bada5c675
   tag:         A
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     A
   
   $ cd ..
 
 Test aborted editor on final message
 
   $ HGMERGE=:merge3
   $ export HGMERGE
   $ hg init aborted-editor
   $ cd aborted-editor
   $ hg debugdrawdag << 'EOF'
   > C   # D/A = D\n
   > |   # C/A = C\n
   > B D # B/A = B\n
   > |/  # A/A = A\n
   > A
   > EOF
   $ hg rebase --collapse -t internal:merge3 -s B -d D
   rebasing 1:f899f3910ce7 "B" (B)
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg tglog
   o  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
-  @ |  1: f899f3910ce7 'B'
+  % |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ cat A
   <<<<<<< dest:   82b8abf9c185 D - test: D
   D
   ||||||| base
   A
   =======
   B
   >>>>>>> source: f899f3910ce7 B - test: B
   $ echo BC > A
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 1:f899f3910ce7 "B" (B)
   rebasing 3:63668d570d21 "C" (C tip)
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg tglog
-  @  3: 63668d570d21 'C'
+  %  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
   o |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ cat A
   <<<<<<< dest:   82b8abf9c185 D - test: D
   BC
   ||||||| base
   B
   =======
   C
   >>>>>>> source: 63668d570d21 C tip - test: C
   $ echo BD > A
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ HGEDITOR=false hg rebase --continue --config ui.interactive=1
   already rebased 1:f899f3910ce7 "B" (B) as 82b8abf9c185
   rebasing 3:63668d570d21 "C" (C tip)
   abort: edit failed: false exited with status 1
   [255]
   $ hg tglog
   %  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
   o |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ hg rebase --continue
   already rebased 1:f899f3910ce7 "B" (B) as 82b8abf9c185
   already rebased 3:63668d570d21 "C" (C tip) as 82b8abf9c185
   saved backup bundle to $TESTTMP/aborted-editor/.hg/strip-backup/f899f3910ce7-7cab5e15-rebase.hg

tests/test-rebase-conflicts.t

@@ -1,501 +1,500 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > drawdag=$TESTDIR/drawdag.py
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}:{phase} '{desc}' {branches} {bookmarks}\n"
   > EOF
 
   $ hg init a
   $ cd a
   $ echo c1 >common
   $ hg add common
   $ hg ci -m C1
 
   $ echo c2 >>common
   $ hg ci -m C2
 
   $ echo c3 >>common
   $ hg ci -m C3
 
   $ hg up -q -C 1
 
   $ echo l1 >>extra
   $ hg add extra
   $ hg ci -m L1
   created new head
 
   $ sed -e 's/c2/l2/' common > common.new
   $ mv common.new common
   $ hg ci -m L2
 
   $ echo l3 >> extra2
   $ hg add extra2
   $ hg ci -m L3
   $ hg bookmark mybook
 
   $ hg phase --force --secret 4
 
   $ hg tglog
   @  5:secret 'L3'  mybook
   |
   o  4:secret 'L2'
   |
   o  3:draft 'L1'
   |
   | o  2:draft 'C3'
   |/
   o  1:draft 'C2'
   |
   o  0:draft 'C1'
   
 Try to call --continue:
 
   $ hg rebase --continue
   abort: no rebase in progress
   [255]
 
 Conflicting rebase:
 
   $ hg rebase -s 3 -d 2
   rebasing 3:3163e20567cc "L1"
   rebasing 4:46f0b057b5c0 "L2"
   merging common
   warning: conflicts while merging common! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ hg status --config commands.status.verbose=1
   M common
   ? common.orig
   # The repository is in an unfinished *rebase* state.
   
   # Unresolved merge conflicts:
   # 
   #     common
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   # To continue:    hg rebase --continue
   # To abort:       hg rebase --abort
   # To stop:        hg rebase --stop
   
 
 Try to continue without solving the conflict:
 
   $ hg rebase --continue
   abort: unresolved merge conflicts (see 'hg help resolve')
   [255]
 
 Conclude rebase:
 
   $ echo 'resolved merge' >common
   $ hg resolve -m common
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   already rebased 3:3163e20567cc "L1" as 3e046f2ecedb
   rebasing 4:46f0b057b5c0 "L2"
   rebasing 5:8029388f38dc "L3" (mybook)
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/3163e20567cc-5ca4656e-rebase.hg
 
   $ hg tglog
   @  5:secret 'L3'  mybook
   |
   o  4:secret 'L2'
   |
   o  3:draft 'L1'
   |
   o  2:draft 'C3'
   |
   o  1:draft 'C2'
   |
   o  0:draft 'C1'
   
 Check correctness:
 
   $ hg cat -r 0 common
   c1
 
   $ hg cat -r 1 common
   c1
   c2
 
   $ hg cat -r 2 common
   c1
   c2
   c3
 
   $ hg cat -r 3 common
   c1
   c2
   c3
 
   $ hg cat -r 4 common
   resolved merge
 
   $ hg cat -r 5 common
   resolved merge
 
 Bookmark stays active after --continue
   $ hg bookmarks
    * mybook                    5:d67b21408fc0
 
   $ cd ..
 
 Check that the right ancestors is used while rebasing a merge (issue4041)
 
   $ hg init issue4041
   $ cd issue4041
   $ hg unbundle "$TESTDIR/bundles/issue4041.hg"
   adding changesets
   adding manifests
   adding file changes
   added 11 changesets with 8 changes to 3 files (+1 heads)
   new changesets 24797d4f68de:2f2496ddf49d (11 drafts)
   (run 'hg heads' to see heads)
   $ hg up default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -G
   o    changeset:   10:2f2496ddf49d
   |\   branch:      f1
   | |  tag:         tip
   | |  parent:      7:4c9fbe56a16f
   | |  parent:      9:e31216eec445
   | |  user:        szhang
   | |  date:        Thu Sep 05 12:59:39 2013 -0400
   | |  summary:     merge
   | |
   | o  changeset:   9:e31216eec445
   | |  branch:      f1
   | |  user:        szhang
   | |  date:        Thu Sep 05 12:59:10 2013 -0400
   | |  summary:     more changes to f1
   | |
   | o    changeset:   8:8e4e2c1a07ae
   | |\   branch:      f1
   | | |  parent:      2:4bc80088dc6b
   | | |  parent:      6:400110238667
   | | |  user:        szhang
   | | |  date:        Thu Sep 05 12:57:59 2013 -0400
   | | |  summary:     bad merge
   | | |
   o | |  changeset:   7:4c9fbe56a16f
   |/ /   branch:      f1
   | |    parent:      2:4bc80088dc6b
   | |    user:        szhang
   | |    date:        Thu Sep 05 12:54:00 2013 -0400
   | |    summary:     changed f1
   | |
   | o  changeset:   6:400110238667
   | |  branch:      f2
   | |  parent:      4:12e8ec6bb010
   | |  user:        szhang
   | |  date:        Tue Sep 03 13:58:02 2013 -0400
   | |  summary:     changed f2 on f2
   | |
   | | @  changeset:   5:d79e2059b5c0
   | | |  parent:      3:8a951942e016
   | | |  user:        szhang
   | | |  date:        Tue Sep 03 13:57:39 2013 -0400
   | | |  summary:     changed f2 on default
   | | |
   | o |  changeset:   4:12e8ec6bb010
   | |/   branch:      f2
   | |    user:        szhang
   | |    date:        Tue Sep 03 13:57:18 2013 -0400
   | |    summary:     created f2 branch
   | |
   | o  changeset:   3:8a951942e016
   | |  parent:      0:24797d4f68de
   | |  user:        szhang
   | |  date:        Tue Sep 03 13:57:11 2013 -0400
   | |  summary:     added f2.txt
   | |
   o |  changeset:   2:4bc80088dc6b
   | |  branch:      f1
   | |  user:        szhang
   | |  date:        Tue Sep 03 13:56:20 2013 -0400
   | |  summary:     added f1.txt
   | |
   o |  changeset:   1:ef53c9e6b608
   |/   branch:      f1
   |    user:        szhang
   |    date:        Tue Sep 03 13:55:26 2013 -0400
   |    summary:     created f1 branch
   |
   o  changeset:   0:24797d4f68de
      user:        szhang
      date:        Tue Sep 03 13:55:08 2013 -0400
      summary:     added default.txt
   
   $ hg rebase -s9 -d2 --debug # use debug to really check merge base used
   rebase onto 4bc80088dc6b starting from e31216eec445
   rebasing on disk
   rebase status stored
   rebasing 9:e31216eec445 "more changes to f1"
    future parents are 2 and -1
    update to 2:4bc80088dc6b
   resolving manifests
    branchmerge: False, force: True, partial: False
    ancestor: d79e2059b5c0+, local: d79e2059b5c0+, remote: 4bc80088dc6b
    f2.txt: other deleted -> r
   removing f2.txt
    f1.txt: remote created -> g
   getting f1.txt
    merge against 9:e31216eec445
      detach base 8:8e4e2c1a07ae
   resolving manifests
    branchmerge: True, force: True, partial: False
    ancestor: 8e4e2c1a07ae, local: 4bc80088dc6b+, remote: e31216eec445
    f1.txt: remote is newer -> g
   getting f1.txt
   committing files:
   f1.txt
   committing manifest
   committing changelog
   updating the branch cache
   rebased as 19c888675e13
   rebase status stored
   rebasing 10:2f2496ddf49d "merge" (tip)
    future parents are 11 and 7
    already in destination
    merge against 10:2f2496ddf49d
      detach base 9:e31216eec445
   resolving manifests
    branchmerge: True, force: True, partial: False
    ancestor: e31216eec445, local: 19c888675e13+, remote: 2f2496ddf49d
    f1.txt: remote is newer -> g
   getting f1.txt
   committing files:
   f1.txt
   committing manifest
   committing changelog
   updating the branch cache
   rebased as 2a7f09cac94c
   rebase status stored
   rebase merging completed
   update back to initial working directory parent
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 2a7f09cac94c, local: 2a7f09cac94c+, remote: d79e2059b5c0
    f1.txt: other deleted -> r
   removing f1.txt
    f2.txt: remote created -> g
   getting f2.txt
   2 changesets found
   list of changesets:
   e31216eec445e44352c5f01588856059466a24c9
   2f2496ddf49d69b5ef23ad8cf9fb2e0e4faf0ac2
   bundle2-output-bundle: "HG20", (1 params) 3 parts total
   bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   bundle2-output-part: "cache:rev-branch-cache" (advisory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   saved backup bundle to $TESTTMP/issue4041/.hg/strip-backup/e31216eec445-15f7a814-rebase.hg
   3 changesets found
   list of changesets:
   4c9fbe56a16f30c0d5dcc40ec1a97bbe3325209c
   19c888675e133ab5dff84516926a65672eaf04d9
   2a7f09cac94c7f4b73ebd5cd1a62d3b2e8e336bf
   bundle2-output-bundle: "HG20", 3 parts total
   bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   bundle2-output-part: "cache:rev-branch-cache" (advisory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   adding branch
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "changegroup" (params: 1 mandatory 1 advisory) supported
   adding changesets
   add changeset 4c9fbe56a16f
   add changeset 19c888675e13
   add changeset 2a7f09cac94c
   adding manifests
   adding file changes
   adding f1.txt revisions
   bundle2-input-part: total payload size 1686
   bundle2-input-part: "cache:rev-branch-cache" (advisory) supported
   bundle2-input-part: total payload size 74
   truncating cache/rbc-revs-v1 to 56
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 3 parts total
   added 2 changesets with 2 changes to 1 files
   updating the branch cache
   invalid branch cache (served): tip differs
   invalid branch cache (served.hidden): tip differs
   rebase completed
 
 Test minimization of merge conflicts
   $ hg up -q null
   $ echo a > a
   $ hg add a
   $ hg commit -q -m 'a'
   $ echo b >> a
   $ hg commit -q -m 'ab'
   $ hg bookmark ab
   $ hg up -q '.^'
   $ echo b >> a
   $ echo c >> a
   $ hg commit -q -m 'abc'
   $ hg rebase -s 7bc217434fc1 -d ab --keep
   rebasing 13:7bc217434fc1 "abc" (tip)
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg diff
   diff -r 328e4ab1f7cc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	* (glob)
   @@ -1,2 +1,6 @@
    a
    b
   +<<<<<<< dest:   328e4ab1f7cc ab - test: ab
   +=======
   +c
   +>>>>>>> source: 7bc217434fc1 - test: abc
   $ hg rebase --abort
   rebase aborted
   $ hg up -q -C 7bc217434fc1
   $ hg rebase -s . -d ab --keep -t internal:merge3
   rebasing 13:7bc217434fc1 "abc" (tip)
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg diff
   diff -r 328e4ab1f7cc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	* (glob)
   @@ -1,2 +1,8 @@
    a
   +<<<<<<< dest:   328e4ab1f7cc ab - test: ab
    b
   +||||||| base
   +=======
   +b
   +c
   +>>>>>>> source: 7bc217434fc1 - test: abc
 
 Test rebase with obsstore turned on and off (issue5606)
 
   $ cd $TESTTMP
   $ hg init b
   $ cd b
   $ hg debugdrawdag <<'EOS'
   > D
   > |
   > C
   > |
   > B E
   > |/
   > A
   > EOS
 
   $ hg update E -q
   $ echo 3 > B
   $ hg commit --amend -m E -A B -q
   $ hg rebase -r B+D -d . --config experimental.evolution=true
   rebasing 1:112478962961 "B" (B)
   merging B
   warning: conflicts while merging B! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ echo 4 > B
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue --config experimental.evolution=none
   rebasing 1:112478962961 "B" (B)
   rebasing 3:f585351a92f8 "D" (D)
   warning: orphaned descendants detected, not stripping 112478962961
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/f585351a92f8-e536a9e4-rebase.hg
 
   $ rm .hg/localtags
   $ hg tglog
   o  5:draft 'D'
   |
   o  4:draft 'B'
   |
   @  3:draft 'E'
   |
   | o  2:draft 'C'
   | |
   | o  1:draft 'B'
   |/
   o  0:draft 'A'
   
 
 Test where the conflict happens when rebasing a merge commit
 
   $ cd $TESTTMP
   $ hg init conflict-in-merge
   $ cd conflict-in-merge
   $ hg debugdrawdag <<'EOS'
   > F # F/conflict = foo\n
   > |\
   > D E
   > |/
   > C B # B/conflict = bar\n
   > |/
   > A
   > EOS
 
   $ hg co F
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg rebase -d B
   rebasing 2:dc0947a82db8 "C" (C)
   rebasing 3:e7b3f00ed42e "D" (D)
   rebasing 4:03ca77807e91 "E" (E)
   rebasing 5:9a6b91dc2044 "F" (F tip)
   merging conflict
   warning: conflicts while merging conflict! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
-The current parents are not 7 and 8 even though that's what we're merging
   $ hg tglog
   @  8:draft 'E'
   |
-  | o  7:draft 'D'
+  | @  7:draft 'D'
   |/
   o  6:draft 'C'
   |
-  | @    5:draft 'F'
+  | %    5:draft 'F'
   | |\
   | | o  4:draft 'E'
   | | |
   | o |  3:draft 'D'
   | |/
   | o  2:draft 'C'
   | |
   o |  1:draft 'B'
   |/
   o  0:draft 'A'
   
   $ echo baz > conflict
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase -c
   already rebased 2:dc0947a82db8 "C" (C) as 0199610c343e
   already rebased 3:e7b3f00ed42e "D" (D) as f0dd538aaa63
   already rebased 4:03ca77807e91 "E" (E) as cbf25af8347d
   rebasing 5:9a6b91dc2044 "F" (F)
   saved backup bundle to $TESTTMP/conflict-in-merge/.hg/strip-backup/dc0947a82db8-ca7e7d5b-rebase.hg
   $ hg tglog
   @    5:draft 'F'
   |\
   | o  4:draft 'E'
   | |
   o |  3:draft 'D'
   |/
   o  2:draft 'C'
   |
   o  1:draft 'B'
   |
   o  0:draft 'A'
   

tests/test-rebase-interruptions.t

@@ -1,480 +1,480 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: {node|short} '{desc}' {branches}\n"
   > tglogp = log -G --template "{rev}: {node|short} {phase} '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
 
   $ echo A > A
   $ hg ci -Am A
   adding A
 
   $ echo B > B
   $ hg ci -Am B
   adding B
 
   $ echo C >> A
   $ hg ci -m C
 
   $ hg up -q -C 0
 
   $ echo D >> A
   $ hg ci -m D
   created new head
 
   $ echo E > E
   $ hg ci -Am E
   adding E
 
   $ cd ..
 
 
 Changes during an interruption - continue:
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg tglog
   @  4: ae36e8e3dfd7 'E'
   |
   o  3: 46b37eabc604 'D'
   |
   | o  2: 965c486023db 'C'
   | |
   | o  1: 27547f69f254 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
 Rebasing B onto E:
 
   $ hg rebase -s 1 -d 4
   rebasing 1:27547f69f254 "B"
   rebasing 2:965c486023db "C"
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
 Force a commit on C during the interruption:
 
   $ hg up -q -C 2 --config 'extensions.rebase=!'
 
   $ echo 'Extra' > Extra
   $ hg add Extra
   $ hg ci -m 'Extra' --config 'extensions.rebase=!'
 
 Force this commit onto secret phase
 
   $ hg phase --force --secret 6
 
   $ hg tglogp
   @  6: deb5d2f93d8b secret 'Extra'
   |
   | o  5: 45396c49d53b draft 'B'
   | |
   | o  4: ae36e8e3dfd7 draft 'E'
   | |
   | o  3: 46b37eabc604 draft 'D'
   | |
   o |  2: 965c486023db draft 'C'
   | |
   o |  1: 27547f69f254 draft 'B'
   |/
   o  0: 4a2df7238c3b draft 'A'
   
 Resume the rebasing:
 
   $ hg rebase --continue
   already rebased 1:27547f69f254 "B" as 45396c49d53b
   rebasing 2:965c486023db "C"
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
 Solve the conflict and go on:
 
   $ echo 'conflict solved' > A
   $ rm A.orig
   $ hg resolve -m A
   (no more unresolved files)
   continue: hg rebase --continue
 
   $ hg rebase --continue
   already rebased 1:27547f69f254 "B" as 45396c49d53b
   rebasing 2:965c486023db "C"
   warning: orphaned descendants detected, not stripping 27547f69f254, 965c486023db
 
   $ hg tglogp
   o  7: d2d25e26288e draft 'C'
   |
   | o  6: deb5d2f93d8b secret 'Extra'
   | |
   o |  5: 45396c49d53b draft 'B'
   | |
   @ |  4: ae36e8e3dfd7 draft 'E'
   | |
   o |  3: 46b37eabc604 draft 'D'
   | |
   | o  2: 965c486023db draft 'C'
   | |
   | o  1: 27547f69f254 draft 'B'
   |/
   o  0: 4a2df7238c3b draft 'A'
   
   $ cd ..
 
 
 Changes during an interruption - abort:
 
   $ hg clone -q -u . a a2
   $ cd a2
 
   $ hg tglog
   @  4: ae36e8e3dfd7 'E'
   |
   o  3: 46b37eabc604 'D'
   |
   | o  2: 965c486023db 'C'
   | |
   | o  1: 27547f69f254 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
 Rebasing B onto E:
 
   $ hg rebase -s 1 -d 4
   rebasing 1:27547f69f254 "B"
   rebasing 2:965c486023db "C"
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
 Force a commit on B' during the interruption:
 
   $ hg up -q -C 5 --config 'extensions.rebase=!'
 
   $ echo 'Extra' > Extra
   $ hg add Extra
   $ hg ci -m 'Extra' --config 'extensions.rebase=!'
 
   $ hg tglog
   @  6: 402ee3642b59 'Extra'
   |
   o  5: 45396c49d53b 'B'
   |
   o  4: ae36e8e3dfd7 'E'
   |
   o  3: 46b37eabc604 'D'
   |
   | o  2: 965c486023db 'C'
   | |
   | o  1: 27547f69f254 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
 Abort the rebasing:
 
   $ hg rebase --abort
   warning: new changesets detected on destination branch, can't strip
   rebase aborted
 
   $ hg tglog
   @  6: 402ee3642b59 'Extra'
   |
   o  5: 45396c49d53b 'B'
   |
   o  4: ae36e8e3dfd7 'E'
   |
   o  3: 46b37eabc604 'D'
   |
   | o  2: 965c486023db 'C'
   | |
   | o  1: 27547f69f254 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ cd ..
 
 Changes during an interruption - abort (again):
 
   $ hg clone -q -u . a a3
   $ cd a3
 
   $ hg tglogp
   @  4: ae36e8e3dfd7 draft 'E'
   |
   o  3: 46b37eabc604 draft 'D'
   |
   | o  2: 965c486023db draft 'C'
   | |
   | o  1: 27547f69f254 draft 'B'
   |/
   o  0: 4a2df7238c3b draft 'A'
   
 Rebasing B onto E:
 
   $ hg rebase -s 1 -d 4
   rebasing 1:27547f69f254 "B"
   rebasing 2:965c486023db "C"
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
 Change phase on B and B'
 
   $ hg up -q -C 5 --config 'extensions.rebase=!'
   $ hg phase --public 1
   $ hg phase --public 5
   $ hg phase --secret -f 2
 
   $ hg tglogp
   @  5: 45396c49d53b public 'B'
   |
   o  4: ae36e8e3dfd7 public 'E'
   |
   o  3: 46b37eabc604 public 'D'
   |
   | o  2: 965c486023db secret 'C'
   | |
   | o  1: 27547f69f254 public 'B'
   |/
   o  0: 4a2df7238c3b public 'A'
   
 Abort the rebasing:
 
   $ hg rebase --abort
   warning: can't clean up public changesets 45396c49d53b
   rebase aborted
 
   $ hg tglogp
   @  5: 45396c49d53b public 'B'
   |
   o  4: ae36e8e3dfd7 public 'E'
   |
   o  3: 46b37eabc604 public 'D'
   |
   | o  2: 965c486023db secret 'C'
   | |
   | o  1: 27547f69f254 public 'B'
   |/
   o  0: 4a2df7238c3b public 'A'
   
 Test rebase interrupted by hooks
 
   $ hg up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo F > F
   $ hg add F
   $ hg ci -m F
 
   $ cd ..
 
 (precommit version)
 
   $ cp -R a3 hook-precommit
   $ cd hook-precommit
   $ hg rebase --source 2 --dest 5 --tool internal:other --config 'hooks.precommit=hg status | grep "M A"'
   rebasing 2:965c486023db "C"
   M A
   rebasing 6:a0b2430ebfb8 "F" (tip)
   abort: precommit hook exited with status 1
   [255]
   $ hg tglogp
   @  7: 401ccec5e39f secret 'C'
   |
-  | @  6: a0b2430ebfb8 secret 'F'
+  | o  6: a0b2430ebfb8 secret 'F'
   | |
   o |  5: 45396c49d53b public 'B'
   | |
   o |  4: ae36e8e3dfd7 public 'E'
   | |
   o |  3: 46b37eabc604 public 'D'
   | |
   | o  2: 965c486023db secret 'C'
   | |
   | o  1: 27547f69f254 public 'B'
   |/
   o  0: 4a2df7238c3b public 'A'
   
   $ hg rebase --continue
   already rebased 2:965c486023db "C" as 401ccec5e39f
   rebasing 6:a0b2430ebfb8 "F"
   saved backup bundle to $TESTTMP/hook-precommit/.hg/strip-backup/965c486023db-aa6250e7-rebase.hg
   $ hg tglogp
   @  6: 6e92a149ac6b secret 'F'
   |
   o  5: 401ccec5e39f secret 'C'
   |
   o  4: 45396c49d53b public 'B'
   |
   o  3: ae36e8e3dfd7 public 'E'
   |
   o  2: 46b37eabc604 public 'D'
   |
   | o  1: 27547f69f254 public 'B'
   |/
   o  0: 4a2df7238c3b public 'A'
   
   $ cd ..
 
 (pretxncommit version)
 
   $ cp -R a3 hook-pretxncommit
   $ cd hook-pretxncommit
   $ hg rebase --source 2 --dest 5 --tool internal:other \
   >     --config 'hooks.tonative.pretxncommit=True' --config 'hooks.pretxncommit=hg log -r $HG_NODE | grep "summary:     C"'
   rebasing 2:965c486023db "C"
   summary:     C
   rebasing 6:a0b2430ebfb8 "F" (tip)
   transaction abort!
   rollback completed
   abort: pretxncommit hook exited with status 1
   [255]
   $ hg tglogp
   @  7: 401ccec5e39f secret 'C'
   |
-  | @  6: a0b2430ebfb8 secret 'F'
+  | o  6: a0b2430ebfb8 secret 'F'
   | |
   o |  5: 45396c49d53b public 'B'
   | |
   o |  4: ae36e8e3dfd7 public 'E'
   | |
   o |  3: 46b37eabc604 public 'D'
   | |
   | o  2: 965c486023db secret 'C'
   | |
   | o  1: 27547f69f254 public 'B'
   |/
   o  0: 4a2df7238c3b public 'A'
   
   $ hg rebase --continue
   already rebased 2:965c486023db "C" as 401ccec5e39f
   rebasing 6:a0b2430ebfb8 "F"
   saved backup bundle to $TESTTMP/hook-pretxncommit/.hg/strip-backup/965c486023db-aa6250e7-rebase.hg
   $ hg tglogp
   @  6: 6e92a149ac6b secret 'F'
   |
   o  5: 401ccec5e39f secret 'C'
   |
   o  4: 45396c49d53b public 'B'
   |
   o  3: ae36e8e3dfd7 public 'E'
   |
   o  2: 46b37eabc604 public 'D'
   |
   | o  1: 27547f69f254 public 'B'
   |/
   o  0: 4a2df7238c3b public 'A'
   
   $ cd ..
 
 (pretxnclose version)
 
   $ cp -R a3 hook-pretxnclose
   $ cd hook-pretxnclose
   $ hg rebase --source 2 --dest 5 --tool internal:other --config 'hooks.pretxnclose=hg log -r tip | grep "summary:     C"'
   rebasing 2:965c486023db "C"
   summary:     C
   rebasing 6:a0b2430ebfb8 "F" (tip)
   transaction abort!
   rollback completed
   abort: pretxnclose hook exited with status 1
   [255]
   $ hg tglogp
   @  7: 401ccec5e39f secret 'C'
   |
-  | @  6: a0b2430ebfb8 secret 'F'
+  | o  6: a0b2430ebfb8 secret 'F'
   | |
   o |  5: 45396c49d53b public 'B'
   | |
   o |  4: ae36e8e3dfd7 public 'E'
   | |
   o |  3: 46b37eabc604 public 'D'
   | |
   | o  2: 965c486023db secret 'C'
   | |
   | o  1: 27547f69f254 public 'B'
   |/
   o  0: 4a2df7238c3b public 'A'
   
   $ hg rebase --continue
   already rebased 2:965c486023db "C" as 401ccec5e39f
   rebasing 6:a0b2430ebfb8 "F"
   saved backup bundle to $TESTTMP/hook-pretxnclose/.hg/strip-backup/965c486023db-aa6250e7-rebase.hg
   $ hg tglogp
   @  6: 6e92a149ac6b secret 'F'
   |
   o  5: 401ccec5e39f secret 'C'
   |
   o  4: 45396c49d53b public 'B'
   |
   o  3: ae36e8e3dfd7 public 'E'
   |
   o  2: 46b37eabc604 public 'D'
   |
   | o  1: 27547f69f254 public 'B'
   |/
   o  0: 4a2df7238c3b public 'A'
   
   $ cd ..
 
 Make sure merge state is cleaned up after a no-op rebase merge (issue5494)
   $ hg init repo
   $ cd repo
   $ echo a > a
   $ hg commit -qAm base
   $ echo b >> a
   $ hg commit -qm b
   $ hg up '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c >> a
   $ hg commit -qm c
   $ hg rebase -s 1 -d 2 --noninteractive
   rebasing 1:fdaca8533b86 "b"
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ echo a > a
   $ echo c >> a
   $ hg resolve --mark a
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 1:fdaca8533b86 "b"
   note: not rebasing 1:fdaca8533b86 "b", its destination already has all its changes
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/fdaca8533b86-7fd70513-rebase.hg
   $ hg resolve --list
   $ test -d .hg/merge
   [1]
 Now try again with --collapse
   $ hg unbundle -q .hg/strip-backup/fdaca8533b86-7fd70513-rebase.hg
   $ hg rebase -s 2 -d 1 --noninteractive --collapse
   rebasing 2:fdaca8533b86 "b" (tip)
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ echo a > a
   $ echo c >> a
   $ hg resolve --mark a
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 2:fdaca8533b86 "b" (tip)
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/fdaca8533b86-7fd70513-rebase.hg
   $ hg resolve --list
   $ test -d .hg/merge
   [1]

tests/test-rebase-obsolete.t

@@ -1,2142 +1,2138 b''
 ==========================
 Test rebase with obsolete
 ==========================
 
 Enable obsolete
 
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > logtemplate= {rev}:{node|short} {desc|firstline}{if(obsolete,' ({obsfate})')}
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > [phases]
   > publish=False
   > [extensions]
   > rebase=
   > drawdag=$TESTDIR/drawdag.py
   > strip=
   > EOF
 
 Setup rebase canonical repo
 
   $ hg init base
   $ cd base
   $ hg unbundle "$TESTDIR/bundles/rebase.hg"
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   new changesets cd010b8cd998:02de42196ebe (8 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -G
   @  7:02de42196ebe H
   |
   | o  6:eea13746799a G
   |/|
   o |  5:24b6387c8c8c F
   | |
   | o  4:9520eea781bc E
   |/
   | o  3:32af7686d403 D
   | |
   | o  2:5fddd98957c8 C
   | |
   | o  1:42ccdea3bb16 B
   |/
   o  0:cd010b8cd998 A
   
   $ cd ..
 
 simple rebase
 ---------------------------------
 
   $ hg clone base simple
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd simple
   $ hg up 32af7686d403
   3 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg rebase -d eea13746799a
   rebasing 1:42ccdea3bb16 "B"
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   $ hg log -G
   @  10:8eeb3c33ad33 D
   |
   o  9:2327fea05063 C
   |
   o  8:e4e5be0395b2 B
   |
   | o  7:02de42196ebe H
   | |
   o |  6:eea13746799a G
   |\|
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
   $ hg log --hidden -G
   @  10:8eeb3c33ad33 D
   |
   o  9:2327fea05063 C
   |
   o  8:e4e5be0395b2 B
   |
   | o  7:02de42196ebe H
   | |
   o |  6:eea13746799a G
   |\|
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   | x  3:32af7686d403 D (rewritten using rebase as 10:8eeb3c33ad33)
   | |
   | x  2:5fddd98957c8 C (rewritten using rebase as 9:2327fea05063)
   | |
   | x  1:42ccdea3bb16 B (rewritten using rebase as 8:e4e5be0395b2)
   |/
   o  0:cd010b8cd998 A
   
   $ hg debugobsolete
   42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 e4e5be0395b2cbd471ed22a26b1b6a1a0658a794 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   5fddd98957c8a54a4d436dfe1da9d87f21a1b97b 2327fea05063f39961b14cb69435a9898dc9a245 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   32af7686d403cf45b5d95f2d70cebea587ac806a 8eeb3c33ad33d452c89e5dcf611c347f978fb42b 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
 
 
   $ cd ..
 
 empty changeset
 ---------------------------------
 
   $ hg clone base empty
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd empty
   $ hg up eea13746799a
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 We make a copy of both the first changeset in the rebased and some other in the
 set.
 
   $ hg graft 42ccdea3bb16 32af7686d403
   grafting 1:42ccdea3bb16 "B"
   grafting 3:32af7686d403 "D"
   $ hg rebase  -s 42ccdea3bb16 -d .
   rebasing 1:42ccdea3bb16 "B"
   note: not rebasing 1:42ccdea3bb16 "B", its destination already has all its changes
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   note: not rebasing 3:32af7686d403 "D", its destination already has all its changes
   $ hg log -G
   o  10:5ae4c968c6ac C
   |
   @  9:08483444fef9 D
   |
   o  8:8877864f1edb B
   |
   | o  7:02de42196ebe H
   | |
   o |  6:eea13746799a G
   |\|
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
   $ hg log --hidden -G
   o  10:5ae4c968c6ac C
   |
   @  9:08483444fef9 D
   |
   o  8:8877864f1edb B
   |
   | o  7:02de42196ebe H
   | |
   o |  6:eea13746799a G
   |\|
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   | x  3:32af7686d403 D (pruned using rebase)
   | |
   | x  2:5fddd98957c8 C (rewritten using rebase as 10:5ae4c968c6ac)
   | |
   | x  1:42ccdea3bb16 B (pruned using rebase)
   |/
   o  0:cd010b8cd998 A
   
   $ hg debugobsolete
   42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 0 {cd010b8cd998f3981a5a8115f94f8da4ab506089} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'rebase', 'user': 'test'}
   5fddd98957c8a54a4d436dfe1da9d87f21a1b97b 5ae4c968c6aca831df823664e706c9d4aa34473d 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   32af7686d403cf45b5d95f2d70cebea587ac806a 0 {5fddd98957c8a54a4d436dfe1da9d87f21a1b97b} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'rebase', 'user': 'test'}
 
 
 More complex case where part of the rebase set were already rebased
 
   $ hg rebase --rev 'desc(D)' --dest 'desc(H)'
   rebasing 9:08483444fef9 "D"
   1 new orphan changesets
   $ hg debugobsolete
   42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 0 {cd010b8cd998f3981a5a8115f94f8da4ab506089} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'rebase', 'user': 'test'}
   5fddd98957c8a54a4d436dfe1da9d87f21a1b97b 5ae4c968c6aca831df823664e706c9d4aa34473d 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   32af7686d403cf45b5d95f2d70cebea587ac806a 0 {5fddd98957c8a54a4d436dfe1da9d87f21a1b97b} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'rebase', 'user': 'test'}
   08483444fef91d6224f6655ee586a65d263ad34c 4596109a6a4328c398bde3a4a3b6737cfade3003 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   $ hg log -G
   @  11:4596109a6a43 D
   |
   | *  10:5ae4c968c6ac C
   | |
   | x  9:08483444fef9 D (rewritten using rebase as 11:4596109a6a43)
   | |
   | o  8:8877864f1edb B
   | |
   o |  7:02de42196ebe H
   | |
   | o  6:eea13746799a G
   |/|
   o |  5:24b6387c8c8c F
   | |
   | o  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
   $ hg rebase --source 'desc(B)' --dest 'tip' --config experimental.rebaseskipobsolete=True
   rebasing 8:8877864f1edb "B"
   note: not rebasing 9:08483444fef9 "D", already in destination as 11:4596109a6a43 "D" (tip)
   rebasing 10:5ae4c968c6ac "C"
   $ hg debugobsolete
   42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 0 {cd010b8cd998f3981a5a8115f94f8da4ab506089} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'rebase', 'user': 'test'}
   5fddd98957c8a54a4d436dfe1da9d87f21a1b97b 5ae4c968c6aca831df823664e706c9d4aa34473d 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   32af7686d403cf45b5d95f2d70cebea587ac806a 0 {5fddd98957c8a54a4d436dfe1da9d87f21a1b97b} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'rebase', 'user': 'test'}
   08483444fef91d6224f6655ee586a65d263ad34c 4596109a6a4328c398bde3a4a3b6737cfade3003 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   8877864f1edb05d0e07dc4ba77b67a80a7b86672 462a34d07e599b87ea08676a449373fe4e2e1347 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   5ae4c968c6aca831df823664e706c9d4aa34473d 98f6af4ee9539e14da4465128f894c274900b6e5 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   $ hg log --rev 'contentdivergent()'
   $ hg log -G
   o  13:98f6af4ee953 C
   |
   o  12:462a34d07e59 B
   |
   @  11:4596109a6a43 D
   |
   o  7:02de42196ebe H
   |
   | o  6:eea13746799a G
   |/|
   o |  5:24b6387c8c8c F
   | |
   | o  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
   $ hg log --style default --debug -r 4596109a6a4328c398bde3a4a3b6737cfade3003
   changeset:   11:4596109a6a4328c398bde3a4a3b6737cfade3003
   phase:       draft
   parent:      7:02de42196ebee42ef284b6780a87cdc96e8eaab6
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    11:a91006e3a02f1edf631f7018e6e5684cf27dd905
   user:        Nicolas Dumazet <[e-mail]>
   date:        Sat Apr 30 15:24:48 2011 +0200
   files+:      D
   extra:       branch=default
   extra:       rebase_source=08483444fef91d6224f6655ee586a65d263ad34c
   extra:       source=32af7686d403cf45b5d95f2d70cebea587ac806a
   description:
   D
   
   
   $ hg up -qr 'desc(G)'
   $ hg graft 4596109a6a4328c398bde3a4a3b6737cfade3003
   grafting 11:4596109a6a43 "D"
   $ hg up -qr 'desc(E)'
   $ hg rebase -s tip -d .
   rebasing 14:9e36056a46e3 "D" (tip)
   $ hg log --style default --debug -r tip
   changeset:   15:627d4614809036ba22b9e7cb31638ddc06ab99ab
   tag:         tip
   phase:       draft
   parent:      4:9520eea781bcca16c1e15acc0ba14335a0e8e5ba
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    15:648e8ede73ae3e497d093d3a4c8fcc2daa864f42
   user:        Nicolas Dumazet <[e-mail]>
   date:        Sat Apr 30 15:24:48 2011 +0200
   files+:      D
   extra:       branch=default
   extra:       intermediate-source=4596109a6a4328c398bde3a4a3b6737cfade3003
   extra:       rebase_source=9e36056a46e37c9776168c7375734eebc70e294f
   extra:       source=32af7686d403cf45b5d95f2d70cebea587ac806a
   description:
   D
   
   
 Start rebase from a commit that is obsolete but not hidden only because it's
 a working copy parent. We should be moved back to the starting commit as usual
 even though it is hidden (until we're moved there).
 
   $ hg --hidden up -qr 'first(hidden())'
   updated to hidden changeset 42ccdea3bb16
   (hidden revision '42ccdea3bb16' is pruned)
   $ hg rebase --rev 13 --dest 15
   rebasing 13:98f6af4ee953 "C"
   $ hg log -G
   o  16:294a2b93eb4d C
   |
   o  15:627d46148090 D
   |
   | o  12:462a34d07e59 B
   | |
   | o  11:4596109a6a43 D
   | |
   | o  7:02de42196ebe H
   | |
   +---o  6:eea13746799a G
   | |/
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   | @  1:42ccdea3bb16 B (pruned using rebase)
   |/
   o  0:cd010b8cd998 A
   
 
   $ cd ..
 
 collapse rebase
 ---------------------------------
 
   $ hg clone base collapse
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd collapse
   $ hg rebase  -s 42ccdea3bb16 -d eea13746799a --collapse
   rebasing 1:42ccdea3bb16 "B"
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   $ hg log -G
   o  8:4dc2197e807b Collapsed revision
   |
   | @  7:02de42196ebe H
   | |
   o |  6:eea13746799a G
   |\|
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
   $ hg log --hidden -G
   o  8:4dc2197e807b Collapsed revision
   |
   | @  7:02de42196ebe H
   | |
   o |  6:eea13746799a G
   |\|
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   | x  3:32af7686d403 D (rewritten using rebase as 8:4dc2197e807b)
   | |
   | x  2:5fddd98957c8 C (rewritten using rebase as 8:4dc2197e807b)
   | |
   | x  1:42ccdea3bb16 B (rewritten using rebase as 8:4dc2197e807b)
   |/
   o  0:cd010b8cd998 A
   
   $ hg id --debug -r tip
   4dc2197e807bae9817f09905b50ab288be2dbbcf tip
   $ hg debugobsolete
   42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 4dc2197e807bae9817f09905b50ab288be2dbbcf 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'fold-id': '6fb65cdc', 'fold-idx': '1', 'fold-size': '3', 'operation': 'rebase', 'user': 'test'}
   5fddd98957c8a54a4d436dfe1da9d87f21a1b97b 4dc2197e807bae9817f09905b50ab288be2dbbcf 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'fold-id': '6fb65cdc', 'fold-idx': '2', 'fold-size': '3', 'operation': 'rebase', 'user': 'test'}
   32af7686d403cf45b5d95f2d70cebea587ac806a 4dc2197e807bae9817f09905b50ab288be2dbbcf 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'fold-id': '6fb65cdc', 'fold-idx': '3', 'fold-size': '3', 'operation': 'rebase', 'user': 'test'}
 
   $ cd ..
 
 Rebase set has hidden descendants
 ---------------------------------
 
 We rebase a changeset which has hidden descendants. Hidden changesets must not
 be rebased.
 
   $ hg clone base hidden
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd hidden
   $ hg log -G
   @  7:02de42196ebe H
   |
   | o  6:eea13746799a G
   |/|
   o |  5:24b6387c8c8c F
   | |
   | o  4:9520eea781bc E
   |/
   | o  3:32af7686d403 D
   | |
   | o  2:5fddd98957c8 C
   | |
   | o  1:42ccdea3bb16 B
   |/
   o  0:cd010b8cd998 A
   
   $ hg rebase -s 5fddd98957c8 -d eea13746799a
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   $ hg log -G
   o  9:cf44d2f5a9f4 D
   |
   o  8:e273c5e7d2d2 C
   |
   | @  7:02de42196ebe H
   | |
   o |  6:eea13746799a G
   |\|
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   | o  1:42ccdea3bb16 B
   |/
   o  0:cd010b8cd998 A
   
   $ hg rebase -s 42ccdea3bb16 -d 02de42196ebe
   rebasing 1:42ccdea3bb16 "B"
   $ hg log -G
   o  10:7c6027df6a99 B
   |
   | o  9:cf44d2f5a9f4 D
   | |
   | o  8:e273c5e7d2d2 C
   | |
   @ |  7:02de42196ebe H
   | |
   | o  6:eea13746799a G
   |/|
   o |  5:24b6387c8c8c F
   | |
   | o  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
   $ hg log --hidden -G
   o  10:7c6027df6a99 B
   |
   | o  9:cf44d2f5a9f4 D
   | |
   | o  8:e273c5e7d2d2 C
   | |
   @ |  7:02de42196ebe H
   | |
   | o  6:eea13746799a G
   |/|
   o |  5:24b6387c8c8c F
   | |
   | o  4:9520eea781bc E
   |/
   | x  3:32af7686d403 D (rewritten using rebase as 9:cf44d2f5a9f4)
   | |
   | x  2:5fddd98957c8 C (rewritten using rebase as 8:e273c5e7d2d2)
   | |
   | x  1:42ccdea3bb16 B (rewritten using rebase as 10:7c6027df6a99)
   |/
   o  0:cd010b8cd998 A
   
   $ hg debugobsolete
   5fddd98957c8a54a4d436dfe1da9d87f21a1b97b e273c5e7d2d29df783dce9f9eaa3ac4adc69c15d 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   32af7686d403cf45b5d95f2d70cebea587ac806a cf44d2f5a9f4297a62be94cbdd3dff7c7dc54258 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
   42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 7c6027df6a99d93f461868e5433f63bde20b6dfb 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
 
 Test that rewriting leaving instability behind is allowed
 ---------------------------------------------------------------------
 
   $ hg log -r 'children(8)'
   9:cf44d2f5a9f4 D (no-eol)
   $ hg rebase -r 8
   rebasing 8:e273c5e7d2d2 "C"
   1 new orphan changesets
   $ hg log -G
   o  11:0d8f238b634c C
   |
   o  10:7c6027df6a99 B
   |
   | *  9:cf44d2f5a9f4 D
   | |
   | x  8:e273c5e7d2d2 C (rewritten using rebase as 11:0d8f238b634c)
   | |
   @ |  7:02de42196ebe H
   | |
   | o  6:eea13746799a G
   |/|
   o |  5:24b6387c8c8c F
   | |
   | o  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
   $ cd ..
   $ cp -R hidden stabilize
   $ cd stabilize
   $ hg rebase --auto-orphans '0::' -d 10
   abort: cannot specify both --auto-orphans and --dest
   [255]
   $ hg rebase --auto-orphans '0::'
   rebasing 9:cf44d2f5a9f4 "D"
   $ hg log -G
   o  12:7e3935feaa68 D
   |
   o  11:0d8f238b634c C
   |
   o  10:7c6027df6a99 B
   |
   @  7:02de42196ebe H
   |
   | o  6:eea13746799a G
   |/|
   o |  5:24b6387c8c8c F
   | |
   | o  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
 
   $ cd ../hidden
   $ rm -r ../stabilize
 
 Test multiple root handling
 ------------------------------------
 
   $ hg rebase --dest 4 --rev '7+11+9'
   rebasing 9:cf44d2f5a9f4 "D"
   rebasing 7:02de42196ebe "H"
   rebasing 11:0d8f238b634c "C" (tip)
   $ hg log -G
   o  14:1e8370e38cca C
   |
   @  13:bfe264faf697 H
   |
   | o  12:102b4c1d889b D
   |/
   | *  10:7c6027df6a99 B
   | |
   | x  7:02de42196ebe H (rewritten using rebase as 13:bfe264faf697)
   | |
   +---o  6:eea13746799a G
   | |/
   | o  5:24b6387c8c8c F
   | |
   o |  4:9520eea781bc E
   |/
   o  0:cd010b8cd998 A
   
   $ cd ..
 
 Detach both parents
 
   $ hg init double-detach
   $ cd double-detach
 
   $ hg debugdrawdag <<EOF
   >   F
   >  /|
   > C E
   > | |
   > B D G
   >  \|/
   >   A
   > EOF
 
   $ hg rebase -d G -r 'B + D + F'
   rebasing 1:112478962961 "B" (B)
   rebasing 2:b18e25de2cf5 "D" (D)
   rebasing 6:f15c3adaf214 "F" (F tip)
   abort: cannot rebase 6:f15c3adaf214 without moving at least one of its parents
   [255]
 
   $ cd ..
 
 test on rebase dropping a merge
 
 (setup)
 
   $ hg init dropmerge
   $ cd dropmerge
   $ hg unbundle "$TESTDIR/bundles/rebase.hg"
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   new changesets cd010b8cd998:02de42196ebe (8 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up 3
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 7
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'M'
   $ echo I > I
   $ hg add I
   $ hg ci -m I
   $ hg log -G
   @  9:4bde274eefcf I
   |
   o    8:53a6a128b2b7 M
   |\
   | o  7:02de42196ebe H
   | |
   | | o  6:eea13746799a G
   | |/|
   | o |  5:24b6387c8c8c F
   | | |
   | | o  4:9520eea781bc E
   | |/
   o |  3:32af7686d403 D
   | |
   o |  2:5fddd98957c8 C
   | |
   o |  1:42ccdea3bb16 B
   |/
   o  0:cd010b8cd998 A
   
 (actual test)
 
   $ hg rebase --dest 6 --rev '((desc(H) + desc(D))::) - desc(M)'
   rebasing 3:32af7686d403 "D"
   rebasing 7:02de42196ebe "H"
   rebasing 9:4bde274eefcf "I" (tip)
   1 new orphan changesets
   $ hg log -G
   @  12:acd174b7ab39 I
   |
   o  11:6c11a6218c97 H
   |
   | o  10:b5313c85b22e D
   |/
   | *    8:53a6a128b2b7 M
   | |\
   | | x  7:02de42196ebe H (rewritten using rebase as 11:6c11a6218c97)
   | | |
   o---+  6:eea13746799a G
   | | |
   | | o  5:24b6387c8c8c F
   | | |
   o---+  4:9520eea781bc E
    / /
   x |  3:32af7686d403 D (rewritten using rebase as 10:b5313c85b22e)
   | |
   o |  2:5fddd98957c8 C
   | |
   o |  1:42ccdea3bb16 B
   |/
   o  0:cd010b8cd998 A
   
 
 Test hidden changesets in the rebase set (issue4504)
 
   $ hg up --hidden 9
   3 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to hidden changeset 4bde274eefcf
   (hidden revision '4bde274eefcf' was rewritten as: acd174b7ab39)
   $ echo J > J
   $ hg add J
   $ hg commit -m J
   1 new orphan changesets
   $ hg debugobsolete `hg log --rev . -T '{node}'`
   1 new obsolescence markers
   obsoleted 1 changesets
 
   $ hg rebase --rev .~1::. --dest 'max(desc(D))' --traceback --config experimental.rebaseskipobsolete=off
   rebasing 9:4bde274eefcf "I"
   rebasing 13:06edfc82198f "J" (tip)
   2 new content-divergent changesets
   $ hg log -G
   @  15:5ae8a643467b J
   |
   *  14:9ad579b4a5de I
   |
   | *  12:acd174b7ab39 I
   | |
   | o  11:6c11a6218c97 H
   | |
   o |  10:b5313c85b22e D
   |/
   | *    8:53a6a128b2b7 M
   | |\
   | | x  7:02de42196ebe H (rewritten using rebase as 11:6c11a6218c97)
   | | |
   o---+  6:eea13746799a G
   | | |
   | | o  5:24b6387c8c8c F
   | | |
   o---+  4:9520eea781bc E
    / /
   x |  3:32af7686d403 D (rewritten using rebase as 10:b5313c85b22e)
   | |
   o |  2:5fddd98957c8 C
   | |
   o |  1:42ccdea3bb16 B
   |/
   o  0:cd010b8cd998 A
   
   $ hg up 14 -C
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "K" > K
   $ hg add K
   $ hg commit --amend -m "K"
   1 new orphan changesets
   $ echo "L" > L
   $ hg add L
   $ hg commit -m "L"
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "M" > M
   $ hg add M
   $ hg commit --amend -m "M"
   1 new orphan changesets
   $ hg log -G
   @  18:bfaedf8eb73b M
   |
   | *  17:97219452e4bd L
   | |
   | x  16:fc37a630c901 K (rewritten using amend as 18:bfaedf8eb73b)
   |/
   | *  15:5ae8a643467b J
   | |
   | x  14:9ad579b4a5de I (rewritten using amend as 16:fc37a630c901)
   |/
   | *  12:acd174b7ab39 I
   | |
   | o  11:6c11a6218c97 H
   | |
   o |  10:b5313c85b22e D
   |/
   | *    8:53a6a128b2b7 M
   | |\
   | | x  7:02de42196ebe H (rewritten using rebase as 11:6c11a6218c97)
   | | |
   o---+  6:eea13746799a G
   | | |
   | | o  5:24b6387c8c8c F
   | | |
   o---+  4:9520eea781bc E
    / /
   x |  3:32af7686d403 D (rewritten using rebase as 10:b5313c85b22e)
   | |
   o |  2:5fddd98957c8 C
   | |
   o |  1:42ccdea3bb16 B
   |/
   o  0:cd010b8cd998 A
   
   $ hg rebase -s 14 -d 17 --config experimental.rebaseskipobsolete=True
   note: not rebasing 14:9ad579b4a5de "I", already in destination as 16:fc37a630c901 "K"
   rebasing 15:5ae8a643467b "J"
   1 new orphan changesets
 
   $ cd ..
 
 Skip obsolete changeset even with multiple hops
 -----------------------------------------------
 
 setup
 
   $ hg init obsskip
   $ cd obsskip
   $ cat << EOF >> .hg/hgrc
   > [experimental]
   > rebaseskipobsolete = True
   > [extensions]
   > strip =
   > EOF
   $ echo A > A
   $ hg add A
   $ hg commit -m A
   $ echo B > B
   $ hg add B
   $ hg commit -m B0
   $ hg commit --amend -m B1
   $ hg commit --amend -m B2
   $ hg up --hidden 'desc(B0)'
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to hidden changeset a8b11f55fb19
   (hidden revision 'a8b11f55fb19' was rewritten as: 261e70097290)
   $ echo C > C
   $ hg add C
   $ hg commit -m C
   1 new orphan changesets
   $ hg log -G
   @  4:212cb178bcbb C
   |
   | o  3:261e70097290 B2
   | |
   x |  1:a8b11f55fb19 B0 (rewritten using amend as 3:261e70097290)
   |/
   o  0:4a2df7238c3b A
   
 
 Rebase finds its way in a chain of marker
 
   $ hg rebase -d 'desc(B2)'
   note: not rebasing 1:a8b11f55fb19 "B0", already in destination as 3:261e70097290 "B2"
   rebasing 4:212cb178bcbb "C" (tip)
 
 Even when the chain include missing node
 
   $ hg up --hidden 'desc(B0)'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to hidden changeset a8b11f55fb19
   (hidden revision 'a8b11f55fb19' was rewritten as: 261e70097290)
   $ echo D > D
   $ hg add D
   $ hg commit -m D
   1 new orphan changesets
   $ hg --hidden strip -r 'desc(B1)'
   saved backup bundle to $TESTTMP/obsskip/.hg/strip-backup/86f6414ccda7-b1c452ee-backup.hg
   1 new orphan changesets
   $ hg log -G
   @  5:1a79b7535141 D
   |
   | o  4:ff2c4d47b71d C
   | |
   | o  2:261e70097290 B2
   | |
   x |  1:a8b11f55fb19 B0 (rewritten using amend as 2:261e70097290)
   |/
   o  0:4a2df7238c3b A
   
 
   $ hg rebase -d 'desc(B2)'
   note: not rebasing 1:a8b11f55fb19 "B0", already in destination as 2:261e70097290 "B2"
   rebasing 5:1a79b7535141 "D" (tip)
   $ hg up 4
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "O" > O
   $ hg add O
   $ hg commit -m O
   $ echo "P" > P
   $ hg add P
   $ hg commit -m P
   $ hg log -G
   @  8:8d47583e023f P
   |
   o  7:360bbaa7d3ce O
   |
   | o  6:9c48361117de D
   | |
   o |  4:ff2c4d47b71d C
   |/
   o  2:261e70097290 B2
   |
   o  0:4a2df7238c3b A
   
   $ hg debugobsolete `hg log -r 7 -T '{node}\n'` --config experimental.evolution=true
   1 new obsolescence markers
   obsoleted 1 changesets
   1 new orphan changesets
   $ hg rebase -d 6 -r "4::"
   rebasing 4:ff2c4d47b71d "C"
   note: not rebasing 7:360bbaa7d3ce "O", it has no successor
   rebasing 8:8d47583e023f "P" (tip)
 
 If all the changeset to be rebased are obsolete and present in the destination, we
 should display a friendly error message
 
   $ hg log -G
   @  10:121d9e3bc4c6 P
   |
   o  9:4be60e099a77 C
   |
   o  6:9c48361117de D
   |
   o  2:261e70097290 B2
   |
   o  0:4a2df7238c3b A
   
 
   $ hg up 9
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "non-relevant change" > nonrelevant
   $ hg add nonrelevant
   $ hg commit -m nonrelevant
   created new head
   $ hg debugobsolete `hg log -r 11 -T '{node}\n'` --config experimental.evolution=true
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg log -G
   @  11:f44da1f4954c nonrelevant (pruned)
   |
   | o  10:121d9e3bc4c6 P
   |/
   o  9:4be60e099a77 C
   |
   o  6:9c48361117de D
   |
   o  2:261e70097290 B2
   |
   o  0:4a2df7238c3b A
   
   $ hg rebase -r . -d 10
   note: not rebasing 11:f44da1f4954c "nonrelevant" (tip), it has no successor
 
 If a rebase is going to create divergence, it should abort
 
   $ hg log -G
   @  10:121d9e3bc4c6 P
   |
   o  9:4be60e099a77 C
   |
   o  6:9c48361117de D
   |
   o  2:261e70097290 B2
   |
   o  0:4a2df7238c3b A
   
 
   $ hg up 9
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "john" > doe
   $ hg add doe
   $ hg commit -m "john doe"
   created new head
   $ hg up 10
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "foo" > bar
   $ hg add bar
   $ hg commit --amend -m "10'"
   $ hg up 10 --hidden
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to hidden changeset 121d9e3bc4c6
   (hidden revision '121d9e3bc4c6' was rewritten as: 77d874d096a2)
   $ echo "bar" > foo
   $ hg add foo
   $ hg commit -m "bar foo"
   1 new orphan changesets
   $ hg log -G
   @  14:73568ab6879d bar foo
   |
   | o  13:77d874d096a2 10'
   | |
   | | o  12:3eb461388009 john doe
   | |/
   x |  10:121d9e3bc4c6 P (rewritten using amend as 13:77d874d096a2)
   |/
   o  9:4be60e099a77 C
   |
   o  6:9c48361117de D
   |
   o  2:261e70097290 B2
   |
   o  0:4a2df7238c3b A
   
   $ hg summary
   parent: 14:73568ab6879d tip (orphan)
    bar foo
   branch: default
   commit: (clean)
   update: 2 new changesets, 3 branch heads (merge)
   phases: 8 draft
   orphan: 1 changesets
   $ hg rebase -s 10 -d 12
   abort: this rebase will cause divergences from: 121d9e3bc4c6
   (to force the rebase please set experimental.evolution.allowdivergence=True)
   [255]
   $ hg log -G
   @  14:73568ab6879d bar foo
   |
   | o  13:77d874d096a2 10'
   | |
   | | o  12:3eb461388009 john doe
   | |/
   x |  10:121d9e3bc4c6 P (rewritten using amend as 13:77d874d096a2)
   |/
   o  9:4be60e099a77 C
   |
   o  6:9c48361117de D
   |
   o  2:261e70097290 B2
   |
   o  0:4a2df7238c3b A
   
 With experimental.evolution.allowdivergence=True, rebase can create divergence
 
   $ hg rebase -s 10 -d 12 --config experimental.evolution.allowdivergence=True
   rebasing 10:121d9e3bc4c6 "P"
   rebasing 14:73568ab6879d "bar foo" (tip)
   2 new content-divergent changesets
   $ hg summary
   parent: 16:61bd55f69bc4 tip
    bar foo
   branch: default
   commit: (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 8 draft
   content-divergent: 2 changesets
 
 rebase --continue + skipped rev because their successors are in destination
 we make a change in trunk and work on conflicting changes to make rebase abort.
 
   $ hg log -G -r 16::
   @  16:61bd55f69bc4 bar foo
   |
   ~
 
 Create the two changes in trunk
   $ printf "a" > willconflict
   $ hg add willconflict
   $ hg commit -m "willconflict first version"
 
   $ printf "dummy" > C
   $ hg commit -m "dummy change successor"
 
 Create the changes that we will rebase
   $ hg update -C 16 -q
   $ printf "b" > willconflict
   $ hg add willconflict
   $ hg commit -m "willconflict second version"
   created new head
   $ printf "dummy" > K
   $ hg add K
   $ hg commit -m "dummy change"
   $ printf "dummy" > L
   $ hg add L
   $ hg commit -m "dummy change"
   $ hg debugobsolete `hg log -r ".^" -T '{node}'` `hg log -r 18 -T '{node}'` --config experimental.evolution=true
   1 new obsolescence markers
   obsoleted 1 changesets
   1 new orphan changesets
 
   $ hg log -G -r 16::
   @  21:7bdc8a87673d dummy change
   |
   x  20:8b31da3c4919 dummy change (rewritten as 18:601db7a18f51)
   |
   o  19:b82fb57ea638 willconflict second version
   |
   | o  18:601db7a18f51 dummy change successor
   | |
   | o  17:357ddf1602d5 willconflict first version
   |/
   o  16:61bd55f69bc4 bar foo
   |
   ~
   $ hg rebase -r ".^^ + .^ + ." -d 18
   rebasing 19:b82fb57ea638 "willconflict second version"
   merging willconflict
   warning: conflicts while merging willconflict! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ hg resolve --mark willconflict
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 19:b82fb57ea638 "willconflict second version"
   note: not rebasing 20:8b31da3c4919 "dummy change", already in destination as 18:601db7a18f51 "dummy change successor"
   rebasing 21:7bdc8a87673d "dummy change" (tip)
   $ cd ..
 
 Divergence cases due to obsolete changesets
 -------------------------------------------
 
 We should ignore branches with unstable changesets when they are based on an
 obsolete changeset which successor is in rebase set.
 
   $ hg init divergence
   $ cd divergence
   $ cat >> .hg/hgrc << EOF
   > [extensions]
   > strip =
   > [alias]
   > strip = strip --no-backup --quiet
   > [templates]
   > instabilities = '{rev}:{node|short} {desc|firstline}{if(instabilities," ({instabilities})")}\n'
   > EOF
 
   $ hg debugdrawdag <<EOF
   >   e   f
   >   |   |
   >   d'  d # replace: d -> d'
   >    \ /
   >     c
   >     |
   >   x b
   >    \|
   >     a
   > EOF
   1 new orphan changesets
   $ hg log -G -r 'a'::
   *  7:1143e9adc121 f
   |
   | o  6:d60ebfa0f1cb e
   | |
   | o  5:027ad6c5830d d'
   | |
   x |  4:76be324c128b d (rewritten using replace as 5:027ad6c5830d)
   |/
   o  3:a82ac2b38757 c
   |
   | o  2:630d7c95eff7 x
   | |
   o |  1:488e1b7e7341 b
   |/
   o  0:b173517d0057 a
   
 
 Changeset d and its descendants are excluded to avoid divergence of d, which
 would occur because the successor of d (d') is also in rebaseset. As a
 consequence f (descendant of d) is left behind.
 
   $ hg rebase -b 'e' -d 'x'
   rebasing 1:488e1b7e7341 "b" (b)
   rebasing 3:a82ac2b38757 "c" (c)
   rebasing 5:027ad6c5830d "d'" (d')
   rebasing 6:d60ebfa0f1cb "e" (e)
   note: not rebasing 4:76be324c128b "d" (d) and its descendants as this would cause divergence
   $ hg log -G -r 'a'::
   o  11:eb6d63fc4ed5 e
   |
   o  10:44d8c724a70c d'
   |
   o  9:d008e6b4d3fd c
   |
   o  8:67e8f4a16c49 b
   |
   | *  7:1143e9adc121 f
   | |
   | | x  6:d60ebfa0f1cb e (rewritten using rebase as 11:eb6d63fc4ed5)
   | | |
   | | x  5:027ad6c5830d d' (rewritten using rebase as 10:44d8c724a70c)
   | | |
   | x |  4:76be324c128b d (rewritten using replace as 5:027ad6c5830d)
   | |/
   | x  3:a82ac2b38757 c (rewritten using rebase as 9:d008e6b4d3fd)
   | |
   o |  2:630d7c95eff7 x
   | |
   | x  1:488e1b7e7341 b (rewritten using rebase as 8:67e8f4a16c49)
   |/
   o  0:b173517d0057 a
   
   $ hg strip -r 8:
   $ hg log -G -r 'a'::
   *  7:1143e9adc121 f
   |
   | o  6:d60ebfa0f1cb e
   | |
   | o  5:027ad6c5830d d'
   | |
   x |  4:76be324c128b d (rewritten using replace as 5:027ad6c5830d)
   |/
   o  3:a82ac2b38757 c
   |
   | o  2:630d7c95eff7 x
   | |
   o |  1:488e1b7e7341 b
   |/
   o  0:b173517d0057 a
   
 
 If the rebase set has an obsolete (d) with a successor (d') outside the rebase
 set and none in destination, we still get the divergence warning.
 By allowing divergence, we can perform the rebase.
 
   $ hg rebase -r 'c'::'f' -d 'x'
   abort: this rebase will cause divergences from: 76be324c128b
   (to force the rebase please set experimental.evolution.allowdivergence=True)
   [255]
   $ hg rebase --config experimental.evolution.allowdivergence=true -r 'c'::'f' -d 'x'
   rebasing 3:a82ac2b38757 "c" (c)
   rebasing 4:76be324c128b "d" (d)
   rebasing 7:1143e9adc121 "f" (f tip)
   1 new orphan changesets
   2 new content-divergent changesets
   $ hg log -G -r 'a':: -T instabilities
   o  10:e1744ea07510 f
   |
   *  9:e2b36ea9a0a0 d (content-divergent)
   |
   o  8:6a0376de376e c
   |
   | x  7:1143e9adc121 f
   | |
   | | *  6:d60ebfa0f1cb e (orphan)
   | | |
   | | *  5:027ad6c5830d d' (orphan content-divergent)
   | | |
   | x |  4:76be324c128b d
   | |/
   | x  3:a82ac2b38757 c
   | |
   o |  2:630d7c95eff7 x
   | |
   | o  1:488e1b7e7341 b
   |/
   o  0:b173517d0057 a
   
   $ hg strip -r 8:
 
 (Not skipping obsoletes means that divergence is allowed.)
 
   $ hg rebase --config experimental.rebaseskipobsolete=false -r 'c'::'f' -d 'x'
   rebasing 3:a82ac2b38757 "c" (c)
   rebasing 4:76be324c128b "d" (d)
   rebasing 7:1143e9adc121 "f" (f tip)
   1 new orphan changesets
   2 new content-divergent changesets
 
   $ hg strip -r 0:
 
 Similar test on a more complex graph
 
   $ hg debugdrawdag <<EOF
   >       g
   >       |
   >   f   e
   >   |   |
   >   e'  d # replace: e -> e'
   >    \ /
   >     c
   >     |
   >   x b
   >    \|
   >     a
   > EOF
   1 new orphan changesets
   $ hg log -G -r 'a':
   *  8:2876ce66c6eb g
   |
   | o  7:3ffec603ab53 f
   | |
   x |  6:e36fae928aec e (rewritten using replace as 5:63324dc512ea)
   | |
   | o  5:63324dc512ea e'
   | |
   o |  4:76be324c128b d
   |/
   o  3:a82ac2b38757 c
   |
   | o  2:630d7c95eff7 x
   | |
   o |  1:488e1b7e7341 b
   |/
   o  0:b173517d0057 a
   
   $ hg rebase -b 'f' -d 'x'
   rebasing 1:488e1b7e7341 "b" (b)
   rebasing 3:a82ac2b38757 "c" (c)
   rebasing 5:63324dc512ea "e'" (e')
   rebasing 7:3ffec603ab53 "f" (f)
   rebasing 4:76be324c128b "d" (d)
   note: not rebasing 6:e36fae928aec "e" (e) and its descendants as this would cause divergence
   $ hg log -G -r 'a':
   o  13:a1707a5b7c2c d
   |
   | o  12:ef6251596616 f
   | |
   | o  11:b6f172e64af9 e'
   |/
   o  10:d008e6b4d3fd c
   |
   o  9:67e8f4a16c49 b
   |
   | *  8:2876ce66c6eb g
   | |
   | | x  7:3ffec603ab53 f (rewritten using rebase as 12:ef6251596616)
   | | |
   | x |  6:e36fae928aec e (rewritten using replace as 5:63324dc512ea)
   | | |
   | | x  5:63324dc512ea e' (rewritten using rebase as 11:b6f172e64af9)
   | | |
   | x |  4:76be324c128b d (rewritten using rebase as 13:a1707a5b7c2c)
   | |/
   | x  3:a82ac2b38757 c (rewritten using rebase as 10:d008e6b4d3fd)
   | |
   o |  2:630d7c95eff7 x
   | |
   | x  1:488e1b7e7341 b (rewritten using rebase as 9:67e8f4a16c49)
   |/
   o  0:b173517d0057 a
   
 
 issue5782
   $ hg strip -r 0:
   $ hg debugdrawdag <<EOF
   >       d
   >       |
   >   c1  c # replace: c -> c1
   >    \ /
   >     b
   >     |
   >     a
   > EOF
   1 new orphan changesets
   $ hg debugobsolete `hg log -T "{node}" --hidden -r 'desc("c1")'`
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg log -G -r 'a': --hidden
   *  4:76be324c128b d
   |
   | x  3:ef8a456de8fa c1 (pruned)
   | |
   x |  2:a82ac2b38757 c (rewritten using replace as 3:ef8a456de8fa)
   |/
   o  1:488e1b7e7341 b
   |
   o  0:b173517d0057 a
   
   $ hg rebase -d 0 -r 2
   rebasing 2:a82ac2b38757 "c" (c)
   $ hg log -G -r 'a': --hidden
   o  5:69ad416a4a26 c
   |
   | *  4:76be324c128b d
   | |
   | | x  3:ef8a456de8fa c1 (pruned)
   | | |
   | x |  2:a82ac2b38757 c (rewritten using replace as 3:ef8a456de8fa rewritten using rebase as 5:69ad416a4a26)
   | |/
   | o  1:488e1b7e7341 b
   |/
   o  0:b173517d0057 a
   
   $ cd ..
 
 Rebase merge where successor of one parent is equal to destination (issue5198)
 
   $ hg init p1-succ-is-dest
   $ cd p1-succ-is-dest
 
   $ hg debugdrawdag <<EOF
   >   F
   >  /|
   > E D B # replace: D -> B
   >  \|/
   >   A
   > EOF
   1 new orphan changesets
 
   $ hg rebase -d B -s D
   note: not rebasing 2:b18e25de2cf5 "D" (D), already in destination as 1:112478962961 "B" (B)
   rebasing 4:66f1a38021c9 "F" (F tip)
   $ hg log -G
   o    5:50e9d60b99c6 F
   |\
   | | x  4:66f1a38021c9 F (rewritten using rebase as 5:50e9d60b99c6)
   | |/|
   | o |  3:7fb047a69f22 E
   | | |
   | | x  2:b18e25de2cf5 D (rewritten using replace as 1:112478962961)
   | |/
   o |  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
   $ cd ..
 
 Rebase merge where successor of other parent is equal to destination
 
   $ hg init p2-succ-is-dest
   $ cd p2-succ-is-dest
 
   $ hg debugdrawdag <<EOF
   >   F
   >  /|
   > E D B # replace: E -> B
   >  \|/
   >   A
   > EOF
   1 new orphan changesets
 
   $ hg rebase -d B -s E
   note: not rebasing 3:7fb047a69f22 "E" (E), already in destination as 1:112478962961 "B" (B)
   rebasing 4:66f1a38021c9 "F" (F tip)
   $ hg log -G
   o    5:aae1787dacee F
   |\
   | | x  4:66f1a38021c9 F (rewritten using rebase as 5:aae1787dacee)
   | |/|
   | | x  3:7fb047a69f22 E (rewritten using replace as 1:112478962961)
   | | |
   | o |  2:b18e25de2cf5 D
   | |/
   o /  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
   $ cd ..
 
 Rebase merge where successor of one parent is ancestor of destination
 
   $ hg init p1-succ-in-dest
   $ cd p1-succ-in-dest
 
   $ hg debugdrawdag <<EOF
   >   F C
   >  /| |
   > E D B # replace: D -> B
   >  \|/
   >   A
   > EOF
   1 new orphan changesets
 
   $ hg rebase -d C -s D
   note: not rebasing 2:b18e25de2cf5 "D" (D), already in destination as 1:112478962961 "B" (B)
   rebasing 5:66f1a38021c9 "F" (F tip)
 
   $ hg log -G
   o    6:0913febf6439 F
   |\
   +---x  5:66f1a38021c9 F (rewritten using rebase as 6:0913febf6439)
   | | |
   | o |  4:26805aba1e60 C
   | | |
   o | |  3:7fb047a69f22 E
   | | |
   +---x  2:b18e25de2cf5 D (rewritten using replace as 1:112478962961)
   | |
   | o  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
   $ cd ..
 
 Rebase merge where successor of other parent is ancestor of destination
 
   $ hg init p2-succ-in-dest
   $ cd p2-succ-in-dest
 
   $ hg debugdrawdag <<EOF
   >   F C
   >  /| |
   > E D B # replace: E -> B
   >  \|/
   >   A
   > EOF
   1 new orphan changesets
 
   $ hg rebase -d C -s E
   note: not rebasing 3:7fb047a69f22 "E" (E), already in destination as 1:112478962961 "B" (B)
   rebasing 5:66f1a38021c9 "F" (F tip)
   $ hg log -G
   o    6:c6ab0cc6d220 F
   |\
   +---x  5:66f1a38021c9 F (rewritten using rebase as 6:c6ab0cc6d220)
   | | |
   | o |  4:26805aba1e60 C
   | | |
   | | x  3:7fb047a69f22 E (rewritten using replace as 1:112478962961)
   | | |
   o---+  2:b18e25de2cf5 D
    / /
   o /  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
   $ cd ..
 
 Rebase merge where successor of one parent is ancestor of destination
 
   $ hg init p1-succ-in-dest-b
   $ cd p1-succ-in-dest-b
 
   $ hg debugdrawdag <<EOF
   >   F C
   >  /| |
   > E D B # replace: E -> B
   >  \|/
   >   A
   > EOF
   1 new orphan changesets
 
   $ hg rebase -d C -b F
   rebasing 2:b18e25de2cf5 "D" (D)
   note: not rebasing 3:7fb047a69f22 "E" (E), already in destination as 1:112478962961 "B" (B)
   rebasing 5:66f1a38021c9 "F" (F tip)
   note: not rebasing 5:66f1a38021c9 "F" (F tip), its destination already has all its changes
   $ hg log -G
   o  6:8f47515dda15 D
   |
   | x    5:66f1a38021c9 F (pruned using rebase)
   | |\
   o | |  4:26805aba1e60 C
   | | |
   | | x  3:7fb047a69f22 E (rewritten using replace as 1:112478962961)
   | | |
   | x |  2:b18e25de2cf5 D (rewritten using rebase as 6:8f47515dda15)
   | |/
   o /  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
   $ cd ..
 
 Rebase merge where successor of other parent is ancestor of destination
 
   $ hg init p2-succ-in-dest-b
   $ cd p2-succ-in-dest-b
 
   $ hg debugdrawdag <<EOF
   >   F C
   >  /| |
   > E D B # replace: D -> B
   >  \|/
   >   A
   > EOF
   1 new orphan changesets
 
   $ hg rebase -d C -b F
   note: not rebasing 2:b18e25de2cf5 "D" (D), already in destination as 1:112478962961 "B" (B)
   rebasing 3:7fb047a69f22 "E" (E)
   rebasing 5:66f1a38021c9 "F" (F tip)
   note: not rebasing 5:66f1a38021c9 "F" (F tip), its destination already has all its changes
 
   $ hg log -G
   o  6:533690786a86 E
   |
   | x    5:66f1a38021c9 F (pruned using rebase)
   | |\
   o | |  4:26805aba1e60 C
   | | |
   | | x  3:7fb047a69f22 E (rewritten using rebase as 6:533690786a86)
   | | |
   | x |  2:b18e25de2cf5 D (rewritten using replace as 1:112478962961)
   | |/
   o /  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
   $ cd ..
 
 Rebase merge where extinct node has successor that is not an ancestor of
 destination
 
   $ hg init extinct-with-succ-not-in-dest
   $ cd extinct-with-succ-not-in-dest
 
   $ hg debugdrawdag <<EOF
   > E C # replace: C -> E
   > | |
   > D B
   > |/
   > A
   > EOF
 
   $ hg rebase -d D -s B
   rebasing 1:112478962961 "B" (B)
   note: not rebasing 3:26805aba1e60 "C" (C) and its descendants as this would cause divergence
 
   $ cd ..
 
   $ hg init p2-succ-in-dest-c
   $ cd p2-succ-in-dest-c
 
 The scenario here was that B::D were developed on default.  B was queued on
 stable, but amended before being push to hg-committed.  C was queued on default,
 along with unrelated J.
 
   $ hg debugdrawdag <<EOF
   > J
   > |
   > F
   > |
   > E
   > | D
   > | |
   > | C      # replace: C -> F
   > | |  H I # replace: B -> H -> I
   > | B  |/
   > |/   G
   > A
   > EOF
   1 new orphan changesets
 
 This strip seems to be the key to avoid an early divergence warning.
   $ hg --config extensions.strip= --hidden strip -qr H
   1 new orphan changesets
 
   $ hg rebase -b 'desc("D")' -d 'desc("J")'
   abort: this rebase will cause divergences from: 112478962961
   (to force the rebase please set experimental.evolution.allowdivergence=True)
   [255]
 
 Rebase merge where both parents have successors in destination
 
   $ hg init p12-succ-in-dest
   $ cd p12-succ-in-dest
   $ hg debugdrawdag <<'EOS'
   >   E   F
   >  /|  /|  # replace: A -> C
   > A B C D  # replace: B -> D
   > | |
   > X Y
   > EOS
   1 new orphan changesets
   $ hg rebase -r A+B+E -d F
   note: not rebasing 4:a3d17304151f "A" (A), already in destination as 0:96cc3511f894 "C" (C)
   note: not rebasing 5:b23a2cc00842 "B" (B), already in destination as 1:058c1e1fb10a "D" (D)
   rebasing 7:dac5d11c5a7d "E" (E tip)
   abort: rebasing 7:dac5d11c5a7d will include unwanted changes from 3:59c792af609c, 5:b23a2cc00842 or 2:ba2b7fa7166d, 4:a3d17304151f
   [255]
   $ cd ..
 
 Rebase a non-clean merge. One parent has successor in destination, the other
 parent moves as requested.
 
   $ hg init p1-succ-p2-move
   $ cd p1-succ-p2-move
   $ hg debugdrawdag <<'EOS'
   >   D Z
   >  /| | # replace: A -> C
   > A B C # D/D = D
   > EOS
   1 new orphan changesets
   $ hg rebase -r A+B+D -d Z
   note: not rebasing 0:426bada5c675 "A" (A), already in destination as 2:96cc3511f894 "C" (C)
   rebasing 1:fc2b737bb2e5 "B" (B)
   rebasing 3:b8ed089c80ad "D" (D)
 
   $ rm .hg/localtags
   $ hg log -G
   o  6:e4f78693cc88 D
   |
   o  5:76840d832e98 B
   |
   o  4:50e41c1f3950 Z
   |
   o  2:96cc3511f894 C
   
   $ hg files -r tip
   B
   C
   D
   Z
 
   $ cd ..
 
   $ hg init p1-move-p2-succ
   $ cd p1-move-p2-succ
   $ hg debugdrawdag <<'EOS'
   >   D Z
   >  /| |  # replace: B -> C
   > A B C  # D/D = D
   > EOS
   1 new orphan changesets
   $ hg rebase -r B+A+D -d Z
   rebasing 0:426bada5c675 "A" (A)
   note: not rebasing 1:fc2b737bb2e5 "B" (B), already in destination as 2:96cc3511f894 "C" (C)
   rebasing 3:b8ed089c80ad "D" (D)
 
   $ rm .hg/localtags
   $ hg log -G
   o  6:1b355ed94d82 D
   |
   o  5:a81a74d764a6 A
   |
   o  4:50e41c1f3950 Z
   |
   o  2:96cc3511f894 C
   
   $ hg files -r tip
   A
   C
   D
   Z
 
   $ cd ..
 
 Test that bookmark is moved and working dir is updated when all changesets have
 equivalents in destination
   $ hg init rbsrepo && cd rbsrepo
   $ echo "[experimental]" > .hg/hgrc
   $ echo "evolution=true" >> .hg/hgrc
   $ echo "rebaseskipobsolete=on" >> .hg/hgrc
   $ echo root > root && hg ci -Am root
   adding root
   $ echo a > a && hg ci -Am a
   adding a
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b > b && hg ci -Am b
   adding b
   created new head
   $ hg rebase -r 2 -d 1
   rebasing 2:1e9a3c00cbe9 "b" (tip)
   $ hg log -r .  # working dir is at rev 3 (successor of 2)
   3:be1832deae9a b (no-eol)
   $ hg book -r 2 mybook --hidden  # rev 2 has a bookmark on it now
   bookmarking hidden changeset 1e9a3c00cbe9
   (hidden revision '1e9a3c00cbe9' was rewritten as: be1832deae9a)
   $ hg up 2 && hg log -r .  # working dir is at rev 2 again
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   2:1e9a3c00cbe9 b (rewritten using rebase as 3:be1832deae9a) (no-eol)
   $ hg rebase -r 2 -d 3 --config experimental.evolution.track-operation=1
   note: not rebasing 2:1e9a3c00cbe9 "b" (mybook), already in destination as 3:be1832deae9a "b" (tip)
 Check that working directory and bookmark was updated to rev 3 although rev 2
 was skipped
   $ hg log -r .
   3:be1832deae9a b (no-eol)
   $ hg bookmarks
      mybook                    3:be1832deae9a
   $ hg debugobsolete --rev tip
   1e9a3c00cbe90d236ac05ef61efcc5e40b7412bc be1832deae9ac531caa7438b8dcf6055a122cd8e 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'rebase', 'user': 'test'}
 
 Obsoleted working parent and bookmark could be moved if an ancestor of working
 parent gets moved:
 
   $ hg init $TESTTMP/ancestor-wd-move
   $ cd $TESTTMP/ancestor-wd-move
   $ hg debugdrawdag <<'EOS'
   >  E D1  # rebase: D1 -> D2
   >  | |
   >  | C
   > D2 |
   >  | B
   >  |/
   >  A
   > EOS
   $ hg update D1 -q
   $ hg bookmark book -i
   $ hg rebase -r B+D1 -d E
   rebasing 1:112478962961 "B" (B)
   note: not rebasing 5:15ecf15e0114 "D1" (book D1 tip), already in destination as 2:0807738e0be9 "D2" (D2)
   1 new orphan changesets
   $ hg log -G -T '{desc} {bookmarks}'
   @  B book
   |
   | x  D1
   | |
   o |  E
   | |
   | *  C
   | |
   o |  D2
   | |
   | x  B
   |/
   o  A
   
 Rebasing a merge with one of its parent having a hidden successor
 
   $ hg init $TESTTMP/merge-p1-hidden-successor
   $ cd $TESTTMP/merge-p1-hidden-successor
 
   $ hg debugdrawdag <<'EOS'
   >  E
   >  |
   > B3 B2 # amend: B1 -> B2 -> B3
   >  |/   # B2 is hidden
   >  |  D
   >  |  |\
   >  | B1 C
   >  |/
   >  A
   > EOS
   1 new orphan changesets
 
   $ eval `hg tags -T '{tag}={node}\n'`
   $ rm .hg/localtags
 
   $ hg rebase -r $D -d $E
   rebasing 5:9e62094e4d94 "D"
 
   $ hg log -G
   o    7:a699d059adcf D
   |\
   | o  6:ecc93090a95c E
   | |
   | o  4:0dc878468a23 B3
   | |
   o |  1:96cc3511f894 C
    /
   o  0:426bada5c675 A
   
 For some reasons (--hidden, rebaseskipobsolete=0, directaccess, etc.),
 rebasestate may contain hidden hashes. "rebase --abort" should work regardless.
 
   $ hg init $TESTTMP/hidden-state1
   $ cd $TESTTMP/hidden-state1
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > rebaseskipobsolete=0
   > EOF
 
   $ hg debugdrawdag <<'EOS'
   >    C
   >    |
   >  D B # prune: B, C
   >  |/  # B/D=B
   >  A
   > EOS
 
   $ eval `hg tags -T '{tag}={node}\n'`
   $ rm .hg/localtags
 
   $ hg update -q $C --hidden
   updated to hidden changeset 7829726be4dc
   (hidden revision '7829726be4dc' is pruned)
   $ hg rebase -s $B -d $D
   rebasing 1:2ec65233581b "B"
   merging D
   warning: conflicts while merging D! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ cp -R . $TESTTMP/hidden-state2
 
   $ hg log -G
   @  2:b18e25de2cf5 D
   |
-  | @  1:2ec65233581b B (pruned using prune)
-  |/
   o  0:426bada5c675 A
   
   $ hg summary
   parent: 2:b18e25de2cf5 tip
    D
-  parent: 1:2ec65233581b  (obsolete)
-   B
   branch: default
-  commit: 2 modified, 1 unknown, 1 unresolved (merge)
+  commit: 1 modified, 1 added, 1 unknown, 1 unresolved
   update: (current)
-  phases: 3 draft
+  phases: 2 draft
   rebase: 0 rebased, 2 remaining (rebase --continue)
 
   $ hg rebase --abort
   rebase aborted
 
 Also test --continue for the above case
 
   $ cd $TESTTMP/hidden-state2
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 1:2ec65233581b "B"
   rebasing 3:7829726be4dc "C" (tip)
   $ hg log -G
   @  5:1964d5d5b547 C
   |
   o  4:68deb90c12a2 B
   |
   o  2:b18e25de2cf5 D
   |
   o  0:426bada5c675 A
   
 ====================
 Test --stop option |
 ====================
   $ cd ..
   $ hg init rbstop
   $ cd rbstop
   $ echo a>a
   $ hg ci -Aqma
   $ echo b>b
   $ hg ci -Aqmb
   $ echo c>c
   $ hg ci -Aqmc
   $ echo d>d
   $ hg ci -Aqmd
   $ hg up 0 -q
   $ echo f>f
   $ hg ci -Aqmf
   $ echo D>d
   $ hg ci -Aqm "conflict with d"
   $ hg up 3 -q
   $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
   o  5:00bfc9898aeb test
   |  conflict with d
   |
   o  4:dafd40200f93 test
   |  f
   |
   | @  3:055a42cdd887 test
   | |  d
   | |
   | o  2:177f92b77385 test
   | |  c
   | |
   | o  1:d2ae7f538514 test
   |/   b
   |
   o  0:cb9a9f314b8b test
      a
   
   $ hg rebase -s 1 -d 5
   rebasing 1:d2ae7f538514 "b"
   rebasing 2:177f92b77385 "c"
   rebasing 3:055a42cdd887 "d"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg rebase --stop
   1 new orphan changesets
   $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
   o  7:7fffad344617 test
   |  c
   |
   o  6:b15528633407 test
   |  b
   |
   o  5:00bfc9898aeb test
   |  conflict with d
   |
   o  4:dafd40200f93 test
   |  f
   |
   | @  3:055a42cdd887 test
   | |  d
   | |
   | x  2:177f92b77385 test
   | |  c
   | |
   | x  1:d2ae7f538514 test
   |/   b
   |
   o  0:cb9a9f314b8b test
      a
   
 Test it aborts if unstable csets is not allowed:
 ===============================================
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.allowunstable=False
   > EOF
 
   $ hg strip 6 --no-backup -q
   $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
   o  5:00bfc9898aeb test
   |  conflict with d
   |
   o  4:dafd40200f93 test
   |  f
   |
   | @  3:055a42cdd887 test
   | |  d
   | |
   | o  2:177f92b77385 test
   | |  c
   | |
   | o  1:d2ae7f538514 test
   |/   b
   |
   o  0:cb9a9f314b8b test
      a
   
   $ hg rebase -s 1 -d 5
   rebasing 1:d2ae7f538514 "b"
   rebasing 2:177f92b77385 "c"
   rebasing 3:055a42cdd887 "d"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg rebase --stop
   abort: cannot remove original changesets with unrebased descendants
   (either enable obsmarkers to allow unstable revisions or use --keep to keep original changesets)
   [255]
   $ hg rebase --abort
   saved backup bundle to $TESTTMP/rbstop/.hg/strip-backup/b15528633407-6eb72b6f-backup.hg
   rebase aborted
 
 Test --stop when --keep is passed:
 ==================================
   $ hg rebase -s 1 -d 5 --keep
   rebasing 1:d2ae7f538514 "b"
   rebasing 2:177f92b77385 "c"
   rebasing 3:055a42cdd887 "d"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg rebase --stop
   $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
   o  7:7fffad344617 test
   |  c
   |
   o  6:b15528633407 test
   |  b
   |
   o  5:00bfc9898aeb test
   |  conflict with d
   |
   o  4:dafd40200f93 test
   |  f
   |
   | @  3:055a42cdd887 test
   | |  d
   | |
   | o  2:177f92b77385 test
   | |  c
   | |
   | o  1:d2ae7f538514 test
   |/   b
   |
   o  0:cb9a9f314b8b test
      a
   
 Test --stop aborts when --collapse was passed:
 =============================================
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.allowunstable=True
   > EOF
 
   $ hg strip 6
   saved backup bundle to $TESTTMP/rbstop/.hg/strip-backup/b15528633407-6eb72b6f-backup.hg
   $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
   o  5:00bfc9898aeb test
   |  conflict with d
   |
   o  4:dafd40200f93 test
   |  f
   |
   | @  3:055a42cdd887 test
   | |  d
   | |
   | o  2:177f92b77385 test
   | |  c
   | |
   | o  1:d2ae7f538514 test
   |/   b
   |
   o  0:cb9a9f314b8b test
      a
   
   $ hg rebase -s 1 -d 5 --collapse -m "collapsed b c d"
   rebasing 1:d2ae7f538514 "b"
   rebasing 2:177f92b77385 "c"
   rebasing 3:055a42cdd887 "d"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg rebase --stop
   abort: cannot stop in --collapse session
   [255]
   $ hg rebase --abort
   rebase aborted
   $ hg diff
   $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
   o  5:00bfc9898aeb test
   |  conflict with d
   |
   o  4:dafd40200f93 test
   |  f
   |
   | @  3:055a42cdd887 test
   | |  d
   | |
   | o  2:177f92b77385 test
   | |  c
   | |
   | o  1:d2ae7f538514 test
   |/   b
   |
   o  0:cb9a9f314b8b test
      a
   
 Test --stop raise errors with conflicting options:
 =================================================
   $ hg rebase -s 3 -d 5
   rebasing 3:055a42cdd887 "d"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg rebase --stop --dry-run
   abort: cannot specify both --stop and --dry-run
   [255]
 
   $ hg rebase -s 3 -d 5
   abort: rebase in progress
   (use 'hg rebase --continue' or 'hg rebase --abort')
   [255]
   $ hg rebase --stop --continue
   abort: cannot specify both --stop and --continue
   [255]
 
 Test --stop moves bookmarks of original revisions to new rebased nodes:
 ======================================================================
   $ cd ..
   $ hg init repo
   $ cd repo
 
   $ echo a > a
   $ hg ci -Am A
   adding a
 
   $ echo b > b
   $ hg ci -Am B
   adding b
   $ hg book X
   $ hg book Y
 
   $ echo c > c
   $ hg ci -Am C
   adding c
   $ hg book Z
 
   $ echo d > d
   $ hg ci -Am D
   adding d
 
   $ hg up 0 -q
   $ echo e > e
   $ hg ci -Am E
   adding e
   created new head
 
   $ echo doubt > d
   $ hg ci -Am "conflict with d"
   adding d
 
   $ hg log -GT "{rev}: {node|short} '{desc}' bookmarks: {bookmarks}\n"
   @  5: 39adf30bc1be 'conflict with d' bookmarks:
   |
   o  4: 9c1e55f411b6 'E' bookmarks:
   |
   | o  3: 67a385d4e6f2 'D' bookmarks: Z
   | |
   | o  2: 49cb3485fa0c 'C' bookmarks: Y
   | |
   | o  1: 6c81ed0049f8 'B' bookmarks: X
   |/
   o  0: 1994f17a630e 'A' bookmarks:
   
   $ hg rebase -s 1 -d 5
   rebasing 1:6c81ed0049f8 "B" (X)
   rebasing 2:49cb3485fa0c "C" (Y)
   rebasing 3:67a385d4e6f2 "D" (Z)
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg rebase --stop
   1 new orphan changesets
   $ hg log -GT "{rev}: {node|short} '{desc}' bookmarks: {bookmarks}\n"
   o  7: 9c86c650b686 'C' bookmarks: Y
   |
   o  6: 9b87b54e5fd8 'B' bookmarks: X
   |
   @  5: 39adf30bc1be 'conflict with d' bookmarks:
   |
   o  4: 9c1e55f411b6 'E' bookmarks:
   |
   | *  3: 67a385d4e6f2 'D' bookmarks: Z
   | |
   | x  2: 49cb3485fa0c 'C' bookmarks:
   | |
   | x  1: 6c81ed0049f8 'B' bookmarks:
   |/
   o  0: 1994f17a630e 'A' bookmarks:
   

tests/test-rebase-parameters.t

@@ -1,529 +1,527 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: {node|short} '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
   $ hg unbundle "$TESTDIR/bundles/rebase.hg"
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   new changesets cd010b8cd998:02de42196ebe (8 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo I > I
   $ hg ci -AmI
   adding I
 
   $ hg tglog
   @  8: e7ec4e813ba6 'I'
   |
   o  7: 02de42196ebe 'H'
   |
   | o  6: eea13746799a 'G'
   |/|
   o |  5: 24b6387c8c8c 'F'
   | |
   | o  4: 9520eea781bc 'E'
   |/
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 Version with only two heads (to allow default destination to work)
 
   $ hg clone -q -u . a a2heads -r 3 -r 8
 
 These fail:
 
   $ hg clone -q -u . a a0
   $ cd a0
 
   $ hg rebase -s 8 -d 7
   nothing to rebase
   [1]
 
   $ hg rebase --continue --abort
   abort: cannot specify both --abort and --continue
   [255]
 
   $ hg rebase --continue --collapse
   abort: cannot use collapse with continue or abort
   [255]
 
   $ hg rebase --continue --dest 4
   abort: cannot specify both --continue and --dest
   [255]
 
   $ hg rebase --base 5 --source 4
   abort: cannot specify both --source and --base
   [255]
 
   $ hg rebase --rev 5 --source 4
   abort: cannot specify both --rev and --source
   [255]
   $ hg rebase --base 5 --rev 4
   abort: cannot specify both --rev and --base
   [255]
 
   $ hg rebase --base 6
   abort: branch 'default' has 3 heads - please rebase to an explicit rev
   (run 'hg heads .' to see heads, specify destination with -d)
   [255]
 
   $ hg rebase --rev '1 & !1' --dest 8
   empty "rev" revision set - nothing to rebase
   [1]
 
   $ hg rebase --rev 'wdir()' --dest 6
   abort: cannot rebase the working copy
   [255]
 
   $ hg rebase --source 'wdir()' --dest 6
   abort: cannot rebase the working copy
   [255]
 
   $ hg rebase --source '1 & !1' --dest 8
   empty "source" revision set - nothing to rebase
   [1]
 
   $ hg rebase --base '1 & !1' --dest 8
   empty "base" revision set - can't compute rebase set
   [1]
 
   $ hg rebase --dest 8
   nothing to rebase - working directory parent is also destination
   [1]
 
   $ hg rebase -b . --dest 8
   nothing to rebase - e7ec4e813ba6 is both "base" and destination
   [1]
 
   $ hg up -q 7
 
   $ hg rebase --dest 8 --traceback
   nothing to rebase - working directory parent is already an ancestor of destination e7ec4e813ba6
   [1]
 
   $ hg rebase --dest 8 -b.
   nothing to rebase - "base" 02de42196ebe is already an ancestor of destination e7ec4e813ba6
   [1]
 
   $ hg rebase --dest '1 & !1'
   abort: empty revision set
   [255]
 
 These work:
 
 Rebase with no arguments (from 3 onto 8):
 
   $ cd ..
   $ hg clone -q -u . a2heads a1
   $ cd a1
   $ hg up -q -C 3
 
   $ hg rebase
   rebasing 1:42ccdea3bb16 "B"
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/42ccdea3bb16-3cb021d3-rebase.hg
 
   $ hg tglog
   @  6: ed65089c18f8 'D'
   |
   o  5: 7621bf1a2f17 'C'
   |
   o  4: 9430a62369c6 'B'
   |
   o  3: e7ec4e813ba6 'I'
   |
   o  2: 02de42196ebe 'H'
   |
   o  1: 24b6387c8c8c 'F'
   |
   o  0: cd010b8cd998 'A'
   
 Try to rollback after a rebase (fail):
 
   $ hg rollback
   no rollback information available
   [1]
 
   $ cd ..
 
 Rebase with base == '.' => same as no arguments (from 3 onto 8):
 
   $ hg clone -q -u 3 a2heads a2
   $ cd a2
 
   $ hg rebase --base .
   rebasing 1:42ccdea3bb16 "B"
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/42ccdea3bb16-3cb021d3-rebase.hg
 
   $ hg tglog
   @  6: ed65089c18f8 'D'
   |
   o  5: 7621bf1a2f17 'C'
   |
   o  4: 9430a62369c6 'B'
   |
   o  3: e7ec4e813ba6 'I'
   |
   o  2: 02de42196ebe 'H'
   |
   o  1: 24b6387c8c8c 'F'
   |
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 Rebase with dest == branch(.) => same as no arguments (from 3 onto 8):
 
   $ hg clone -q -u 3 a a3
   $ cd a3
 
   $ hg rebase --dest 'branch(.)'
   rebasing 1:42ccdea3bb16 "B"
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a3/.hg/strip-backup/42ccdea3bb16-3cb021d3-rebase.hg
 
   $ hg tglog
   @  8: ed65089c18f8 'D'
   |
   o  7: 7621bf1a2f17 'C'
   |
   o  6: 9430a62369c6 'B'
   |
   o  5: e7ec4e813ba6 'I'
   |
   o  4: 02de42196ebe 'H'
   |
   | o  3: eea13746799a 'G'
   |/|
   o |  2: 24b6387c8c8c 'F'
   | |
   | o  1: 9520eea781bc 'E'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 Specify only source (from 2 onto 8):
 
   $ hg clone -q -u . a2heads a4
   $ cd a4
 
   $ hg rebase --source 'desc("C")'
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a4/.hg/strip-backup/5fddd98957c8-f9244fa1-rebase.hg
 
   $ hg tglog
   o  6: 7726e9fd58f7 'D'
   |
   o  5: 72c8333623d0 'C'
   |
   @  4: e7ec4e813ba6 'I'
   |
   o  3: 02de42196ebe 'H'
   |
   o  2: 24b6387c8c8c 'F'
   |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 Specify only dest (from 3 onto 6):
 
   $ hg clone -q -u 3 a a5
   $ cd a5
 
   $ hg rebase --dest 6
   rebasing 1:42ccdea3bb16 "B"
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a5/.hg/strip-backup/42ccdea3bb16-3cb021d3-rebase.hg
 
   $ hg tglog
   @  8: 8eeb3c33ad33 'D'
   |
   o  7: 2327fea05063 'C'
   |
   o  6: e4e5be0395b2 'B'
   |
   | o  5: e7ec4e813ba6 'I'
   | |
   | o  4: 02de42196ebe 'H'
   | |
   o |  3: eea13746799a 'G'
   |\|
   | o  2: 24b6387c8c8c 'F'
   | |
   o |  1: 9520eea781bc 'E'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 Specify only base (from 1 onto 8):
 
   $ hg clone -q -u . a2heads a6
   $ cd a6
 
   $ hg rebase --base 'desc("D")'
   rebasing 1:42ccdea3bb16 "B"
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a6/.hg/strip-backup/42ccdea3bb16-3cb021d3-rebase.hg
 
   $ hg tglog
   o  6: ed65089c18f8 'D'
   |
   o  5: 7621bf1a2f17 'C'
   |
   o  4: 9430a62369c6 'B'
   |
   @  3: e7ec4e813ba6 'I'
   |
   o  2: 02de42196ebe 'H'
   |
   o  1: 24b6387c8c8c 'F'
   |
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 Specify source and dest (from 2 onto 7):
 
   $ hg clone -q -u . a a7
   $ cd a7
 
   $ hg rebase --source 2 --dest 7
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/5fddd98957c8-f9244fa1-rebase.hg
 
   $ hg tglog
   o  8: 668acadedd30 'D'
   |
   o  7: 09eb682ba906 'C'
   |
   | @  6: e7ec4e813ba6 'I'
   |/
   o  5: 02de42196ebe 'H'
   |
   | o  4: eea13746799a 'G'
   |/|
   o |  3: 24b6387c8c8c 'F'
   | |
   | o  2: 9520eea781bc 'E'
   |/
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 Specify base and dest (from 1 onto 7):
 
   $ hg clone -q -u . a a8
   $ cd a8
 
   $ hg rebase --base 3 --dest 7
   rebasing 1:42ccdea3bb16 "B"
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a8/.hg/strip-backup/42ccdea3bb16-3cb021d3-rebase.hg
 
   $ hg tglog
   o  8: 287cc92ba5a4 'D'
   |
   o  7: 6824f610a250 'C'
   |
   o  6: 7c6027df6a99 'B'
   |
   | @  5: e7ec4e813ba6 'I'
   |/
   o  4: 02de42196ebe 'H'
   |
   | o  3: eea13746799a 'G'
   |/|
   o |  2: 24b6387c8c8c 'F'
   | |
   | o  1: 9520eea781bc 'E'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 Specify only revs (from 2 onto 8)
 
   $ hg clone -q -u . a2heads a9
   $ cd a9
 
   $ hg rebase --rev 'desc("C")::'
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a9/.hg/strip-backup/5fddd98957c8-f9244fa1-rebase.hg
 
   $ hg tglog
   o  6: 7726e9fd58f7 'D'
   |
   o  5: 72c8333623d0 'C'
   |
   @  4: e7ec4e813ba6 'I'
   |
   o  3: 02de42196ebe 'H'
   |
   o  2: 24b6387c8c8c 'F'
   |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 Rebasing both a single revision and a merge in one command
 
   $ hg clone -q -u . a aX
   $ cd aX
   $ hg rebase -r 3 -r 6 --dest 8
   rebasing 3:32af7686d403 "D"
   rebasing 6:eea13746799a "G"
   saved backup bundle to $TESTTMP/aX/.hg/strip-backup/eea13746799a-ad273fd6-rebase.hg
   $ cd ..
 
 Test --tool parameter:
 
   $ hg init b
   $ cd b
 
   $ echo c1 > c1
   $ hg ci -Am c1
   adding c1
 
   $ echo c2 > c2
   $ hg ci -Am c2
   adding c2
 
   $ hg up -q 0
   $ echo c2b > c2
   $ hg ci -Am c2b
   adding c2
   created new head
 
   $ cd ..
 
   $ hg clone -q -u . b b1
   $ cd b1
 
   $ hg rebase -s 2 -d 1 --tool internal:local
   rebasing 2:e4e3f3546619 "c2b" (tip)
   note: not rebasing 2:e4e3f3546619 "c2b" (tip), its destination already has all its changes
   saved backup bundle to $TESTTMP/b1/.hg/strip-backup/e4e3f3546619-b0841178-rebase.hg
 
   $ hg cat c2
   c2
 
   $ cd ..
 
 
   $ hg clone -q -u . b b2
   $ cd b2
 
   $ hg rebase -s 2 -d 1 --tool internal:other
   rebasing 2:e4e3f3546619 "c2b" (tip)
   saved backup bundle to $TESTTMP/b2/.hg/strip-backup/e4e3f3546619-b0841178-rebase.hg
 
   $ hg cat c2
   c2b
 
   $ cd ..
 
 
   $ hg clone -q -u . b b3
   $ cd b3
 
   $ hg rebase -s 2 -d 1 --tool internal:fail
   rebasing 2:e4e3f3546619 "c2b" (tip)
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ hg summary
   parent: 1:56daeba07f4b 
    c2
-  parent: 2:e4e3f3546619 tip
-   c2b
   branch: default
-  commit: 1 modified, 1 unresolved (merge)
-  update: (current)
+  commit: 1 unresolved (clean)
+  update: 1 new changesets, 2 branch heads (merge)
   phases: 3 draft
   rebase: 0 rebased, 1 remaining (rebase --continue)
 
   $ hg resolve -l
   U c2
 
   $ hg resolve -m c2
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg graft --continue
   abort: no graft in progress
   (continue: hg rebase --continue)
   [255]
   $ hg rebase -c --tool internal:fail
   rebasing 2:e4e3f3546619 "c2b" (tip)
   note: not rebasing 2:e4e3f3546619 "c2b" (tip), its destination already has all its changes
   saved backup bundle to $TESTTMP/b3/.hg/strip-backup/e4e3f3546619-b0841178-rebase.hg
 
   $ hg rebase -i
   abort: interactive history editing is supported by the 'histedit' extension (see "hg --config extensions.histedit= help -e histedit")
   [255]
 
   $ hg rebase --interactive
   abort: interactive history editing is supported by the 'histedit' extension (see "hg --config extensions.histedit= help -e histedit")
   [255]
 
   $ cd ..
 
 No common ancestor
 
   $ hg init separaterepo
   $ cd separaterepo
   $ touch a
   $ hg commit -Aqm a
   $ hg up -q null
   $ touch b
   $ hg commit -Aqm b
   $ hg rebase -d 0
   nothing to rebase from d7486e00c6f1 to 3903775176ed
   [1]
   $ cd ..

tests/test-rebase-transaction.t

@@ -1,204 +1,204 b''
 #testcases continuecommand continueflag
 Rebasing using a single transaction
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > drawdag=$TESTDIR/drawdag.py
   > 
   > [rebase]
   > singletransaction=True
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: {desc}"
   > EOF
 
 #if continueflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > continue = rebase --continue
   > EOF
 #endif
 
 Check that a simple rebase works
 
   $ hg init simple && cd simple
   $ hg debugdrawdag <<'EOF'
   >   Z
   >   |
   >   | D
   >   | |
   >   | C
   >   | |
   >   Y B
   >   |/
   >   A
   > EOF
 - We should only see one status stored message. It comes from the start.
   $ hg rebase --debug -b D -d Z | grep 'status stored'
   rebase status stored
   $ hg tglog
   o  5: D
   |
   o  4: C
   |
   o  3: B
   |
   o  2: Z
   |
   o  1: Y
   |
   o  0: A
   
   $ cd ..
 
 Check that --collapse works
 
   $ hg init collapse && cd collapse
   $ hg debugdrawdag <<'EOF'
   >   Z
   >   |
   >   | D
   >   | |
   >   | C
   >   | |
   >   Y B
   >   |/
   >   A
   > EOF
 - We should only see two status stored messages. One from the start, one from
 - cmdutil.commitforceeditor() which forces tr.writepending()
   $ hg rebase --collapse --debug -b D -d Z | grep 'status stored'
   rebase status stored
   rebase status stored
   $ hg tglog
   o  3: Collapsed revision
   |  * B
   |  * C
   |  * D
   o  2: Z
   |
   o  1: Y
   |
   o  0: A
   
   $ cd ..
 
 With --collapse, check that conflicts can be resolved and rebase can then be
 continued
 
   $ hg init collapse-conflict && cd collapse-conflict
   $ hg debugdrawdag <<'EOF'
   >   Z   # Z/conflict=Z
   >   |
   >   | D
   >   | |
   >   | C # C/conflict=C
   >   | |
   >   Y B
   >   |/
   >   A
   > EOF
   $ hg rebase --collapse -b D -d Z
   rebasing 1:112478962961 "B" (B)
   rebasing 3:c26739dbe603 "C" (C)
   merging conflict
   warning: conflicts while merging conflict! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg tglog
   o  5: D
   |
   | @  4: Z
   | |
-  @ |  3: C
+  % |  3: C
   | |
   | o  2: Y
   | |
   o |  1: B
   |/
   o  0: A
   
   $ hg st
-  M C
   M conflict
   A B
+  A C
   ? conflict.orig
   $ echo resolved > conflict
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg continue
   already rebased 1:112478962961 "B" (B) as 79bc8f4973ce
   rebasing 3:c26739dbe603 "C" (C)
   rebasing 5:d24bb333861c "D" (D tip)
   saved backup bundle to $TESTTMP/collapse-conflict/.hg/strip-backup/112478962961-b5b34645-rebase.hg
   $ hg tglog
   o  3: Collapsed revision
   |  * B
   |  * C
   |  * D
   o  2: Z
   |
   o  1: Y
   |
   o  0: A
   
   $ cd ..
 
 With --collapse, check that the commit message editing can be canceled and
 rebase can then be continued
 
   $ hg init collapse-cancel-editor && cd collapse-cancel-editor
   $ hg debugdrawdag <<'EOF'
   >   Z
   >   |
   >   | D
   >   | |
   >   | C
   >   | |
   >   Y B
   >   |/
   >   A
   > EOF
   $ HGEDITOR=false hg --config ui.interactive=1 rebase --collapse -b D -d Z
   rebasing 1:112478962961 "B" (B)
   rebasing 3:26805aba1e60 "C" (C)
   rebasing 5:f585351a92f8 "D" (D tip)
   transaction abort!
   rollback completed
   abort: edit failed: false exited with status 1
   [255]
   $ hg tglog
   o  5: D
   |
   | o  4: Z
   | |
   o |  3: C
   | |
   | o  2: Y
   | |
   o |  1: B
   |/
   o  0: A
   
   $ hg continue
   rebasing 1:112478962961 "B" (B)
   rebasing 3:26805aba1e60 "C" (C)
   rebasing 5:f585351a92f8 "D" (D tip)
   saved backup bundle to $TESTTMP/collapse-cancel-editor/.hg/strip-backup/112478962961-cb2a9b47-rebase.hg
   $ hg tglog
   o  3: Collapsed revision
   |  * B
   |  * C
   |  * D
   o  2: Z
   |
   o  1: Y
   |
   o  0: A
   
   $ cd ..