destutil: choose non-closed branch head at first (BC)

Before this patch, destupdate() returns the tipmost (descendant)
branch head regardless of closed or not. But updating to closed branch
head isn't reasonable for ordinary workflow, because:

  - "hg heads" doesn't show closed heads (= updated parent itself) by
    default

  - subsequent committing on it re-opens closed branch

    even if inactivation of closed head is needed, update destination
    isn't it, because it should be merged into to another branch in
    such case.

This patch chooses non-closed descendant branch head as default update
destination at first. If all descendant branch heads are closed,
destupdate() returns the tipmost closed branch head.

For simplicity, this patch chooses adding _destupdatebranchfallback()
instead largely changing _destupdatebranch().

This patch changes not only normal lookup code path, but also the "no
default branch" code path, for consistency.

mercurial/destutil.py

@@ -1,378 +1,422
 # 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,
     obsolete,
 )
 
 def _destupdatevalidate(repo, rev, clean, check):
     """validate that the destination comply to various rules
 
     This exists as its own function to help wrapping from extensions."""
     wc = repo[None]
     p1 = wc.p1()
     if not clean:
         # Check that the update is linear.
         #
         # Mercurial do not allow update-merge for non linear pattern
         # (that would be technically possible but was considered too confusing
         # for user a long time ago)
         #
         # See mercurial.merge.update for details
         if p1.rev() not in repo.changelog.ancestors([rev], inclusive=True):
             dirty = wc.dirty(missing=True)
             foreground = obsolete.foreground(repo, [p1.node()])
             if not repo[rev].node() in foreground:
                 if dirty:
                     msg = _("uncommitted changes")
                     hint = _("commit and merge, or update --clean to"
                              " discard changes")
                     raise error.UpdateAbort(msg, hint=hint)
                 elif not check:  # destination is not a descendant.
                     msg = _("not a linear update")
                     hint = _("merge or update --check to force update")
                     raise error.UpdateAbort(msg, hint=hint)
 
 def _destupdateobs(repo, clean, check):
     """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 = obsolete.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('max(%ln)', successors).first()
             if bookmarks.isactivewdirparent(repo):
                 movemark = repo['.'].node()
     return node, movemark, None
 
 def _destupdatebook(repo, clean, check):
     """decide on an update destination from active bookmark"""
     # we also move the active bookmark, if any
     activemark = None
     node, movemark = bookmarks.calculateupdate(repo.ui, repo, None)
     if node is not None:
         activemark = node
     return node, movemark, activemark
 
 def _destupdatebranch(repo, clean, check):
-    """decide on an update destination from current branch"""
+    """decide on an update destination from current branch
+
+    This ignores closed branch heads.
+    """
     wc = repo[None]
     movemark = node = None
     currentbranch = wc.branch()
     if currentbranch in repo.branchmap():
-        heads = repo.branchheads(currentbranch, closed=True)
+        heads = repo.branchheads(currentbranch)
         if heads:
             node = repo.revs('max(.::(%ln))', heads).first()
         if bookmarks.isactivewdirparent(repo):
             movemark = repo['.'].node()
     else:
         if currentbranch == 'default': # no default branch!
-            node = repo.lookup('tip') # update to tip
+            # update to the tipmost non-closed branch head
+            node = repo.revs('max(head() and not closed())').first()
         else:
             raise error.Abort(_("branch %s not found") % currentbranch)
     return node, movemark, None
 
+def _destupdatebranchfallback(repo, clean, check):
+    """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, "any branch has at least one head"
+        node = repo.revs('max(.::(%ln))', heads).first()
+        assert node is not None, ("any revision has at least "
+                                  "one descendant branch head")
+        if bookmarks.isactivewdirparent(repo):
+            movemark = repo['.'].node()
+    else:
+        # here, no "default" branch, and all branches are closed
+        node = repo.lookup('tip')
+        assert node is not None, "'tip' exists even in empty repository"
+    return node, movemark, None
+
 # order in which each step should be evalutated
 # steps are run until one finds a destination
-destupdatesteps = ['evolution', 'bookmark', 'branch']
+destupdatesteps = ['evolution', 'bookmark', 'branch', 'branchfallback']
 # mapping to ease extension overriding steps.
 destupdatestepmap = {'evolution': _destupdateobs,
                      'bookmark': _destupdatebook,
                      'branch': _destupdatebranch,
+                     'branchfallback': _destupdatebranchfallback,
                      }
 
 def destupdate(repo, clean=False, check=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, check)
         if node is not None:
             break
     rev = repo[node].rev()
 
     _destupdatevalidate(repo, rev, clean, check)
 
     return rev, movemark, activemark
 
 msgdestmerge = {
     # too many matching divergent bookmark
     'toomanybookmarks':
         {'merge':
             (_("multiple matching bookmarks to merge -"
                " please merge with an explicit rev or bookmark"),
              _("run 'hg heads' to see all heads")),
          'rebase':
             (_("multiple matching bookmarks to rebase -"
                " please rebase to an explicit rev or bookmark"),
              _("run 'hg heads' to see all heads")),
         },
     # no other matching divergent bookmark
     'nootherbookmarks':
         {'merge':
             (_("no matching bookmark to merge - "
                "please merge with an explicit rev or bookmark"),
              _("run 'hg heads' to see all heads")),
          'rebase':
             (_("no matching bookmark to rebase - "
                "please rebase to an explicit rev or bookmark"),
              _("run 'hg heads' to see all heads")),
         },
     # branch have too many unbookmarked heads, no obvious destination
     'toomanyheads':
         {'merge':
             (_("branch '%s' has %d heads - please merge with an explicit rev"),
              _("run 'hg heads .' to see heads")),
          'rebase':
             (_("branch '%s' has %d heads - please rebase to an explicit rev"),
              _("run 'hg heads .' to see heads")),
         },
     # branch have no other unbookmarked heads
     'bookmarkedheads':
         {'merge':
             (_("heads are bookmarked - please merge with an explicit rev"),
              _("run 'hg heads' to see all heads")),
          'rebase':
             (_("heads are bookmarked - please rebase to an explicit rev"),
              _("run 'hg heads' to see all heads")),
         },
     # branch have just a single heads, but there is other branches
     'nootherbranchheads':
         {'merge':
             (_("branch '%s' has one head - please merge with an explicit rev"),
              _("run 'hg heads' to see all heads")),
          'rebase':
             (_("branch '%s' has one head - please rebase to an explicit rev"),
              _("run 'hg heads' to see all heads")),
         },
     # repository have a single head
     'nootherheads':
         {'merge':
             (_('nothing to merge'),
             None),
          'rebase':
             (_('nothing to rebase'),
             None),
         },
     # repository have a single head and we are not on it
     'nootherheadsbehind':
         {'merge':
             (_('nothing to merge'),
              _("use 'hg update' instead")),
          'rebase':
             (_('nothing to rebase'),
              _("use 'hg update' instead")),
         },
     # We are not on a head
     'notatheads':
         {'merge':
             (_('working directory not at a head revision'),
              _("use 'hg update' or merge with an explicit revision")),
          'rebase':
             (_('working directory not at a head revision'),
              _("use 'hg update' or rebase to an explicit revision"))
         },
     'emptysourceset':
         {'merge':
             (_('source set is empty'),
              None),
          'rebase':
             (_('source set is empty'),
              None),
         },
     'multiplebranchessourceset':
         {'merge':
             (_('source set is rooted in multiple branches'),
              None),
          'rebase':
             (_('rebaseset is rooted in multiple named branches'),
              _('specify an explicit destination with --dest')),
         },
     }
 
 def _destmergebook(repo, action='merge', sourceset=None):
     """find merge destination in the active bookmark case"""
     node = None
     bmheads = repo.bookmarkheads(repo._activebookmark)
     curhead = repo[repo._activebookmark].node()
     if len(bmheads) == 2:
         if curhead == bmheads[0]:
             node = bmheads[1]
         else:
             node = bmheads[0]
     elif len(bmheads) > 2:
         msg, hint = msgdestmerge['toomanybookmarks'][action]
         raise error.ManyMergeDestAbort(msg, hint=hint)
     elif len(bmheads) <= 1:
         msg, hint = msgdestmerge['nootherbookmarks'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     assert node is not None
     return node
 
 def _destmergebranch(repo, action='merge', sourceset=None, onheadcheck=True):
     """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['emptysourceset'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     else:
         branch = None
         for ctx in repo.set('roots(%ld::%ld)', sourceset, sourceset):
             if branch is not None and ctx.branch() != branch:
                 msg, hint = msgdestmerge['multiplebranchessourceset'][action]
                 raise error.ManyMergeDestAbort(msg, hint=hint)
             branch = ctx.branch()
 
     bheads = repo.branchheads(branch)
     onhead = repo.revs('%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['nootherheadsbehind'][action]
         else:
             msg, hint = msgdestmerge['notatheads'][action]
         raise error.Abort(msg, hint=hint)
     # remove heads descendants of source from the set
     bheads = list(repo.revs('%ln - (%ld::)', bheads, sourceset))
     # filters out bookmarked heads
     nbhs = list(repo.revs('%ld - bookmark()', bheads))
     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['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['bookmarkedheads'][action]
         elif len(repo.heads()) > 1:
             msg, hint = msgdestmerge['nootherbranchheads'][action]
             msg %= branch
         elif not onhead:
             # if 'onheadcheck == False' (rebase case),
             # this was not caught in Case A.
             msg, hint = msgdestmerge['nootherheadsbehind'][action]
         else:
             msg, hint = msgdestmerge['nootherheads'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     else:
         node = nbhs[0]
     assert node is not None
     return node
 
 def destmerge(repo, action='merge', sourceset=None, onheadcheck=True):
     """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
     """
     if repo._activebookmark:
         node = _destmergebook(repo, action=action, sourceset=sourceset)
     else:
         node = _destmergebranch(repo, action=action, sourceset=sourceset,
                                 onheadcheck=onheadcheck)
     return repo[node].rev()
 
 histeditdefaultrevset = 'reverse(only(.) and not public() and not ::merge())'
 
 def desthistedit(ui, repo):
     """Default base revision to edit for `hg histedit`."""
     # Avoid cycle: scmutil -> revset -> destutil
     from . import scmutil
 
     default = ui.config('histedit', 'defaultrev', histeditdefaultrevset)
     if default:
         revs = scmutil.revrange(repo, [default])
         if revs:
             # The revset supplied by the user may not be in ascending order nor
             # take the first revision. So do this manually.
             revs.sort()
             return revs.first()
 
     return None
 
 def _statusotherbook(ui, repo):
     bmheads = repo.bookmarkheads(repo._activebookmark)
     curhead = repo[repo._activebookmark].node()
     if repo.revs('%n and parents()', curhead):
         # we are on the active bookmark
         bmheads = [b for b in bmheads if curhead != b]
         if bmheads:
             msg = _('%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('%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('%ln - parents()', heads)
+        if repo['.'].closesbranch():
+            ui.status(_('updated to a closed branch head, '
+                        'because all descendant heads are closed.\n'
+                        'beware of re-opening closed head '
+                        'by subsequent commit here.\n'))
         if otherheads:
             ui.status(_('%i other heads for branch "%s"\n') %
                       (len(otherheads), currentbranch))
+            else:
+                ui.status(_('all heads for branch "%s" are closed.\n') %
+                          currentbranch)
+        elif otherheads:
+            ui.status(_('%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-current.t

@@ -1,204 +1,223
   $ hg init
 
 no bookmarks
 
   $ hg bookmarks
   no bookmarks set
 
 set bookmark X
 
   $ hg bookmark X
 
 list bookmarks
 
   $ hg bookmark
    * X                         -1:000000000000
 
 list bookmarks with color
 
   $ hg --config extensions.color= --config color.mode=ansi \
   >     bookmark --color=always
   \x1b[0;32m * \x1b[0m\x1b[0;32mX\x1b[0m\x1b[0;32m                         -1:000000000000\x1b[0m (esc)
 
 update to bookmark X
 
   $ hg update X
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark X)
 
 list bookmarks
 
   $ hg bookmarks
    * X                         -1:000000000000
 
 rename
 
   $ hg bookmark -m X Z
 
 list bookmarks
 
   $ cat .hg/bookmarks.current
   Z (no-eol)
   $ cat .hg/bookmarks
   0000000000000000000000000000000000000000 Z
   $ hg bookmarks
    * Z                         -1:000000000000
 
 new bookmarks X and Y, first one made active
 
   $ hg bookmark Y X
 
 list bookmarks
 
   $ hg bookmark
      X                         -1:000000000000
    * Y                         -1:000000000000
      Z                         -1:000000000000
 
   $ hg bookmark -d X
 
 commit
 
   $ echo 'b' > b
   $ hg add b
   $ hg commit -m'test'
 
 list bookmarks
 
   $ hg bookmark
    * Y                         0:719295282060
      Z                         -1:000000000000
 
 Verify that switching to Z updates the active bookmark:
   $ hg update Z
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (activating bookmark Z)
   $ hg bookmark
      Y                         0:719295282060
    * Z                         -1:000000000000
 
 Switch back to Y for the remaining tests in this file:
   $ hg update Y
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark Y)
 
 delete bookmarks
 
   $ hg bookmark -d Y
   $ hg bookmark -d Z
 
 list bookmarks
 
   $ hg bookmark
   no bookmarks set
 
 update to tip
 
   $ hg update tip
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 set bookmark Y using -r . but make sure that the active
 bookmark is not activated
 
   $ hg bookmark -r . Y
 
 list bookmarks, Y should not be active
 
   $ hg bookmark
      Y                         0:719295282060
 
 now, activate Y
 
   $ hg up -q Y
 
 set bookmark Z using -i
 
   $ hg bookmark -r . -i Z
   $ hg bookmarks
    * Y                         0:719295282060
      Z                         0:719295282060
 
 deactivate active bookmark using -i
 
   $ hg bookmark -i Y
   $ hg bookmarks
      Y                         0:719295282060
      Z                         0:719295282060
 
   $ hg up -q Y
   $ hg bookmark -i
   $ hg bookmarks
      Y                         0:719295282060
      Z                         0:719295282060
   $ hg bookmark -i
   no active bookmark
   $ hg up -q Y
   $ hg bookmarks
    * Y                         0:719295282060
      Z                         0:719295282060
 
 deactivate active bookmark while renaming
 
   $ hg bookmark -i -m Y X
   $ hg bookmarks
      X                         0:719295282060
      Z                         0:719295282060
 
 bare update moves the active bookmark forward and clear the divergent bookmarks
 
   $ echo a > a
   $ hg ci -Am1
   adding a
   $ echo b >> a
   $ hg ci -Am2
   $ hg bookmark X@1 -r 1
   $ hg bookmark X@2 -r 2
   $ hg update X
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (activating bookmark X)
   $ hg bookmarks
    * X                         0:719295282060
      X@1                       1:cc586d725fbe
      X@2                       2:49e1c4e84c58
      Z                         0:719295282060
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updating bookmark X
   $ hg bookmarks
    * X                         2:49e1c4e84c58
      Z                         0:719295282060
 
 test deleting .hg/bookmarks.current when explicitly updating
 to a revision
 
   $ echo a >> b
   $ hg ci -m.
   $ hg up -q X
   $ test -f .hg/bookmarks.current
 
 try to update to it again to make sure we don't
 set and then unset it
 
   $ hg up -q X
   $ test -f .hg/bookmarks.current
 
   $ hg up -q 1
   $ test -f .hg/bookmarks.current
   [1]
 
 when a bookmark is active, hg up -r . is
 analogous to hg book -i <active bookmark>
 
   $ hg up -q X
   $ hg up -q .
   $ test -f .hg/bookmarks.current
   [1]
 
 issue 4552 -- simulate a pull moving the active bookmark
 
   $ hg up -q X
   $ printf "Z" > .hg/bookmarks.current
   $ hg log -T '{activebookmark}\n' -r Z
   Z
   $ hg log -T '{bookmarks % "{active}\n"}' -r Z
   Z
+
+test that updating to closed branch head also advances active bookmark
+
+  $ hg commit --close-branch -m "closed"
+  $ hg update -q ".^1"
+  $ hg bookmark Y
+  $ hg bookmarks
+     X                         3:4d6bd4bfb1ae
+   * Y                         3:4d6bd4bfb1ae
+     Z                         0:719295282060
+  $ hg update
+  0 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  updating bookmark Y
+  $ hg bookmarks
+     X                         3:4d6bd4bfb1ae
+   * Y                         4:8fa964221e8e
+     Z                         0:719295282060
+  $ hg parents -q
+  4:8fa964221e8e

tests/test-update-branches.t

@@ -1,303 +1,386
 # Construct the following history tree:
 #
 # @  5:e1bb631146ca  b1
 # |
 # o  4:a4fdb3b883c4 0:b608b9236435  b1
 # |
 # | o  3:4b57d2520816 1:44592833ba9f
 # | |
 # | | o  2:063f31070f65
 # | |/
 # | o  1:44592833ba9f
 # |/
 # o  0:b608b9236435
 
   $ mkdir b1
   $ cd b1
   $ hg init
   $ echo foo > foo
   $ echo zero > a
   $ hg init sub
   $ echo suba > sub/suba
   $ hg --cwd sub ci -Am addsuba
   adding suba
   $ echo 'sub = sub' > .hgsub
   $ hg ci -qAm0
   $ echo one > a ; hg ci -m1
   $ echo two > a ; hg ci -m2
   $ hg up -q 1
   $ echo three > a ; hg ci -qm3
   $ hg up -q 0
   $ hg branch -q b1
   $ echo four > a ; hg ci -qm4
   $ echo five > a ; hg ci -qm5
 
 Initial repo state:
 
   $ hg log -G --template '{rev}:{node|short} {parents} {branches}\n'
   @  5:ff252e8273df  b1
   |
   o  4:d047485b3896 0:60829823a42a  b1
   |
   | o  3:6efa171f091b 1:0786582aa4b1
   | |
   | | o  2:bd10386d478c
   | |/
   | o  1:0786582aa4b1
   |/
   o  0:60829823a42a
   
 
 Make sure update doesn't assume b1 is a repository if invoked from outside:
 
   $ cd ..
   $ hg update b1
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
   $ cd b1
 
 Test helper functions:
 
   $ revtest () {
   >     msg=$1
   >     dirtyflag=$2   # 'clean', 'dirty' or 'dirtysub'
   >     startrev=$3
   >     targetrev=$4
   >     opt=$5
   >     hg up -qC $startrev
   >     test $dirtyflag = dirty && echo dirty > foo
   >     test $dirtyflag = dirtysub && echo dirty > sub/suba
   >     hg up $opt $targetrev
   >     hg parent --template 'parent={rev}\n'
   >     hg stat -S
   > }
 
   $ norevtest () {
   >     msg=$1
   >     dirtyflag=$2   # 'clean', 'dirty' or 'dirtysub'
   >     startrev=$3
   >     opt=$4
   >     hg up -qC $startrev
   >     test $dirtyflag = dirty && echo dirty > foo
   >     test $dirtyflag = dirtysub && echo dirty > sub/suba
   >     hg up $opt
   >     hg parent --template 'parent={rev}\n'
   >     hg stat -S
   > }
 
 Test cases are documented in a table in the update function of merge.py.
 Cases are run as shown in that table, row by row.
 
   $ norevtest 'none clean linear' clean 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=5
 
   $ norevtest 'none clean same'   clean 2
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 other heads for branch "default"
   parent=2
 
 
   $ revtest 'none clean linear' clean 1 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ revtest 'none clean same'   clean 2 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=3
 
   $ revtest 'none clean cross'  clean 3 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=4
 
 
   $ revtest 'none dirty linear' dirty 1 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M foo
 
   $ revtest 'none dirtysub linear' dirtysub 1 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M sub/suba
 
   $ revtest 'none dirty same'   dirty 2 3
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=2
   M foo
 
   $ revtest 'none dirtysub same'   dirtysub 2 3
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=2
   M sub/suba
 
   $ revtest 'none dirty cross'  dirty 3 4
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=3
   M foo
 
   $ norevtest 'none dirty cross'  dirty 2
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 other heads for branch "default"
   parent=2
   M foo
 
   $ revtest 'none dirtysub cross'  dirtysub 3 4
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=3
   M sub/suba
 
   $ revtest '-C dirty linear'   dirty 1 2 -C
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ revtest '-c dirty linear'   dirty 1 2 -c
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest '-c dirtysub linear'   dirtysub 1 2 -c
   abort: uncommitted changes in subrepository 'sub'
   parent=1
   M sub/suba
 
   $ norevtest '-c clean same'   clean 2 -c
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 other heads for branch "default"
   parent=2
 
   $ revtest '-cC dirty linear'  dirty 1 2 -cC
   abort: cannot specify both -c/--check and -C/--clean
   parent=1
   M foo
 
   $ cd ..
 
 Test updating with closed head
 ---------------------------------------------------------------------
 
   $ hg clone -U -q b1 closed-heads
   $ cd closed-heads
 
 Test updating if at least one non-closed branch head exists
 
 if on the closed branch head:
-- updating is no-op
+- update to "."
+- "updated to a closed branch head ...." message is displayed
 - "N other heads for ...." message is displayed
 
   $ hg update -q -C 3
   $ hg commit --close-branch -m 6
   $ norevtest "on closed branch head" clean 6
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  updated to a closed branch head, because all descendant heads are closed.
+  beware of re-opening closed head by subsequent commit here.
+  1 other heads for branch "default"
+  parent=6
+
+if descendant non-closed branch head exists, and it is only one branch head:
+- update to it, even if its revision is less than closed one
+- "N other heads for ...." message isn't displayed
+
+  $ norevtest "non-closed 2 should be chosen" clean 1
+  1 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  parent=2
+
+if all descendant branch heads are closed, but there is another branch head:
+- update to the tipmost descendant head
+- "updated to a closed branch head ...." message is displayed
+- "N other heads for ...." message is displayed
+
+  $ norevtest "all descendant branch heads are closed" clean 3
+  0 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  updated to a closed branch head, because all descendant heads are closed.
+  beware of re-opening closed head by subsequent commit here.
   1 other heads for branch "default"
   parent=6
 
 Test updating if all branch heads are closed
 
 if on the closed branch head:
-- updating is no-op
-- "N other heads for ...." message isn't displayed
+- update to "."
+- "updated to a closed branch head ...." message is displayed
+- "all heads of branch ...." message is displayed
 
   $ hg update -q -C 2
   $ hg commit --close-branch -m 7
   $ norevtest "all heads of branch default are closed" clean 6
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  updated to a closed branch head, because all descendant heads are closed.
+  beware of re-opening closed head by subsequent commit here.
+  all heads for branch "default" are closed.
   parent=6
 
+if not on the closed branch head:
+- update to the tipmost descendant (closed) head
+- "updated to a closed branch head ...." message is displayed
+- "all heads of branch ...." message is displayed
+
+  $ norevtest "all heads of branch default are closed" clean 1
+  1 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  updated to a closed branch head, because all descendant heads are closed.
+  beware of re-opening closed head by subsequent commit here.
+  all heads for branch "default" are closed.
+  parent=7
+
+  $ cd ..
+
+Test updating if "default" branch doesn't exist and no revision is
+checked out (= "default" is used as current branch)
+
+  $ hg init no-default-branch
+  $ cd no-default-branch
+
+  $ hg branch foobar
+  marked working directory as branch foobar
+  (branches are permanent and global, did you want a bookmark?)
+  $ echo a > a
+  $ hg commit -m "#0" -A
+  adding a
+  $ echo 1 >> a
+  $ hg commit -m "#1"
+  $ hg update -q 0
+  $ echo 3 >> a
+  $ hg commit -m "#2"
+  created new head
+  $ hg commit --close-branch -m "#3"
+
+if there is at least one non-closed branch head:
+- update to the tipmost branch head
+
+  $ norevtest "non-closed 1 should be chosen" clean null
+  1 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  parent=1
+
+if all branch heads are closed
+- update to "tip"
+- "updated to a closed branch head ...." message is displayed
+- "all heads for branch "XXXX" are closed" message is displayed
+
+  $ hg update -q -C 1
+  $ hg commit --close-branch -m "#4"
+
+  $ norevtest "all branches are closed" clean null
+  1 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  updated to a closed branch head, because all descendant heads are closed.
+  beware of re-opening closed head by subsequent commit here.
+  all heads for branch "foobar" are closed.
+  parent=4
+
   $ cd ../b1
 
 Test obsolescence behavior
 ---------------------------------------------------------------------
 
 successors should be taken in account when checking head destination
 
   $ cat << EOF >> $HGRCPATH
   > [ui]
   > logtemplate={rev}:{node|short} {desc|firstline}
   > [experimental]
   > evolution=createmarkers
   > EOF
 
 Test no-argument update to a successor of an obsoleted changeset
 
   $ hg log -G
   o  5:ff252e8273df 5
   |
   o  4:d047485b3896 4
   |
   | o  3:6efa171f091b 3
   | |
   | | o  2:bd10386d478c 2
   | |/
   | @  1:0786582aa4b1 1
   |/
   o  0:60829823a42a 0
   
   $ hg book bm -r 3
   $ hg status
   M foo
 
 We add simple obsolescence marker between 3 and 4 (indirect successors)
 
   $ hg id --debug -i -r 3
   6efa171f091b00a3c35edc15d48c52a498929953
   $ hg id --debug -i -r 4
   d047485b3896813b2a624e86201983520f003206
   $ hg debugobsolete 6efa171f091b00a3c35edc15d48c52a498929953 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
   $ hg debugobsolete aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa d047485b3896813b2a624e86201983520f003206
 
 Test that 5 is detected as a valid destination from 3 and also accepts moving
 the bookmark (issue4015)
 
   $ hg up --quiet --hidden 3
   $ hg up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg book bm
   moving bookmark 'bm' forward from 6efa171f091b
   $ hg bookmarks
    * bm                        5:ff252e8273df
 
 Test that 4 is detected as the no-argument destination from 3 and also moves
 the bookmark with it
   $ hg up --quiet 0          # we should be able to update to 3 directly
   $ hg up --quiet --hidden 3 # but not implemented yet.
   $ hg book -f bm
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updating bookmark bm
   $ hg book
    * bm                        4:d047485b3896
 
 Test that 5 is detected as a valid destination from 1
   $ hg up --quiet 0          # we should be able to update to 3 directly
   $ hg up --quiet --hidden 3 # but not implemented yet.
   $ hg up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test that 5 is not detected as a valid destination from 2
   $ hg up --quiet 0
   $ hg up --quiet 2
   $ hg up 5
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   [255]
 
 Test that we don't crash when updating from a pruned changeset (i.e. has no
 successors). Behavior should probably be that we update to the first
 non-obsolete parent but that will be decided later.
   $ hg id --debug -r 2
   bd10386d478cd5a9faf2e604114c8e6da62d3889
   $ hg up --quiet 0
   $ hg up --quiet 2
   $ hg debugobsolete bd10386d478cd5a9faf2e604114c8e6da62d3889
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test experimental revset support
 
   $ hg log -r '_destupdate()'
   2:bd10386d478c 2 (no-eol)