rebase: skip resolved but emptied revisions

When rebasing, if a conflict occurs and is resolved in a way the rebased
revision becomes empty, it is not skipped, unlike revisions being emptied
without conflicts.

The reason is:
- File 'x' is merged and resolved, merge.update() marks it as 'm' in the
  dirstate.
- rebase.concludenode() calls localrepo.commit(), which calls
  localrepo.status() which calls dirstate.status(). 'x' shows up as 'm' and is
  unconditionnally added to the modified files list, instead of being checked
  again.
- localrepo.commit() detects 'x' as changed an create a new revision where only
  the manifest parents and linkrev differ.

Marking 'x' as modified without checking it makes sense for regular merges. But
in rebase case, the merge looks normal but the second parent is usually
discarded. When this happens, 'm' files in dirstate are a bit irrelevant and
should be considered 'n' possibly dirty instead. That is what the current patch
does.

Another approach, maybe more efficient, would be to pass another flag to
merge.update() saying the 'branchmerge' is a bit of a lie and recordupdate()
should call dirstate.normallookup() instead of merge().

It is also tempting to add this logic to dirstate.setparents(), moving from two
to one parent is what invalidates the 'm' markers. But this is a far bigger
change to make.

v2: succumb to the temptation and move the logic in dirstate.setparents(). mpm
suggested trying _filecommit() first but it is called by commitctx() which
knows nothing about the dirstate and comes too late into the game. A second
approach was to rewrite the 'm' state into 'n' on the fly in dirstate.status()
which failed for graft in the following case:

  $ hg init repo
  $ cd repo
  $ echo a > a
  $ hg ci -qAm0
  $ echo a >> a
  $ hg ci -m1
  $ hg up 0
  1 files updated, 0 files merged, 0 files removed, 0 files unresolved
  $ hg mv a b
  $ echo c > b
  $ hg ci -m2
  created new head
  $ hg graft 1 --tool internal:local
  grafting revision 1
  $ hg --config extensions.graphlog= glog --template '{rev} {desc|firstline}\n'
  @  3 1
  |
  o  2 2
  |
  | o  1 1
  |/
  o  0 0

  $ hg log -r 3 --debug --patch --git --copies
  changeset:   3:19cd7d1417952af13161b94c32e901769104560c
  tag:         tip
  phase:       draft
  parent:      2:b5c505595c9e9a12d5dd457919c143e05fc16fb8
  parent:      -1:0000000000000000000000000000000000000000
  manifest:    3:3d27ce8d02241aa59b60804805edf103c5c0cda4
  user:        test
  date:        Thu Jan 01 00:00:00 1970 +0000
  extra:       branch=default
  extra:       source=a03df74c41413a75c0a42997fc36c2de97b26658
  description:
  1

Here, revision 3 is created because there is a copy record for 'b' in the
dirstate and thus 'b' is considered modified. But this information is discarded
at commit time since 'b' content is unchanged. I do not know if discarding this
information is correct or not, but at this time we cannot represent it anyway.

This patch therefore implements the last solution of moving the logic into
dirstate.setparents(). It does not sound crazy as 'm' files makes no sense with
only one parent. It also makes dirstate.merge() calls .lookupnormal() if there
is one parent, to preserve the invariant.

I am a bit concerned about introducing this kind of stateful behaviour to
existing code which historically treated setparents() as a basic setter without
side-effects. And doing that during the code freeze.

mercurial/dirstate.py

@@ -1,759 +1,767 b''
 # dirstate.py - working directory tracking for mercurial
 #
 # Copyright 2005-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.
 import errno
 
 from node import nullid
 from i18n import _
 import scmutil, util, ignore, osutil, parsers, encoding
 import struct, os, stat, errno
 import cStringIO
 
 _format = ">cllll"
 propertycache = util.propertycache
 filecache = scmutil.filecache
 
 class repocache(filecache):
     """filecache for files in .hg/"""
     def join(self, obj, fname):
         return obj._opener.join(fname)
 
 class rootcache(filecache):
     """filecache for files in the repository root"""
     def join(self, obj, fname):
         return obj._join(fname)
 
 def _finddirs(path):
     pos = path.rfind('/')
     while pos != -1:
         yield path[:pos]
         pos = path.rfind('/', 0, pos)
 
 def _incdirs(dirs, path):
     for base in _finddirs(path):
         if base in dirs:
             dirs[base] += 1
             return
         dirs[base] = 1
 
 def _decdirs(dirs, path):
     for base in _finddirs(path):
         if dirs[base] > 1:
             dirs[base] -= 1
             return
         del dirs[base]
 
 class dirstate(object):
 
     def __init__(self, opener, ui, root, validate):
         '''Create a new dirstate object.
 
         opener is an open()-like callable that can be used to open the
         dirstate file; root is the root of the directory tracked by
         the dirstate.
         '''
         self._opener = opener
         self._validate = validate
         self._root = root
         self._rootdir = os.path.join(root, '')
         self._dirty = False
         self._dirtypl = False
         self._lastnormaltime = 0
         self._ui = ui
         self._filecache = {}
 
     @propertycache
     def _map(self):
         '''Return the dirstate contents as a map from filename to
         (state, mode, size, time).'''
         self._read()
         return self._map
 
     @propertycache
     def _copymap(self):
         self._read()
         return self._copymap
 
     @propertycache
     def _foldmap(self):
         f = {}
         for name in self._map:
             f[util.normcase(name)] = name
         for name in self._dirs:
             f[util.normcase(name)] = name
         f['.'] = '.' # prevents useless util.fspath() invocation
         return f
 
     @repocache('branch')
     def _branch(self):
         try:
             return self._opener.read("branch").strip() or "default"
         except IOError, inst:
             if inst.errno != errno.ENOENT:
                 raise
             return "default"
 
     @propertycache
     def _pl(self):
         try:
             fp = self._opener("dirstate")
             st = fp.read(40)
             fp.close()
             l = len(st)
             if l == 40:
                 return st[:20], st[20:40]
             elif l > 0 and l < 40:
                 raise util.Abort(_('working directory state appears damaged!'))
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
         return [nullid, nullid]
 
     @propertycache
     def _dirs(self):
         dirs = {}
         for f, s in self._map.iteritems():
             if s[0] != 'r':
                 _incdirs(dirs, f)
         return dirs
 
     def dirs(self):
         return self._dirs
 
     @rootcache('.hgignore')
     def _ignore(self):
         files = [self._join('.hgignore')]
         for name, path in self._ui.configitems("ui"):
             if name == 'ignore' or name.startswith('ignore.'):
                 files.append(util.expandpath(path))
         return ignore.ignore(self._root, files, self._ui.warn)
 
     @propertycache
     def _slash(self):
         return self._ui.configbool('ui', 'slash') and os.sep != '/'
 
     @propertycache
     def _checklink(self):
         return util.checklink(self._root)
 
     @propertycache
     def _checkexec(self):
         return util.checkexec(self._root)
 
     @propertycache
     def _checkcase(self):
         return not util.checkcase(self._join('.hg'))
 
     def _join(self, f):
         # much faster than os.path.join()
         # it's safe because f is always a relative path
         return self._rootdir + f
 
     def flagfunc(self, buildfallback):
         if self._checklink and self._checkexec:
             def f(x):
                 p = self._join(x)
                 if os.path.islink(p):
                     return 'l'
                 if util.isexec(p):
                     return 'x'
                 return ''
             return f
 
         fallback = buildfallback()
         if self._checklink:
             def f(x):
                 if os.path.islink(self._join(x)):
                     return 'l'
                 if 'x' in fallback(x):
                     return 'x'
                 return ''
             return f
         if self._checkexec:
             def f(x):
                 if 'l' in fallback(x):
                     return 'l'
                 if util.isexec(self._join(x)):
                     return 'x'
                 return ''
             return f
         else:
             return fallback
 
     def getcwd(self):
         cwd = os.getcwd()
         if cwd == self._root:
             return ''
         # self._root ends with a path separator if self._root is '/' or 'C:\'
         rootsep = self._root
         if not util.endswithsep(rootsep):
             rootsep += os.sep
         if cwd.startswith(rootsep):
             return cwd[len(rootsep):]
         else:
             # we're outside the repo. return an absolute path.
             return cwd
 
     def pathto(self, f, cwd=None):
         if cwd is None:
             cwd = self.getcwd()
         path = util.pathto(self._root, cwd, f)
         if self._slash:
             return util.normpath(path)
         return path
 
     def __getitem__(self, key):
         '''Return the current state of key (a filename) in the dirstate.
 
         States are:
           n  normal
           m  needs merging
           r  marked for removal
           a  marked for addition
           ?  not tracked
         '''
         return self._map.get(key, ("?",))[0]
 
     def __contains__(self, key):
         return key in self._map
 
     def __iter__(self):
         for x in sorted(self._map):
             yield x
 
     def parents(self):
         return [self._validate(p) for p in self._pl]
 
     def p1(self):
         return self._validate(self._pl[0])
 
     def p2(self):
         return self._validate(self._pl[1])
 
     def branch(self):
         return encoding.tolocal(self._branch)
 
     def setparents(self, p1, p2=nullid):
         self._dirty = self._dirtypl = True
+        oldp2 = self._pl[1]
         self._pl = p1, p2
+        if oldp2 != nullid and p2 == nullid:
+            # Discard 'm' markers when moving away from a merge state
+            for f, s in self._map.iteritems():
+                if s[0] == 'm':
+                    self.normallookup(f)
 
     def setbranch(self, branch):
         if branch in ['tip', '.', 'null']:
             raise util.Abort(_('the name \'%s\' is reserved') % branch)
         self._branch = encoding.fromlocal(branch)
         f = self._opener('branch', 'w', atomictemp=True)
         try:
             f.write(self._branch + '\n')
         finally:
             f.close()
 
     def _read(self):
         self._map = {}
         self._copymap = {}
         try:
             st = self._opener.read("dirstate")
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
             return
         if not st:
             return
 
         p = parsers.parse_dirstate(self._map, self._copymap, st)
         if not self._dirtypl:
             self._pl = p
 
     def invalidate(self):
         for a in ("_map", "_copymap", "_foldmap", "_branch", "_pl", "_dirs",
                 "_ignore"):
             if a in self.__dict__:
                 delattr(self, a)
         self._lastnormaltime = 0
         self._dirty = False
 
     def copy(self, source, dest):
         """Mark dest as a copy of source. Unmark dest if source is None."""
         if source == dest:
             return
         self._dirty = True
         if source is not None:
             self._copymap[dest] = source
         elif dest in self._copymap:
             del self._copymap[dest]
 
     def copied(self, file):
         return self._copymap.get(file, None)
 
     def copies(self):
         return self._copymap
 
     def _droppath(self, f):
         if self[f] not in "?r" and "_dirs" in self.__dict__:
             _decdirs(self._dirs, f)
 
     def _addpath(self, f, check=False):
         oldstate = self[f]
         if check or oldstate == "r":
             scmutil.checkfilename(f)
             if f in self._dirs:
                 raise util.Abort(_('directory %r already in dirstate') % f)
             # shadows
             for d in _finddirs(f):
                 if d in self._dirs:
                     break
                 if d in self._map and self[d] != 'r':
                     raise util.Abort(
                         _('file %r in dirstate clashes with %r') % (d, f))
         if oldstate in "?r" and "_dirs" in self.__dict__:
             _incdirs(self._dirs, f)
 
     def normal(self, f):
         '''Mark a file normal and clean.'''
         self._dirty = True
         self._addpath(f)
         s = os.lstat(self._join(f))
         mtime = int(s.st_mtime)
         self._map[f] = ('n', s.st_mode, s.st_size, mtime)
         if f in self._copymap:
             del self._copymap[f]
         if mtime > self._lastnormaltime:
             # Remember the most recent modification timeslot for status(),
             # to make sure we won't miss future size-preserving file content
             # modifications that happen within the same timeslot.
             self._lastnormaltime = mtime
 
     def normallookup(self, f):
         '''Mark a file normal, but possibly dirty.'''
         if self._pl[1] != nullid and f in self._map:
             # if there is a merge going on and the file was either
             # in state 'm' (-1) or coming from other parent (-2) before
             # being removed, restore that state.
             entry = self._map[f]
             if entry[0] == 'r' and entry[2] in (-1, -2):
                 source = self._copymap.get(f)
                 if entry[2] == -1:
                     self.merge(f)
                 elif entry[2] == -2:
                     self.otherparent(f)
                 if source:
                     self.copy(source, f)
                 return
             if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2:
                 return
         self._dirty = True
         self._addpath(f)
         self._map[f] = ('n', 0, -1, -1)
         if f in self._copymap:
             del self._copymap[f]
 
     def otherparent(self, f):
         '''Mark as coming from the other parent, always dirty.'''
         if self._pl[1] == nullid:
             raise util.Abort(_("setting %r to other parent "
                                "only allowed in merges") % f)
         self._dirty = True
         self._addpath(f)
         self._map[f] = ('n', 0, -2, -1)
         if f in self._copymap:
             del self._copymap[f]
 
     def add(self, f):
         '''Mark a file added.'''
         self._dirty = True
         self._addpath(f, True)
         self._map[f] = ('a', 0, -1, -1)
         if f in self._copymap:
             del self._copymap[f]
 
     def remove(self, f):
         '''Mark a file removed.'''
         self._dirty = True
         self._droppath(f)
         size = 0
         if self._pl[1] != nullid and f in self._map:
             # backup the previous state
             entry = self._map[f]
             if entry[0] == 'm': # merge
                 size = -1
             elif entry[0] == 'n' and entry[2] == -2: # other parent
                 size = -2
         self._map[f] = ('r', 0, size, 0)
         if size == 0 and f in self._copymap:
             del self._copymap[f]
 
     def merge(self, f):
         '''Mark a file merged.'''
+        if self._pl[1] == nullid:
+            return self.normallookup(f)
         self._dirty = True
         s = os.lstat(self._join(f))
         self._addpath(f)
         self._map[f] = ('m', s.st_mode, s.st_size, int(s.st_mtime))
         if f in self._copymap:
             del self._copymap[f]
 
     def drop(self, f):
         '''Drop a file from the dirstate'''
         if f in self._map:
             self._dirty = True
             self._droppath(f)
             del self._map[f]
 
     def _normalize(self, path, isknown):
         normed = util.normcase(path)
         folded = self._foldmap.get(normed, None)
         if folded is None:
             if isknown or not os.path.lexists(os.path.join(self._root, path)):
                 folded = path
             else:
                 # recursively normalize leading directory components
                 # against dirstate
                 if '/' in normed:
                     d, f = normed.rsplit('/', 1)
                     d = self._normalize(d, isknown)
                     r = self._root + "/" + d
                     folded = d + "/" + util.fspath(f, r)
                 else:
                     folded = util.fspath(normed, self._root)
                 self._foldmap[normed] = folded
 
         return folded
 
     def normalize(self, path, isknown=False):
         '''
         normalize the case of a pathname when on a casefolding filesystem
 
         isknown specifies whether the filename came from walking the
         disk, to avoid extra filesystem access
 
         The normalized case is determined based on the following precedence:
 
         - version of name already stored in the dirstate
         - version of name stored on disk
         - version provided via command arguments
         '''
 
         if self._checkcase:
             return self._normalize(path, isknown)
         return path
 
     def clear(self):
         self._map = {}
         if "_dirs" in self.__dict__:
             delattr(self, "_dirs")
         self._copymap = {}
         self._pl = [nullid, nullid]
         self._lastnormaltime = 0
         self._dirty = True
 
     def rebuild(self, parent, files):
         self.clear()
         for f in files:
             if 'x' in files.flags(f):
                 self._map[f] = ('n', 0777, -1, 0)
             else:
                 self._map[f] = ('n', 0666, -1, 0)
         self._pl = (parent, nullid)
         self._dirty = True
 
     def write(self):
         if not self._dirty:
             return
         st = self._opener("dirstate", "w", atomictemp=True)
 
         # use the modification time of the newly created temporary file as the
         # filesystem's notion of 'now'
         now = int(util.fstat(st).st_mtime)
 
         cs = cStringIO.StringIO()
         copymap = self._copymap
         pack = struct.pack
         write = cs.write
         write("".join(self._pl))
         for f, e in self._map.iteritems():
             if e[0] == 'n' and e[3] == now:
                 # The file was last modified "simultaneously" with the current
                 # write to dirstate (i.e. within the same second for file-
                 # systems with a granularity of 1 sec). This commonly happens
                 # for at least a couple of files on 'update'.
                 # The user could change the file without changing its size
                 # within the same second. Invalidate the file's stat data in
                 # dirstate, forcing future 'status' calls to compare the
                 # contents of the file. This prevents mistakenly treating such
                 # files as clean.
                 e = (e[0], 0, -1, -1)   # mark entry as 'unset'
                 self._map[f] = e
 
             if f in copymap:
                 f = "%s\0%s" % (f, copymap[f])
             e = pack(_format, e[0], e[1], e[2], e[3], len(f))
             write(e)
             write(f)
         st.write(cs.getvalue())
         st.close()
         self._lastnormaltime = 0
         self._dirty = self._dirtypl = False
 
     def _dirignore(self, f):
         if f == '.':
             return False
         if self._ignore(f):
             return True
         for p in _finddirs(f):
             if self._ignore(p):
                 return True
         return False
 
     def walk(self, match, subrepos, unknown, ignored):
         '''
         Walk recursively through the directory tree, finding all files
         matched by match.
 
         Return a dict mapping filename to stat-like object (either
         mercurial.osutil.stat instance or return value of os.stat()).
         '''
 
         def fwarn(f, msg):
             self._ui.warn('%s: %s\n' % (self.pathto(f), msg))
             return False
 
         def badtype(mode):
             kind = _('unknown')
             if stat.S_ISCHR(mode):
                 kind = _('character device')
             elif stat.S_ISBLK(mode):
                 kind = _('block device')
             elif stat.S_ISFIFO(mode):
                 kind = _('fifo')
             elif stat.S_ISSOCK(mode):
                 kind = _('socket')
             elif stat.S_ISDIR(mode):
                 kind = _('directory')
             return _('unsupported file type (type is %s)') % kind
 
         ignore = self._ignore
         dirignore = self._dirignore
         if ignored:
             ignore = util.never
             dirignore = util.never
         elif not unknown:
             # if unknown and ignored are False, skip step 2
             ignore = util.always
             dirignore = util.always
 
         matchfn = match.matchfn
         badfn = match.bad
         dmap = self._map
         normpath = util.normpath
         listdir = osutil.listdir
         lstat = os.lstat
         getkind = stat.S_IFMT
         dirkind = stat.S_IFDIR
         regkind = stat.S_IFREG
         lnkkind = stat.S_IFLNK
         join = self._join
         work = []
         wadd = work.append
 
         exact = skipstep3 = False
         if matchfn == match.exact: # match.exact
             exact = True
             dirignore = util.always # skip step 2
         elif match.files() and not match.anypats(): # match.match, no patterns
             skipstep3 = True
 
         if not exact and self._checkcase:
             normalize = self._normalize
             skipstep3 = False
         else:
             normalize = lambda x, y: x
 
         files = sorted(match.files())
         subrepos.sort()
         i, j = 0, 0
         while i < len(files) and j < len(subrepos):
             subpath = subrepos[j] + "/"
             if files[i] < subpath:
                 i += 1
                 continue
             while i < len(files) and files[i].startswith(subpath):
                 del files[i]
             j += 1
 
         if not files or '.' in files:
             files = ['']
         results = dict.fromkeys(subrepos)
         results['.hg'] = None
 
         # step 1: find all explicit files
         for ff in files:
             nf = normalize(normpath(ff), False)
             if nf in results:
                 continue
 
             try:
                 st = lstat(join(nf))
                 kind = getkind(st.st_mode)
                 if kind == dirkind:
                     skipstep3 = False
                     if nf in dmap:
                         #file deleted on disk but still in dirstate
                         results[nf] = None
                     match.dir(nf)
                     if not dirignore(nf):
                         wadd(nf)
                 elif kind == regkind or kind == lnkkind:
                     results[nf] = st
                 else:
                     badfn(ff, badtype(kind))
                     if nf in dmap:
                         results[nf] = None
             except OSError, inst:
                 if nf in dmap: # does it exactly match a file?
                     results[nf] = None
                 else: # does it match a directory?
                     prefix = nf + "/"
                     for fn in dmap:
                         if fn.startswith(prefix):
                             match.dir(nf)
                             skipstep3 = False
                             break
                     else:
                         badfn(ff, inst.strerror)
 
         # step 2: visit subdirectories
         while work:
             nd = work.pop()
             skip = None
             if nd == '.':
                 nd = ''
             else:
                 skip = '.hg'
             try:
                 entries = listdir(join(nd), stat=True, skip=skip)
             except OSError, inst:
                 if inst.errno == errno.EACCES:
                     fwarn(nd, inst.strerror)
                     continue
                 raise
             for f, kind, st in entries:
                 nf = normalize(nd and (nd + "/" + f) or f, True)
                 if nf not in results:
                     if kind == dirkind:
                         if not ignore(nf):
                             match.dir(nf)
                             wadd(nf)
                         if nf in dmap and matchfn(nf):
                             results[nf] = None
                     elif kind == regkind or kind == lnkkind:
                         if nf in dmap:
                             if matchfn(nf):
                                 results[nf] = st
                         elif matchfn(nf) and not ignore(nf):
                             results[nf] = st
                     elif nf in dmap and matchfn(nf):
                         results[nf] = None
 
         # step 3: report unseen items in the dmap hash
         if not skipstep3 and not exact:
             visit = sorted([f for f in dmap if f not in results and matchfn(f)])
             for nf, st in zip(visit, util.statfiles([join(i) for i in visit])):
                 if not st is None and not getkind(st.st_mode) in (regkind, lnkkind):
                     st = None
                 results[nf] = st
         for s in subrepos:
             del results[s]
         del results['.hg']
         return results
 
     def status(self, match, subrepos, ignored, clean, unknown):
         '''Determine the status of the working copy relative to the
         dirstate and return a tuple of lists (unsure, modified, added,
         removed, deleted, unknown, ignored, clean), where:
 
           unsure:
             files that might have been modified since the dirstate was
             written, but need to be read to be sure (size is the same
             but mtime differs)
           modified:
             files that have definitely been modified since the dirstate
             was written (different size or mode)
           added:
             files that have been explicitly added with hg add
           removed:
             files that have been explicitly removed with hg remove
           deleted:
             files that have been deleted through other means ("missing")
           unknown:
             files not in the dirstate that are not ignored
           ignored:
             files not in the dirstate that are ignored
             (by _dirignore())
           clean:
             files that have definitely not been modified since the
             dirstate was written
         '''
         listignored, listclean, listunknown = ignored, clean, unknown
         lookup, modified, added, unknown, ignored = [], [], [], [], []
         removed, deleted, clean = [], [], []
 
         dmap = self._map
         ladd = lookup.append            # aka "unsure"
         madd = modified.append
         aadd = added.append
         uadd = unknown.append
         iadd = ignored.append
         radd = removed.append
         dadd = deleted.append
         cadd = clean.append
 
         lnkkind = stat.S_IFLNK
 
         for fn, st in self.walk(match, subrepos, listunknown,
                                 listignored).iteritems():
             if fn not in dmap:
                 if (listignored or match.exact(fn)) and self._dirignore(fn):
                     if listignored:
                         iadd(fn)
                 elif listunknown:
                     uadd(fn)
                 continue
 
             state, mode, size, time = dmap[fn]
 
             if not st and state in "nma":
                 dadd(fn)
             elif state == 'n':
                 # The "mode & lnkkind != lnkkind or self._checklink"
                 # lines are an expansion of "islink => checklink"
                 # where islink means "is this a link?" and checklink
                 # means "can we check links?".
                 mtime = int(st.st_mtime)
                 if (size >= 0 and
                     (size != st.st_size
                      or ((mode ^ st.st_mode) & 0100 and self._checkexec))
                     and (mode & lnkkind != lnkkind or self._checklink)
                     or size == -2 # other parent
                     or fn in self._copymap):
                     madd(fn)
                 elif (mtime != time
                       and (mode & lnkkind != lnkkind or self._checklink)):
                     ladd(fn)
                 elif mtime == self._lastnormaltime:
                     # fn may have been changed in the same timeslot without
                     # changing its size. This can happen if we quickly do
                     # multiple commits in a single transaction.
                     # Force lookup, so we don't miss such a racy file change.
                     ladd(fn)
                 elif listclean:
                     cadd(fn)
             elif state == 'm':
                 madd(fn)
             elif state == 'a':
                 aadd(fn)
             elif state == 'r':
                 radd(fn)
 
         return (lookup, modified, added, removed, deleted, unknown, ignored,
                 clean)

tests/test-graft.t

@@ -1,290 +1,277 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 d2e44c99fd3f31c176ea4efb9eca9f6306c81756
   # Parent  68795b066622ca79a25816a662041d8f78f3cd9e
   2
   
   diff --git a/a b/b
   rename from a
   rename to b
   --- a/a
   +++ b/b
   @@ -1,1 +1,1 @@
   -a
   +b
 
 Look for extra:source
 
   $ hg log --debug -r tip
   changeset:   7:d2e44c99fd3f31c176ea4efb9eca9f6306c81756
   tag:         tip
   phase:       draft
   parent:      0:68795b066622ca79a25816a662041d8f78f3cd9e
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    7:5d59766436fd8fbcd38e7bebef0f6eaf3eebe637
   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):
      b -> a *
     checking for directory renames
   resolving manifests
    overwrite: False, partial: False
    ancestor: 68795b066622, local: d2e44c99fd3f+, remote: 5d205f8b35b6
    b: local copied/moved to a -> m
   preserving b for resolve of b
   updating: b 1/1 files (100.00%)
-  b
-   b: searching for copy revision for a
-   b: copy a:b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3
   grafting revision 5
     searching for copies back to rev 1
   resolving manifests
    overwrite: False, partial: False
-   ancestor: 4c60f11aa304, local: 6f5ea6ac8b70+, remote: 97f8bfe72746
+   ancestor: 4c60f11aa304, local: d2e44c99fd3f+, 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: 77eb504366ab+, remote: 9c233e8e184d
+   ancestor: 4c60f11aa304, local: 839a7e8fcf80+, 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@77eb504366ab+ other e@9c233e8e184d ancestor e@68795b066622
+  my e@839a7e8fcf80+ 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
+  @  [e-mail]: 3
   |
-  o  [e-mail]: 5
+  o  [e-mail]: 4
   |
-  o  [e-mail]: 1
+  o  [e-mail]: 5
   |
   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
   
-  $ hg export --git 8
-  # HG changeset patch
-  # User bar
-  # Date 0 0
-  # Node ID 6f5ea6ac8b705521c6d5f49a04ed142e3f76645d
-  # Parent  d2e44c99fd3f31c176ea4efb9eca9f6306c81756
-  1
-  
 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:d2e44c99fd3f31c176ea4efb9eca9f6306c81756
   $ hg log -r 2 --template '{rev}:{node}\n'
   2:5c095ad7e90f871700f02dd1fa5012cb4498a2d4
 
   $ hg log --debug -r tip
-  changeset:   13:95adbe5de6b10f376b699ece9ed5a57cd7b4b0f6
+  changeset:   12:95adbe5de6b10f376b699ece9ed5a57cd7b4b0f6
   tag:         tip
   phase:       draft
-  parent:      12:b592ea63bb0c19a6c5c44685ee29a2284f9f1b8f
+  parent:      11:b592ea63bb0c19a6c5c44685ee29a2284f9f1b8f
   parent:      -1:0000000000000000000000000000000000000000
-  manifest:    13:9944044f82a462bbaccc9bdf7e0ac5b811db7d1b
+  manifest:    12:9944044f82a462bbaccc9bdf7e0ac5b811db7d1b
   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 up -q 12
   $ 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)
+  skipping already grafted revision 12 (same origin 2)
   [255]

tests/test-rebase-detach.t

@@ -1,408 +1,398 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
   $ hg unbundle "$TESTDIR/bundles/rebase.hg"
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ..
 
 
 Rebasing D onto H detaching from C:
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg phase --force --secret 3
   $ hg rebase --detach -s 3 -d 7
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg log -G --template "{rev}:{phase} '{desc}' {branches}\n"
   @  7:secret 'D'
   |
   o  6:draft 'H'
   |
   | o  5:draft 'G'
   |/|
   o |  4:draft 'F'
   | |
   | o  3:draft 'E'
   |/
   | o  2:draft 'C'
   | |
   | o  1:draft 'B'
   |/
   o  0:draft 'A'
   
   $ hg manifest
   A
   D
   F
   H
 
   $ cd ..
 
 
 Rebasing C onto H detaching from B:
 
   $ hg clone -q -u . a a2
   $ cd a2
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 2 -d 7
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  7: 'D'
   |
   o  6: 'C'
   |
   o  5: 'H'
   |
   | o  4: 'G'
   |/|
   o |  3: 'F'
   | |
   | o  2: 'E'
   |/
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   C
   D
   F
   H
 
   $ cd ..
 
 
 Rebasing B onto H using detach (same as not using it):
 
   $ hg clone -q -u . a a3
   $ cd a3
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 1 -d 7
   saved backup bundle to $TESTTMP/a3/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  7: 'D'
   |
   o  6: 'C'
   |
   o  5: 'B'
   |
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ hg manifest
   A
   B
   C
   D
   F
   H
 
   $ cd ..
 
 
 Rebasing C onto H detaching from B and collapsing:
 
   $ hg clone -q -u . a a4
   $ cd a4
   $ hg phase --force --secret 3
 
   $ hg tglog
   @  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach --collapse -s 2 -d 7
   saved backup bundle to $TESTTMP/a4/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg  log -G --template "{rev}:{phase} '{desc}' {branches}\n"
   @  6:secret 'Collapsed revision
   |  * C
   |  * D'
   o  5:draft 'H'
   |
   | o  4:draft 'G'
   |/|
   o |  3:draft 'F'
   | |
   | o  2:draft 'E'
   |/
   | o  1:draft 'B'
   |/
   o  0:draft 'A'
   
   $ hg manifest
   A
   C
   D
   F
   H
 
   $ cd ..
 
 Rebasing across null as ancestor
   $ hg clone -q -U a a5
 
   $ cd a5
 
   $ echo x > x
 
   $ hg add x
 
   $ hg ci -m "extra branch"
   created new head
 
   $ hg tglog
   @  8: 'extra branch'
   
   o  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
   $ hg rebase --detach -s 1 -d tip
   saved backup bundle to $TESTTMP/a5/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   o  6: 'B'
   |
   o  5: 'extra branch'
   
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
 
   $ hg rebase -d 5 -s 7
   saved backup bundle to $TESTTMP/a5/.hg/strip-backup/13547172c9c0-backup.hg (glob)
   $ hg tglog
   @  8: 'D'
   |
   o  7: 'C'
   |
   | o  6: 'B'
   |/
   o  5: 'extra branch'
   
   o  4: 'H'
   |
   | o  3: 'G'
   |/|
   o |  2: 'F'
   | |
   | o  1: 'E'
   |/
   o  0: 'A'
   
   $ cd ..
 
 Verify that target is not selected as external rev (issue3085)
 
   $ hg clone -q -U a a6
   $ cd a6
   $ hg up -q 6
 
   $ echo "I" >> E
   $ hg ci -m "I"
   $ hg merge 7
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m "Merge"
   $ echo "J" >> F
   $ hg ci -m "J"
 
   $ hg rebase -s 8 -d 7 --collapse --detach --config ui.merge=internal:other
   remote changed E which local deleted
   use (c)hanged version or leave (d)eleted? c
   saved backup bundle to $TESTTMP/a6/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  8: 'Collapsed revision
   |  * I
   |  * Merge
   |  * J'
   o  7: 'H'
   |
   | o  6: 'G'
   |/|
   o |  5: 'F'
   | |
   | o  4: 'E'
   |/
   | o  3: 'D'
   | |
   | o  2: 'C'
   | |
   | o  1: 'B'
   |/
   o  0: 'A'
   
 
   $ hg parents
   changeset:   8:9472f4b1d736
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Collapsed revision
   
 
   $ cd ..
 
 Ensure --continue restores a correct state (issue3046) and phase:
   $ hg clone -q a a7
   $ cd a7
   $ hg up -q 3
   $ echo 'H2' > H
   $ hg ci -A -m 'H2'
   adding H
   $ hg phase --force --secret 8
   $ hg rebase -s 8 -d 7 --detach --config ui.merge=internal:fail
   merging H
   warning: conflicts during merge.
   merging H incomplete! (edit conflicts, then use 'hg resolve --mark')
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
   $ hg resolve --all -t internal:local
   $ hg rebase -c
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/6215fafa5447-backup.hg (glob)
   $ hg  log -G --template "{rev}:{phase} '{desc}' {branches}\n"
-  @  8:secret 'H2'
-  |
-  o  7:draft 'H'
+  @  7:draft 'H'
   |
   | o  6:draft 'G'
   |/|
   o |  5:draft 'F'
   | |
   | o  4:draft 'E'
   |/
   | o  3:draft 'D'
   | |
   | o  2:draft 'C'
   | |
   | o  1:draft 'B'
   |/
   o  0:draft 'A'
   
-  $ hg export --git 8
-  # HG changeset patch
-  # User test
-  # Date 0 0
-  # Node ID 248209b40064fe67181915fa7a4f3395520f700a
-  # Parent  02de42196ebee42ef284b6780a87cdc96e8eaab6
-  H2
-  

tests/test-rebase-mq-skip.t

@@ -1,147 +1,137 b''
 This emulates the effects of an hg pull --rebase in which the remote repo
 already has one local mq patch
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > rebase=
   > mq=
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: '{desc}' tags: {tags}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
   $ hg qinit -c
 
   $ echo c1 > c1
   $ hg add c1
   $ hg ci -m C1
 
   $ echo r1 > r1
   $ hg add r1
   $ hg ci -m R1
 
   $ hg up -q 0
 
   $ hg qnew p0.patch
   $ echo p0 > p0
   $ hg add p0
   $ hg qref -m P0
 
   $ hg qnew p1.patch
   $ echo p1 > p1
   $ hg add p1
   $ hg qref -m P1
 
   $ hg export qtip > p1.patch 
 
   $ hg up -q -C 1
 
   $ hg import p1.patch
   applying p1.patch
 
   $ rm p1.patch
 
   $ hg up -q -C qtip
 
   $ hg rebase
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
   @  3: 'P0' tags: p0.patch qbase qtip tip
   |
   o  2: 'P1' tags: qparent
   |
   o  1: 'R1' tags:
   |
   o  0: 'C1' tags:
   
   $ cd ..
 
 
   $ hg init b
   $ cd b
   $ hg qinit -c
 
   $ for i in r0 r1 r2 r3 r4 r5 r6;
   > do
   >     echo $i > $i
   >     hg ci -Am $i
   > done
   adding r0
   adding r1
   adding r2
   adding r3
   adding r4
   adding r5
   adding r6
 
   $ hg qimport -r 1:tip
 
   $ hg up -q 0
 
   $ for i in r1 r3 r7 r8;
   > do
   >     echo $i > $i
   >     hg ci -Am branch2-$i
   > done
   adding r1
   created new head
   adding r3
   adding r7
   adding r8
 
   $ echo somethingelse > r4
   $ hg ci -Am branch2-r4
   adding r4
 
   $ echo r6 > r6
   $ hg ci -Am branch2-r6
   adding r6
 
   $ hg up -q qtip
 
   $ HGMERGE=internal:fail hg rebase
   abort: unresolved conflicts (see hg resolve, then hg rebase --continue)
   [255]
 
   $ HGMERGE=internal:local hg resolve --all
 
   $ hg rebase --continue
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/*-backup.hg (glob)
 
   $ hg tglog
-  @  9: 'r5' tags: 5.diff qtip tip
-  |
-  o  8: 'r4' tags: 4.diff
+  @  8: 'r5' tags: 5.diff qtip tip
   |
   o  7: 'r2' tags: 2.diff qbase
   |
   o  6: 'branch2-r6' tags: qparent
   |
   o  5: 'branch2-r4' tags:
   |
   o  4: 'branch2-r8' tags:
   |
   o  3: 'branch2-r7' tags:
   |
   o  2: 'branch2-r3' tags:
   |
   o  1: 'branch2-r1' tags:
   |
   o  0: 'r0' tags:
   
-  $ hg export --git 4.diff
-  # HG changeset patch
-  # User test
-  # Date 0 0
-  # Node ID 315eb21a13c2b06e787f5d0000e36f8f8f3a1768
-  # Parent  1660ab13ce9aea3da22ea54926bd49aeff8a4e20
-  r4
-