merge: show renamed on one and deleted on the other side in debug output

mercurial/copies.py

@@ -1,365 +1,370 b''
 # copies.py - copy detection for Mercurial
 #
 # Copyright 2008 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.
 
 import util
 import heapq
 
 def _nonoverlap(d1, d2, d3):
     "Return list of elements in d1 not in d2 or d3"
     return sorted([d for d in d1 if d not in d3 and d not in d2])
 
 def _dirname(f):
     s = f.rfind("/")
     if s == -1:
         return ""
     return f[:s]
 
 def _findlimit(repo, a, b):
     """Find the earliest revision that's an ancestor of a or b but not both,
     None if no such revision exists.
     """
     # basic idea:
     # - mark a and b with different sides
     # - if a parent's children are all on the same side, the parent is
     #   on that side, otherwise it is on no side
     # - walk the graph in topological order with the help of a heap;
     #   - add unseen parents to side map
     #   - clear side of any parent that has children on different sides
     #   - track number of interesting revs that might still be on a side
     #   - track the lowest interesting rev seen
     #   - quit when interesting revs is zero
 
     cl = repo.changelog
     working = len(cl) # pseudo rev for the working directory
     if a is None:
         a = working
     if b is None:
         b = working
 
     side = {a: -1, b: 1}
     visit = [-a, -b]
     heapq.heapify(visit)
     interesting = len(visit)
     hascommonancestor = False
     limit = working
 
     while interesting:
         r = -heapq.heappop(visit)
         if r == working:
             parents = [cl.rev(p) for p in repo.dirstate.parents()]
         else:
             parents = cl.parentrevs(r)
         for p in parents:
             if p < 0:
                 continue
             if p not in side:
                 # first time we see p; add it to visit
                 side[p] = side[r]
                 if side[p]:
                     interesting += 1
                 heapq.heappush(visit, -p)
             elif side[p] and side[p] != side[r]:
                 # p was interesting but now we know better
                 side[p] = 0
                 interesting -= 1
                 hascommonancestor = True
         if side[r]:
             limit = r # lowest rev visited
             interesting -= 1
 
     if not hascommonancestor:
         return None
     return limit
 
 def _chain(src, dst, a, b):
     '''chain two sets of copies a->b'''
     t = a.copy()
     for k, v in b.iteritems():
         if v in t:
             # found a chain
             if t[v] != k:
                 # file wasn't renamed back to itself
                 t[k] = t[v]
             if v not in dst:
                 # chain was a rename, not a copy
                 del t[v]
         if v in src:
             # file is a copy of an existing file
             t[k] = v
 
     # remove criss-crossed copies
     for k, v in t.items():
         if k in src and v in dst:
             del t[k]
 
     return t
 
 def _tracefile(fctx, actx):
     '''return file context that is the ancestor of fctx present in actx'''
     stop = actx.rev()
     am = actx.manifest()
 
     for f in fctx.ancestors():
         if am.get(f.path(), None) == f.filenode():
             return f
         if f.rev() < stop:
             return None
 
 def _dirstatecopies(d):
     ds = d._repo.dirstate
     c = ds.copies().copy()
     for k in c.keys():
         if ds[k] not in 'anm':
             del c[k]
     return c
 
 def _forwardcopies(a, b):
     '''find {dst@b: src@a} copy mapping where a is an ancestor of b'''
 
     # check for working copy
     w = None
     if b.rev() is None:
         w = b
         b = w.p1()
         if a == b:
             # short-circuit to avoid issues with merge states
             return _dirstatecopies(w)
 
     # find where new files came from
     # we currently don't try to find where old files went, too expensive
     # this means we can miss a case like 'hg rm b; hg cp a b'
     cm = {}
     for f in b:
         if f not in a:
             ofctx = _tracefile(b[f], a)
             if ofctx:
                 cm[f] = ofctx.path()
 
     # combine copies from dirstate if necessary
     if w is not None:
         cm = _chain(a, w, cm, _dirstatecopies(w))
 
     return cm
 
 def _backwardcopies(a, b):
     # because the forward mapping is 1:n, we can lose renames here
     # in particular, we find renames better than copies
     f = _forwardcopies(b, a)
     r = {}
     for k, v in f.iteritems():
         r[v] = k
     return r
 
 def pathcopies(x, y):
     '''find {dst@y: src@x} copy mapping for directed compare'''
     if x == y or not x or not y:
         return {}
     a = y.ancestor(x)
     if a == x:
         return _forwardcopies(x, y)
     if a == y:
         return _backwardcopies(x, y)
     return _chain(x, y, _backwardcopies(x, a), _forwardcopies(a, y))
 
 def mergecopies(repo, c1, c2, ca):
     """
     Find moves and copies between context c1 and c2 that are relevant
     for merging.
 
     Returns two dicts, "copy" and "diverge".
 
     "copy" is a mapping from destination name -> source name,
     where source is in c1 and destination is in c2 or vice-versa.
 
     "diverge" is a mapping of source name -> list of destination names
     for divergent renames.
 
     "renamedelete" is a mapping of source name -> list of destination
     names for files deleted in c1 that were renamed in c2 or vice-versa.
     """
     # avoid silly behavior for update from empty dir
     if not c1 or not c2 or c1 == c2:
         return {}, {}, {}
 
     # avoid silly behavior for parent -> working dir
     if c2.node() is None and c1.node() == repo.dirstate.p1():
         return repo.dirstate.copies(), {}, {}
 
     limit = _findlimit(repo, c1.rev(), c2.rev())
     if limit is None:
         # no common ancestor, no copies
         return {}, {}, {}
     m1 = c1.manifest()
     m2 = c2.manifest()
     ma = ca.manifest()
 
     def makectx(f, n):
         if len(n) != 20: # in a working context?
             if c1.rev() is None:
                 return c1.filectx(f)
             return c2.filectx(f)
         return repo.filectx(f, fileid=n)
 
     ctx = util.lrucachefunc(makectx)
     copy = {}
     fullcopy = {}
     diverge = {}
 
     def related(f1, f2, limit):
         # Walk back to common ancestor to see if the two files originate
         # from the same file. Since workingfilectx's rev() is None it messes
         # up the integer comparison logic, hence the pre-step check for
         # None (f1 and f2 can only be workingfilectx's initially).
 
         if f1 == f2:
             return f1 # a match
 
         g1, g2 = f1.ancestors(), f2.ancestors()
         try:
             f1r, f2r = f1.rev(), f2.rev()
 
             if f1r is None:
                 f1 = g1.next()
             if f2r is None:
                 f2 = g2.next()
 
             while True:
                 f1r, f2r = f1.rev(), f2.rev()
                 if f1r > f2r:
                     f1 = g1.next()
                 elif f2r > f1r:
                     f2 = g2.next()
                 elif f1 == f2:
                     return f1 # a match
                 elif f1r == f2r or f1r < limit or f2r < limit:
                     return False # copy no longer relevant
         except StopIteration:
             return False
 
     def checkcopies(f, m1, m2):
         '''check possible copies of f from m1 to m2'''
         of = None
         seen = set([f])
         for oc in ctx(f, m1[f]).ancestors():
             ocr = oc.rev()
             of = oc.path()
             if of in seen:
                 # check limit late - grab last rename before
                 if ocr < limit:
                     break
                 continue
             seen.add(of)
 
             fullcopy[f] = of # remember for dir rename detection
             if of not in m2:
                 continue # no match, keep looking
             if m2[of] == ma.get(of):
                 break # no merge needed, quit early
             c2 = ctx(of, m2[of])
             cr = related(oc, c2, ca.rev())
             if cr and (of == f or of == c2.path()): # non-divergent
                 copy[f] = of
                 of = None
                 break
 
         if of in ma:
             diverge.setdefault(of, []).append(f)
 
     repo.ui.debug("  searching for copies back to rev %d\n" % limit)
 
     u1 = _nonoverlap(m1, m2, ma)
     u2 = _nonoverlap(m2, m1, ma)
 
     if u1:
         repo.ui.debug("  unmatched files in local:\n   %s\n"
                       % "\n   ".join(u1))
     if u2:
         repo.ui.debug("  unmatched files in other:\n   %s\n"
                       % "\n   ".join(u2))
 
     for f in u1:
         checkcopies(f, m1, m2)
     for f in u2:
         checkcopies(f, m2, m1)
 
     renamedelete = {}
+    renamedelete2 = set()
     diverge2 = set()
     for of, fl in diverge.items():
         if len(fl) == 1 or of in c1 or of in c2:
             del diverge[of] # not actually divergent, or not a rename
             if of not in c1 and of not in c2:
                 # renamed on one side, deleted on the other side, but filter
                 # out files that have been renamed and then deleted
                 renamedelete[of] = [f for f in fl if f in c1 or f in c2]
+                renamedelete2.update(fl) # reverse map for below
         else:
             diverge2.update(fl) # reverse map for below
 
     if fullcopy:
-        repo.ui.debug("  all copies found (* = to merge, ! = divergent):\n")
+        repo.ui.debug("  all copies found (* = to merge, ! = divergent, "
+                      "% = renamed and deleted):\n")
         for f in fullcopy:
             note = ""
             if f in copy:
                 note += "*"
             if f in diverge2:
                 note += "!"
+            if f in renamedelete2:
+                note += "%"
             repo.ui.debug("   %s -> %s %s\n" % (f, fullcopy[f], note))
     del diverge2
 
     if not fullcopy:
         return copy, diverge, renamedelete
 
     repo.ui.debug("  checking for directory renames\n")
 
     # generate a directory move map
     d1, d2 = c1.dirs(), c2.dirs()
     invalid = set([""])
     dirmove = {}
 
     # examine each file copy for a potential directory move, which is
     # when all the files in a directory are moved to a new directory
     for dst, src in fullcopy.iteritems():
         dsrc, ddst = _dirname(src), _dirname(dst)
         if dsrc in invalid:
             # already seen to be uninteresting
             continue
         elif dsrc in d1 and ddst in d1:
             # directory wasn't entirely moved locally
             invalid.add(dsrc)
         elif dsrc in d2 and ddst in d2:
             # directory wasn't entirely moved remotely
             invalid.add(dsrc)
         elif dsrc in dirmove and dirmove[dsrc] != ddst:
             # files from the same directory moved to two different places
             invalid.add(dsrc)
         else:
             # looks good so far
             dirmove[dsrc + "/"] = ddst + "/"
 
     for i in invalid:
         if i in dirmove:
             del dirmove[i]
     del d1, d2, invalid
 
     if not dirmove:
         return copy, diverge, renamedelete
 
     for d in dirmove:
         repo.ui.debug("  dir %s -> %s\n" % (d, dirmove[d]))
 
     # check unaccounted nonoverlapping files against directory moves
     for f in u1 + u2:
         if f not in fullcopy:
             for d in dirmove:
                 if f.startswith(d):
                     # new file added in a directory that was moved, move it
                     df = dirmove[d] + f[len(d):]
                     if df not in copy:
                         copy[f] = df
                         repo.ui.debug("  file %s -> %s\n" % (f, copy[f]))
                     break
 
     return copy, diverge, renamedelete

tests/test-copy-move-merge.t

@@ -1,62 +1,62 b''
   $ hg init t
   $ cd t
 
   $ echo 1 > a
   $ hg ci -qAm "first"
 
   $ hg cp a b
   $ hg mv a c
   $ echo 2 >> b
   $ echo 2 >> c
 
   $ hg ci -qAm "second"
 
   $ hg co -C 0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ echo 0 > a
   $ echo 1 >> a
 
   $ hg ci -qAm "other"
 
   $ hg merge --debug
     searching for copies back to rev 1
     unmatched files in other:
      b
      c
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      c -> a *
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: b8bf91eeebbc, local: add3f11052fa+, remote: 17c05bb7fcb6
    a: remote moved to c -> m
    a: remote moved to b -> m
   preserving a for resolve of b
   preserving a for resolve of c
   removing a
   updating: a 1/2 files (50.00%)
   picked tool 'internal:merge' for b (binary False symlink False)
   merging a and b to b
   my b@add3f11052fa+ other b@17c05bb7fcb6 ancestor a@b8bf91eeebbc
    premerge successful
   updating: a 2/2 files (100.00%)
   picked tool 'internal:merge' for c (binary False symlink False)
   merging a and c to c
   my c@add3f11052fa+ other c@17c05bb7fcb6 ancestor a@b8bf91eeebbc
    premerge successful
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 file b
   $ cat b
   0
   1
   2
 
 file c
   $ cat c
   0
   1
   2

tests/test-double-merge.t

@@ -1,65 +1,65 b''
   $ hg init repo
   $ cd repo
 
   $ echo line 1 > foo
   $ hg ci -qAm 'add foo'
 
 copy foo to bar and change both files
   $ hg cp foo bar
   $ echo line 2-1 >> foo
   $ echo line 2-2 >> bar
   $ hg ci -m 'cp foo bar; change both'
 
 in another branch, change foo in a way that doesn't conflict with
 the other changes
   $ hg up -qC 0
   $ echo line 0 > foo
   $ hg cat foo >> foo
   $ hg ci -m 'change foo'
   created new head
 
 we get conflicts that shouldn't be there
   $ hg merge -P
   changeset:   1:484bf6903104
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     cp foo bar; change both
   
   $ hg merge --debug
     searching for copies back to rev 1
     unmatched files in other:
      bar
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      bar -> foo *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: e6dc8efe11cc, local: 6a0df1dad128+, remote: 484bf6903104
    foo: versions differ -> m
    foo: remote copied to bar -> m
   preserving foo for resolve of bar
   preserving foo for resolve of foo
   updating: foo 1/2 files (50.00%)
   picked tool 'internal:merge' for bar (binary False symlink False)
   merging foo and bar to bar
   my bar@6a0df1dad128+ other bar@484bf6903104 ancestor foo@e6dc8efe11cc
    premerge successful
   updating: foo 2/2 files (100.00%)
   picked tool 'internal:merge' for foo (binary False symlink False)
   merging foo
   my foo@6a0df1dad128+ other foo@484bf6903104 ancestor foo@e6dc8efe11cc
    premerge successful
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 contents of foo
   $ cat foo
   line 0
   line 1
   line 2-1
 
 contents of bar
   $ cat bar
   line 0
   line 1
   line 2-2

tests/test-graft.t

@@ -1,289 +1,289 b''
 Create a repo with some stuff in it:
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ echo a > d
   $ echo a > e
   $ hg ci -qAm0
   $ echo b > a
   $ hg ci -m1 -u bar
   $ hg mv a b
   $ hg ci -m2
   $ hg cp b c
   $ hg ci -m3 -u baz
   $ echo b > d
   $ echo f > e
   $ hg ci -m4
   $ hg up -q 3
   $ echo b > e
   $ hg branch -q stable
   $ hg ci -m5
   $ hg merge -q default --tool internal:local
   $ hg branch -q default
   $ hg ci -m6
   $ hg phase --public 3
   $ hg phase --force --secret 6
 
   $ hg --config extensions.graphlog= log -G --template '{author}@{rev}.{phase}: {desc}\n'
   @    [e-mail]: 6
   |\
   | o  [e-mail]: 5
   | |
   o |  [e-mail]: 4
   |/
   o  [e-mail]: 3
   |
   o  [e-mail]: 2
   |
   o  [e-mail]: 1
   |
   o  [e-mail]: 0
   
 
 Need to specify a rev:
 
   $ hg graft
   abort: no revisions specified
   [255]
 
 Can't graft ancestor:
 
   $ hg graft 1 2
   skipping ancestor revision 1
   skipping ancestor revision 2
   [255]
 
 Can't graft with dirty wd:
 
   $ hg up -q 0
   $ echo foo > a
   $ hg graft 1
   abort: outstanding uncommitted changes
   [255]
   $ hg revert a
 
 Graft a rename:
 
   $ hg graft 2 -u foo
   grafting revision 2
   merging a and b to b
   $ hg export tip --git
   # HG changeset patch
   # User foo
   # Date 0 0
   # Node ID ef0ef43d49e79e81ddafdc7997401ba0041efc82
   # Parent  68795b066622ca79a25816a662041d8f78f3cd9e
   2
   
   diff --git a/a b/b
   rename from a
   rename to b
 
 Look for extra:source
 
   $ hg log --debug -r tip
   changeset:   7:ef0ef43d49e79e81ddafdc7997401ba0041efc82
   tag:         tip
   phase:       draft
   parent:      0:68795b066622ca79a25816a662041d8f78f3cd9e
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    7:e59b6b228f9cbf9903d5e9abf996e083a1f533eb
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      b
   files-:      a
   extra:       branch=default
   extra:       source=5c095ad7e90f871700f02dd1fa5012cb4498a2d4
   description:
   2
   
   
 
 Graft out of order, skipping a merge and a duplicate
 
   $ hg graft 1 5 4 3 'merge()' 2 -n
   skipping ungraftable merge revision 6
   skipping already grafted revision 2
   grafting revision 1
   grafting revision 5
   grafting revision 4
   grafting revision 3
 
   $ hg graft 1 5 4 3 'merge()' 2 --debug
   skipping ungraftable merge revision 6
   scanning for duplicate grafts
   skipping already grafted revision 2
   grafting revision 1
     searching for copies back to rev 1
     unmatched files in local:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 68795b066622, local: ef0ef43d49e7+, remote: 5d205f8b35b6
    b: local copied/moved to a -> m
   preserving b for resolve of b
   updating: b 1/1 files (100.00%)
   picked tool 'internal:merge' for b (binary False symlink False)
   merging b and a to b
   my b@ef0ef43d49e7+ other a@5d205f8b35b6 ancestor a@68795b066622
    premerge successful
   b
   grafting revision 5
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 4c60f11aa304, local: 6b9e5368ca4e+, remote: 97f8bfe72746
    e: remote is newer -> g
   updating: e 1/1 files (100.00%)
   getting e
   e
   grafting revision 4
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 4c60f11aa304, local: 1905859650ec+, remote: 9c233e8e184d
    e: versions differ -> m
    d: remote is newer -> g
   preserving e for resolve of e
   updating: d 1/2 files (50.00%)
   getting d
   updating: e 2/2 files (100.00%)
   picked tool 'internal:merge' for e (binary False symlink False)
   merging e
   my e@1905859650ec+ other e@9c233e8e184d ancestor e@68795b066622
   warning: conflicts during merge.
   merging e incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use hg resolve and hg graft --continue)
   [255]
 
 Continue without resolve should fail:
 
   $ hg graft -c
   grafting revision 4
   abort: unresolved merge conflicts (see hg help resolve)
   [255]
 
 Fix up:
 
   $ echo b > e
   $ hg resolve -m e
 
 Continue with a revision should fail:
 
   $ hg graft -c 6
   abort: can't specify --continue and revisions
   [255]
 
 Continue for real, clobber usernames
 
   $ hg graft -c -U
   grafting revision 4
   grafting revision 3
 
 Compare with original:
 
   $ hg diff -r 6
   $ hg status --rev 0:. -C
   M d
   M e
   A b
     a
   A c
     a
   R a
 
 View graph:
 
   $ hg --config extensions.graphlog= log -G --template '{author}@{rev}.{phase}: {desc}\n'
   @  [e-mail]: 3
   |
   o  [e-mail]: 4
   |
   o  [e-mail]: 5
   |
   o  [e-mail]: 1
   |
   o  [e-mail]: 2
   |
   | o    [e-mail]: 6
   | |\
   | | o  [e-mail]: 5
   | | |
   | o |  [e-mail]: 4
   | |/
   | o  [e-mail]: 3
   | |
   | o  [e-mail]: 2
   | |
   | o  [e-mail]: 1
   |/
   o  [e-mail]: 0
   
 Graft again onto another branch should preserve the original source
   $ hg up -q 0
   $ echo 'g'>g
   $ hg add g
   $ hg ci -m 7
   created new head
   $ hg graft 7
   grafting revision 7
 
   $ hg log -r 7 --template '{rev}:{node}\n'
   7:ef0ef43d49e79e81ddafdc7997401ba0041efc82
   $ hg log -r 2 --template '{rev}:{node}\n'
   2:5c095ad7e90f871700f02dd1fa5012cb4498a2d4
 
   $ hg log --debug -r tip
   changeset:   13:9db0f28fd3747e92c57d015f53b5593aeec53c2d
   tag:         tip
   phase:       draft
   parent:      12:b592ea63bb0c19a6c5c44685ee29a2284f9f1b8f
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    13:dc313617b8c32457c0d589e0dbbedfe71f3cd637
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      b
   files-:      a
   extra:       branch=default
   extra:       source=5c095ad7e90f871700f02dd1fa5012cb4498a2d4
   description:
   2
   
   
 Disallow grafting an already grafted cset onto its original branch
   $ hg up -q 6
   $ hg graft 7
   skipping already grafted revision 7 (was grafted from 2)
   [255]
 
 Disallow grafting already grafted csets with the same origin onto each other
   $ hg up -q 13
   $ hg graft 2
   skipping already grafted revision 2
   [255]
   $ hg graft 7
   skipping already grafted revision 7 (same origin 2)
   [255]
 
   $ hg up -q 7
   $ hg graft 2
   skipping already grafted revision 2
   [255]
   $ hg graft tip
   skipping already grafted revision 13 (same origin 2)
   [255]
 
 Graft with --log
 
   $ hg up -Cq 1
   $ hg graft 3 --log -u foo
   grafting revision 3
   warning: can't find ancestor for 'c' copied from 'b'!
   $ hg log --template '{rev} {parents} {desc}\n' -r tip
   14 1:5d205f8b35b6  3
   (grafted from 4c60f11aa304a54ae1c199feb94e7fc771e51ed8)

tests/test-issue672.t

@@ -1,101 +1,101 b''
 http://mercurial.selenic.com/bts/issue672
 
 # 0-2-4
 #  \ \ \
 #   1-3-5
 #
 # rename in #1, content change in #4.
 
   $ hg init
 
   $ touch 1
   $ touch 2
   $ hg commit -Am init  # 0
   adding 1
   adding 2
 
   $ hg rename 1 1a
   $ hg commit -m rename # 1
 
   $ hg co -C 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ echo unrelated >> 2
   $ hg ci -m unrelated1 # 2
   created new head
 
   $ hg merge --debug 1
     searching for copies back to rev 1
     unmatched files in other:
      1a
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      1a -> 1 
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 81f4b099af3d, local: c64f439569a9+, remote: c12dcd37c90a
    1: other deleted -> r
    1a: remote created -> g
   updating: 1 1/2 files (50.00%)
   removing 1
   updating: 1a 2/2 files (100.00%)
   getting 1a
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg ci -m merge1 # 3
 
   $ hg co -C 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ echo hello >> 1
   $ hg ci -m unrelated2 # 4
   created new head
 
   $ hg co -C 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg merge -y --debug 4
     searching for copies back to rev 1
     unmatched files in local:
      1a
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      1a -> 1 *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: c64f439569a9, local: e327dca35ac8+, remote: 746e9549ea96
    1a: local copied/moved to 1 -> m
   preserving 1a for resolve of 1a
   updating: 1a 1/1 files (100.00%)
   picked tool 'internal:merge' for 1a (binary False symlink False)
   merging 1a and 1 to 1a
   my 1a@e327dca35ac8+ other 1@746e9549ea96 ancestor 1@81f4b099af3d
    premerge successful
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg co -C 4
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg merge -y --debug 3
     searching for copies back to rev 1
     unmatched files in other:
      1a
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      1a -> 1 *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: c64f439569a9, local: 746e9549ea96+, remote: e327dca35ac8
    1: remote moved to 1a -> m
   preserving 1 for resolve of 1a
   removing 1
   updating: 1 1/1 files (100.00%)
   picked tool 'internal:merge' for 1a (binary False symlink False)
   merging 1 and 1a to 1a
   my 1a@746e9549ea96+ other 1a@e327dca35ac8 ancestor 1@81f4b099af3d
    premerge successful
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 

tests/test-rename-dir-merge.t

@@ -1,157 +1,157 b''
   $ hg init t
   $ cd t
 
   $ mkdir a
   $ echo foo > a/a
   $ echo bar > a/b
   $ hg ci -Am "0"
   adding a/a
   adding a/b
 
   $ hg co -C 0
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg mv a b
   moving a/a to b/a (glob)
   moving a/b to b/b (glob)
   $ hg ci -m "1 mv a/ b/"
 
   $ hg co -C 0
   2 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo baz > a/c
   $ echo quux > a/d
   $ hg add a/c
   $ hg ci -m "2 add a/c"
   created new head
 
   $ hg merge --debug 1
     searching for copies back to rev 1
     unmatched files in local:
      a/c
     unmatched files in other:
      b/a
      b/b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b/a -> a/a 
      b/b -> a/b 
     checking for directory renames
     dir a/ -> b/
     file a/c -> b/c
   resolving manifests
    overwrite: False, partial: False
    ancestor: f9b20c0d4c51, local: ce36d17b18fb+, remote: 397f8b00a740
    a/c: remote renamed directory to b/c -> d
    a/b: other deleted -> r
    a/a: other deleted -> r
    b/a: remote created -> g
    b/b: remote created -> g
   updating: a/a 1/5 files (20.00%)
   removing a/a
   updating: a/b 2/5 files (40.00%)
   removing a/b
   updating: a/c 3/5 files (60.00%)
   moving a/c to b/c
   updating: b/a 4/5 files (80.00%)
   getting b/a
   updating: b/b 5/5 files (100.00%)
   getting b/b
   3 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ echo a/* b/*
   a/d b/a b/b b/c
   $ hg st -C
   M b/a
   M b/b
   A b/c
     a/c
   R a/a
   R a/b
   R a/c
   ? a/d
   $ hg ci -m "3 merge 2+1"
   $ hg debugrename b/c
   b/c renamed from a/c:354ae8da6e890359ef49ade27b68bbc361f3ca88 (glob)
 
   $ hg co -C 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge --debug 2
     searching for copies back to rev 1
     unmatched files in local:
      b/a
      b/b
     unmatched files in other:
      a/c
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b/a -> a/a 
      b/b -> a/b 
     checking for directory renames
     dir a/ -> b/
     file a/c -> b/c
   resolving manifests
    overwrite: False, partial: False
    ancestor: f9b20c0d4c51, local: 397f8b00a740+, remote: ce36d17b18fb
    None: local renamed directory to b/c -> d
   updating:None 1/1 files (100.00%)
   getting a/c to b/c
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ echo a/* b/*
   a/d b/a b/b b/c
   $ hg st -C
   A b/c
     a/c
   ? a/d
   $ hg ci -m "4 merge 1+2"
   created new head
   $ hg debugrename b/c
   b/c renamed from a/c:354ae8da6e890359ef49ade27b68bbc361f3ca88 (glob)
 
 
 Second scenario with two repos:
 
   $ cd ..
   $ hg init r1
   $ cd r1
   $ mkdir a
   $ echo foo > a/f
   $ hg add a
   adding a/f (glob)
   $ hg ci -m "a/f == foo"
   $ cd ..
 
   $ hg clone r1 r2
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd r2
   $ hg mv a b
   moving a/f to b/f (glob)
   $ echo foo1 > b/f
   $ hg ci -m" a -> b, b/f == foo1"
   $ cd ..
 
   $ cd r1
   $ mkdir a/aa
   $ echo bar > a/aa/g
   $ hg add a/aa
   adding a/aa/g (glob)
   $ hg ci -m "a/aa/g"
   $ hg pull ../r2
   pulling from ../r2
   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 merge
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg st -C
   M b/f
   A b/aa/g
     a/aa/g
   R a/aa/g
   R a/f

tests/test-rename-merge1.t

@@ -1,181 +1,195 b''
   $ hg init
 
   $ echo "[merge]" >> .hg/hgrc
   $ echo "followcopies = 1" >> .hg/hgrc
 
   $ echo foo > a
   $ echo foo > a2
   $ hg add a a2
   $ hg ci -m "start"
 
   $ hg mv a b
   $ hg mv a2 b2
   $ hg ci -m "rename"
 
   $ hg co 0
   2 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ echo blahblah > a
   $ echo blahblah > a2
   $ hg mv a2 c2
   $ hg ci -m "modify"
   created new head
 
   $ hg merge -y --debug
     searching for copies back to rev 1
     unmatched files in local:
      c2
     unmatched files in other:
      b
      b2
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      c2 -> a2 !
      b -> a *
      b2 -> a2 !
     checking for directory renames
    a2: divergent renames -> dr
   resolving manifests
    overwrite: False, partial: False
    ancestor: af1939970a1c, local: 044f8520aeeb+, remote: 85c198ef2f6c
    a: remote moved to b -> m
    b2: remote created -> g
   preserving a for resolve of b
   removing a
   updating: a 1/3 files (33.33%)
   picked tool 'internal:merge' for b (binary False symlink False)
   merging a and b to b
   my b@044f8520aeeb+ other b@85c198ef2f6c ancestor a@af1939970a1c
    premerge successful
   updating: a2 2/3 files (66.67%)
   note: possible conflict - a2 was renamed multiple times to:
    c2
    b2
   updating: b2 3/3 files (100.00%)
   getting b2
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg status -AC
   M b
     a
   M b2
   R a
   C c2
 
   $ cat b
   blahblah
 
   $ hg ci -m "merge"
 
   $ hg debugindex b
      rev    offset  length   base linkrev nodeid       p1           p2
        0         0      67      0       1 57eacc201a7f 000000000000 000000000000
        1        67      72      1       3 4727ba907962 000000000000 57eacc201a7f
 
   $ hg debugrename b
   b renamed from a:dd03b83622e78778b403775d0d074b9ac7387a66
 
 This used to trigger a "divergent renames" warning, despite no renames
 
   $ hg cp b b3
   $ hg cp b b4
   $ hg ci -A -m 'copy b twice'
   $ hg up eb92d88a9712
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg rm b3 b4
   $ hg ci -m 'clean up a bit of our mess'
 
 We'd rather not warn on divergent renames done in the same changeset (issue2113)
 
   $ hg cp b b3
   $ hg mv b b4
   $ hg ci -A -m 'divergent renames in same changeset'
   $ hg up c761c6948de0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Check for issue2642
 
   $ hg init t
   $ cd t
 
   $ echo c0 > f1
   $ hg ci -Aqm0
 
   $ hg up null -q
   $ echo c1 > f1 # backport
   $ hg ci -Aqm1
   $ hg mv f1 f2
   $ hg ci -qm2
 
   $ hg up 0 -q
   $ hg merge 1 -q --tool internal:local
   $ hg ci -qm3
 
   $ hg merge 2
   merging f1 and f2 to f2
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat f2
   c0
 
   $ cd ..
 
 Check for issue2089
 
   $ hg init repo2089
   $ cd repo2089
 
   $ echo c0 > f1
   $ hg ci -Aqm0
 
   $ hg up null -q
   $ echo c1 > f1
   $ hg ci -Aqm1
 
   $ hg up 0 -q
   $ hg merge 1 -q --tool internal:local
   $ echo c2 > f1
   $ hg ci -qm2
 
   $ hg up 1 -q
   $ hg mv f1 f2
   $ hg ci -Aqm3
 
   $ hg up 2 -q
   $ hg merge 3
   merging f1 and f2 to f2
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat f2
   c2
 
   $ cd ..
 
 Check for issue3074
 
   $ hg init repo3074
   $ cd repo3074
   $ echo foo > file
   $ hg add file
   $ hg commit -m "added file"
   $ hg mv file newfile
   $ hg commit -m "renamed file"
   $ hg update 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg rm file
   $ hg commit -m "deleted file"
   created new head
-  $ hg merge
+  $ hg merge --debug
+    searching for copies back to rev 1
+    unmatched files in other:
+     newfile
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
+     newfile -> file %
+    checking for directory renames
+   file: rename and delete -> rd
+  resolving manifests
+   overwrite: False, partial: False
+   ancestor: 19d7f95df299, local: 0084274f6b67+, remote: 5d32493049f0
+   newfile: remote created -> g
+  updating: file 1/2 files (50.00%)
   note: possible conflict - file was deleted and renamed to:
    newfile
+  updating: newfile 2/2 files (100.00%)
+  getting newfile
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg status
   M newfile
   $ cd ..

tests/test-rename-merge2.t

@@ -1,752 +1,752 b''
 
   $ mkdir -p t
   $ cd t
   $ cat <<EOF > merge
   > import sys, os
   > f = open(sys.argv[1], "wb")
   > f.write("merge %s %s %s" % (sys.argv[1], sys.argv[2], sys.argv[3]))
   > f.close()
   > EOF
 
 perform a test merge with possible renaming
 args:
 $1 = action in local branch
 $2 = action in remote branch
 $3 = action in working dir
 $4 = expected result
 
   $ tm()
   > {
   >     hg init t
   >     cd t
   >     echo "[merge]" >> .hg/hgrc
   >     echo "followcopies = 1" >> .hg/hgrc
   > 
   >     # base
   >     echo base > a
   >     echo base > rev # used to force commits
   >     hg add a rev
   >     hg ci -m "base"
   > 
   >     # remote
   >     echo remote > rev
   >     if [ "$2" != "" ] ; then $2 ; fi
   >     hg ci -m "remote"
   > 
   >     # local
   >     hg co -q 0
   >     echo local > rev
   >     if [ "$1" != "" ] ; then $1 ; fi
   >     hg ci -m "local"
   > 
   >     # working dir
   >     echo local > rev
   >     if [ "$3" != "" ] ; then $3 ; fi
   > 
   >     # merge
   >     echo "--------------"
   >     echo "test L:$1 R:$2 W:$3 - $4"
   >     echo "--------------"
   >     hg merge -y --debug --traceback --tool="python ../merge"
   > 
   >     echo "--------------"
   >     hg status -camC -X rev
   > 
   >     hg ci -m "merge"
   > 
   >     echo "--------------"
   >     echo
   > 
   >     cd ..
   >     rm -r t
   > }
   $ up() {
   >     cp rev $1
   >     hg add $1 2> /dev/null
   >     if [ "$2" != "" ] ; then
   >         cp rev $2
   >         hg add $2 2> /dev/null
   >     fi
   > }
   $ uc() { up $1; hg cp $1 $2; } # update + copy
   $ um() { up $1; hg mv $1 $2; }
   $ nc() { hg cp $1 $2; } # just copy
   $ nm() { hg mv $1 $2; } # just move
   $ tm "up a  " "nc a b" "      " "1  get local a to b"
   created new head
   --------------
   test L:up a   R:nc a b W:       - 1  get local a to b
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: e300d1c794ec+, remote: 4ce40f5aca24
    rev: versions differ -> m
    a: remote copied to b -> m
   preserving a for resolve of b
   preserving rev for resolve of rev
   updating: a 1/2 files (50.00%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging a and b to b
   my b@e300d1c794ec+ other b@4ce40f5aca24 ancestor a@924404dff337
    premerge successful
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@e300d1c794ec+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   C a
   --------------
   
   $ tm "nc a b" "up a  " "      " "2  get rem change to a and b"
   created new head
   --------------
   test L:nc a b R:up a   W:       - 2  get rem change to a and b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: f4db7e329e71
    a: remote is newer -> g
    b: local copied/moved to a -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   getting a
   updating: b 2/3 files (66.67%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b and a to b
   my b@86a2aa42fc76+ other a@f4db7e329e71 ancestor a@924404dff337
    premerge successful
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@86a2aa42fc76+ other rev@f4db7e329e71 ancestor rev@924404dff337
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M a
   M b
     a
   --------------
   
   $ tm "up a  " "nm a b" "      " "3  get local a change to b, remove a"
   created new head
   --------------
   test L:up a   R:nm a b W:       - 3  get local a change to b, remove a
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: e300d1c794ec+, remote: bdb19105162a
    rev: versions differ -> m
    a: remote moved to b -> m
   preserving a for resolve of b
   preserving rev for resolve of rev
   removing a
   updating: a 1/2 files (50.00%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging a and b to b
   my b@e300d1c794ec+ other b@bdb19105162a ancestor a@924404dff337
    premerge successful
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@e300d1c794ec+ other rev@bdb19105162a ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   --------------
   
   $ tm "nm a b" "up a  " "      " "4  get remote change to b"
   created new head
   --------------
   test L:nm a b R:up a   W:       - 4  get remote change to b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: f4db7e329e71
    b: local copied/moved to a -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: b 1/2 files (50.00%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b and a to b
   my b@02963e448370+ other a@f4db7e329e71 ancestor a@924404dff337
    premerge successful
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@02963e448370+ other rev@f4db7e329e71 ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   --------------
   
   $ tm "      " "nc a b" "      " "5  get b"
   created new head
   --------------
   test L:       R:nc a b W:       - 5  get b
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a 
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 94b33a1b7f2d+, remote: 4ce40f5aca24
    rev: versions differ -> m
    b: remote created -> g
   preserving rev for resolve of rev
   updating: b 1/2 files (50.00%)
   getting b
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@94b33a1b7f2d+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   C a
   --------------
   
   $ tm "nc a b" "      " "      " "6  nothing"
   created new head
   --------------
   test L:nc a b R:       W:       - 6  nothing
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a 
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: 97c705ade336
    rev: versions differ -> m
   preserving rev for resolve of rev
   updating: rev 1/1 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@86a2aa42fc76+ other rev@97c705ade336 ancestor rev@924404dff337
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   C a
   C b
   --------------
   
   $ tm "      " "nm a b" "      " "7  get b"
   created new head
   --------------
   test L:       R:nm a b W:       - 7  get b
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a 
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 94b33a1b7f2d+, remote: bdb19105162a
    a: other deleted -> r
    rev: versions differ -> m
    b: remote created -> g
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   removing a
   updating: b 2/3 files (66.67%)
   getting b
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@94b33a1b7f2d+ other rev@bdb19105162a ancestor rev@924404dff337
   1 files updated, 1 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   --------------
   
   $ tm "nm a b" "      " "      " "8  nothing"
   created new head
   --------------
   test L:nm a b R:       W:       - 8  nothing
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a 
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: 97c705ade336
    rev: versions differ -> m
   preserving rev for resolve of rev
   updating: rev 1/1 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@02963e448370+ other rev@97c705ade336 ancestor rev@924404dff337
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   C b
   --------------
   
   $ tm "um a b" "um a b" "      " "9  do merge with ancestor in a"
   created new head
   --------------
   test L:um a b R:um a b W:       - 9  do merge with ancestor in a
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 62e7bf090eba+, remote: 49b6d8032493
    b: versions differ -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: b 1/2 files (50.00%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@62e7bf090eba+ other b@49b6d8032493 ancestor a@924404dff337
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@62e7bf090eba+ other rev@49b6d8032493 ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   --------------
   
 
 m "um a c" "um x c" "      " "10 do merge with no ancestor"
 
   $ tm "nm a b" "nm a c" "      " "11 get c, keep b"
   created new head
   --------------
   test L:nm a b R:nm a c W:       - 11 get c, keep b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     unmatched files in other:
      c
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      c -> a !
      b -> a !
     checking for directory renames
    a: divergent renames -> dr
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: fe905ef2c33e
    rev: versions differ -> m
    c: remote created -> g
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   note: possible conflict - a was renamed multiple times to:
    b
    c
   updating: c 2/3 files (66.67%)
   getting c
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@02963e448370+ other rev@fe905ef2c33e ancestor rev@924404dff337
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M c
   C b
   --------------
   
   $ tm "nc a b" "up b  " "      " "12 merge b no ancestor"
   created new head
   --------------
   test L:nc a b R:up b   W:       - 12 merge b no ancestor
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: af30c7647fc7
    b: versions differ -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: b 1/2 files (50.00%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@86a2aa42fc76+ other b@af30c7647fc7 ancestor b@000000000000
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@86a2aa42fc76+ other rev@af30c7647fc7 ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   C a
   --------------
   
   $ tm "up b  " "nm a b" "      " "13 merge b no ancestor"
   created new head
   --------------
   test L:up b   R:nm a b W:       - 13 merge b no ancestor
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 59318016310c+, remote: bdb19105162a
    a: other deleted -> r
    b: versions differ -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   removing a
   updating: b 2/3 files (66.67%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
   0 files updated, 2 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   --------------
   
   $ tm "nc a b" "up a b" "      " "14 merge b no ancestor"
   created new head
   --------------
   test L:nc a b R:up a b W:       - 14 merge b no ancestor
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: 8dbce441892a
    a: remote is newer -> g
    b: versions differ -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   getting a
   updating: b 2/3 files (66.67%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M a
   M b
   --------------
   
   $ tm "up b  " "nm a b" "      " "15 merge b no ancestor, remove a"
   created new head
   --------------
   test L:up b   R:nm a b W:       - 15 merge b no ancestor, remove a
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 59318016310c+, remote: bdb19105162a
    a: other deleted -> r
    b: versions differ -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   removing a
   updating: b 2/3 files (66.67%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
   0 files updated, 2 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   --------------
   
   $ tm "nc a b" "up a b" "      " "16 get a, merge b no ancestor"
   created new head
   --------------
   test L:nc a b R:up a b W:       - 16 get a, merge b no ancestor
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: 8dbce441892a
    a: remote is newer -> g
    b: versions differ -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   getting a
   updating: b 2/3 files (66.67%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M a
   M b
   --------------
   
   $ tm "up a b" "nc a b" "      " "17 keep a, merge b no ancestor"
   created new head
   --------------
   test L:up a b R:nc a b W:       - 17 keep a, merge b no ancestor
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 0b76e65c8289+, remote: 4ce40f5aca24
    b: versions differ -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: b 1/2 files (50.00%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@0b76e65c8289+ other b@4ce40f5aca24 ancestor b@000000000000
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@0b76e65c8289+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   C a
   --------------
   
   $ tm "nm a b" "up a b" "      " "18 merge b no ancestor"
   created new head
   --------------
   test L:nm a b R:up a b W:       - 18 merge b no ancestor
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: 8dbce441892a
    b: versions differ -> m
    rev: versions differ -> m
   remote changed a which local deleted
   use (c)hanged version or leave (d)eleted? c
    a: prompt recreating -> g
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   getting a
   updating: b 2/3 files (66.67%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@02963e448370+ other b@8dbce441892a ancestor b@000000000000
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@02963e448370+ other rev@8dbce441892a ancestor rev@924404dff337
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M a
   M b
   --------------
   
   $ tm "up a b" "nm a b" "      " "19 merge b no ancestor, prompt remove a"
   created new head
   --------------
   test L:up a b R:nm a b W:       - 19 merge b no ancestor, prompt remove a
   --------------
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 0b76e65c8289+, remote: bdb19105162a
    local changed a which remote deleted
   use (c)hanged version or (d)elete? c
    a: prompt keep -> a
    b: versions differ -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: a 1/3 files (33.33%)
   updating: b 2/3 files (66.67%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b
   my b@0b76e65c8289+ other b@bdb19105162a ancestor b@000000000000
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@0b76e65c8289+ other rev@bdb19105162a ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   C a
   --------------
   
   $ tm "up a  " "um a b" "      " "20 merge a and b to b, remove a"
   created new head
   --------------
   test L:up a   R:um a b W:       - 20 merge a and b to b, remove a
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: e300d1c794ec+, remote: 49b6d8032493
    rev: versions differ -> m
    a: remote moved to b -> m
   preserving a for resolve of b
   preserving rev for resolve of rev
   removing a
   updating: a 1/2 files (50.00%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging a and b to b
   my b@e300d1c794ec+ other b@49b6d8032493 ancestor a@924404dff337
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@e300d1c794ec+ other rev@49b6d8032493 ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   --------------
   
   $ tm "um a b" "up a  " "      " "21 merge a and b to b"
   created new head
   --------------
   test L:um a b R:up a   W:       - 21 merge a and b to b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 62e7bf090eba+, remote: f4db7e329e71
    b: local copied/moved to a -> m
    rev: versions differ -> m
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: b 1/2 files (50.00%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b and a to b
   my b@62e7bf090eba+ other a@f4db7e329e71 ancestor a@924404dff337
   updating: rev 2/2 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@62e7bf090eba+ other rev@f4db7e329e71 ancestor rev@924404dff337
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   --------------
   
 
 m "nm a b" "um x a" "      " "22 get a, keep b"
 
   $ tm "nm a b" "up a c" "      " "23 get c, keep b"
   created new head
   --------------
   test L:nm a b R:up a c W:       - 23 get c, keep b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     unmatched files in other:
      c
-    all copies found (* = to merge, ! = divergent):
+    all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: 2b958612230f
    b: local copied/moved to a -> m
    rev: versions differ -> m
    c: remote created -> g
   preserving b for resolve of b
   preserving rev for resolve of rev
   updating: b 1/3 files (33.33%)
   picked tool 'python ../merge' for b (binary False symlink False)
   merging b and a to b
   my b@02963e448370+ other a@2b958612230f ancestor a@924404dff337
    premerge successful
   updating: c 2/3 files (66.67%)
   getting c
   updating: rev 3/3 files (100.00%)
   picked tool 'python ../merge' for rev (binary False symlink False)
   merging rev
   my rev@02963e448370+ other rev@2b958612230f ancestor rev@924404dff337
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   M c
   --------------