destutil: if wdp is obsolete, update to the closest non-obsolete ancestor

As the original comments suggest, using prune as a model here was an existing
idea, and now this patch implements it.

I think it would be even better to do what solveobswdp() from evolve does (in
short, it allows to update to a successor of the closest ancestor even if that
ancestor is obsolete), but that is outside of this series' scope.

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

mercurial/destutil.py

@@ -1,493 +1,496 b''
 # destutil.py - Mercurial utility function for command destination
 #
 #  Copyright Olivia 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'
+        # pruned changeset: update to the closest non-obsolete ancestor,
+        # similar to what 'hg prune' currently does
 
         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):
+        else:
+            p1 = p1.p1()
+            while p1.obsolete():
+                p1 = p1.p1()
+            node = p1.node()
+
+        if node is not None and bookmarks.isactivewdirparent(repo):
                 movemark = repo[b'.'].node()
-        else:
-            # TODO: copy hg prune logic
-            node = 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 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, 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, 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, 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, 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, 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, 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, specify rev with -r"),
         ),
         b'rebase': (
             _(b"heads are bookmarked - please rebase to an explicit rev"),
             _(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, 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, 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.ConfigError(
             _(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-update-branches.t

@@ -1,726 +1,722 b''
   $ cat >> $HGRCPATH <<EOF
   > [commands]
   > status.verbose=1
   > EOF
 
 # 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)
   [10]
   $ 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
   updated to "bd10386d478c: 2"
   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
   updated to "bd10386d478c: 2"
   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 '--clean dirty linear'   dirty 1 2 --clean
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ revtest '--check dirty linear'   dirty 1 2 --check
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest '--merge dirty linear'   dirty 1 2 --merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M foo
 
   $ revtest '--merge dirty cross'  dirty 3 4 --merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=4
   M foo
 
   $ revtest '--check dirtysub linear'   dirtysub 1 2 --check
   abort: uncommitted changes in subrepository "sub"
   parent=1
   M sub/suba
 
   $ norevtest '--check clean same'   clean 2 -c
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "bd10386d478c: 2"
   1 other heads for branch "default"
   parent=2
 
   $ revtest '--check --clean dirty linear'  dirty 1 2 "--check --clean"
   abort: cannot specify both --clean and --check
   parent=1
   M foo
 
   $ revtest '--merge -checkc dirty linear'  dirty 1 2 "--merge --check"
   abort: cannot specify both --check and --merge
   parent=1
   M foo
 
   $ revtest '--merge -clean dirty linear'  dirty 1 2 "--merge --clean"
   abort: cannot specify both --clean and --merge
   parent=1
   M foo
 
   $ echo '[commands]' >> .hg/hgrc
   $ echo 'update.check = abort' >> .hg/hgrc
 
   $ revtest 'none dirty linear' dirty 1 2
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 --check
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest '--merge none dirty linear' dirty 1 2 --check
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest '--merge none dirty linear' dirty 1 2 --merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M foo
 
   $ revtest '--merge none dirty linear' dirty 1 2 --no-check
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 --clean
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ echo 'update.check = none' >> .hg/hgrc
 
   $ revtest 'none dirty cross'  dirty 3 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=4
   M foo
 
   $ 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 dirty linear' dirty 1 2 --check
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 --no-merge
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 --clean
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ hg co -qC 3
   $ echo dirty >> a
   $ hg co --tool :merge3 4
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg log -G --template '{rev}:{node|short} {parents} {branches}\n'
   o  5:ff252e8273df  b1
   |
   @  4:d047485b3896 0:60829823a42a  b1
   |
   | %  3:6efa171f091b 1:0786582aa4b1
   | |
   | | o  2:bd10386d478c
   | |/
   | o  1:0786582aa4b1
   |/
   o  0:60829823a42a
   
   $ hg st
   M a
   ? a.orig
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   $ cat a
   <<<<<<< working copy:        6efa171f091b - test: 3
   three
   dirty
   ||||||| working copy parent: 6efa171f091b - test: 3
   three
   =======
   four
   >>>>>>> destination:         d047485b3896 b1 - test: 4
   $ rm a.orig
 
   $ echo 'update.check = noconflict' >> .hg/hgrc
 
   $ revtest 'none dirty cross'  dirty 3 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=4
   M foo
 
   $ 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 dirty linear' dirty 1 2 -c
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 -C
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
 Locally added file is allowed
   $ hg up -qC 3
   $ echo a > bar
   $ hg add bar
   $ hg up -q 4
   $ hg st
   A bar
   $ hg forget bar
   $ rm bar
 
 Locally removed file is allowed
   $ hg up -qC 3
   $ hg rm foo
   $ hg up -q 4
 
 File conflict is not allowed
   $ hg up -qC 3
   $ echo dirty >> a
   $ hg up -q 4
   abort: conflicting changes
   (commit or update --clean to discard changes)
   [20]
   $ hg up -m 4
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ rm a.orig
   $ hg status
   M a
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   $ hg resolve -l
   U a
 
 Try to make empty commit while there are conflicts
   $ hg revert -r . a
   $ rm a.orig
   $ hg ci -m empty
   abort: unresolved merge conflicts (see 'hg help resolve')
   [20]
   $ hg resolve -m a
   (no more unresolved files)
   $ hg resolve -l
   R a
   $ hg ci -m empty
   nothing changed
   [1]
   $ hg resolve -l
 
 Change/delete conflict is not allowed
   $ hg up -qC 3
   $ hg rm foo
   $ hg up -q 4
 
 Uses default value of "linear" when value is misspelled
   $ echo 'update.check = linyar' >> .hg/hgrc
 
   $ revtest 'dirty cross'  dirty 3 4
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=3
   M foo
 
 Setup for later tests
   $ revtest 'none dirty linear' dirty 1 2 -c
   abort: uncommitted changes
   parent=1
   M foo
 
   $ cd ..
 
 Test updating to null revision
 
   $ hg init null-repo
   $ cd null-repo
   $ echo a > a
   $ hg add a
   $ hg ci -m a
   $ hg up -qC 0
   $ echo b > b
   $ hg add b
   $ hg up null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg st
   A b
   $ hg up -q 0
   $ hg st
   A b
   $ hg up -qC null
   $ hg st
   ? b
   $ 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:
 - 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
   no open descendant heads on branch "default", updating to a closed head
   (committing will reopen the head, use 'hg heads .' to see 1 other heads)
   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
   no open descendant heads on branch "default", updating to a closed head
   (committing will reopen the head, use 'hg heads .' to see 1 other heads)
   parent=6
 
 Test updating if all branch heads are closed
 
 if on the closed branch head:
 - 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
   no open descendant heads on branch "default", updating to a closed head
   (committing will reopen branch "default")
   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
   no open descendant heads on branch "default", updating to a closed head
   (committing will reopen branch "default")
   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
   no open descendant heads on branch "foobar", updating to a closed head
   (committing will reopen branch "foobar")
   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=True
   > 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
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg debugobsolete aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa d047485b3896813b2a624e86201983520f003206
   1 new obsolescence markers
 
 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 we abort before we warn about the hidden commit if the working
 directory is dirty
   $ echo conflict > a
   $ hg up --hidden 3
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   [255]
 
 Test that we still warn also when there are conflicts
   $ hg up -m --hidden 3
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   (leaving bookmark bm)
   updated to hidden changeset 6efa171f091b
   (hidden revision '6efa171f091b' was rewritten as: d047485b3896)
   [1]
 
 Test that statuses are reported properly before and after merge resolution.
   $ rm a.orig
   $ hg resolve -l
   U a
   $ hg status
   M a
   M foo
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
 
   $ hg revert -r . a
 
   $ rm a.orig
   $ hg resolve -l
   U a
   $ hg status
   M foo
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   $ hg status -Tjson
   [
    {
     "itemtype": "file",
     "path": "foo",
     "status": "M"
    },
    {
     "itemtype": "file",
     "path": "a",
     "unresolved": true
    }
   ]
 
   $ hg resolve -m
   (no more unresolved files)
 
   $ hg resolve -l
   R a
   $ hg status
   M foo
   # No unresolved merge conflicts.
   
   $ hg status -Tjson
   [
    {
     "itemtype": "file",
     "path": "foo",
     "status": "M"
    }
   ]
 
 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 status
   M foo
   $ hg up --quiet --hidden 3 # but not implemented yet.
   updated to hidden changeset 6efa171f091b
   (hidden revision '6efa171f091b' was rewritten as: d047485b3896)
   $ 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.
   updated to hidden changeset 6efa171f091b
   (hidden revision '6efa171f091b' was rewritten as: d047485b3896)
   $ 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.
+Test that we update to the closest non-obsolete ancestor when updating from a
+pruned changeset (i.e. that has no successors)
   $ hg id --debug -r 2
   bd10386d478cd5a9faf2e604114c8e6da62d3889
   $ hg up --quiet 0
   $ hg up --quiet 2
   $ hg debugobsolete bd10386d478cd5a9faf2e604114c8e6da62d3889
   1 new obsolescence markers
   obsoleted 1 changesets
+  $ hg log -r '_destupdate()'
+  1:0786582aa4b1 1 (no-eol)
   $ 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)
+  1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test that boolean flags allow --no-flag specification to override [defaults]
   $ cat >> $HGRCPATH <<EOF
   > [defaults]
   > update = --check
   > EOF
-  $ hg co 2
+  $ hg co 1
   abort: uncommitted changes
   [20]
-  $ hg co --no-check 2
+  $ hg co --no-check 1
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved