merge: back out single-parent fast-forward merge

This backs out

 changeset:   13158:9e7e24052745
 user:        Mads Kiilerich <[e-mail]>
 date:        Tue Dec 07 03:29:21 2010 +0100
 summary:     merge: fast-forward merge with descendant

Before named branches, the invariants were:

a) "merges" always have two parents
b) p1 is not linearly related to p2

Adding named branches made (b) problematic, so the above patch was
introduced, which fixed (b) but broke (a).

After discussion, we decided that the invariants should be:

a) "merges" always have two parents
b) p1 is not linearly related to p2 OR p1 and p2 are on different branches

mercurial/merge.py

@@ -1,560 +1,560 b''
 # merge.py - directory-level update/merge handling for Mercurial
 #
 # Copyright 2006, 2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from node import nullid, nullrev, hex, bin
 from i18n import _
 import util, filemerge, copies, subrepo
 import errno, os, shutil
 
 class mergestate(object):
     '''track 3-way merge state of individual files'''
     def __init__(self, repo):
         self._repo = repo
         self._dirty = False
         self._read()
     def reset(self, node=None):
         self._state = {}
         if node:
             self._local = node
         shutil.rmtree(self._repo.join("merge"), True)
         self._dirty = False
     def _read(self):
         self._state = {}
         try:
             f = self._repo.opener("merge/state")
             for i, l in enumerate(f):
                 if i == 0:
                     self._local = bin(l[:-1])
                 else:
                     bits = l[:-1].split("\0")
                     self._state[bits[0]] = bits[1:]
             f.close()
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
         self._dirty = False
     def commit(self):
         if self._dirty:
             f = self._repo.opener("merge/state", "w")
             f.write(hex(self._local) + "\n")
             for d, v in self._state.iteritems():
                 f.write("\0".join([d] + v) + "\n")
             f.close()
             self._dirty = False
     def add(self, fcl, fco, fca, fd, flags):
         hash = util.sha1(fcl.path()).hexdigest()
         self._repo.opener("merge/" + hash, "w").write(fcl.data())
         self._state[fd] = ['u', hash, fcl.path(), fca.path(),
                            hex(fca.filenode()), fco.path(), flags]
         self._dirty = True
     def __contains__(self, dfile):
         return dfile in self._state
     def __getitem__(self, dfile):
         return self._state[dfile][0]
     def __iter__(self):
         l = self._state.keys()
         l.sort()
         for f in l:
             yield f
     def mark(self, dfile, state):
         self._state[dfile][0] = state
         self._dirty = True
     def resolve(self, dfile, wctx, octx):
         if self[dfile] == 'r':
             return 0
         state, hash, lfile, afile, anode, ofile, flags = self._state[dfile]
         f = self._repo.opener("merge/" + hash)
         self._repo.wwrite(dfile, f.read(), flags)
         f.close()
         fcd = wctx[dfile]
         fco = octx[ofile]
         fca = self._repo.filectx(afile, fileid=anode)
         r = filemerge.filemerge(self._repo, self._local, lfile, fcd, fco, fca)
         if r is None:
             # no real conflict
             del self._state[dfile]
         elif not r:
             self.mark(dfile, 'r')
         return r
 
 def _checkunknown(wctx, mctx):
     "check for collisions between unknown files and files in mctx"
     for f in wctx.unknown():
         if f in mctx and mctx[f].cmp(wctx[f]):
             raise util.Abort(_("untracked file in working directory differs"
                                " from file in requested revision: '%s'") % f)
 
 def _checkcollision(mctx):
     "check for case folding collisions in the destination context"
     folded = {}
     for fn in mctx:
         fold = fn.lower()
         if fold in folded:
             raise util.Abort(_("case-folding collision between %s and %s")
                              % (fn, folded[fold]))
         folded[fold] = fn
 
 def _forgetremoved(wctx, mctx, branchmerge):
     """
     Forget removed files
 
     If we're jumping between revisions (as opposed to merging), and if
     neither the working directory nor the target rev has the file,
     then we need to remove it from the dirstate, to prevent the
     dirstate from listing the file when it is no longer in the
     manifest.
 
     If we're merging, and the other revision has removed a file
     that is not present in the working directory, we need to mark it
     as removed.
     """
 
     action = []
     state = branchmerge and 'r' or 'f'
     for f in wctx.deleted():
         if f not in mctx:
             action.append((f, state))
 
     if not branchmerge:
         for f in wctx.removed():
             if f not in mctx:
                 action.append((f, "f"))
 
     return action
 
 def manifestmerge(repo, p1, p2, pa, overwrite, partial):
     """
     Merge p1 and p2 with ancestor pa and generate merge action list
 
     overwrite = whether we clobber working files
     partial = function to filter file lists
     """
 
     def fmerge(f, f2, fa):
         """merge flags"""
         a, m, n = ma.flags(fa), m1.flags(f), m2.flags(f2)
         if m == n: # flags agree
             return m # unchanged
         if m and n and not a: # flags set, don't agree, differ from parent
             r = repo.ui.promptchoice(
                 _(" conflicting flags for %s\n"
                   "(n)one, e(x)ec or sym(l)ink?") % f,
                 (_("&None"), _("E&xec"), _("Sym&link")), 0)
             if r == 1:
                 return "x" # Exec
             if r == 2:
                 return "l" # Symlink
             return ""
         if m and m != a: # changed from a to m
             return m
         if n and n != a: # changed from a to n
             return n
         return '' # flag was cleared
 
     def act(msg, m, f, *args):
         repo.ui.debug(" %s: %s -> %s\n" % (f, msg, m))
         action.append((f, m) + args)
 
     action, copy = [], {}
 
     if overwrite:
         pa = p1
     elif pa == p2: # backwards
         pa = p1.p1()
     elif pa and repo.ui.configbool("merge", "followcopies", True):
         dirs = repo.ui.configbool("merge", "followdirs", True)
         copy, diverge = copies.copies(repo, p1, p2, pa, dirs)
         for of, fl in diverge.iteritems():
             act("divergent renames", "dr", of, fl)
 
     repo.ui.note(_("resolving manifests\n"))
     repo.ui.debug(" overwrite %s partial %s\n" % (overwrite, bool(partial)))
     repo.ui.debug(" ancestor %s local %s remote %s\n" % (pa, p1, p2))
 
     m1, m2, ma = p1.manifest(), p2.manifest(), pa.manifest()
     copied = set(copy.values())
 
     if '.hgsubstate' in m1:
         # check whether sub state is modified
         for s in p1.substate:
             if p1.sub(s).dirty():
                 m1['.hgsubstate'] += "+"
                 break
 
     # Compare manifests
     for f, n in m1.iteritems():
         if partial and not partial(f):
             continue
         if f in m2:
             rflags = fmerge(f, f, f)
             a = ma.get(f, nullid)
             if n == m2[f] or m2[f] == a: # same or local newer
                 # is file locally modified or flags need changing?
                 # dirstate flags may need to be made current
                 if m1.flags(f) != rflags or n[20:]:
                     act("update permissions", "e", f, rflags)
             elif n == a: # remote newer
                 act("remote is newer", "g", f, rflags)
             else: # both changed
                 act("versions differ", "m", f, f, f, rflags, False)
         elif f in copied: # files we'll deal with on m2 side
             pass
         elif f in copy:
             f2 = copy[f]
             if f2 not in m2: # directory rename
                 act("remote renamed directory to " + f2, "d",
                     f, None, f2, m1.flags(f))
             else: # case 2 A,B/B/B or case 4,21 A/B/B
                 act("local copied/moved to " + f2, "m",
                     f, f2, f, fmerge(f, f2, f2), False)
         elif f in ma: # clean, a different, no remote
             if n != ma[f]:
                 if repo.ui.promptchoice(
                     _(" local changed %s which remote deleted\n"
                       "use (c)hanged version or (d)elete?") % f,
                     (_("&Changed"), _("&Delete")), 0):
                     act("prompt delete", "r", f)
                 else:
                     act("prompt keep", "a", f)
             elif n[20:] == "a": # added, no remote
                 act("remote deleted", "f", f)
             elif n[20:] != "u":
                 act("other deleted", "r", f)
 
     for f, n in m2.iteritems():
         if partial and not partial(f):
             continue
         if f in m1 or f in copied: # files already visited
             continue
         if f in copy:
             f2 = copy[f]
             if f2 not in m1: # directory rename
                 act("local renamed directory to " + f2, "d",
                     None, f, f2, m2.flags(f))
             elif f2 in m2: # rename case 1, A/A,B/A
                 act("remote copied to " + f, "m",
                     f2, f, f, fmerge(f2, f, f2), False)
             else: # case 3,20 A/B/A
                 act("remote moved to " + f, "m",
                     f2, f, f, fmerge(f2, f, f2), True)
         elif f not in ma:
             act("remote created", "g", f, m2.flags(f))
         elif n != ma[f]:
             if repo.ui.promptchoice(
                 _("remote changed %s which local deleted\n"
                   "use (c)hanged version or leave (d)eleted?") % f,
                 (_("&Changed"), _("&Deleted")), 0) == 0:
                 act("prompt recreating", "g", f, m2.flags(f))
 
     return action
 
 def actionkey(a):
     return a[1] == 'r' and -1 or 0, a
 
 def applyupdates(repo, action, wctx, mctx, actx, overwrite):
     """apply the merge action list to the working directory
 
     wctx is the working copy context
     mctx is the context to be merged into the working copy
     actx is the context of the common ancestor
 
     Return a tuple of counts (updated, merged, removed, unresolved) that
     describes how many files were affected by the update.
     """
 
     updated, merged, removed, unresolved = 0, 0, 0, 0
     ms = mergestate(repo)
     ms.reset(wctx.parents()[0].node())
     moves = []
     action.sort(key=actionkey)
     substate = wctx.substate # prime
 
     # prescan for merges
     u = repo.ui
     for a in action:
         f, m = a[:2]
         if m == 'm': # merge
             f2, fd, flags, move = a[2:]
             if f == '.hgsubstate': # merged internally
                 continue
             repo.ui.debug("preserving %s for resolve of %s\n" % (f, fd))
             fcl = wctx[f]
             fco = mctx[f2]
             if mctx == actx: # backwards, use working dir parent as ancestor
                 if fcl.parents():
                     fca = fcl.parents()[0]
                 else:
                     fca = repo.filectx(f, fileid=nullrev)
             else:
                 fca = fcl.ancestor(fco, actx)
             if not fca:
                 fca = repo.filectx(f, fileid=nullrev)
             ms.add(fcl, fco, fca, fd, flags)
             if f != fd and move:
                 moves.append(f)
 
     # remove renamed files after safely stored
     for f in moves:
         if os.path.lexists(repo.wjoin(f)):
             repo.ui.debug("removing %s\n" % f)
             os.unlink(repo.wjoin(f))
 
     audit_path = util.path_auditor(repo.root)
 
     numupdates = len(action)
     for i, a in enumerate(action):
         f, m = a[:2]
         u.progress(_('updating'), i + 1, item=f, total=numupdates,
                    unit=_('files'))
         if f and f[0] == "/":
             continue
         if m == "r": # remove
             repo.ui.note(_("removing %s\n") % f)
             audit_path(f)
             if f == '.hgsubstate': # subrepo states need updating
                 subrepo.submerge(repo, wctx, mctx, wctx, overwrite)
             try:
                 util.unlinkpath(repo.wjoin(f))
             except OSError, inst:
                 if inst.errno != errno.ENOENT:
                     repo.ui.warn(_("update failed to remove %s: %s!\n") %
                                  (f, inst.strerror))
             removed += 1
         elif m == "m": # merge
             if f == '.hgsubstate': # subrepo states need updating
                 subrepo.submerge(repo, wctx, mctx, wctx.ancestor(mctx), overwrite)
                 continue
             f2, fd, flags, move = a[2:]
             r = ms.resolve(fd, wctx, mctx)
             if r is not None and r > 0:
                 unresolved += 1
             else:
                 if r is None:
                     updated += 1
                 else:
                     merged += 1
             util.set_flags(repo.wjoin(fd), 'l' in flags, 'x' in flags)
             if f != fd and move and os.path.lexists(repo.wjoin(f)):
                 repo.ui.debug("removing %s\n" % f)
                 os.unlink(repo.wjoin(f))
         elif m == "g": # get
             flags = a[2]
             repo.ui.note(_("getting %s\n") % f)
             t = mctx.filectx(f).data()
             repo.wwrite(f, t, flags)
             t = None
             updated += 1
             if f == '.hgsubstate': # subrepo states need updating
                 subrepo.submerge(repo, wctx, mctx, wctx, overwrite)
         elif m == "d": # directory rename
             f2, fd, flags = a[2:]
             if f:
                 repo.ui.note(_("moving %s to %s\n") % (f, fd))
                 t = wctx.filectx(f).data()
                 repo.wwrite(fd, t, flags)
                 util.unlinkpath(repo.wjoin(f))
             if f2:
                 repo.ui.note(_("getting %s to %s\n") % (f2, fd))
                 t = mctx.filectx(f2).data()
                 repo.wwrite(fd, t, flags)
             updated += 1
         elif m == "dr": # divergent renames
             fl = a[2]
             repo.ui.warn(_("note: possible conflict - %s was renamed "
                            "multiple times to:\n") % f)
             for nf in fl:
                 repo.ui.warn(" %s\n" % nf)
         elif m == "e": # exec
             flags = a[2]
             util.set_flags(repo.wjoin(f), 'l' in flags, 'x' in flags)
     ms.commit()
     u.progress(_('updating'), None, total=numupdates, unit=_('files'))
 
     return updated, merged, removed, unresolved
 
 def recordupdates(repo, action, branchmerge):
     "record merge actions to the dirstate"
 
     for a in action:
         f, m = a[:2]
         if m == "r": # remove
             if branchmerge:
                 repo.dirstate.remove(f)
             else:
                 repo.dirstate.forget(f)
         elif m == "a": # re-add
             if not branchmerge:
                 repo.dirstate.add(f)
         elif m == "f": # forget
             repo.dirstate.forget(f)
         elif m == "e": # exec change
             repo.dirstate.normallookup(f)
         elif m == "g": # get
             if branchmerge:
                 repo.dirstate.otherparent(f)
             else:
                 repo.dirstate.normal(f)
         elif m == "m": # merge
             f2, fd, flag, move = a[2:]
             if branchmerge:
                 # We've done a branch merge, mark this file as merged
                 # so that we properly record the merger later
                 repo.dirstate.merge(fd)
                 if f != f2: # copy/rename
                     if move:
                         repo.dirstate.remove(f)
                     if f != fd:
                         repo.dirstate.copy(f, fd)
                     else:
                         repo.dirstate.copy(f2, fd)
             else:
                 # We've update-merged a locally modified file, so
                 # we set the dirstate to emulate a normal checkout
                 # of that file some time in the past. Thus our
                 # merge will appear as a normal local file
                 # modification.
                 if f2 == fd: # file not locally copied/moved
                     repo.dirstate.normallookup(fd)
                 if move:
                     repo.dirstate.forget(f)
         elif m == "d": # directory rename
             f2, fd, flag = a[2:]
             if not f2 and f not in repo.dirstate:
                 # untracked file moved
                 continue
             if branchmerge:
                 repo.dirstate.add(fd)
                 if f:
                     repo.dirstate.remove(f)
                     repo.dirstate.copy(f, fd)
                 if f2:
                     repo.dirstate.copy(f2, fd)
             else:
                 repo.dirstate.normal(fd)
                 if f:
                     repo.dirstate.forget(f)
 
 def update(repo, node, branchmerge, force, partial):
     """
     Perform a merge between the working directory and the given node
 
     node = the node to update to, or None if unspecified
     branchmerge = whether to merge between branches
     force = whether to force branch merging or file overwriting
     partial = a function to filter file lists (dirstate not updated)
 
     The table below shows all the behaviors of the update command
     given the -c and -C or no options, whether the working directory
     is dirty, whether a revision is specified, and the relationship of
     the parent rev to the target rev (linear, on the same named
     branch, or on another named branch).
 
     This logic is tested by test-update-branches.t.
 
     -c  -C  dirty  rev  |  linear   same  cross
      n   n    n     n   |    ok     (1)     x
      n   n    n     y   |    ok     ok     ok
      n   n    y     *   |   merge   (2)    (2)
      n   y    *     *   |    ---  discard  ---
      y   n    y     *   |    ---    (3)    ---
      y   n    n     *   |    ---    ok     ---
      y   y    *     *   |    ---    (4)    ---
 
     x = can't happen
     * = don't-care
     1 = abort: crosses branches (use 'hg merge' or 'hg update -c')
     2 = abort: crosses branches (use 'hg merge' to merge or
                  use 'hg update -C' to discard changes)
     3 = abort: uncommitted local changes
     4 = incompatible options (checked in commands.py)
 
     Return the same tuple as applyupdates().
     """
 
     onode = node
     wlock = repo.wlock()
     try:
         wc = repo[None]
         if node is None:
             # tip of current branch
             try:
                 node = repo.branchtags()[wc.branch()]
             except KeyError:
                 if wc.branch() == "default": # no default branch!
                     node = repo.lookup("tip") # update to tip
                 else:
                     raise util.Abort(_("branch %s not found") % wc.branch())
         overwrite = force and not branchmerge
         pl = wc.parents()
         p1, p2 = pl[0], repo[node]
         pa = p1.ancestor(p2)
         fp1, fp2, xp1, xp2 = p1.node(), p2.node(), str(p1), str(p2)
         fastforward = False
 
         ### check phase
         if not overwrite and len(pl) > 1:
             raise util.Abort(_("outstanding uncommitted merges"))
         if branchmerge:
             if pa == p2:
                 raise util.Abort(_("merging with a working directory ancestor"
                                    " has no effect"))
             elif pa == p1:
                 if p1.branch() != p2.branch():
                     fastforward = True
                 else:
                     raise util.Abort(_("nothing to merge (use 'hg update'"
                                        " or check 'hg heads')"))
             if not force and (wc.files() or wc.deleted()):
                 raise util.Abort(_("outstanding uncommitted changes "
                                    "(use 'hg status' to list changes)"))
             for s in wc.substate:
                 if wc.sub(s).dirty():
                     raise util.Abort(_("outstanding uncommitted changes in "
                                        "subrepository '%s'") % s)
 
         elif not overwrite:
             if pa == p1 or pa == p2: # linear
                 pass # all good
             elif wc.files() or wc.deleted():
                 raise util.Abort(_("crosses branches (merge branches or use"
                                    " --clean to discard changes)"))
             elif onode is None:
                 raise util.Abort(_("crosses branches (merge branches or use"
                                    " --check to force update)"))
             else:
                 # Allow jumping branches if clean and specific rev given
                 overwrite = True
 
         ### calculate phase
         action = []
         wc.status(unknown=True) # prime cache
         if not force:
             _checkunknown(wc, p2)
         if not util.checkcase(repo.path):
             _checkcollision(p2)
         action += _forgetremoved(wc, p2, branchmerge)
         action += manifestmerge(repo, wc, p2, pa, overwrite, partial)
 
         ### apply phase
-        if not branchmerge or fastforward: # just jump to the new rev
+        if not branchmerge: # just jump to the new rev
             fp1, fp2, xp1, xp2 = fp2, nullid, xp2, ''
         if not partial:
             repo.hook('preupdate', throw=True, parent1=xp1, parent2=xp2)
 
         stats = applyupdates(repo, action, wc, p2, pa, overwrite)
 
         if not partial:
             repo.dirstate.setparents(fp1, fp2)
-            recordupdates(repo, action, branchmerge and not fastforward)
+            recordupdates(repo, action, branchmerge)
             if not branchmerge and not fastforward:
                 repo.dirstate.setbranch(p2.branch())
     finally:
         wlock.release()
 
     if not partial:
         repo.hook('update', parent1=xp1, parent2=xp2, error=stats[3])
     return stats

tests/test-issue619.t

@@ -1,34 +1,29 b''
 http://mercurial.selenic.com/bts/issue619
 
   $ hg init
   $ echo a > a
   $ hg ci -Ama
   adding a
 
   $ echo b > b
   $ hg branch b
   marked working directory as branch b
   $ hg ci -Amb
   adding b
 
   $ hg co -C 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Fast-forward:
 
   $ hg merge b
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
-  $ hg branch
-  default
-  $ hg parent --template '{rev}:{node|short} {branches}: {desc}\n'
-  1:06c2121185be b: b
   $ hg ci -Ammerge
-  created new head
 
 Bogus fast-forward should fail:
 
   $ hg merge b
   abort: merging with a working directory ancestor has no effect
   [255]
 

tests/test-newbranch.t

@@ -1,320 +1,321 b''
   $ branchcache=.hg/cache/branchheads
 
   $ 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
   $ 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:9d567d0b51f9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     clear branch name
   
 
   $ hg co foo
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg 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
   $ hg ci -m "merge"
 
   $ hg log
   changeset:   5:dc140083783b
   branch:      foo
   tag:         tip
   parent:      4:98d14f698afe
   parent:      3:9d567d0b51f9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge
   
   changeset:   4:98d14f698afe
   branch:      foo
   parent:      1:0079f24813e2
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify a branch
   
   changeset:   3:9d567d0b51f9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     clear branch name
   
   changeset:   2:ed2bbf4e0102
   branch:      bar
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change branch name
   
   changeset:   1:0079f24813e2
   branch:      foo
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add branch name
   
   changeset:   0:db01e8ea3388
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     initial
   
   $ hg branches
   foo                            5:dc140083783b
   default                        3:9d567d0b51f9 (inactive)
   bar                            2:ed2bbf4e0102 (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 .hg/bc-invalid
 
   $ hg log -r foo
   changeset:   4:98d14f698afe
   branch:      foo
   tag:         tip
   parent:      1:0079f24813e2
   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
   invalidating branch cache (tip differs)
   changeset:   4:98d14f698afeaff8cb612dcf215ce95e639effc3
   branch:      foo
   tag:         tip
   parent:      1:0079f24813e2b73a891577c243684c5066347bc8
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    4:d01b250baaa05909152f7ae07d7a649deea0df9a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       a
   extra:       branch=foo
   description:
   modify a branch
   
   
   $ rm $branchcache
   $ echo corrupted > $branchcache
 
   $ hg log -qr foo
   4:98d14f698afe
 
   $ cat $branchcache
   98d14f698afeaff8cb612dcf215ce95e639effc3 4
   9d567d0b51f9e2068b054e1948e1a927f99b5874 default
   98d14f698afeaff8cb612dcf215ce95e639effc3 foo
   ed2bbf4e01029020711be82ca905283e883f0e11 bar
 
 Push should update the branch cache:
 
   $ hg init ../target
 
 Pushing just rev 0:
 
   $ hg push -qr 0 ../target
 
   $ cat ../target/$branchcache
   db01e8ea3388fd3c7c94e1436ea2bd6a53d581c5 0
   db01e8ea3388fd3c7c94e1436ea2bd6a53d581c5 default
 
 Pushing everything:
 
   $ hg push -qf ../target
 
   $ cat ../target/$branchcache
   98d14f698afeaff8cb612dcf215ce95e639effc3 4
   9d567d0b51f9e2068b054e1948e1a927f99b5874 default
   98d14f698afeaff8cb612dcf215ce95e639effc3 foo
   ed2bbf4e01029020711be82ca905283e883f0e11 bar
 
 Update with no arguments: tipmost revision of the current branch:
 
   $ hg up -q -C 0
   $ hg up -q
   $ hg id
   9d567d0b51f9
 
   $ hg up -q 1
   $ hg up -q
   $ hg id
   98d14f698afe (foo) tip
 
   $ hg branch foobar
   marked working directory as branch foobar
 
   $ hg up
   abort: branch foobar not found
   [255]
 
 Fastforward 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'
-  created new head
   $ hg parents
-  changeset:   6:6af8030670c9
+  changeset:   6:917eb54e1b4b
   branch:      foo
   tag:         tip
+  parent:      4:98d14f698afe
+  parent:      5:6683a60370cb
   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
   $ 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)
   [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)
   [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)
 

tests/test-push-warn.t

@@ -1,719 +1,718 b''
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "graphlog=" >> $HGRCPATH
 
   $ mkdir a
   $ cd a
   $ hg init
   $ echo foo > t1
   $ hg add t1
   $ hg commit -m "1"
 
   $ cd ..
   $ hg clone a b
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd a
   $ echo foo > t2
   $ hg add t2
   $ hg commit -m "2"
 
   $ cd ../b
   $ echo foo > t3
   $ hg add t3
   $ hg commit -m "3"
 
   $ hg push ../a
   pushing to ../a
   searching for changes
   abort: push creates new remote heads on branch 'default'!
   (you should pull and merge or use push -f to force)
   [255]
 
   $ hg push --debug ../a
   pushing to ../a
   searching for changes
   examining 1c9246a22a0a:d8d565842d04
   found incomplete branch 1c9246a22a0a:d8d565842d04
   searching: 1 queries
   narrowing 1:1 d8d565842d04
   found new branch changeset 1c9246a22a0a
   found new changesets starting at 1c9246a22a0a
   1 total queries
   common changesets up to d8d565842d04
   new remote heads on branch 'default'
   new remote head 1e108cc5548c
   abort: push creates new remote heads on branch 'default'!
   (you should pull and merge or use push -f to force)
   [255]
 
   $ hg pull ../a
   pulling from ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ hg push ../a
   pushing to ../a
   searching for changes
   abort: push creates new remote heads on branch 'default'!
   (did you forget to merge? use push -f to force)
   [255]
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg commit -m "4"
   $ hg push ../a
   pushing to ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1 changes to 1 files
 
   $ cd ..
 
   $ hg init c
   $ cd c
   $ for i in 0 1 2; do
   >     echo $i >> foo
   >     hg ci -Am $i
   > done
   adding foo
   $ cd ..
 
   $ hg clone c d
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd d
   $ for i in 0 1; do
   >    hg co -C $i
   >    echo d-$i >> foo
   >    hg ci -m d-$i
   > done
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   created new head
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   created new head
 
   $ HGMERGE=true hg merge 3
   merging foo
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg ci -m c-d
 
   $ hg push ../c
   pushing to ../c
   searching for changes
   abort: push creates new remote heads on branch 'default'!
   (did you forget to merge? use push -f to force)
   [255]
 
   $ hg push -r 2 ../c
   pushing to ../c
   searching for changes
   no changes found
 
   $ hg push -r 3 ../c
   pushing to ../c
   searching for changes
   abort: push creates new remote heads on branch 'default'!
   (did you forget to merge? use push -f to force)
   [255]
 
   $ hg push -r 3 -r 4 ../c
   pushing to ../c
   searching for changes
   abort: push creates new remote heads on branch 'default'!
   (did you forget to merge? use push -f to force)
   [255]
 
   $ hg push -f -r 3 -r 4 ../c
   pushing to ../c
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files (+2 heads)
 
   $ hg push -r 5 ../c
   pushing to ../c
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (-1 heads)
 
   $ hg in ../c
   comparing with ../c
   searching for changes
   no changes found
   [1]
 
 
 Issue450: push -r warns about remote head creation even if no heads
 will be created
 
   $ hg init ../e
   $ hg push -r 0 ../e
   pushing to ../e
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
   $ hg push -r 1 ../e
   pushing to ../e
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
   $ cd ..
 
 
 Issue736: named branches are not considered for detection of
 unmerged heads in "hg push"
 
   $ hg init f
   $ cd f
   $ hg -q branch a
   $ echo 0 > foo
   $ hg -q ci -Am 0
   $ echo 1 > foo
   $ hg -q ci -m 1
   $ hg -q up 0
   $ echo 2 > foo
   $ hg -q ci -m 2
   $ hg -q up 0
   $ hg -q branch b
   $ echo 3 > foo
   $ hg -q ci -m 3
   $ cd ..
 
   $ hg -q clone f g
   $ cd g
 
 Push on existing branch and new branch:
 
   $ hg -q up 1
   $ echo 4 > foo
   $ hg -q ci -m 4
   $ hg -q up 0
   $ echo 5 > foo
   $ hg -q branch c
   $ hg -q ci -m 5
 
   $ hg push ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: c!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
   $ hg push -r 4 -r 5 ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: c!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
 
 Multiple new branches:
 
   $ hg -q branch d
   $ echo 6 > foo
   $ hg -q ci -m 6
 
   $ hg push ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: c, d!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
   $ hg push -r 4 -r 6 ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: c, d!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
   $ cd ../g
 
 
 Fail on multiple head push:
 
   $ hg -q up 1
   $ echo 7 > foo
   $ hg -q ci -m 7
 
   $ hg push -r 4 -r 7 ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote heads on branch 'a'!
   (did you forget to merge? use push -f to force)
   [255]
 
 Push replacement head on existing branches:
 
   $ hg -q up 3
   $ echo 8 > foo
   $ hg -q ci -m 8
 
   $ hg push -r 7 -r 8 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
 
 
 Merge of branch a to other branch b followed by unrelated push
 on branch a:
 
   $ hg -q up 7
   $ HGMERGE=true hg -q merge 8
   $ hg -q ci -m 9
   $ hg -q up 8
   $ echo 10 > foo
   $ hg -q ci -m 10
 
   $ hg push -r 9 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (-1 heads)
 
   $ hg push -r 10 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
 
 
 Cheating the counting algorithm:
 
   $ hg -q up 9
   $ HGMERGE=true hg -q merge 2
   $ hg -q ci -m 11
   $ hg -q up 1
   $ echo 12 > foo
   $ hg -q ci -m 12
 
   $ hg push -r 11 -r 12 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
 
 
 Failed push of new named branch:
 
   $ echo 12 > foo
   $ hg -q ci -m 12a
   [1]
   $ hg -q up 11
   $ echo 13 > foo
   $ hg -q branch e
   $ hg -q ci -m 13d
 
   $ hg push -r 12 -r 13 ../f
   pushing to ../f
   searching for changes
   abort: push creates new remote branches: e!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
 
 Using --new-branch to push new named branch:
 
   $ hg push --new-branch -r 12 -r 13 ../f
   pushing to ../f
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 
 Checking prepush logic does not allow silently pushing
 multiple new heads:
 
   $ cd ..
   $ hg init h
   $ echo init > h/init
   $ hg -R h ci -Am init
   adding init
   $ echo a > h/a
   $ hg -R h ci -Am a
   adding a
   $ hg clone h i
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R h up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b > h/b
   $ hg -R h ci -Am b
   adding b
   created new head
   $ hg -R i up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > i/c
   $ hg -R i ci -Am c
   adding c
   created new head
 
   $ hg -R i push h
   pushing to h
   searching for changes
   abort: push creates new remote heads on branch 'default'!
   (you should pull and merge or use push -f to force)
   [255]
 
 
 Check prepush logic with merged branches:
 
   $ hg init j
   $ hg -R j branch a
   marked working directory as branch a
   $ echo init > j/foo
   $ hg -R j ci -Am init
   adding foo
   $ hg clone j k
   updating to branch a
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo a1 > j/foo
   $ hg -R j ci -m a1
   $ hg -R k branch b
   marked working directory as branch b
   $ echo b > k/foo
   $ hg -R k ci -m b
   $ hg -R k up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R k merge b
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg -R k ci -m merge
-  created new head
 
   $ hg -R k push -r a j
   pushing to j
   searching for changes
   abort: push creates new remote branches: b!
   (use 'hg push --new-branch' to create new remote branches)
   [255]
 
 
 Prepush -r should not allow you to sneak in new heads:
 
   $ hg init l
   $ cd l
   $ echo a >> foo
   $ hg -q add foo
   $ hg -q branch a
   $ hg -q ci -ma
   $ hg -q up null
   $ echo a >> foo
   $ hg -q add foo
   $ hg -q branch b
   $ hg -q ci -mb
   $ cd ..
   $ hg -q clone l m -u a
   $ cd m
   $ hg -q merge b
   $ hg -q ci -mmb
   $ hg -q up 0
   $ echo a >> foo
   $ hg -q ci -ma2
   $ hg -q up 2
   $ echo a >> foo
   $ hg -q branch -f b
   $ hg -q ci -mb2
   $ hg -q merge 3
   $ hg -q ci -mma
 
   $ hg push ../l -b b
   pushing to ../l
   searching for changes
   abort: push creates new remote heads on branch 'a'!
   (did you forget to merge? use push -f to force)
   [255]
 
   $ cd ..
 
 
 Check prepush with new branch head on former topo non-head:
 
   $ hg init n
   $ cd n
   $ hg branch A
   marked working directory as branch A
   $ echo a >a
   $ hg ci -Ama
   adding a
   $ hg branch B
   marked working directory as branch B
   $ echo b >b
   $ hg ci -Amb
   adding b
 
 b is now branch head of B, and a topological head
 a is now branch head of A, but not a topological head
 
   $ hg clone . inner
   updating to branch B
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd inner
   $ hg up B
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b1 >b1
   $ hg ci -Amb1
   adding b1
 
 in the clone b1 is now the head of B
 
   $ cd ..
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo a2 >a2
   $ hg ci -Ama2
   adding a2
 
 a2 is now the new branch head of A, and a new topological head
 it replaces a former inner branch head, so it should at most warn about
 A, not B
 
 glog of local:
 
   $ hg glog --template "{rev}: {branches} {desc}\n"
   @  2: A a2
   |
   | o  1: B b
   |/
   o  0: A a
   
 glog of remote:
 
   $ hg glog -R inner --template "{rev}: {branches} {desc}\n"
   @  2: B b1
   |
   o  1: B b
   |
   o  0: A a
   
 outgoing:
 
   $ hg out inner --template "{rev}: {branches} {desc}\n"
   comparing with inner
   searching for changes
   2: A a2
 
   $ hg push inner
   pushing to inner
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
 
   $ cd ..
 
 
 Check prepush with new branch head on former topo head:
 
   $ hg init o
   $ cd o
   $ hg branch A
   marked working directory as branch A
   $ echo a >a
   $ hg ci -Ama
   adding a
   $ hg branch B
   marked working directory as branch B
   $ echo b >b
   $ hg ci -Amb
   adding b
 
 b is now branch head of B, and a topological head
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo a1 >a1
   $ hg ci -Ama1
   adding a1
 
 a1 is now branch head of A, and a topological head
 
   $ hg clone . inner
   updating to branch A
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd inner
   $ hg up B
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b1 >b1
   $ hg ci -Amb1
   adding b1
 
 in the clone b1 is now the head of B
 
   $ cd ..
   $ echo a2 >a2
   $ hg ci -Ama2
   adding a2
 
 a2 is now the new branch head of A, and a topological head
 it replaces a former topological and branch head, so this should not warn
 
 glog of local:
 
   $ hg glog --template "{rev}: {branches} {desc}\n"
   @  3: A a2
   |
   o  2: A a1
   |
   | o  1: B b
   |/
   o  0: A a
   
 glog of remote:
 
   $ hg glog -R inner --template "{rev}: {branches} {desc}\n"
   @  3: B b1
   |
   | o  2: A a1
   | |
   o |  1: B b
   |/
   o  0: A a
   
 outgoing:
 
   $ hg out inner --template "{rev}: {branches} {desc}\n"
   comparing with inner
   searching for changes
   3: A a2
 
   $ hg push inner
   pushing to inner
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
   $ cd ..
 
 
 Check prepush with new branch head and new child of former branch head
 but child is on different branch:
 
   $ hg init p
   $ cd p
   $ hg branch A
   marked working directory as branch A
   $ echo a0 >a
   $ hg ci -Ama0
   adding a
   $ echo a1 >a
   $ hg ci -ma1
   $ hg up null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch B
   marked working directory as branch B
   $ echo b0 >b
   $ hg ci -Amb0
   adding b
   $ echo b1 >b
   $ hg ci -mb1
 
   $ hg clone . inner
   updating to branch B
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg up A
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch -f B
   marked working directory as branch B
   $ echo a3 >a
   $ hg ci -ma3
   created new head
   $ hg up 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch -f A
   marked working directory as branch A
   $ echo b3 >b
   $ hg ci -mb3
   created new head
 
 glog of local:
 
   $ hg glog --template "{rev}: {branches} {desc}\n"
   @  5: A b3
   |
   | o  4: B a3
   | |
   o |  3: B b1
   | |
   o |  2: B b0
    /
   o  1: A a1
   |
   o  0: A a0
   
 glog of remote:
 
   $ hg glog -R inner --template "{rev}: {branches} {desc}\n"
   @  3: B b1
   |
   o  2: B b0
   
   o  1: A a1
   |
   o  0: A a0
   
 outgoing:
 
   $ hg out inner --template "{rev}: {branches} {desc}\n"
   comparing with inner
   searching for changes
   4: B a3
   5: A b3
 
   $ hg push inner
   pushing to inner
   searching for changes
   abort: push creates new remote heads on branch 'A'!
   (did you forget to merge? use push -f to force)
   [255]
 
   $ hg push inner -r4 -r5
   pushing to inner
   searching for changes
   abort: push creates new remote heads on branch 'A'!
   (did you forget to merge? use push -f to force)
   [255]
 
   $ hg in inner
   comparing with inner
   searching for changes
   no changes found
   [1]