destutil: provide hint on rebase+merge for how to specify destination/rev

Without a destination specified, rebase and merge attempt to identify a good
candidate; this fails if there's too many heads, the heads have a bookmark, or
other reasons.

Complicating the issue, users may have specified -t, thinking it means target,
and are confused when the error message says that they need to specify an
explicit rev or explicit destination - they feel like they already have.

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

mercurial/destutil.py

@@ -1,490 +1,490 b''
 # destutil.py - Mercurial utility function for command destination
 #
 #  Copyright Matt Mackall <[e-mail]> and other
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from .i18n import _
 from . import bookmarks, error, obsutil, scmutil, stack
 
 
 def orphanpossibledestination(repo, rev):
     """Return all changesets that may be a new parent for orphan `rev`.
 
     This function works fine on non-orphan revisions, it's just silly
     because there's no destination implied by obsolete markers, so
     it'll return nothing.
     """
     tonode = repo.changelog.node
     parents = repo.changelog.parentrevs
     torev = repo.changelog.rev
     dest = set()
     tovisit = list(parents(rev))
     while tovisit:
         r = tovisit.pop()
         succsets = obsutil.successorssets(repo, tonode(r))
         if not succsets:
             # if there are no successors for r, r was probably pruned
             # and we should walk up to r's parents to try and find
             # some successors.
             tovisit.extend(parents(r))
         else:
             # We should probably pick only one destination from split
             # (case where '1 < len(ss)'), This could be the currently
             # tipmost, but the correct result is less clear when
             # results of the split have been moved such that they
             # reside on multiple branches.
             for ss in succsets:
                 for n in ss:
                     dr = torev(n)
                     if dr != -1:
                         dest.add(dr)
     return dest
 
 
 def _destupdateobs(repo, clean):
     """decide of an update destination from obsolescence markers"""
     node = None
     wc = repo[None]
     p1 = wc.p1()
     movemark = None
 
     if p1.obsolete() and not p1.children():
         # allow updating to successors
         successors = obsutil.successorssets(repo, p1.node())
 
         # behavior of certain cases is as follows,
         #
         # divergent changesets: update to highest rev, similar to what
         #     is currently done when there are more than one head
         #     (i.e. 'tip')
         #
         # replaced changesets: same as divergent except we know there
         # is no conflict
         #
         # pruned changeset: no update is done; though, we could
         #     consider updating to the first non-obsolete parent,
         #     similar to what is current done for 'hg prune'
 
         if successors:
             # flatten the list here handles both divergent (len > 1)
             # and the usual case (len = 1)
             successors = [n for sub in successors for n in sub]
 
             # get the max revision for the given successors set,
             # i.e. the 'tip' of a set
             node = repo.revs(b'max(%ln)', successors).first()
             if bookmarks.isactivewdirparent(repo):
                 movemark = repo[b'.'].node()
     return node, movemark, None
 
 
 def _destupdatebook(repo, clean):
     """decide on an update destination from active bookmark"""
     # we also move the active bookmark, if any
     node = None
     activemark, movemark = bookmarks.calculateupdate(repo.ui, repo)
     if activemark is not None:
         node = repo._bookmarks[activemark]
     return node, movemark, activemark
 
 
 def _destupdatebranch(repo, clean):
     """decide on an update destination from current branch
 
     This ignores closed branch heads.
     """
     wc = repo[None]
     movemark = node = None
     currentbranch = wc.branch()
 
     if clean:
         currentbranch = repo[b'.'].branch()
 
     if currentbranch in repo.branchmap():
         heads = repo.branchheads(currentbranch)
         if heads:
             node = repo.revs(b'max(.::(%ln))', heads).first()
         if bookmarks.isactivewdirparent(repo):
             movemark = repo[b'.'].node()
     elif currentbranch == b'default' and not wc.p1():
         # "null" parent belongs to "default" branch, but it doesn't exist, so
         # update to the tipmost non-closed branch head
         node = repo.revs(b'max(head() and not closed())').first()
     else:
         node = repo[b'.'].node()
     return node, movemark, None
 
 
 def _destupdatebranchfallback(repo, clean):
     """decide on an update destination from closed heads in current branch"""
     wc = repo[None]
     currentbranch = wc.branch()
     movemark = None
     if currentbranch in repo.branchmap():
         # here, all descendant branch heads are closed
         heads = repo.branchheads(currentbranch, closed=True)
         assert heads, b"any branch has at least one head"
         node = repo.revs(b'max(.::(%ln))', heads).first()
         assert node is not None, (
             b"any revision has at least " b"one descendant branch head"
         )
         if bookmarks.isactivewdirparent(repo):
             movemark = repo[b'.'].node()
     else:
         # here, no "default" branch, and all branches are closed
         node = repo.lookup(b'tip')
         assert node is not None, b"'tip' exists even in empty repository"
     return node, movemark, None
 
 
 # order in which each step should be evaluated
 # steps are run until one finds a destination
 destupdatesteps = [b'evolution', b'bookmark', b'branch', b'branchfallback']
 # mapping to ease extension overriding steps.
 destupdatestepmap = {
     b'evolution': _destupdateobs,
     b'bookmark': _destupdatebook,
     b'branch': _destupdatebranch,
     b'branchfallback': _destupdatebranchfallback,
 }
 
 
 def destupdate(repo, clean=False):
     """destination for bare update operation
 
     return (rev, movemark, activemark)
 
     - rev: the revision to update to,
     - movemark: node to move the active bookmark from
                 (cf bookmark.calculate update),
     - activemark: a bookmark to activate at the end of the update.
     """
     node = movemark = activemark = None
 
     for step in destupdatesteps:
         node, movemark, activemark = destupdatestepmap[step](repo, clean)
         if node is not None:
             break
     rev = repo[node].rev()
 
     return rev, movemark, activemark
 
 
 msgdestmerge = {
     # too many matching divergent bookmark
     b'toomanybookmarks': {
         b'merge': (
             _(
                 b"multiple matching bookmarks to merge -"
                 b" please merge with an explicit rev or bookmark"
             ),
-            _(b"run 'hg heads' to see all heads"),
+            _(b"run 'hg heads' to see all heads, specify rev with -r"),
         ),
         b'rebase': (
             _(
                 b"multiple matching bookmarks to rebase -"
                 b" please rebase to an explicit rev or bookmark"
             ),
-            _(b"run 'hg heads' to see all heads"),
+            _(b"run 'hg heads' to see all heads, specify destination with -d"),
         ),
     },
     # no other matching divergent bookmark
     b'nootherbookmarks': {
         b'merge': (
             _(
                 b"no matching bookmark to merge - "
                 b"please merge with an explicit rev or bookmark"
             ),
-            _(b"run 'hg heads' to see all heads"),
+            _(b"run 'hg heads' to see all heads, specify rev with -r"),
         ),
         b'rebase': (
             _(
                 b"no matching bookmark to rebase - "
                 b"please rebase to an explicit rev or bookmark"
             ),
-            _(b"run 'hg heads' to see all heads"),
+            _(b"run 'hg heads' to see all heads, specify destination with -d"),
         ),
     },
     # branch have too many unbookmarked heads, no obvious destination
     b'toomanyheads': {
         b'merge': (
             _(b"branch '%s' has %d heads - please merge with an explicit rev"),
-            _(b"run 'hg heads .' to see heads"),
+            _(b"run 'hg heads .' to see heads, specify rev with -r"),
         ),
         b'rebase': (
             _(b"branch '%s' has %d heads - please rebase to an explicit rev"),
-            _(b"run 'hg heads .' to see heads"),
+            _(b"run 'hg heads .' to see heads, specify destination with -d"),
         ),
     },
     # branch have no other unbookmarked heads
     b'bookmarkedheads': {
         b'merge': (
             _(b"heads are bookmarked - please merge with an explicit rev"),
-            _(b"run 'hg heads' to see all heads"),
+            _(b"run 'hg heads' to see all heads, specify rev with -r"),
         ),
         b'rebase': (
             _(b"heads are bookmarked - please rebase to an explicit rev"),
-            _(b"run 'hg heads' to see all heads"),
+            _(b"run 'hg heads' to see all heads, specify destination with -d"),
         ),
     },
     # branch have just a single heads, but there is other branches
     b'nootherbranchheads': {
         b'merge': (
             _(b"branch '%s' has one head - please merge with an explicit rev"),
-            _(b"run 'hg heads' to see all heads"),
+            _(b"run 'hg heads' to see all heads, specify rev with -r"),
         ),
         b'rebase': (
             _(b"branch '%s' has one head - please rebase to an explicit rev"),
-            _(b"run 'hg heads' to see all heads"),
+            _(b"run 'hg heads' to see all heads, specify destination with -d"),
         ),
     },
     # repository have a single head
     b'nootherheads': {
         b'merge': (_(b'nothing to merge'), None),
         b'rebase': (_(b'nothing to rebase'), None),
     },
     # repository have a single head and we are not on it
     b'nootherheadsbehind': {
         b'merge': (_(b'nothing to merge'), _(b"use 'hg update' instead")),
         b'rebase': (_(b'nothing to rebase'), _(b"use 'hg update' instead")),
     },
     # We are not on a head
     b'notatheads': {
         b'merge': (
             _(b'working directory not at a head revision'),
             _(b"use 'hg update' or merge with an explicit revision"),
         ),
         b'rebase': (
             _(b'working directory not at a head revision'),
             _(b"use 'hg update' or rebase to an explicit revision"),
         ),
     },
     b'emptysourceset': {
         b'merge': (_(b'source set is empty'), None),
         b'rebase': (_(b'source set is empty'), None),
     },
     b'multiplebranchessourceset': {
         b'merge': (_(b'source set is rooted in multiple branches'), None),
         b'rebase': (
             _(b'rebaseset is rooted in multiple named branches'),
             _(b'specify an explicit destination with --dest'),
         ),
     },
 }
 
 
 def _destmergebook(repo, action=b'merge', sourceset=None, destspace=None):
     """find merge destination in the active bookmark case"""
     node = None
     bmheads = bookmarks.headsforactive(repo)
     curhead = repo._bookmarks[repo._activebookmark]
     if len(bmheads) == 2:
         if curhead == bmheads[0]:
             node = bmheads[1]
         else:
             node = bmheads[0]
     elif len(bmheads) > 2:
         msg, hint = msgdestmerge[b'toomanybookmarks'][action]
         raise error.ManyMergeDestAbort(msg, hint=hint)
     elif len(bmheads) <= 1:
         msg, hint = msgdestmerge[b'nootherbookmarks'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     assert node is not None
     return node
 
 
 def _destmergebranch(
     repo, action=b'merge', sourceset=None, onheadcheck=True, destspace=None
 ):
     """find merge destination based on branch heads"""
     node = None
 
     if sourceset is None:
         sourceset = [repo[repo.dirstate.p1()].rev()]
         branch = repo.dirstate.branch()
     elif not sourceset:
         msg, hint = msgdestmerge[b'emptysourceset'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     else:
         branch = None
         for ctx in repo.set(b'roots(%ld::%ld)', sourceset, sourceset):
             if branch is not None and ctx.branch() != branch:
                 msg, hint = msgdestmerge[b'multiplebranchessourceset'][action]
                 raise error.ManyMergeDestAbort(msg, hint=hint)
             branch = ctx.branch()
 
     bheads = repo.branchheads(branch)
     onhead = repo.revs(b'%ld and %ln', sourceset, bheads)
     if onheadcheck and not onhead:
         # Case A: working copy if not on a head. (merge only)
         #
         # This is probably a user mistake We bailout pointing at 'hg update'
         if len(repo.heads()) <= 1:
             msg, hint = msgdestmerge[b'nootherheadsbehind'][action]
         else:
             msg, hint = msgdestmerge[b'notatheads'][action]
         raise error.Abort(msg, hint=hint)
     # remove heads descendants of source from the set
     bheads = list(repo.revs(b'%ln - (%ld::)', bheads, sourceset))
     # filters out bookmarked heads
     nbhs = list(repo.revs(b'%ld - bookmark()', bheads))
 
     if destspace is not None:
         # restrict search space
         # used in the 'hg pull --rebase' case, see issue 5214.
         nbhs = list(repo.revs(b'%ld and %ld', destspace, nbhs))
 
     if len(nbhs) > 1:
         # Case B: There is more than 1 other anonymous heads
         #
         # This means that there will be more than 1 candidate. This is
         # ambiguous. We abort asking the user to pick as explicit destination
         # instead.
         msg, hint = msgdestmerge[b'toomanyheads'][action]
         msg %= (branch, len(bheads) + 1)
         raise error.ManyMergeDestAbort(msg, hint=hint)
     elif not nbhs:
         # Case B: There is no other anonymous heads
         #
         # This means that there is no natural candidate to merge with.
         # We abort, with various messages for various cases.
         if bheads:
             msg, hint = msgdestmerge[b'bookmarkedheads'][action]
         elif len(repo.heads()) > 1:
             msg, hint = msgdestmerge[b'nootherbranchheads'][action]
             msg %= branch
         elif not onhead:
             # if 'onheadcheck == False' (rebase case),
             # this was not caught in Case A.
             msg, hint = msgdestmerge[b'nootherheadsbehind'][action]
         else:
             msg, hint = msgdestmerge[b'nootherheads'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     else:
         node = nbhs[0]
     assert node is not None
     return node
 
 
 def destmerge(
     repo, action=b'merge', sourceset=None, onheadcheck=True, destspace=None
 ):
     """return the default destination for a merge
 
     (or raise exception about why it can't pick one)
 
     :action: the action being performed, controls emitted error message
     """
     # destspace is here to work around issues with `hg pull --rebase` see
     # issue5214 for details
     if repo._activebookmark:
         node = _destmergebook(
             repo, action=action, sourceset=sourceset, destspace=destspace
         )
     else:
         node = _destmergebranch(
             repo,
             action=action,
             sourceset=sourceset,
             onheadcheck=onheadcheck,
             destspace=destspace,
         )
     return repo[node].rev()
 
 
 def desthistedit(ui, repo):
     """Default base revision to edit for `hg histedit`."""
     default = ui.config(b'histedit', b'defaultrev')
 
     if default is None:
         revs = stack.getstack(repo)
     elif default:
         revs = scmutil.revrange(repo, [default])
     else:
         raise error.Abort(
             _(b"config option histedit.defaultrev can't be empty")
         )
 
     if revs:
         # Take the first revision of the revset as the root
         return revs.min()
 
     return None
 
 
 def stackbase(ui, repo):
     revs = stack.getstack(repo)
     return revs.first() if revs else None
 
 
 def _statusotherbook(ui, repo):
     bmheads = bookmarks.headsforactive(repo)
     curhead = repo._bookmarks[repo._activebookmark]
     if repo.revs(b'%n and parents()', curhead):
         # we are on the active bookmark
         bmheads = [b for b in bmheads if curhead != b]
         if bmheads:
             msg = _(b'%i other divergent bookmarks for "%s"\n')
             ui.status(msg % (len(bmheads), repo._activebookmark))
 
 
 def _statusotherbranchheads(ui, repo):
     currentbranch = repo.dirstate.branch()
     allheads = repo.branchheads(currentbranch, closed=True)
     heads = repo.branchheads(currentbranch)
     if repo.revs(b'%ln and parents()', allheads):
         # we are on a head, even though it might be closed
         #
         #  on closed otherheads
         #  ========= ==========
         #      o        0       all heads for current branch are closed
         #               N       only descendant branch heads are closed
         #      x        0       there is only one non-closed branch head
         #               N       there are some non-closed branch heads
         #  ========= ==========
         otherheads = repo.revs(b'%ln - parents()', heads)
         if repo[b'.'].closesbranch():
             ui.warn(
                 _(
                     b'no open descendant heads on branch "%s", '
                     b'updating to a closed head\n'
                 )
                 % currentbranch
             )
             if otherheads:
                 ui.warn(
                     _(
                         b"(committing will reopen the head, "
                         b"use 'hg heads .' to see %i other heads)\n"
                     )
                     % (len(otherheads))
                 )
             else:
                 ui.warn(
                     _(b'(committing will reopen branch "%s")\n') % currentbranch
                 )
         elif otherheads:
             curhead = repo[b'.']
             ui.status(
                 _(b'updated to "%s: %s"\n')
                 % (curhead, curhead.description().split(b'\n')[0])
             )
             ui.status(
                 _(b'%i other heads for branch "%s"\n')
                 % (len(otherheads), currentbranch)
             )
 
 
 def statusotherdests(ui, repo):
     """Print message about other head"""
     # XXX we should probably include a hint:
     # - about what to do
     # - how to see such heads
     if repo._activebookmark:
         _statusotherbook(ui, repo)
     else:
         _statusotherbranchheads(ui, repo)

tests/test-bookmarks-merge.t

@@ -1,152 +1,152 b''
 # init
 
   $ hg init
   $ echo a > a
   $ hg add a
   $ hg commit -m'a'
   $ echo b > b
   $ hg add b
   $ hg commit -m'b'
   $ hg up -C 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg add c
   $ hg commit -m'c'
   created new head
 
 # test merging of diverged bookmarks
   $ hg bookmark -r 1 "c@diverge"
   $ hg bookmark -r 1 b
   $ hg bookmark c
   $ hg bookmarks
      b                         1:d2ae7f538514
    * c                         2:d36c0562f908
      c@diverge                 1:d2ae7f538514
   $ hg merge "c@diverge"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m'merge'
   $ hg bookmarks
      b                         1:d2ae7f538514
    * c                         3:b8f96cf4688b
 
   $ hg up -C 3
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (leaving bookmark c)
   $ echo d > d
   $ hg add d
   $ hg commit -m'd'
 
   $ hg up -C 3
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo e > e
   $ hg add e
   $ hg commit -m'e'
   created new head
   $ hg up -C 5
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg bookmark e
   $ hg bookmarks
      b                         1:d2ae7f538514
      c                         3:b8f96cf4688b
    * e                         5:26bee9c5bcf3
 
 # the picked side is bookmarked
 
   $ hg up -C 4
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (leaving bookmark e)
   $ hg merge
   abort: heads are bookmarked - please merge with an explicit rev
-  (run 'hg heads' to see all heads)
+  (run 'hg heads' to see all heads, specify rev with -r)
   [255]
 
 # our revision is bookmarked
 
   $ hg up -C e
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (activating bookmark e)
   $ hg merge
   abort: no matching bookmark to merge - please merge with an explicit rev or bookmark
-  (run 'hg heads' to see all heads)
+  (run 'hg heads' to see all heads, specify rev with -r)
   [255]
 
 # merge bookmark heads
 
   $ hg up -C 4
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (leaving bookmark e)
   $ echo f > f
   $ hg commit -Am "f"
   adding f
   $ hg bookmarks -r 4 "e@diverged"
   $ hg up -q -C "e@diverged"
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg parents
   changeset:   4:a0546fcfe0fb
   bookmark:    e@diverged
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   5:26bee9c5bcf3
   bookmark:    e
   parent:      3:b8f96cf4688b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   $ hg up -C e
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (activating bookmark e)
   $ hg bookmarks
      b                         1:d2ae7f538514
      c                         3:b8f96cf4688b
    * e                         5:26bee9c5bcf3
      e@diverged                4:a0546fcfe0fb
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m'merge'
   $ hg bookmarks
      b                         1:d2ae7f538514
      c                         3:b8f96cf4688b
    * e                         7:ca784329f0ba
 
 # test warning when all heads are inactive bookmarks
 
   $ hg up -C 6
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (leaving bookmark e)
   $ echo g > g
   $ hg commit -Am 'g'
   adding g
   $ hg bookmark -i g
   $ hg bookmarks
      b                         1:d2ae7f538514
      c                         3:b8f96cf4688b
      e                         7:ca784329f0ba
      g                         8:04dd21731d95
   $ hg heads
   changeset:   8:04dd21731d95
   bookmark:    g
   tag:         tip
   parent:      6:be381d1126a0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     g
   
   changeset:   7:ca784329f0ba
   bookmark:    e
   parent:      5:26bee9c5bcf3
   parent:      4:a0546fcfe0fb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge
   
   $ hg merge
   abort: heads are bookmarked - please merge with an explicit rev
-  (run 'hg heads' to see all heads)
+  (run 'hg heads' to see all heads, specify rev with -r)
   [255]

tests/test-merge-closedheads.t

@@ -1,87 +1,87 b''
   $ hgcommit() {
   >    hg commit -u user "$@"
   > }
 
   $ hg init clhead
   $ cd clhead
 
   $ touch foo && hg add && hgcommit -m 'foo'
   adding foo
   $ touch bar && hg add && hgcommit -m 'bar'
   adding bar
   $ touch baz && hg add && hgcommit -m 'baz'
   adding baz
 
   $ echo "flub" > foo
   $ hgcommit -m "flub"
   $ echo "nub" > foo
   $ hgcommit -m "nub"
 
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo "c1" > c1
   $ hg add c1
   $ hgcommit -m "c1"
   created new head
   $ echo "c2" > c1
   $ hgcommit -m "c2"
 
   $ hg up -C 2
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ echo "d1" > d1
   $ hg add d1
   $ hgcommit -m "d1"
   created new head
   $ echo "d2" > d1
   $ hgcommit -m "d2"
   $ hg tag -l good
 
 fail with three heads
   $ hg up -C good
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge
   abort: branch 'default' has 3 heads - please merge with an explicit rev
-  (run 'hg heads .' to see heads)
+  (run 'hg heads .' to see heads, specify rev with -r)
   [255]
 
 close one of the heads
   $ hg up -C 6
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hgcommit -m 'close this head' --close-branch
 
 succeed with two open heads
   $ hg up -C good
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg up -C good
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hgcommit -m 'merged heads'
 
 hg update -C 8
   $ hg update -C 8
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 hg branch some-branch
   $ hg branch some-branch
   marked working directory as branch some-branch
   (branches are permanent and global, did you want a bookmark?)
 hg commit
   $ hgcommit -m 'started some-branch'
 hg commit --close-branch
   $ hgcommit --close-branch -m 'closed some-branch'
 
 hg update default
   $ hg update default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 hg merge some-branch
   $ hg merge some-branch
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 hg commit (no reopening of some-branch)
   $ hgcommit -m 'merge with closed branch'
 
   $ cd ..

tests/test-merge-default.t

@@ -1,175 +1,175 b''
   $ hg init
   $ echo a > a
   $ hg commit -A -ma
   adding a
 
   $ echo b >> a
   $ hg commit -mb
 
   $ echo c >> a
   $ hg commit -mc
 
   $ hg up 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo d >> a
   $ hg commit -md
   created new head
 
   $ hg up 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo e >> a
   $ hg commit -me
   created new head
 
   $ hg up 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Should fail because not at a head:
 
   $ hg merge
   abort: working directory not at a head revision
   (use 'hg update' or merge with an explicit revision)
   [255]
 
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "f25cbe84d8b3: e"
   2 other heads for branch "default"
 
 Should fail because > 2 heads:
 
   $ HGMERGE=internal:other; export HGMERGE
   $ hg merge
   abort: branch 'default' has 3 heads - please merge with an explicit rev
-  (run 'hg heads .' to see heads)
+  (run 'hg heads .' to see heads, specify rev with -r)
   [255]
 
 Should succeed:
 
   $ hg merge 2
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg id -Tjson
   [
    {
     "bookmarks": [],
     "branch": "default",
     "dirty": "+",
     "id": "f25cbe84d8b320e298e7703f18a25a3959518c23+2d95304fed5d89bc9d70b2a0d02f0d567469c3ab+",
     "node": "ffffffffffffffffffffffffffffffffffffffff",
     "parents": ["f25cbe84d8b320e298e7703f18a25a3959518c23", "2d95304fed5d89bc9d70b2a0d02f0d567469c3ab"],
     "tags": ["tip"]
    }
   ]
   $ hg commit -mm1
 
 Should succeed - 2 heads:
 
   $ hg merge -P
   changeset:   3:ea9ff125ff88
   parent:      1:1846eede8b68
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   $ hg merge
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -mm2
 
   $ hg id -r 1 -Tjson
   [
    {
     "bookmarks": [],
     "branch": "default",
     "id": "1846eede8b6886d8cc8a88c96a687b7fe8f3b9d1",
     "node": "1846eede8b6886d8cc8a88c96a687b7fe8f3b9d1",
     "tags": []
    }
   ]
 
 Should fail because at tip:
 
   $ hg merge
   abort: nothing to merge
   [255]
 
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Should fail because there is only one head:
 
   $ hg merge
   abort: nothing to merge
   (use 'hg update' instead)
   [255]
 
   $ hg up 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo f >> a
   $ hg branch foobranch
   marked working directory as branch foobranch
   (branches are permanent and global, did you want a bookmark?)
   $ hg commit -mf
 
 Should fail because merge with other branch:
 
   $ hg merge
   abort: branch 'foobranch' has one head - please merge with an explicit rev
-  (run 'hg heads' to see all heads)
+  (run 'hg heads' to see all heads, specify rev with -r)
   [255]
 
 
 Test for issue2043: ensure that 'merge -P' shows ancestors of 6 that
 are not ancestors of 7, regardless of where their common ancestors are.
 
 Merge preview not affected by common ancestor:
 
   $ hg up -q 7
   $ hg merge -q -P 6
   2:2d95304fed5d
   4:f25cbe84d8b3
   5:a431fabd6039
   6:e88e33f3bf62
 
 Test experimental destination revset
 
   $ hg log -r '_destmerge()'
   abort: branch 'foobranch' has one head - please merge with an explicit rev
-  (run 'hg heads' to see all heads)
+  (run 'hg heads' to see all heads, specify rev with -r)
   [255]
 
 (on a branch with a two heads)
 
   $ hg up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo f >> a
   $ hg commit -mf
   created new head
   $ hg log -r '_destmerge()'
   changeset:   6:e88e33f3bf62
   parent:      5:a431fabd6039
   parent:      3:ea9ff125ff88
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     m2
   
 
 (from the other head)
 
   $ hg log -r '_destmerge(e88e33f3bf62)'
   changeset:   8:b613918999e2
   tag:         tip
   parent:      5:a431fabd6039
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     f
   
 
 (from unrelated branch)
 
   $ hg log -r '_destmerge(foobranch)'
   abort: branch 'foobranch' has one head - please merge with an explicit rev
-  (run 'hg heads' to see all heads)
+  (run 'hg heads' to see all heads, specify rev with -r)
   [255]

tests/test-newbranch.t

@@ -1,534 +1,534 b''
   $ branchcache=.hg/cache/branch2
 
   $ listbranchcaches() {
   >    for f in .hg/cache/branch2*;
   >       do echo === $f ===;
   >       cat $f;
   >     done;
   > }
   $ purgebranchcaches() {
   >     rm .hg/cache/branch2*
   > }
 
   $ hg init t
   $ cd t
 
   $ hg branches
   $ echo foo > a
   $ hg add a
   $ hg ci -m "initial"
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ hg branch
   foo
   $ hg ci -m "add branch name"
   $ hg branch bar
   marked working directory as branch bar
   $ hg ci -m "change branch name"
 
 Branch shadowing:
 
   $ hg branch default
   abort: a branch of the same name already exists
   (use 'hg update' to switch to it)
   [255]
 
   $ hg branch -f default
   marked working directory as branch default
 
   $ hg ci -m "clear branch name"
   created new head
 
 There should be only one default branch head
 
   $ hg heads .
   changeset:   3:1c28f494dae6
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     clear branch name
   
 Merging and branches
 
   $ hg co foo
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   foo
 
  set existing branch name fails unless force - setting existing parent branch works without force:
 
   $ hg branch bar
   abort: a branch of the same name already exists
   (use 'hg update' to switch to it)
   [255]
 
   $ hg branch -f bar
   marked working directory as branch bar
 
   $ hg branch foo
   marked working directory as branch foo
 
   $ echo bleah > a
   $ hg ci -m "modify a branch"
 
   $ hg merge default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg branch
   foo
 
  set existing branch name where branch head is ancestor:
 
   $ hg branch bar
   abort: a branch of the same name already exists
   (use 'hg update' to switch to it)
   [255]
 
  set (other) parent branch as branch name
 
   $ hg branch default
   marked working directory as branch default
 
  set (first) parent branch as branch name
 
   $ hg branch foo
   marked working directory as branch foo
 
   $ hg ci -m "merge"
 
   $ hg log -G -T '{rev}:{node|short} {branch} {desc}\n'
   @    5:530046499edf foo merge
   |\
   | o  4:adf1a74a7f7b foo modify a branch
   | |
   o |  3:1c28f494dae6 default clear branch name
   | |
   o |  2:c21617b13b22 bar change branch name
   |/
   o  1:6c0e42da283a foo add branch name
   |
   o  0:db01e8ea3388 default initial
   
   $ hg branches
   foo                            5:530046499edf
   default                        3:1c28f494dae6 (inactive)
   bar                            2:c21617b13b22 (inactive)
 
   $ hg branches -q
   foo
   default
   bar
 
 Test for invalid branch cache:
 
   $ hg rollback
   repository tip rolled back to revision 4 (undo commit)
   working directory now based on revisions 4 and 3
 
   $ cp ${branchcache}-served .hg/bc-invalid
 
   $ hg log -r foo
   changeset:   4:adf1a74a7f7b
   branch:      foo
   tag:         tip
   parent:      1:6c0e42da283a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify a branch
   
   $ cp .hg/bc-invalid $branchcache
 
   $ hg --debug log -r foo
   changeset:   4:adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6
   branch:      foo
   tag:         tip
   phase:       draft
   parent:      1:6c0e42da283a56b5edc5b4fadb491365ec7f5fa8
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    1:8c342a37dfba0b3d3ce073562a00d8a813c54ffe
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       a
   extra:       branch=foo
   description:
   modify a branch
   
   
   $ purgebranchcaches
   $ echo corrupted > $branchcache
 
   $ hg log -qr foo
   4:adf1a74a7f7b
 
   $ listbranchcaches
   === .hg/cache/branch2 ===
   corrupted
   === .hg/cache/branch2-served ===
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 4
   c21617b13b220988e7a2e26290fbe4325ffa7139 o bar
   1c28f494dae69a2f8fc815059d257eccf3fcfe75 o default
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 o foo
 
 Push should update the branch cache:
 
   $ hg init ../target
 
 Pushing just rev 0:
 
   $ hg push -qr 0 ../target
 
   $ (cd ../target/; listbranchcaches)
   === .hg/cache/branch2-base ===
   db01e8ea3388fd3c7c94e1436ea2bd6a53d581c5 0
   db01e8ea3388fd3c7c94e1436ea2bd6a53d581c5 o default
 
 Pushing everything:
 
   $ hg push -qf ../target
 
   $ (cd ../target/; listbranchcaches)
   === .hg/cache/branch2-base ===
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 4
   c21617b13b220988e7a2e26290fbe4325ffa7139 o bar
   1c28f494dae69a2f8fc815059d257eccf3fcfe75 o default
   adf1a74a7f7b4cd193d12992f5d0d6a004ed21d6 o foo
 
 Update with no arguments: tipmost revision of the current branch:
 
   $ hg up -q -C 0
   $ hg up -q
   $ hg id
   1c28f494dae6
 
   $ hg up -q 1
   $ hg up -q
   $ hg id
   adf1a74a7f7b (foo) tip
 
   $ hg branch foobar
   marked working directory as branch foobar
 
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Fast-forward merge:
 
   $ hg branch ff
   marked working directory as branch ff
 
   $ echo ff > ff
   $ hg ci -Am'fast forward'
   adding ff
 
   $ hg up foo
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg merge ff
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg branch
   foo
   $ hg commit -m'Merge ff into foo'
   $ hg parents
   changeset:   6:185ffbfefa30
   branch:      foo
   tag:         tip
   parent:      4:adf1a74a7f7b
   parent:      5:1a3c27dc5e11
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Merge ff into foo
   
   $ hg manifest
   a
   ff
 
 
 Test merging, add 3 default heads and one test head:
 
   $ cd ..
   $ hg init merges
   $ cd merges
   $ echo a > a
   $ hg ci -Ama
   adding a
 
   $ echo b > b
   $ hg ci -Amb
   adding b
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Amc
   adding c
   created new head
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo d > d
   $ hg ci -Amd
   adding d
   created new head
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo e >> e
   $ hg ci -Ame
   adding e
 
   $ hg log
   changeset:   4:3a1e01ed1df4
   branch:      test
   tag:         tip
   parent:      0:cb9a9f314b8b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   changeset:   3:980f7dc84c29
   parent:      0:cb9a9f314b8b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   2:d36c0562f908
   parent:      0:cb9a9f314b8b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   1:d2ae7f538514
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:cb9a9f314b8b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 Implicit merge with test branch as parent:
 
   $ hg merge
   abort: branch 'test' has one head - please merge with an explicit rev
-  (run 'hg heads' to see all heads)
+  (run 'hg heads' to see all heads, specify rev with -r)
   [255]
   $ hg up -C default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Implicit merge with default branch as parent:
 
   $ hg merge
   abort: branch 'default' has 3 heads - please merge with an explicit rev
-  (run 'hg heads .' to see heads)
+  (run 'hg heads .' to see heads, specify rev with -r)
   [255]
 
 3 branch heads, explicit merge required:
 
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
 
 2 branch heads, implicit merge works:
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cd ..
 
 We expect that bare update on new branch, updates to parent
 
   $ hg init bareupdateonnewbranch
   $ cd bareupdateonnewbranch
   $ hg update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ touch a
   $ hg commit -A -m "a"
   adding a
   $ touch b
   $ hg commit -A -m "b"
   adding b
   $ touch c
   $ hg commit -A -m "c"
   adding c
   $ hg update -r 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -G
   o  changeset:   2:991a3460af53
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   @  changeset:   1:0e067c57feba
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:3903775176ed
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg branch dev
   marked working directory as branch dev
   (branches are permanent and global, did you want a bookmark?)
   $ hg update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg summary
   parent: 1:0e067c57feba 
    b
   branch: dev
   commit: (new branch)
   update: (current)
   phases: 3 draft
 
   $ cd ..
 
 We need special handling for repositories with no "default" branch because
 "null" revision belongs to non-existent "default" branch.
 
   $ hg init nodefault
   $ cd nodefault
   $ hg branch -q foo
   $ touch 0
   $ hg ci -Aqm0
   $ touch 1
   $ hg ci -Aqm1
   $ hg update -qr0
   $ hg branch -q bar
   $ touch 2
   $ hg ci -Aqm2
   $ hg update -qr0
   $ hg branch -q baz
   $ touch 3
   $ hg ci -Aqm3
   $ hg ci --close-branch -m 'close baz'
   $ hg update -q null
   $ hg log -GT'{rev} {branch}\n'
   _  4 baz
   |
   o  3 baz
   |
   | o  2 bar
   |/
   | o  1 foo
   |/
   o  0 foo
   
 
  a) updating from "null" should bring us to the tip-most branch head as
  there is no "default" branch:
 
   $ hg update -q null
   $ hg id -bn
   -1 default
   $ hg update
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -bn
   2 bar
 
  b) but if we are at uncommitted "default" branch, we should stick to the
  current revision:
 
   $ hg update -q 0
   $ hg branch default
   marked working directory as branch default
   $ hg id -bn
   0 default
   $ hg update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -bn
   0 default
 
  c) also, if we have uncommitted branch at "null", we should stick to it:
 
   $ hg update -q null
   $ hg branch new
   marked working directory as branch new
   $ hg id -bn
   -1 new
   $ hg update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -bn
   -1 new
 
   $ cd ..
 
 We expect that update --clean discard changes in working directory,
 and updates to the head of parent branch.
 
   $ hg init updatebareclean
   $ cd updatebareclean
   $ hg update --clean
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ touch a
   $ hg commit -A -m "a"
   adding a
   $ touch b
   $ hg commit -A -m "b"
   adding b
   $ touch c
   $ hg commit -A -m "c"
   adding c
   $ hg log
   changeset:   2:991a3460af53
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   1:0e067c57feba
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:3903775176ed
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg update -r 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch new-branch
   marked working directory as branch new-branch
   (branches are permanent and global, did you want a bookmark?)
   $ echo "aa" >> a
   $ hg update --clean
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status
   $ hg branch
   default
   $ hg parent
   changeset:   2:991a3460af53
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
 We expect that update --clean on non existing parent discards a new branch
 and updates to the tipmost non-closed branch head
 
   $ hg update null
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ hg branch newbranch
   marked working directory as branch newbranch
   (branches are permanent and global, did you want a bookmark?)
   $ hg update -C
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg summary
   parent: 2:991a3460af53 tip
    c
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft

tests/test-rebase-named-branches.t

@@ -1,410 +1,410 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
   $ cd ..
 
   $ hg clone -q -u . a a1
 
   $ cd a1
 
   $ hg update 3
   3 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg branch dev-one
   marked working directory as branch dev-one
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m 'dev-one named branch'
 
   $ hg update 7
   2 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ hg branch dev-two
   marked working directory as branch dev-two
 
   $ echo x > x
 
   $ hg add x
 
   $ hg ci -m 'dev-two named branch'
 
   $ hg tglog
   @  9: cb039b7cae8e 'dev-two named branch' dev-two
   |
   | o  8: 643fc9128048 'dev-one named branch' dev-one
   | |
   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'
   
 
 Branch name containing a dash (issue3181)
 
   $ hg rebase -b dev-two -d dev-one --keepbranches
   rebasing 5:24b6387c8c8c "F"
   rebasing 6:eea13746799a "G"
   rebasing 7:02de42196ebe "H"
   rebasing 9:cb039b7cae8e "dev-two named branch" (tip)
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/24b6387c8c8c-24cb8001-rebase.hg
 
   $ hg tglog
   @  9: 9e70cd31750f 'dev-two named branch' dev-two
   |
   o  8: 31d0e4ba75e6 'H'
   |
   | o  7: 4b988a958030 'G'
   |/|
   o |  6: 24de4aff8e28 'F'
   | |
   o |  5: 643fc9128048 'dev-one named branch' dev-one
   | |
   | o  4: 9520eea781bc 'E'
   | |
   o |  3: 32af7686d403 'D'
   | |
   o |  2: 5fddd98957c8 'C'
   | |
   o |  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ hg rebase -s dev-one -d 0 --keepbranches
   rebasing 5:643fc9128048 "dev-one named branch"
   rebasing 6:24de4aff8e28 "F"
   rebasing 7:4b988a958030 "G"
   rebasing 8:31d0e4ba75e6 "H"
   rebasing 9:9e70cd31750f "dev-two named branch" (tip)
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/643fc9128048-c4ee9ef5-rebase.hg
 
   $ hg tglog
   @  9: 59c2e59309fe 'dev-two named branch' dev-two
   |
   o  8: 904590360559 'H'
   |
   | o  7: 1a1e6f72ec38 'G'
   |/|
   o |  6: 42aa3cf0fa7a 'F'
   | |
   o |  5: bc8139ee757c 'dev-one named branch' dev-one
   | |
   | o  4: 9520eea781bc 'E'
   |/
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ hg update 3
   3 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ hg branch -f dev-one
   marked working directory as branch dev-one
   $ hg ci -m 'dev-one named branch'
   created new head
 
   $ hg tglog
   @  10: 643fc9128048 'dev-one named branch' dev-one
   |
   | o  9: 59c2e59309fe 'dev-two named branch' dev-two
   | |
   | o  8: 904590360559 'H'
   | |
   | | o  7: 1a1e6f72ec38 'G'
   | |/|
   | o |  6: 42aa3cf0fa7a 'F'
   | | |
   | o |  5: bc8139ee757c 'dev-one named branch' dev-one
   | | |
   | | o  4: 9520eea781bc 'E'
   | |/
   o |  3: 32af7686d403 'D'
   | |
   o |  2: 5fddd98957c8 'C'
   | |
   o |  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ hg rebase -b 'max(branch("dev-two"))' -d dev-one --keepbranches
   rebasing 5:bc8139ee757c "dev-one named branch"
   note: not rebasing 5:bc8139ee757c "dev-one named branch", its destination already has all its changes
   rebasing 6:42aa3cf0fa7a "F"
   rebasing 7:1a1e6f72ec38 "G"
   rebasing 8:904590360559 "H"
   rebasing 9:59c2e59309fe "dev-two named branch"
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/bc8139ee757c-f11c1080-rebase.hg
 
   $ hg tglog
   o  9: 71325f8bc082 'dev-two named branch' dev-two
   |
   o  8: 12b2bc666e20 'H'
   |
   | o  7: 549f007a9f5f 'G'
   |/|
   o |  6: 679f28760620 'F'
   | |
   @ |  5: 643fc9128048 'dev-one named branch' dev-one
   | |
   | o  4: 9520eea781bc 'E'
   | |
   o |  3: 32af7686d403 'D'
   | |
   o |  2: 5fddd98957c8 'C'
   | |
   o |  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ hg rebase -s 'max(branch("dev-one"))' -d 0 --keepbranches
   rebasing 5:643fc9128048 "dev-one named branch"
   rebasing 6:679f28760620 "F"
   rebasing 7:549f007a9f5f "G"
   rebasing 8:12b2bc666e20 "H"
   rebasing 9:71325f8bc082 "dev-two named branch" (tip)
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/643fc9128048-6cdd1a52-rebase.hg
 
   $ hg tglog
   o  9: 3944801ae4ea 'dev-two named branch' dev-two
   |
   o  8: 8e279d293175 'H'
   |
   | o  7: aeefee77ab01 'G'
   |/|
   o |  6: e908b85f3729 'F'
   | |
   @ |  5: bc8139ee757c 'dev-one named branch' dev-one
   | |
   | o  4: 9520eea781bc 'E'
   |/
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ hg up -r 0 > /dev/null
 
 Rebasing descendant onto ancestor across different named branches
 
   $ hg rebase -s 1 -d 9 --keepbranches
   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
   o  9: e9f862ce8bad 'D'
   |
   o  8: a0d543090fa4 'C'
   |
   o  7: 3bdb949809d9 'B'
   |
   o  6: 3944801ae4ea 'dev-two named branch' dev-two
   |
   o  5: 8e279d293175 'H'
   |
   | o  4: aeefee77ab01 'G'
   |/|
   o |  3: e908b85f3729 'F'
   | |
   o |  2: bc8139ee757c 'dev-one named branch' dev-one
   | |
   | o  1: 9520eea781bc 'E'
   |/
   @  0: cd010b8cd998 'A'
   
   $ hg rebase -s 5 -d 6
   abort: source and destination form a cycle
   [255]
 
   $ hg rebase -s 6 -d 5
   rebasing 6:3944801ae4ea "dev-two named branch"
   rebasing 7:3bdb949809d9 "B"
   rebasing 8:a0d543090fa4 "C"
   rebasing 9:e9f862ce8bad "D" (tip)
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/3944801ae4ea-fb46ed74-rebase.hg
 
   $ hg tglog
   o  9: e522577ccdbd 'D'
   |
   o  8: 810110211f50 'C'
   |
   o  7: 160b0930ccc6 'B'
   |
   o  6: c57724c84928 'dev-two named branch'
   |
   o  5: 8e279d293175 'H'
   |
   | o  4: aeefee77ab01 'G'
   |/|
   o |  3: e908b85f3729 'F'
   | |
   o |  2: bc8139ee757c 'dev-one named branch' dev-one
   | |
   | o  1: 9520eea781bc 'E'
   |/
   @  0: cd010b8cd998 'A'
   
 
 Reopen branch by rebase
 
   $ hg up -qr3
   $ hg branch -q b
   $ hg ci -m 'create b'
   $ hg ci -m 'close b' --close
   $ hg rebase -b 8 -d b
   reopening closed branch head 2b586e70108d
   rebasing 5:8e279d293175 "H"
   rebasing 6:c57724c84928 "dev-two named branch"
   rebasing 7:160b0930ccc6 "B"
   rebasing 8:810110211f50 "C"
   rebasing 9:e522577ccdbd "D"
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/8e279d293175-b023e27c-rebase.hg
 
   $ cd ..
 
 Rebase to other head on branch
 
 Set up a case:
 
   $ hg init case1
   $ cd case1
   $ touch f
   $ hg ci -qAm0
   $ hg branch -q b
   $ echo >> f
   $ hg ci -qAm 'b1'
   $ hg up -qr -2
   $ hg branch -qf b
   $ hg ci -qm 'b2'
   $ hg up -qr -3
   $ hg branch -q c
   $ hg ci -m 'c1'
 
   $ hg tglog
   @  3: c062e3ecd6c6 'c1' c
   |
   | o  2: 792845bb77ee 'b2' b
   |/
   | o  1: 40039acb7ca5 'b1' b
   |/
   o  0: d681519c3ea7 '0'
   
   $ hg clone -q . ../case2
 
 rebase 'b2' to another lower branch head
 
   $ hg up -qr 2
   $ hg rebase
   rebasing 2:792845bb77ee "b2"
   note: not rebasing 2:792845bb77ee "b2", its destination already has all its changes
   saved backup bundle to $TESTTMP/case1/.hg/strip-backup/792845bb77ee-627120ee-rebase.hg
   $ hg tglog
   o  2: c062e3ecd6c6 'c1' c
   |
   | @  1: 40039acb7ca5 'b1' b
   |/
   o  0: d681519c3ea7 '0'
   
 
 rebase 'b1' on top of the tip of the branch ('b2') - ignoring the tip branch ('c1')
 
   $ cd ../case2
   $ hg up -qr 1
   $ hg rebase
   rebasing 1:40039acb7ca5 "b1"
   saved backup bundle to $TESTTMP/case2/.hg/strip-backup/40039acb7ca5-342b72d1-rebase.hg
   $ hg tglog
   @  3: 76abc1c6f8c7 'b1' b
   |
   | o  2: c062e3ecd6c6 'c1' c
   | |
   o |  1: 792845bb77ee 'b2' b
   |/
   o  0: d681519c3ea7 '0'
   
 
 rebase 'c1' to the branch head 'c2' that is closed
 
   $ hg branch -qf c
   $ hg ci -qm 'c2 closed' --close
   $ hg up -qr 2
   $ hg tglog
   _  4: 8427af5d86f2 'c2 closed' c
   |
   o  3: 76abc1c6f8c7 'b1' b
   |
   | @  2: c062e3ecd6c6 'c1' c
   | |
   o |  1: 792845bb77ee 'b2' b
   |/
   o  0: d681519c3ea7 '0'
   
   $ hg rebase
   abort: branch 'c' has one head - please rebase to an explicit rev
-  (run 'hg heads' to see all heads)
+  (run 'hg heads' to see all heads, specify destination with -d)
   [255]
   $ hg tglog
   _  4: 8427af5d86f2 'c2 closed' c
   |
   o  3: 76abc1c6f8c7 'b1' b
   |
   | @  2: c062e3ecd6c6 'c1' c
   | |
   o |  1: 792845bb77ee 'b2' b
   |/
   o  0: d681519c3ea7 '0'
   
 
   $ hg up -cr 1
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch x
   marked working directory as branch x
   $ hg rebase -r 3:: -d .
   rebasing 3:76abc1c6f8c7 "b1"
   rebasing 4:8427af5d86f2 "c2 closed" (tip)
   note: not rebasing 4:8427af5d86f2 "c2 closed" (tip), its destination already has all its changes
   saved backup bundle to $TESTTMP/case2/.hg/strip-backup/76abc1c6f8c7-cd698d13-rebase.hg
   $ hg tglog
   o  3: 117b0ed08075 'b1' x
   |
   | o  2: c062e3ecd6c6 'c1' c
   | |
   @ |  1: 792845bb77ee 'b2' b
   |/
   o  0: d681519c3ea7 '0'
   
 
   $ cd ..

tests/test-rebase-parameters.t

@@ -1,521 +1,521 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 use --abort with --continue
   [255]
 
   $ hg rebase --continue --collapse
   abort: cannot use collapse with continue or abort
   [255]
 
   $ hg rebase --continue --dest 4
   abort: abort and continue do not allow specifying revisions
   [255]
 
   $ hg rebase --base 5 --source 4
   abort: cannot specify both a source and a base
   [255]
 
   $ hg rebase --rev 5 --source 4
   abort: cannot specify both a revision and a source
   [255]
   $ hg rebase --base 5 --rev 4
   abort: cannot specify both a revision and a base
   [255]
 
   $ hg rebase --base 6
   abort: branch 'default' has 3 heads - please rebase to an explicit rev
-  (run 'hg heads .' to see heads)
+  (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 --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)
   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 ..