branchcache: introduce hasbranch()

This will be used to check whether a branch exists or not. This will optimized
in future.

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

mercurial/branchmap.py

@@ -1,616 +1,620 b''
 # branchmap.py - logic to computes, maintain and stores branchmap for local repo
 #
 # 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.
 
 from __future__ import absolute_import
 
 import struct
 
 from .node import (
     bin,
     hex,
     nullid,
     nullrev,
 )
 from . import (
     encoding,
     error,
     pycompat,
     scmutil,
     util,
 )
 from .utils import (
     stringutil,
 )
 
 calcsize = struct.calcsize
 pack_into = struct.pack_into
 unpack_from = struct.unpack_from
 
 
 ### Nearest subset relation
 # Nearest subset of filter X is a filter Y so that:
 # * Y is included in X,
 # * X - Y is as small as possible.
 # This create and ordering used for branchmap purpose.
 # the ordering may be partial
 subsettable = {None: 'visible',
                'visible-hidden': 'visible',
                'visible': 'served',
                'served': 'immutable',
                'immutable': 'base'}
 
 
 class BranchMapCache(object):
     """mapping of filtered views of repo with their branchcache"""
     def __init__(self):
         self._per_filter = {}
 
     def __getitem__(self, repo):
         self.updatecache(repo)
         return self._per_filter[repo.filtername]
 
     def updatecache(self, repo):
         """Update the cache for the given filtered view on a repository"""
         # This can trigger updates for the caches for subsets of the filtered
         # view, e.g. when there is no cache for this filtered view or the cache
         # is stale.
 
         cl = repo.changelog
         filtername = repo.filtername
         bcache = self._per_filter.get(filtername)
         if bcache is None or not bcache.validfor(repo):
             # cache object missing or cache object stale? Read from disk
             bcache = branchcache.fromfile(repo)
 
         revs = []
         if bcache is None:
             # no (fresh) cache available anymore, perhaps we can re-use
             # the cache for a subset, then extend that to add info on missing
             # revisions.
             subsetname = subsettable.get(filtername)
             if subsetname is not None:
                 subset = repo.filtered(subsetname)
                 bcache = self[subset].copy()
                 extrarevs = subset.changelog.filteredrevs - cl.filteredrevs
                 revs.extend(r for r in extrarevs if r <= bcache.tiprev)
             else:
                 # nothing to fall back on, start empty.
                 bcache = branchcache()
 
         revs.extend(cl.revs(start=bcache.tiprev + 1))
         if revs:
             bcache.update(repo, revs)
 
         assert bcache.validfor(repo), filtername
         self._per_filter[repo.filtername] = bcache
 
     def replace(self, repo, remotebranchmap):
         """Replace the branchmap cache for a repo with a branch mapping.
 
         This is likely only called during clone with a branch map from a
         remote.
 
         """
         cl = repo.changelog
         clrev = cl.rev
         clbranchinfo = cl.branchinfo
         rbheads = []
         closed = []
         for bheads in remotebranchmap.itervalues():
             rbheads += bheads
             for h in bheads:
                 r = clrev(h)
                 b, c = clbranchinfo(r)
                 if c:
                     closed.append(h)
 
         if rbheads:
             rtiprev = max((int(clrev(node)) for node in rbheads))
             cache = branchcache(
                 remotebranchmap, repo[rtiprev].node(), rtiprev,
                 closednodes=closed)
 
             # Try to stick it as low as possible
             # filter above served are unlikely to be fetch from a clone
             for candidate in ('base', 'immutable', 'served'):
                 rview = repo.filtered(candidate)
                 if cache.validfor(rview):
                     self._per_filter[candidate] = cache
                     cache.write(rview)
                     return
 
     def clear(self):
         self._per_filter.clear()
 
 
 class branchcache(object):
     """A dict like object that hold branches heads cache.
 
     This cache is used to avoid costly computations to determine all the
     branch heads of a repo.
 
     The cache is serialized on disk in the following format:
 
     <tip hex node> <tip rev number> [optional filtered repo hex hash]
     <branch head hex node> <open/closed state> <branch name>
     <branch head hex node> <open/closed state> <branch name>
     ...
 
     The first line is used to check if the cache is still valid. If the
     branch cache is for a filtered repo view, an optional third hash is
     included that hashes the hashes of all filtered revisions.
 
     The open/closed state is represented by a single letter 'o' or 'c'.
     This field can be used to avoid changelog reads when determining if a
     branch head closes a branch or not.
     """
 
     def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev,
                  filteredhash=None, closednodes=None):
         self.tipnode = tipnode
         self.tiprev = tiprev
         self.filteredhash = filteredhash
         # closednodes is a set of nodes that close their branch. If the branch
         # cache has been updated, it may contain nodes that are no longer
         # heads.
         if closednodes is None:
             self._closednodes = set()
         else:
             self._closednodes = closednodes
         self.entries = dict(entries)
 
     def __iter__(self):
         return iter(self.entries)
 
     def __setitem__(self, key, value):
         self.entries[key] = value
 
     def __getitem__(self, key):
         return self.entries[key]
 
     def iteritems(self):
         return self.entries.iteritems()
 
+    def hasbranch(self, label):
+        """ checks whether a branch of this name exists or not """
+        return label in self.entries
+
     @classmethod
     def fromfile(cls, repo):
         f = None
         try:
             f = repo.cachevfs(cls._filename(repo))
             lineiter = iter(f)
             cachekey = next(lineiter).rstrip('\n').split(" ", 2)
             last, lrev = cachekey[:2]
             last, lrev = bin(last), int(lrev)
             filteredhash = None
             if len(cachekey) > 2:
                 filteredhash = bin(cachekey[2])
             bcache = cls(tipnode=last, tiprev=lrev, filteredhash=filteredhash)
             if not bcache.validfor(repo):
                 # invalidate the cache
                 raise ValueError(r'tip differs')
             bcache.load(repo, lineiter)
         except (IOError, OSError):
             return None
 
         except Exception as inst:
             if repo.ui.debugflag:
                 msg = 'invalid branchheads cache'
                 if repo.filtername is not None:
                     msg += ' (%s)' % repo.filtername
                 msg += ': %s\n'
                 repo.ui.debug(msg % pycompat.bytestr(inst))
             bcache = None
 
         finally:
             if f:
                 f.close()
 
         return bcache
 
     def load(self, repo, lineiter):
         """ fully loads the branchcache by reading from the file using the line
         iterator passed"""
         cl = repo.changelog
         for line in lineiter:
             line = line.rstrip('\n')
             if not line:
                 continue
             node, state, label = line.split(" ", 2)
             if state not in 'oc':
                 raise ValueError(r'invalid branch state')
             label = encoding.tolocal(label.strip())
             node = bin(node)
             if not cl.hasnode(node):
                 raise ValueError(
                     r'node %s does not exist' % pycompat.sysstr(hex(node)))
             self.entries.setdefault(label, []).append(node)
             if state == 'c':
                 self._closednodes.add(node)
 
     @staticmethod
     def _filename(repo):
         """name of a branchcache file for a given repo or repoview"""
         filename = "branch2"
         if repo.filtername:
             filename = '%s-%s' % (filename, repo.filtername)
         return filename
 
     def validfor(self, repo):
         """Is the cache content valid regarding a repo
 
         - False when cached tipnode is unknown or if we detect a strip.
         - True when cache is up to date or a subset of current repo."""
         try:
             return ((self.tipnode == repo.changelog.node(self.tiprev))
                     and (self.filteredhash ==
                          scmutil.filteredhash(repo, self.tiprev)))
         except IndexError:
             return False
 
     def _branchtip(self, heads):
         '''Return tuple with last open head in heads and false,
         otherwise return last closed head and true.'''
         tip = heads[-1]
         closed = True
         for h in reversed(heads):
             if h not in self._closednodes:
                 tip = h
                 closed = False
                 break
         return tip, closed
 
     def branchtip(self, branch):
         '''Return the tipmost open head on branch head, otherwise return the
         tipmost closed head on branch.
         Raise KeyError for unknown branch.'''
         return self._branchtip(self[branch])[0]
 
     def iteropen(self, nodes):
         return (n for n in nodes if n not in self._closednodes)
 
     def branchheads(self, branch, closed=False):
         heads = self[branch]
         if not closed:
             heads = list(self.iteropen(heads))
         return heads
 
     def iterbranches(self):
         for bn, heads in self.iteritems():
             yield (bn, heads) + self._branchtip(heads)
 
     def iterheads(self):
         """ returns all the heads """
         return self.entries.itervalues()
 
     def copy(self):
         """return an deep copy of the branchcache object"""
         return branchcache(
             self.entries, self.tipnode, self.tiprev, self.filteredhash,
             self._closednodes)
 
     def write(self, repo):
         try:
             f = repo.cachevfs(self._filename(repo), "w", atomictemp=True)
             cachekey = [hex(self.tipnode), '%d' % self.tiprev]
             if self.filteredhash is not None:
                 cachekey.append(hex(self.filteredhash))
             f.write(" ".join(cachekey) + '\n')
             nodecount = 0
             for label, nodes in sorted(self.iteritems()):
                 label = encoding.fromlocal(label)
                 for node in nodes:
                     nodecount += 1
                     if node in self._closednodes:
                         state = 'c'
                     else:
                         state = 'o'
                     f.write("%s %s %s\n" % (hex(node), state, label))
             f.close()
             repo.ui.log('branchcache',
                         'wrote %s branch cache with %d labels and %d nodes\n',
                         repo.filtername, len(self.entries), nodecount)
         except (IOError, OSError, error.Abort) as inst:
             # Abort may be raised by read only opener, so log and continue
             repo.ui.debug("couldn't write branch cache: %s\n" %
                           stringutil.forcebytestr(inst))
 
     def update(self, repo, revgen):
         """Given a branchhead cache, self, that may have extra nodes or be
         missing heads, and a generator of nodes that are strictly a superset of
         heads missing, this function updates self to be correct.
         """
         starttime = util.timer()
         cl = repo.changelog
         # collect new branch entries
         newbranches = {}
         getbranchinfo = repo.revbranchcache().branchinfo
         for r in revgen:
             branch, closesbranch = getbranchinfo(r)
             newbranches.setdefault(branch, []).append(r)
             if closesbranch:
                 self._closednodes.add(cl.node(r))
 
         # fetch current topological heads to speed up filtering
         topoheads = set(cl.headrevs())
 
         # if older branchheads are reachable from new ones, they aren't
         # really branchheads. Note checking parents is insufficient:
         # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
         for branch, newheadrevs in newbranches.iteritems():
             bheads = self.entries.setdefault(branch, [])
             bheadset = set(cl.rev(node) for node in bheads)
 
             # This have been tested True on all internal usage of this function.
             # run it again in case of doubt
             # assert not (set(bheadrevs) & set(newheadrevs))
             bheadset.update(newheadrevs)
 
             # This prunes out two kinds of heads - heads that are superseded by
             # a head in newheadrevs, and newheadrevs that are not heads because
             # an existing head is their descendant.
             uncertain = bheadset - topoheads
             if uncertain:
                 floorrev = min(uncertain)
                 ancestors = set(cl.ancestors(newheadrevs, floorrev))
                 bheadset -= ancestors
             bheadrevs = sorted(bheadset)
             self[branch] = [cl.node(rev) for rev in bheadrevs]
             tiprev = bheadrevs[-1]
             if tiprev > self.tiprev:
                 self.tipnode = cl.node(tiprev)
                 self.tiprev = tiprev
 
         if not self.validfor(repo):
             # cache key are not valid anymore
             self.tipnode = nullid
             self.tiprev = nullrev
             for heads in self.iterheads():
                 tiprev = max(cl.rev(node) for node in heads)
                 if tiprev > self.tiprev:
                     self.tipnode = cl.node(tiprev)
                     self.tiprev = tiprev
         self.filteredhash = scmutil.filteredhash(repo, self.tiprev)
 
         duration = util.timer() - starttime
         repo.ui.log('branchcache', 'updated %s branch cache in %.4f seconds\n',
                     repo.filtername or b'None', duration)
 
         self.write(repo)
 
 
 class remotebranchcache(branchcache):
     """Branchmap info for a remote connection, should not write locally"""
     def write(self, repo):
         pass
 
 
 # Revision branch info cache
 
 _rbcversion = '-v1'
 _rbcnames = 'rbc-names' + _rbcversion
 _rbcrevs = 'rbc-revs' + _rbcversion
 # [4 byte hash prefix][4 byte branch name number with sign bit indicating open]
 _rbcrecfmt = '>4sI'
 _rbcrecsize = calcsize(_rbcrecfmt)
 _rbcnodelen = 4
 _rbcbranchidxmask = 0x7fffffff
 _rbccloseflag = 0x80000000
 
 class revbranchcache(object):
     """Persistent cache, mapping from revision number to branch name and close.
     This is a low level cache, independent of filtering.
 
     Branch names are stored in rbc-names in internal encoding separated by 0.
     rbc-names is append-only, and each branch name is only stored once and will
     thus have a unique index.
 
     The branch info for each revision is stored in rbc-revs as constant size
     records. The whole file is read into memory, but it is only 'parsed' on
     demand. The file is usually append-only but will be truncated if repo
     modification is detected.
     The record for each revision contains the first 4 bytes of the
     corresponding node hash, and the record is only used if it still matches.
     Even a completely trashed rbc-revs fill thus still give the right result
     while converging towards full recovery ... assuming no incorrectly matching
     node hashes.
     The record also contains 4 bytes where 31 bits contains the index of the
     branch and the last bit indicate that it is a branch close commit.
     The usage pattern for rbc-revs is thus somewhat similar to 00changelog.i
     and will grow with it but be 1/8th of its size.
     """
 
     def __init__(self, repo, readonly=True):
         assert repo.filtername is None
         self._repo = repo
         self._names = [] # branch names in local encoding with static index
         self._rbcrevs = bytearray()
         self._rbcsnameslen = 0 # length of names read at _rbcsnameslen
         try:
             bndata = repo.cachevfs.read(_rbcnames)
             self._rbcsnameslen = len(bndata) # for verification before writing
             if bndata:
                 self._names = [encoding.tolocal(bn)
                                for bn in bndata.split('\0')]
         except (IOError, OSError):
             if readonly:
                 # don't try to use cache - fall back to the slow path
                 self.branchinfo = self._branchinfo
 
         if self._names:
             try:
                 data = repo.cachevfs.read(_rbcrevs)
                 self._rbcrevs[:] = data
             except (IOError, OSError) as inst:
                 repo.ui.debug("couldn't read revision branch cache: %s\n" %
                               stringutil.forcebytestr(inst))
         # remember number of good records on disk
         self._rbcrevslen = min(len(self._rbcrevs) // _rbcrecsize,
                                len(repo.changelog))
         if self._rbcrevslen == 0:
             self._names = []
         self._rbcnamescount = len(self._names) # number of names read at
                                                # _rbcsnameslen
 
     def _clear(self):
         self._rbcsnameslen = 0
         del self._names[:]
         self._rbcnamescount = 0
         self._rbcrevslen = len(self._repo.changelog)
         self._rbcrevs = bytearray(self._rbcrevslen * _rbcrecsize)
         util.clearcachedproperty(self, '_namesreverse')
 
     @util.propertycache
     def _namesreverse(self):
         return dict((b, r) for r, b in enumerate(self._names))
 
     def branchinfo(self, rev):
         """Return branch name and close flag for rev, using and updating
         persistent cache."""
         changelog = self._repo.changelog
         rbcrevidx = rev * _rbcrecsize
 
         # avoid negative index, changelog.read(nullrev) is fast without cache
         if rev == nullrev:
             return changelog.branchinfo(rev)
 
         # if requested rev isn't allocated, grow and cache the rev info
         if len(self._rbcrevs) < rbcrevidx + _rbcrecsize:
             return self._branchinfo(rev)
 
         # fast path: extract data from cache, use it if node is matching
         reponode = changelog.node(rev)[:_rbcnodelen]
         cachenode, branchidx = unpack_from(
             _rbcrecfmt, util.buffer(self._rbcrevs), rbcrevidx)
         close = bool(branchidx & _rbccloseflag)
         if close:
             branchidx &= _rbcbranchidxmask
         if cachenode == '\0\0\0\0':
             pass
         elif cachenode == reponode:
             try:
                 return self._names[branchidx], close
             except IndexError:
                 # recover from invalid reference to unknown branch
                 self._repo.ui.debug("referenced branch names not found"
                     " - rebuilding revision branch cache from scratch\n")
                 self._clear()
         else:
             # rev/node map has changed, invalidate the cache from here up
             self._repo.ui.debug("history modification detected - truncating "
                 "revision branch cache to revision %d\n" % rev)
             truncate = rbcrevidx + _rbcrecsize
             del self._rbcrevs[truncate:]
             self._rbcrevslen = min(self._rbcrevslen, truncate)
 
         # fall back to slow path and make sure it will be written to disk
         return self._branchinfo(rev)
 
     def _branchinfo(self, rev):
         """Retrieve branch info from changelog and update _rbcrevs"""
         changelog = self._repo.changelog
         b, close = changelog.branchinfo(rev)
         if b in self._namesreverse:
             branchidx = self._namesreverse[b]
         else:
             branchidx = len(self._names)
             self._names.append(b)
             self._namesreverse[b] = branchidx
         reponode = changelog.node(rev)
         if close:
             branchidx |= _rbccloseflag
         self._setcachedata(rev, reponode, branchidx)
         return b, close
 
     def setdata(self, branch, rev, node, close):
         """add new data information to the cache"""
         if branch in self._namesreverse:
             branchidx = self._namesreverse[branch]
         else:
             branchidx = len(self._names)
             self._names.append(branch)
             self._namesreverse[branch] = branchidx
         if close:
             branchidx |= _rbccloseflag
         self._setcachedata(rev, node, branchidx)
         # If no cache data were readable (non exists, bad permission, etc)
         # the cache was bypassing itself by setting:
         #
         #   self.branchinfo = self._branchinfo
         #
         # Since we now have data in the cache, we need to drop this bypassing.
         if r'branchinfo' in vars(self):
             del self.branchinfo
 
     def _setcachedata(self, rev, node, branchidx):
         """Writes the node's branch data to the in-memory cache data."""
         if rev == nullrev:
             return
         rbcrevidx = rev * _rbcrecsize
         if len(self._rbcrevs) < rbcrevidx + _rbcrecsize:
             self._rbcrevs.extend('\0' *
                                  (len(self._repo.changelog) * _rbcrecsize -
                                   len(self._rbcrevs)))
         pack_into(_rbcrecfmt, self._rbcrevs, rbcrevidx, node, branchidx)
         self._rbcrevslen = min(self._rbcrevslen, rev)
 
         tr = self._repo.currenttransaction()
         if tr:
             tr.addfinalize('write-revbranchcache', self.write)
 
     def write(self, tr=None):
         """Save branch cache if it is dirty."""
         repo = self._repo
         wlock = None
         step = ''
         try:
             if self._rbcnamescount < len(self._names):
                 step = ' names'
                 wlock = repo.wlock(wait=False)
                 if self._rbcnamescount != 0:
                     f = repo.cachevfs.open(_rbcnames, 'ab')
                     if f.tell() == self._rbcsnameslen:
                         f.write('\0')
                     else:
                         f.close()
                         repo.ui.debug("%s changed - rewriting it\n" % _rbcnames)
                         self._rbcnamescount = 0
                         self._rbcrevslen = 0
                 if self._rbcnamescount == 0:
                     # before rewriting names, make sure references are removed
                     repo.cachevfs.unlinkpath(_rbcrevs, ignoremissing=True)
                     f = repo.cachevfs.open(_rbcnames, 'wb')
                 f.write('\0'.join(encoding.fromlocal(b)
                                   for b in self._names[self._rbcnamescount:]))
                 self._rbcsnameslen = f.tell()
                 f.close()
                 self._rbcnamescount = len(self._names)
 
             start = self._rbcrevslen * _rbcrecsize
             if start != len(self._rbcrevs):
                 step = ''
                 if wlock is None:
                     wlock = repo.wlock(wait=False)
                 revs = min(len(repo.changelog),
                            len(self._rbcrevs) // _rbcrecsize)
                 f = repo.cachevfs.open(_rbcrevs, 'ab')
                 if f.tell() != start:
                     repo.ui.debug("truncating cache/%s to %d\n"
                                   % (_rbcrevs, start))
                     f.seek(start)
                     if f.tell() != start:
                         start = 0
                         f.seek(start)
                     f.truncate()
                 end = revs * _rbcrecsize
                 f.write(self._rbcrevs[start:end])
                 f.close()
                 self._rbcrevslen = revs
         except (IOError, OSError, error.Abort, error.LockError) as inst:
             repo.ui.debug("couldn't write revision branch cache%s: %s\n"
                           % (step, stringutil.forcebytestr(inst)))
         finally:
             if wlock is not None:
                 wlock.release()

mercurial/localrepo.py

@@ -1,3092 +1,3092 b''
 # localrepo.py - read/write repository class 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.
 
 from __future__ import absolute_import
 
 import errno
 import hashlib
 import os
 import random
 import sys
 import time
 import weakref
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullid,
     nullrev,
     short,
 )
 from . import (
     bookmarks,
     branchmap,
     bundle2,
     changegroup,
     changelog,
     color,
     context,
     dirstate,
     dirstateguard,
     discovery,
     encoding,
     error,
     exchange,
     extensions,
     filelog,
     hook,
     lock as lockmod,
     manifest,
     match as matchmod,
     merge as mergemod,
     mergeutil,
     namespaces,
     narrowspec,
     obsolete,
     pathutil,
     phases,
     pushkey,
     pycompat,
     repository,
     repoview,
     revset,
     revsetlang,
     scmutil,
     sparse,
     store as storemod,
     subrepoutil,
     tags as tagsmod,
     transaction,
     txnutil,
     util,
     vfs as vfsmod,
 )
 from .utils import (
     interfaceutil,
     procutil,
     stringutil,
 )
 
 from .revlogutils import (
     constants as revlogconst,
 )
 
 release = lockmod.release
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 # set of (path, vfs-location) tuples. vfs-location is:
 # - 'plain for vfs relative paths
 # - '' for svfs relative paths
 _cachedfiles = set()
 
 class _basefilecache(scmutil.filecache):
     """All filecache usage on repo are done for logic that should be unfiltered
     """
     def __get__(self, repo, type=None):
         if repo is None:
             return self
         # proxy to unfiltered __dict__ since filtered repo has no entry
         unfi = repo.unfiltered()
         try:
             return unfi.__dict__[self.sname]
         except KeyError:
             pass
         return super(_basefilecache, self).__get__(unfi, type)
 
     def set(self, repo, value):
         return super(_basefilecache, self).set(repo.unfiltered(), value)
 
 class repofilecache(_basefilecache):
     """filecache for files in .hg but outside of .hg/store"""
     def __init__(self, *paths):
         super(repofilecache, self).__init__(*paths)
         for path in paths:
             _cachedfiles.add((path, 'plain'))
 
     def join(self, obj, fname):
         return obj.vfs.join(fname)
 
 class storecache(_basefilecache):
     """filecache for files in the store"""
     def __init__(self, *paths):
         super(storecache, self).__init__(*paths)
         for path in paths:
             _cachedfiles.add((path, ''))
 
     def join(self, obj, fname):
         return obj.sjoin(fname)
 
 def isfilecached(repo, name):
     """check if a repo has already cached "name" filecache-ed property
 
     This returns (cachedobj-or-None, iscached) tuple.
     """
     cacheentry = repo.unfiltered()._filecache.get(name, None)
     if not cacheentry:
         return None, False
     return cacheentry.obj, True
 
 class unfilteredpropertycache(util.propertycache):
     """propertycache that apply to unfiltered repo only"""
 
     def __get__(self, repo, type=None):
         unfi = repo.unfiltered()
         if unfi is repo:
             return super(unfilteredpropertycache, self).__get__(unfi)
         return getattr(unfi, self.name)
 
 class filteredpropertycache(util.propertycache):
     """propertycache that must take filtering in account"""
 
     def cachevalue(self, obj, value):
         object.__setattr__(obj, self.name, value)
 
 
 def hasunfilteredcache(repo, name):
     """check if a repo has an unfilteredpropertycache value for <name>"""
     return name in vars(repo.unfiltered())
 
 def unfilteredmethod(orig):
     """decorate method that always need to be run on unfiltered version"""
     def wrapper(repo, *args, **kwargs):
         return orig(repo.unfiltered(), *args, **kwargs)
     return wrapper
 
 moderncaps = {'lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
               'unbundle'}
 legacycaps = moderncaps.union({'changegroupsubset'})
 
 @interfaceutil.implementer(repository.ipeercommandexecutor)
 class localcommandexecutor(object):
     def __init__(self, peer):
         self._peer = peer
         self._sent = False
         self._closed = False
 
     def __enter__(self):
         return self
 
     def __exit__(self, exctype, excvalue, exctb):
         self.close()
 
     def callcommand(self, command, args):
         if self._sent:
             raise error.ProgrammingError('callcommand() cannot be used after '
                                          'sendcommands()')
 
         if self._closed:
             raise error.ProgrammingError('callcommand() cannot be used after '
                                          'close()')
 
         # We don't need to support anything fancy. Just call the named
         # method on the peer and return a resolved future.
         fn = getattr(self._peer, pycompat.sysstr(command))
 
         f = pycompat.futures.Future()
 
         try:
             result = fn(**pycompat.strkwargs(args))
         except Exception:
             pycompat.future_set_exception_info(f, sys.exc_info()[1:])
         else:
             f.set_result(result)
 
         return f
 
     def sendcommands(self):
         self._sent = True
 
     def close(self):
         self._closed = True
 
 @interfaceutil.implementer(repository.ipeercommands)
 class localpeer(repository.peer):
     '''peer for a local repo; reflects only the most recent API'''
 
     def __init__(self, repo, caps=None):
         super(localpeer, self).__init__()
 
         if caps is None:
             caps = moderncaps.copy()
         self._repo = repo.filtered('served')
         self.ui = repo.ui
         self._caps = repo._restrictcapabilities(caps)
 
     # Begin of _basepeer interface.
 
     def url(self):
         return self._repo.url()
 
     def local(self):
         return self._repo
 
     def peer(self):
         return self
 
     def canpush(self):
         return True
 
     def close(self):
         self._repo.close()
 
     # End of _basepeer interface.
 
     # Begin of _basewirecommands interface.
 
     def branchmap(self):
         return self._repo.branchmap()
 
     def capabilities(self):
         return self._caps
 
     def clonebundles(self):
         return self._repo.tryread('clonebundles.manifest')
 
     def debugwireargs(self, one, two, three=None, four=None, five=None):
         """Used to test argument passing over the wire"""
         return "%s %s %s %s %s" % (one, two, pycompat.bytestr(three),
                                    pycompat.bytestr(four),
                                    pycompat.bytestr(five))
 
     def getbundle(self, source, heads=None, common=None, bundlecaps=None,
                   **kwargs):
         chunks = exchange.getbundlechunks(self._repo, source, heads=heads,
                                           common=common, bundlecaps=bundlecaps,
                                           **kwargs)[1]
         cb = util.chunkbuffer(chunks)
 
         if exchange.bundle2requested(bundlecaps):
             # When requesting a bundle2, getbundle returns a stream to make the
             # wire level function happier. We need to build a proper object
             # from it in local peer.
             return bundle2.getunbundler(self.ui, cb)
         else:
             return changegroup.getunbundler('01', cb, None)
 
     def heads(self):
         return self._repo.heads()
 
     def known(self, nodes):
         return self._repo.known(nodes)
 
     def listkeys(self, namespace):
         return self._repo.listkeys(namespace)
 
     def lookup(self, key):
         return self._repo.lookup(key)
 
     def pushkey(self, namespace, key, old, new):
         return self._repo.pushkey(namespace, key, old, new)
 
     def stream_out(self):
         raise error.Abort(_('cannot perform stream clone against local '
                             'peer'))
 
     def unbundle(self, bundle, heads, url):
         """apply a bundle on a repo
 
         This function handles the repo locking itself."""
         try:
             try:
                 bundle = exchange.readbundle(self.ui, bundle, None)
                 ret = exchange.unbundle(self._repo, bundle, heads, 'push', url)
                 if util.safehasattr(ret, 'getchunks'):
                     # This is a bundle20 object, turn it into an unbundler.
                     # This little dance should be dropped eventually when the
                     # API is finally improved.
                     stream = util.chunkbuffer(ret.getchunks())
                     ret = bundle2.getunbundler(self.ui, stream)
                 return ret
             except Exception as exc:
                 # If the exception contains output salvaged from a bundle2
                 # reply, we need to make sure it is printed before continuing
                 # to fail. So we build a bundle2 with such output and consume
                 # it directly.
                 #
                 # This is not very elegant but allows a "simple" solution for
                 # issue4594
                 output = getattr(exc, '_bundle2salvagedoutput', ())
                 if output:
                     bundler = bundle2.bundle20(self._repo.ui)
                     for out in output:
                         bundler.addpart(out)
                     stream = util.chunkbuffer(bundler.getchunks())
                     b = bundle2.getunbundler(self.ui, stream)
                     bundle2.processbundle(self._repo, b)
                 raise
         except error.PushRaced as exc:
             raise error.ResponseError(_('push failed:'),
                                       stringutil.forcebytestr(exc))
 
     # End of _basewirecommands interface.
 
     # Begin of peer interface.
 
     def commandexecutor(self):
         return localcommandexecutor(self)
 
     # End of peer interface.
 
 @interfaceutil.implementer(repository.ipeerlegacycommands)
 class locallegacypeer(localpeer):
     '''peer extension which implements legacy methods too; used for tests with
     restricted capabilities'''
 
     def __init__(self, repo):
         super(locallegacypeer, self).__init__(repo, caps=legacycaps)
 
     # Begin of baselegacywirecommands interface.
 
     def between(self, pairs):
         return self._repo.between(pairs)
 
     def branches(self, nodes):
         return self._repo.branches(nodes)
 
     def changegroup(self, nodes, source):
         outgoing = discovery.outgoing(self._repo, missingroots=nodes,
                                       missingheads=self._repo.heads())
         return changegroup.makechangegroup(self._repo, outgoing, '01', source)
 
     def changegroupsubset(self, bases, heads, source):
         outgoing = discovery.outgoing(self._repo, missingroots=bases,
                                       missingheads=heads)
         return changegroup.makechangegroup(self._repo, outgoing, '01', source)
 
     # End of baselegacywirecommands interface.
 
 # Increment the sub-version when the revlog v2 format changes to lock out old
 # clients.
 REVLOGV2_REQUIREMENT = 'exp-revlogv2.1'
 
 # A repository with the sparserevlog feature will have delta chains that
 # can spread over a larger span. Sparse reading cuts these large spans into
 # pieces, so that each piece isn't too big.
 # Without the sparserevlog capability, reading from the repository could use
 # huge amounts of memory, because the whole span would be read at once,
 # including all the intermediate revisions that aren't pertinent for the chain.
 # This is why once a repository has enabled sparse-read, it becomes required.
 SPARSEREVLOG_REQUIREMENT = 'sparserevlog'
 
 # Functions receiving (ui, features) that extensions can register to impact
 # the ability to load repositories with custom requirements. Only
 # functions defined in loaded extensions are called.
 #
 # The function receives a set of requirement strings that the repository
 # is capable of opening. Functions will typically add elements to the
 # set to reflect that the extension knows how to handle that requirements.
 featuresetupfuncs = set()
 
 def makelocalrepository(baseui, path, intents=None):
     """Create a local repository object.
 
     Given arguments needed to construct a local repository, this function
     performs various early repository loading functionality (such as
     reading the ``.hg/requires`` and ``.hg/hgrc`` files), validates that
     the repository can be opened, derives a type suitable for representing
     that repository, and returns an instance of it.
 
     The returned object conforms to the ``repository.completelocalrepository``
     interface.
 
     The repository type is derived by calling a series of factory functions
     for each aspect/interface of the final repository. These are defined by
     ``REPO_INTERFACES``.
 
     Each factory function is called to produce a type implementing a specific
     interface. The cumulative list of returned types will be combined into a
     new type and that type will be instantiated to represent the local
     repository.
 
     The factory functions each receive various state that may be consulted
     as part of deriving a type.
 
     Extensions should wrap these factory functions to customize repository type
     creation. Note that an extension's wrapped function may be called even if
     that extension is not loaded for the repo being constructed. Extensions
     should check if their ``__name__`` appears in the
     ``extensionmodulenames`` set passed to the factory function and no-op if
     not.
     """
     ui = baseui.copy()
     # Prevent copying repo configuration.
     ui.copy = baseui.copy
 
     # Working directory VFS rooted at repository root.
     wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
 
     # Main VFS for .hg/ directory.
     hgpath = wdirvfs.join(b'.hg')
     hgvfs = vfsmod.vfs(hgpath, cacheaudited=True)
 
     # The .hg/ path should exist and should be a directory. All other
     # cases are errors.
     if not hgvfs.isdir():
         try:
             hgvfs.stat()
         except OSError as e:
             if e.errno != errno.ENOENT:
                 raise
 
         raise error.RepoError(_(b'repository %s not found') % path)
 
     # .hg/requires file contains a newline-delimited list of
     # features/capabilities the opener (us) must have in order to use
     # the repository. This file was introduced in Mercurial 0.9.2,
     # which means very old repositories may not have one. We assume
     # a missing file translates to no requirements.
     try:
         requirements = set(hgvfs.read(b'requires').splitlines())
     except IOError as e:
         if e.errno != errno.ENOENT:
             raise
         requirements = set()
 
     # The .hg/hgrc file may load extensions or contain config options
     # that influence repository construction. Attempt to load it and
     # process any new extensions that it may have pulled in.
     if loadhgrc(ui, wdirvfs, hgvfs, requirements):
         afterhgrcload(ui, wdirvfs, hgvfs, requirements)
         extensions.loadall(ui)
         extensions.populateui(ui)
 
     # Set of module names of extensions loaded for this repository.
     extensionmodulenames = {m.__name__ for n, m in extensions.extensions(ui)}
 
     supportedrequirements = gathersupportedrequirements(ui)
 
     # We first validate the requirements are known.
     ensurerequirementsrecognized(requirements, supportedrequirements)
 
     # Then we validate that the known set is reasonable to use together.
     ensurerequirementscompatible(ui, requirements)
 
     # TODO there are unhandled edge cases related to opening repositories with
     # shared storage. If storage is shared, we should also test for requirements
     # compatibility in the pointed-to repo. This entails loading the .hg/hgrc in
     # that repo, as that repo may load extensions needed to open it. This is a
     # bit complicated because we don't want the other hgrc to overwrite settings
     # in this hgrc.
     #
     # This bug is somewhat mitigated by the fact that we copy the .hg/requires
     # file when sharing repos. But if a requirement is added after the share is
     # performed, thereby introducing a new requirement for the opener, we may
     # will not see that and could encounter a run-time error interacting with
     # that shared store since it has an unknown-to-us requirement.
 
     # At this point, we know we should be capable of opening the repository.
     # Now get on with doing that.
 
     features = set()
 
     # The "store" part of the repository holds versioned data. How it is
     # accessed is determined by various requirements. The ``shared`` or
     # ``relshared`` requirements indicate the store lives in the path contained
     # in the ``.hg/sharedpath`` file. This is an absolute path for
     # ``shared`` and relative to ``.hg/`` for ``relshared``.
     if b'shared' in requirements or b'relshared' in requirements:
         sharedpath = hgvfs.read(b'sharedpath').rstrip(b'\n')
         if b'relshared' in requirements:
             sharedpath = hgvfs.join(sharedpath)
 
         sharedvfs = vfsmod.vfs(sharedpath, realpath=True)
 
         if not sharedvfs.exists():
             raise error.RepoError(_(b'.hg/sharedpath points to nonexistent '
                                     b'directory %s') % sharedvfs.base)
 
         features.add(repository.REPO_FEATURE_SHARED_STORAGE)
 
         storebasepath = sharedvfs.base
         cachepath = sharedvfs.join(b'cache')
     else:
         storebasepath = hgvfs.base
         cachepath = hgvfs.join(b'cache')
     wcachepath = hgvfs.join(b'wcache')
 
 
     # The store has changed over time and the exact layout is dictated by
     # requirements. The store interface abstracts differences across all
     # of them.
     store = makestore(requirements, storebasepath,
                       lambda base: vfsmod.vfs(base, cacheaudited=True))
     hgvfs.createmode = store.createmode
 
     storevfs = store.vfs
     storevfs.options = resolvestorevfsoptions(ui, requirements, features)
 
     # The cache vfs is used to manage cache files.
     cachevfs = vfsmod.vfs(cachepath, cacheaudited=True)
     cachevfs.createmode = store.createmode
     # The cache vfs is used to manage cache files related to the working copy
     wcachevfs = vfsmod.vfs(wcachepath, cacheaudited=True)
     wcachevfs.createmode = store.createmode
 
     # Now resolve the type for the repository object. We do this by repeatedly
     # calling a factory function to produces types for specific aspects of the
     # repo's operation. The aggregate returned types are used as base classes
     # for a dynamically-derived type, which will represent our new repository.
 
     bases = []
     extrastate = {}
 
     for iface, fn in REPO_INTERFACES:
         # We pass all potentially useful state to give extensions tons of
         # flexibility.
         typ = fn()(ui=ui,
                  intents=intents,
                  requirements=requirements,
                  features=features,
                  wdirvfs=wdirvfs,
                  hgvfs=hgvfs,
                  store=store,
                  storevfs=storevfs,
                  storeoptions=storevfs.options,
                  cachevfs=cachevfs,
                  wcachevfs=wcachevfs,
                  extensionmodulenames=extensionmodulenames,
                  extrastate=extrastate,
                  baseclasses=bases)
 
         if not isinstance(typ, type):
             raise error.ProgrammingError('unable to construct type for %s' %
                                          iface)
 
         bases.append(typ)
 
     # type() allows you to use characters in type names that wouldn't be
     # recognized as Python symbols in source code. We abuse that to add
     # rich information about our constructed repo.
     name = pycompat.sysstr(b'derivedrepo:%s<%s>' % (
         wdirvfs.base,
         b','.join(sorted(requirements))))
 
     cls = type(name, tuple(bases), {})
 
     return cls(
         baseui=baseui,
         ui=ui,
         origroot=path,
         wdirvfs=wdirvfs,
         hgvfs=hgvfs,
         requirements=requirements,
         supportedrequirements=supportedrequirements,
         sharedpath=storebasepath,
         store=store,
         cachevfs=cachevfs,
         wcachevfs=wcachevfs,
         features=features,
         intents=intents)
 
 def loadhgrc(ui, wdirvfs, hgvfs, requirements):
     """Load hgrc files/content into a ui instance.
 
     This is called during repository opening to load any additional
     config files or settings relevant to the current repository.
 
     Returns a bool indicating whether any additional configs were loaded.
 
     Extensions should monkeypatch this function to modify how per-repo
     configs are loaded. For example, an extension may wish to pull in
     configs from alternate files or sources.
     """
     try:
         ui.readconfig(hgvfs.join(b'hgrc'), root=wdirvfs.base)
         return True
     except IOError:
         return False
 
 def afterhgrcload(ui, wdirvfs, hgvfs, requirements):
     """Perform additional actions after .hg/hgrc is loaded.
 
     This function is called during repository loading immediately after
     the .hg/hgrc file is loaded and before per-repo extensions are loaded.
 
     The function can be used to validate configs, automatically add
     options (including extensions) based on requirements, etc.
     """
 
     # Map of requirements to list of extensions to load automatically when
     # requirement is present.
     autoextensions = {
         b'largefiles': [b'largefiles'],
         b'lfs': [b'lfs'],
     }
 
     for requirement, names in sorted(autoextensions.items()):
         if requirement not in requirements:
             continue
 
         for name in names:
             if not ui.hasconfig(b'extensions', name):
                 ui.setconfig(b'extensions', name, b'', source='autoload')
 
 def gathersupportedrequirements(ui):
     """Determine the complete set of recognized requirements."""
     # Start with all requirements supported by this file.
     supported = set(localrepository._basesupported)
 
     # Execute ``featuresetupfuncs`` entries if they belong to an extension
     # relevant to this ui instance.
     modules = {m.__name__ for n, m in extensions.extensions(ui)}
 
     for fn in featuresetupfuncs:
         if fn.__module__ in modules:
             fn(ui, supported)
 
     # Add derived requirements from registered compression engines.
     for name in util.compengines:
         engine = util.compengines[name]
         if engine.revlogheader():
             supported.add(b'exp-compression-%s' % name)
 
     return supported
 
 def ensurerequirementsrecognized(requirements, supported):
     """Validate that a set of local requirements is recognized.
 
     Receives a set of requirements. Raises an ``error.RepoError`` if there
     exists any requirement in that set that currently loaded code doesn't
     recognize.
 
     Returns a set of supported requirements.
     """
     missing = set()
 
     for requirement in requirements:
         if requirement in supported:
             continue
 
         if not requirement or not requirement[0:1].isalnum():
             raise error.RequirementError(_(b'.hg/requires file is corrupt'))
 
         missing.add(requirement)
 
     if missing:
         raise error.RequirementError(
             _(b'repository requires features unknown to this Mercurial: %s') %
             b' '.join(sorted(missing)),
             hint=_(b'see https://mercurial-scm.org/wiki/MissingRequirement '
                    b'for more information'))
 
 def ensurerequirementscompatible(ui, requirements):
     """Validates that a set of recognized requirements is mutually compatible.
 
     Some requirements may not be compatible with others or require
     config options that aren't enabled. This function is called during
     repository opening to ensure that the set of requirements needed
     to open a repository is sane and compatible with config options.
 
     Extensions can monkeypatch this function to perform additional
     checking.
 
     ``error.RepoError`` should be raised on failure.
     """
     if b'exp-sparse' in requirements and not sparse.enabled:
         raise error.RepoError(_(b'repository is using sparse feature but '
                                 b'sparse is not enabled; enable the '
                                 b'"sparse" extensions to access'))
 
 def makestore(requirements, path, vfstype):
     """Construct a storage object for a repository."""
     if b'store' in requirements:
         if b'fncache' in requirements:
             return storemod.fncachestore(path, vfstype,
                                          b'dotencode' in requirements)
 
         return storemod.encodedstore(path, vfstype)
 
     return storemod.basicstore(path, vfstype)
 
 def resolvestorevfsoptions(ui, requirements, features):
     """Resolve the options to pass to the store vfs opener.
 
     The returned dict is used to influence behavior of the storage layer.
     """
     options = {}
 
     if b'treemanifest' in requirements:
         options[b'treemanifest'] = True
 
     # experimental config: format.manifestcachesize
     manifestcachesize = ui.configint(b'format', b'manifestcachesize')
     if manifestcachesize is not None:
         options[b'manifestcachesize'] = manifestcachesize
 
     # In the absence of another requirement superseding a revlog-related
     # requirement, we have to assume the repo is using revlog version 0.
     # This revlog format is super old and we don't bother trying to parse
     # opener options for it because those options wouldn't do anything
     # meaningful on such old repos.
     if b'revlogv1' in requirements or REVLOGV2_REQUIREMENT in requirements:
         options.update(resolverevlogstorevfsoptions(ui, requirements, features))
 
     return options
 
 def resolverevlogstorevfsoptions(ui, requirements, features):
     """Resolve opener options specific to revlogs."""
 
     options = {}
     options[b'flagprocessors'] = {}
 
     if b'revlogv1' in requirements:
         options[b'revlogv1'] = True
     if REVLOGV2_REQUIREMENT in requirements:
         options[b'revlogv2'] = True
 
     if b'generaldelta' in requirements:
         options[b'generaldelta'] = True
 
     # experimental config: format.chunkcachesize
     chunkcachesize = ui.configint(b'format', b'chunkcachesize')
     if chunkcachesize is not None:
         options[b'chunkcachesize'] = chunkcachesize
 
     deltabothparents = ui.configbool(b'storage',
                                      b'revlog.optimize-delta-parent-choice')
     options[b'deltabothparents'] = deltabothparents
 
     lazydelta = ui.configbool(b'storage', b'revlog.reuse-external-delta')
     lazydeltabase = False
     if lazydelta:
         lazydeltabase = ui.configbool(b'storage',
                                       b'revlog.reuse-external-delta-parent')
     if lazydeltabase is None:
         lazydeltabase = not scmutil.gddeltaconfig(ui)
     options[b'lazydelta'] = lazydelta
     options[b'lazydeltabase'] = lazydeltabase
 
     chainspan = ui.configbytes(b'experimental', b'maxdeltachainspan')
     if 0 <= chainspan:
         options[b'maxdeltachainspan'] = chainspan
 
     mmapindexthreshold = ui.configbytes(b'experimental',
                                         b'mmapindexthreshold')
     if mmapindexthreshold is not None:
         options[b'mmapindexthreshold'] = mmapindexthreshold
 
     withsparseread = ui.configbool(b'experimental', b'sparse-read')
     srdensitythres = float(ui.config(b'experimental',
                                      b'sparse-read.density-threshold'))
     srmingapsize = ui.configbytes(b'experimental',
                                   b'sparse-read.min-gap-size')
     options[b'with-sparse-read'] = withsparseread
     options[b'sparse-read-density-threshold'] = srdensitythres
     options[b'sparse-read-min-gap-size'] = srmingapsize
 
     sparserevlog = SPARSEREVLOG_REQUIREMENT in requirements
     options[b'sparse-revlog'] = sparserevlog
     if sparserevlog:
         options[b'generaldelta'] = True
 
     maxchainlen = None
     if sparserevlog:
         maxchainlen = revlogconst.SPARSE_REVLOG_MAX_CHAIN_LENGTH
     # experimental config: format.maxchainlen
     maxchainlen = ui.configint(b'format', b'maxchainlen', maxchainlen)
     if maxchainlen is not None:
         options[b'maxchainlen'] = maxchainlen
 
     for r in requirements:
         if r.startswith(b'exp-compression-'):
             options[b'compengine'] = r[len(b'exp-compression-'):]
 
     if repository.NARROW_REQUIREMENT in requirements:
         options[b'enableellipsis'] = True
 
     return options
 
 def makemain(**kwargs):
     """Produce a type conforming to ``ilocalrepositorymain``."""
     return localrepository
 
 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
 class revlogfilestorage(object):
     """File storage when using revlogs."""
 
     def file(self, path):
         if path[0] == b'/':
             path = path[1:]
 
         return filelog.filelog(self.svfs, path)
 
 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
 class revlognarrowfilestorage(object):
     """File storage when using revlogs and narrow files."""
 
     def file(self, path):
         if path[0] == b'/':
             path = path[1:]
 
         return filelog.narrowfilelog(self.svfs, path, self._storenarrowmatch)
 
 def makefilestorage(requirements, features, **kwargs):
     """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
     features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE)
     features.add(repository.REPO_FEATURE_STREAM_CLONE)
 
     if repository.NARROW_REQUIREMENT in requirements:
         return revlognarrowfilestorage
     else:
         return revlogfilestorage
 
 # List of repository interfaces and factory functions for them. Each
 # will be called in order during ``makelocalrepository()`` to iteratively
 # derive the final type for a local repository instance. We capture the
 # function as a lambda so we don't hold a reference and the module-level
 # functions can be wrapped.
 REPO_INTERFACES = [
     (repository.ilocalrepositorymain, lambda: makemain),
     (repository.ilocalrepositoryfilestorage, lambda: makefilestorage),
 ]
 
 @interfaceutil.implementer(repository.ilocalrepositorymain)
 class localrepository(object):
     """Main class for representing local repositories.
 
     All local repositories are instances of this class.
 
     Constructed on its own, instances of this class are not usable as
     repository objects. To obtain a usable repository object, call
     ``hg.repository()``, ``localrepo.instance()``, or
     ``localrepo.makelocalrepository()``. The latter is the lowest-level.
     ``instance()`` adds support for creating new repositories.
     ``hg.repository()`` adds more extension integration, including calling
     ``reposetup()``. Generally speaking, ``hg.repository()`` should be
     used.
     """
 
     # obsolete experimental requirements:
     #  - manifestv2: An experimental new manifest format that allowed
     #    for stem compression of long paths. Experiment ended up not
     #    being successful (repository sizes went up due to worse delta
     #    chains), and the code was deleted in 4.6.
     supportedformats = {
         'revlogv1',
         'generaldelta',
         'treemanifest',
         REVLOGV2_REQUIREMENT,
         SPARSEREVLOG_REQUIREMENT,
     }
     _basesupported = supportedformats | {
         'store',
         'fncache',
         'shared',
         'relshared',
         'dotencode',
         'exp-sparse',
         'internal-phase'
     }
 
     # list of prefix for file which can be written without 'wlock'
     # Extensions should extend this list when needed
     _wlockfreeprefix = {
         # We migh consider requiring 'wlock' for the next
         # two, but pretty much all the existing code assume
         # wlock is not needed so we keep them excluded for
         # now.
         'hgrc',
         'requires',
         # XXX cache is a complicatged business someone
         # should investigate this in depth at some point
         'cache/',
         # XXX shouldn't be dirstate covered by the wlock?
         'dirstate',
         # XXX bisect was still a bit too messy at the time
         # this changeset was introduced. Someone should fix
         # the remainig bit and drop this line
         'bisect.state',
     }
 
     def __init__(self, baseui, ui, origroot, wdirvfs, hgvfs, requirements,
                  supportedrequirements, sharedpath, store, cachevfs, wcachevfs,
                  features, intents=None):
         """Create a new local repository instance.
 
         Most callers should use ``hg.repository()``, ``localrepo.instance()``,
         or ``localrepo.makelocalrepository()`` for obtaining a new repository
         object.
 
         Arguments:
 
         baseui
            ``ui.ui`` instance that ``ui`` argument was based off of.
 
         ui
            ``ui.ui`` instance for use by the repository.
 
         origroot
            ``bytes`` path to working directory root of this repository.
 
         wdirvfs
            ``vfs.vfs`` rooted at the working directory.
 
         hgvfs
            ``vfs.vfs`` rooted at .hg/
 
         requirements
            ``set`` of bytestrings representing repository opening requirements.
 
         supportedrequirements
            ``set`` of bytestrings representing repository requirements that we
            know how to open. May be a supetset of ``requirements``.
 
         sharedpath
            ``bytes`` Defining path to storage base directory. Points to a
            ``.hg/`` directory somewhere.
 
         store
            ``store.basicstore`` (or derived) instance providing access to
            versioned storage.
 
         cachevfs
            ``vfs.vfs`` used for cache files.
 
         wcachevfs
            ``vfs.vfs`` used for cache files related to the working copy.
 
         features
            ``set`` of bytestrings defining features/capabilities of this
            instance.
 
         intents
            ``set`` of system strings indicating what this repo will be used
            for.
         """
         self.baseui = baseui
         self.ui = ui
         self.origroot = origroot
         # vfs rooted at working directory.
         self.wvfs = wdirvfs
         self.root = wdirvfs.base
         # vfs rooted at .hg/. Used to access most non-store paths.
         self.vfs = hgvfs
         self.path = hgvfs.base
         self.requirements = requirements
         self.supported = supportedrequirements
         self.sharedpath = sharedpath
         self.store = store
         self.cachevfs = cachevfs
         self.wcachevfs = wcachevfs
         self.features = features
 
         self.filtername = None
 
         if (self.ui.configbool('devel', 'all-warnings') or
             self.ui.configbool('devel', 'check-locks')):
             self.vfs.audit = self._getvfsward(self.vfs.audit)
         # A list of callback to shape the phase if no data were found.
         # Callback are in the form: func(repo, roots) --> processed root.
         # This list it to be filled by extension during repo setup
         self._phasedefaults = []
 
         color.setup(self.ui)
 
         self.spath = self.store.path
         self.svfs = self.store.vfs
         self.sjoin = self.store.join
         if (self.ui.configbool('devel', 'all-warnings') or
             self.ui.configbool('devel', 'check-locks')):
             if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs
                 self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit)
             else: # standard vfs
                 self.svfs.audit = self._getsvfsward(self.svfs.audit)
 
         self._dirstatevalidatewarned = False
 
         self._branchcaches = branchmap.BranchMapCache()
         self._revbranchcache = None
         self._filterpats = {}
         self._datafilters = {}
         self._transref = self._lockref = self._wlockref = None
 
         # A cache for various files under .hg/ that tracks file changes,
         # (used by the filecache decorator)
         #
         # Maps a property name to its util.filecacheentry
         self._filecache = {}
 
         # hold sets of revision to be filtered
         # should be cleared when something might have changed the filter value:
         # - new changesets,
         # - phase change,
         # - new obsolescence marker,
         # - working directory parent change,
         # - bookmark changes
         self.filteredrevcache = {}
 
         # post-dirstate-status hooks
         self._postdsstatus = []
 
         # generic mapping between names and nodes
         self.names = namespaces.namespaces()
 
         # Key to signature value.
         self._sparsesignaturecache = {}
         # Signature to cached matcher instance.
         self._sparsematchercache = {}
 
     def _getvfsward(self, origfunc):
         """build a ward for self.vfs"""
         rref = weakref.ref(self)
         def checkvfs(path, mode=None):
             ret = origfunc(path, mode=mode)
             repo = rref()
             if (repo is None
                 or not util.safehasattr(repo, '_wlockref')
                 or not util.safehasattr(repo, '_lockref')):
                 return
             if mode in (None, 'r', 'rb'):
                 return
             if path.startswith(repo.path):
                 # truncate name relative to the repository (.hg)
                 path = path[len(repo.path) + 1:]
             if path.startswith('cache/'):
                 msg = 'accessing cache with vfs instead of cachevfs: "%s"'
                 repo.ui.develwarn(msg % path, stacklevel=3, config="cache-vfs")
             if path.startswith('journal.') or path.startswith('undo.'):
                 # journal is covered by 'lock'
                 if repo._currentlock(repo._lockref) is None:
                     repo.ui.develwarn('write with no lock: "%s"' % path,
                                       stacklevel=3, config='check-locks')
             elif repo._currentlock(repo._wlockref) is None:
                 # rest of vfs files are covered by 'wlock'
                 #
                 # exclude special files
                 for prefix in self._wlockfreeprefix:
                     if path.startswith(prefix):
                         return
                 repo.ui.develwarn('write with no wlock: "%s"' % path,
                                   stacklevel=3, config='check-locks')
             return ret
         return checkvfs
 
     def _getsvfsward(self, origfunc):
         """build a ward for self.svfs"""
         rref = weakref.ref(self)
         def checksvfs(path, mode=None):
             ret = origfunc(path, mode=mode)
             repo = rref()
             if repo is None or not util.safehasattr(repo, '_lockref'):
                 return
             if mode in (None, 'r', 'rb'):
                 return
             if path.startswith(repo.sharedpath):
                 # truncate name relative to the repository (.hg)
                 path = path[len(repo.sharedpath) + 1:]
             if repo._currentlock(repo._lockref) is None:
                 repo.ui.develwarn('write with no lock: "%s"' % path,
                                   stacklevel=4)
             return ret
         return checksvfs
 
     def close(self):
         self._writecaches()
 
     def _writecaches(self):
         if self._revbranchcache:
             self._revbranchcache.write()
 
     def _restrictcapabilities(self, caps):
         if self.ui.configbool('experimental', 'bundle2-advertise'):
             caps = set(caps)
             capsblob = bundle2.encodecaps(bundle2.getrepocaps(self,
                                                               role='client'))
             caps.add('bundle2=' + urlreq.quote(capsblob))
         return caps
 
     def _writerequirements(self):
         scmutil.writerequires(self.vfs, self.requirements)
 
     # Don't cache auditor/nofsauditor, or you'll end up with reference cycle:
     # self -> auditor -> self._checknested -> self
 
     @property
     def auditor(self):
         # This is only used by context.workingctx.match in order to
         # detect files in subrepos.
         return pathutil.pathauditor(self.root, callback=self._checknested)
 
     @property
     def nofsauditor(self):
         # This is only used by context.basectx.match in order to detect
         # files in subrepos.
         return pathutil.pathauditor(self.root, callback=self._checknested,
                                     realfs=False, cached=True)
 
     def _checknested(self, path):
         """Determine if path is a legal nested repository."""
         if not path.startswith(self.root):
             return False
         subpath = path[len(self.root) + 1:]
         normsubpath = util.pconvert(subpath)
 
         # XXX: Checking against the current working copy is wrong in
         # the sense that it can reject things like
         #
         #   $ hg cat -r 10 sub/x.txt
         #
         # if sub/ is no longer a subrepository in the working copy
         # parent revision.
         #
         # However, it can of course also allow things that would have
         # been rejected before, such as the above cat command if sub/
         # is a subrepository now, but was a normal directory before.
         # The old path auditor would have rejected by mistake since it
         # panics when it sees sub/.hg/.
         #
         # All in all, checking against the working copy seems sensible
         # since we want to prevent access to nested repositories on
         # the filesystem *now*.
         ctx = self[None]
         parts = util.splitpath(subpath)
         while parts:
             prefix = '/'.join(parts)
             if prefix in ctx.substate:
                 if prefix == normsubpath:
                     return True
                 else:
                     sub = ctx.sub(prefix)
                     return sub.checknested(subpath[len(prefix) + 1:])
             else:
                 parts.pop()
         return False
 
     def peer(self):
         return localpeer(self) # not cached to avoid reference cycle
 
     def unfiltered(self):
         """Return unfiltered version of the repository
 
         Intended to be overwritten by filtered repo."""
         return self
 
     def filtered(self, name, visibilityexceptions=None):
         """Return a filtered version of a repository"""
         cls = repoview.newtype(self.unfiltered().__class__)
         return cls(self, name, visibilityexceptions)
 
     @repofilecache('bookmarks', 'bookmarks.current')
     def _bookmarks(self):
         return bookmarks.bmstore(self)
 
     @property
     def _activebookmark(self):
         return self._bookmarks.active
 
     # _phasesets depend on changelog. what we need is to call
     # _phasecache.invalidate() if '00changelog.i' was changed, but it
     # can't be easily expressed in filecache mechanism.
     @storecache('phaseroots', '00changelog.i')
     def _phasecache(self):
         return phases.phasecache(self, self._phasedefaults)
 
     @storecache('obsstore')
     def obsstore(self):
         return obsolete.makestore(self.ui, self)
 
     @storecache('00changelog.i')
     def changelog(self):
         return changelog.changelog(self.svfs,
                                    trypending=txnutil.mayhavepending(self.root))
 
     @storecache('00manifest.i')
     def manifestlog(self):
         rootstore = manifest.manifestrevlog(self.svfs)
         return manifest.manifestlog(self.svfs, self, rootstore,
                                     self._storenarrowmatch)
 
     @repofilecache('dirstate')
     def dirstate(self):
         return self._makedirstate()
 
     def _makedirstate(self):
         """Extension point for wrapping the dirstate per-repo."""
         sparsematchfn = lambda: sparse.matcher(self)
 
         return dirstate.dirstate(self.vfs, self.ui, self.root,
                                  self._dirstatevalidate, sparsematchfn)
 
     def _dirstatevalidate(self, node):
         try:
             self.changelog.rev(node)
             return node
         except error.LookupError:
             if not self._dirstatevalidatewarned:
                 self._dirstatevalidatewarned = True
                 self.ui.warn(_("warning: ignoring unknown"
                                " working parent %s!\n") % short(node))
             return nullid
 
     @storecache(narrowspec.FILENAME)
     def narrowpats(self):
         """matcher patterns for this repository's narrowspec
 
         A tuple of (includes, excludes).
         """
         return narrowspec.load(self)
 
     @storecache(narrowspec.FILENAME)
     def _storenarrowmatch(self):
         if repository.NARROW_REQUIREMENT not in self.requirements:
             return matchmod.always()
         include, exclude = self.narrowpats
         return narrowspec.match(self.root, include=include, exclude=exclude)
 
     @storecache(narrowspec.FILENAME)
     def _narrowmatch(self):
         if repository.NARROW_REQUIREMENT not in self.requirements:
             return matchmod.always()
         narrowspec.checkworkingcopynarrowspec(self)
         include, exclude = self.narrowpats
         return narrowspec.match(self.root, include=include, exclude=exclude)
 
     def narrowmatch(self, match=None, includeexact=False):
         """matcher corresponding the the repo's narrowspec
 
         If `match` is given, then that will be intersected with the narrow
         matcher.
 
         If `includeexact` is True, then any exact matches from `match` will
         be included even if they're outside the narrowspec.
         """
         if match:
             if includeexact and not self._narrowmatch.always():
                 # do not exclude explicitly-specified paths so that they can
                 # be warned later on
                 em = matchmod.exact(match.files())
                 nm = matchmod.unionmatcher([self._narrowmatch, em])
                 return matchmod.intersectmatchers(match, nm)
             return matchmod.intersectmatchers(match, self._narrowmatch)
         return self._narrowmatch
 
     def setnarrowpats(self, newincludes, newexcludes):
         narrowspec.save(self, newincludes, newexcludes)
         self.invalidate(clearfilecache=True)
 
     def __getitem__(self, changeid):
         if changeid is None:
             return context.workingctx(self)
         if isinstance(changeid, context.basectx):
             return changeid
         if isinstance(changeid, slice):
             # wdirrev isn't contiguous so the slice shouldn't include it
             return [self[i]
                     for i in pycompat.xrange(*changeid.indices(len(self)))
                     if i not in self.changelog.filteredrevs]
         try:
             if isinstance(changeid, int):
                 node = self.changelog.node(changeid)
                 rev = changeid
             elif changeid == 'null':
                 node = nullid
                 rev = nullrev
             elif changeid == 'tip':
                 node = self.changelog.tip()
                 rev = self.changelog.rev(node)
             elif changeid == '.':
                 # this is a hack to delay/avoid loading obsmarkers
                 # when we know that '.' won't be hidden
                 node = self.dirstate.p1()
                 rev = self.unfiltered().changelog.rev(node)
             elif len(changeid) == 20:
                 try:
                     node = changeid
                     rev = self.changelog.rev(changeid)
                 except error.FilteredLookupError:
                     changeid = hex(changeid) # for the error message
                     raise
                 except LookupError:
                     # check if it might have come from damaged dirstate
                     #
                     # XXX we could avoid the unfiltered if we had a recognizable
                     # exception for filtered changeset access
                     if (self.local()
                         and changeid in self.unfiltered().dirstate.parents()):
                         msg = _("working directory has unknown parent '%s'!")
                         raise error.Abort(msg % short(changeid))
                     changeid = hex(changeid) # for the error message
                     raise
 
             elif len(changeid) == 40:
                 node = bin(changeid)
                 rev = self.changelog.rev(node)
             else:
                 raise error.ProgrammingError(
                         "unsupported changeid '%s' of type %s" %
                         (changeid, type(changeid)))
 
             return context.changectx(self, rev, node)
 
         except (error.FilteredIndexError, error.FilteredLookupError):
             raise error.FilteredRepoLookupError(_("filtered revision '%s'")
                                                 % pycompat.bytestr(changeid))
         except (IndexError, LookupError):
             raise error.RepoLookupError(
                 _("unknown revision '%s'") % pycompat.bytestr(changeid))
         except error.WdirUnsupported:
             return context.workingctx(self)
 
     def __contains__(self, changeid):
         """True if the given changeid exists
 
         error.AmbiguousPrefixLookupError is raised if an ambiguous node
         specified.
         """
         try:
             self[changeid]
             return True
         except error.RepoLookupError:
             return False
 
     def __nonzero__(self):
         return True
 
     __bool__ = __nonzero__
 
     def __len__(self):
         # no need to pay the cost of repoview.changelog
         unfi = self.unfiltered()
         return len(unfi.changelog)
 
     def __iter__(self):
         return iter(self.changelog)
 
     def revs(self, expr, *args):
         '''Find revisions matching a revset.
 
         The revset is specified as a string ``expr`` that may contain
         %-formatting to escape certain types. See ``revsetlang.formatspec``.
 
         Revset aliases from the configuration are not expanded. To expand
         user aliases, consider calling ``scmutil.revrange()`` or
         ``repo.anyrevs([expr], user=True)``.
 
         Returns a revset.abstractsmartset, which is a list-like interface
         that contains integer revisions.
         '''
         tree = revsetlang.spectree(expr, *args)
         return revset.makematcher(tree)(self)
 
     def set(self, expr, *args):
         '''Find revisions matching a revset and emit changectx instances.
 
         This is a convenience wrapper around ``revs()`` that iterates the
         result and is a generator of changectx instances.
 
         Revset aliases from the configuration are not expanded. To expand
         user aliases, consider calling ``scmutil.revrange()``.
         '''
         for r in self.revs(expr, *args):
             yield self[r]
 
     def anyrevs(self, specs, user=False, localalias=None):
         '''Find revisions matching one of the given revsets.
 
         Revset aliases from the configuration are not expanded by default. To
         expand user aliases, specify ``user=True``. To provide some local
         definitions overriding user aliases, set ``localalias`` to
         ``{name: definitionstring}``.
         '''
         if user:
             m = revset.matchany(self.ui, specs,
                                 lookup=revset.lookupfn(self),
                                 localalias=localalias)
         else:
             m = revset.matchany(None, specs, localalias=localalias)
         return m(self)
 
     def url(self):
         return 'file:' + self.root
 
     def hook(self, name, throw=False, **args):
         """Call a hook, passing this repo instance.
 
         This a convenience method to aid invoking hooks. Extensions likely
         won't call this unless they have registered a custom hook or are
         replacing code that is expected to call a hook.
         """
         return hook.hook(self.ui, self, name, throw, **args)
 
     @filteredpropertycache
     def _tagscache(self):
         '''Returns a tagscache object that contains various tags related
         caches.'''
 
         # This simplifies its cache management by having one decorated
         # function (this one) and the rest simply fetch things from it.
         class tagscache(object):
             def __init__(self):
                 # These two define the set of tags for this repository. tags
                 # maps tag name to node; tagtypes maps tag name to 'global' or
                 # 'local'. (Global tags are defined by .hgtags across all
                 # heads, and local tags are defined in .hg/localtags.)
                 # They constitute the in-memory cache of tags.
                 self.tags = self.tagtypes = None
 
                 self.nodetagscache = self.tagslist = None
 
         cache = tagscache()
         cache.tags, cache.tagtypes = self._findtags()
 
         return cache
 
     def tags(self):
         '''return a mapping of tag to node'''
         t = {}
         if self.changelog.filteredrevs:
             tags, tt = self._findtags()
         else:
             tags = self._tagscache.tags
         rev = self.changelog.rev
         for k, v in tags.iteritems():
             try:
                 # ignore tags to unknown nodes
                 rev(v)
                 t[k] = v
             except (error.LookupError, ValueError):
                 pass
         return t
 
     def _findtags(self):
         '''Do the hard work of finding tags.  Return a pair of dicts
         (tags, tagtypes) where tags maps tag name to node, and tagtypes
         maps tag name to a string like \'global\' or \'local\'.
         Subclasses or extensions are free to add their own tags, but
         should be aware that the returned dicts will be retained for the
         duration of the localrepo object.'''
 
         # XXX what tagtype should subclasses/extensions use?  Currently
         # mq and bookmarks add tags, but do not set the tagtype at all.
         # Should each extension invent its own tag type?  Should there
         # be one tagtype for all such "virtual" tags?  Or is the status
         # quo fine?
 
 
         # map tag name to (node, hist)
         alltags = tagsmod.findglobaltags(self.ui, self)
         # map tag name to tag type
         tagtypes = dict((tag, 'global') for tag in alltags)
 
         tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
 
         # Build the return dicts.  Have to re-encode tag names because
         # the tags module always uses UTF-8 (in order not to lose info
         # writing to the cache), but the rest of Mercurial wants them in
         # local encoding.
         tags = {}
         for (name, (node, hist)) in alltags.iteritems():
             if node != nullid:
                 tags[encoding.tolocal(name)] = node
         tags['tip'] = self.changelog.tip()
         tagtypes = dict([(encoding.tolocal(name), value)
                          for (name, value) in tagtypes.iteritems()])
         return (tags, tagtypes)
 
     def tagtype(self, tagname):
         '''
         return the type of the given tag. result can be:
 
         'local'  : a local tag
         'global' : a global tag
         None     : tag does not exist
         '''
 
         return self._tagscache.tagtypes.get(tagname)
 
     def tagslist(self):
         '''return a list of tags ordered by revision'''
         if not self._tagscache.tagslist:
             l = []
             for t, n in self.tags().iteritems():
                 l.append((self.changelog.rev(n), t, n))
             self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
 
         return self._tagscache.tagslist
 
     def nodetags(self, node):
         '''return the tags associated with a node'''
         if not self._tagscache.nodetagscache:
             nodetagscache = {}
             for t, n in self._tagscache.tags.iteritems():
                 nodetagscache.setdefault(n, []).append(t)
             for tags in nodetagscache.itervalues():
                 tags.sort()
             self._tagscache.nodetagscache = nodetagscache
         return self._tagscache.nodetagscache.get(node, [])
 
     def nodebookmarks(self, node):
         """return the list of bookmarks pointing to the specified node"""
         return self._bookmarks.names(node)
 
     def branchmap(self):
         '''returns a dictionary {branch: [branchheads]} with branchheads
         ordered by increasing revision number'''
         return self._branchcaches[self]
 
     @unfilteredmethod
     def revbranchcache(self):
         if not self._revbranchcache:
             self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
         return self._revbranchcache
 
     def branchtip(self, branch, ignoremissing=False):
         '''return the tip node for a given branch
 
         If ignoremissing is True, then this method will not raise an error.
         This is helpful for callers that only expect None for a missing branch
         (e.g. namespace).
 
         '''
         try:
             return self.branchmap().branchtip(branch)
         except KeyError:
             if not ignoremissing:
                 raise error.RepoLookupError(_("unknown branch '%s'") % branch)
             else:
                 pass
 
     def lookup(self, key):
         return scmutil.revsymbol(self, key).node()
 
     def lookupbranch(self, key):
-        if key in self.branchmap().entries:
+        if self.branchmap().hasbranch(key):
             return key
 
         return scmutil.revsymbol(self, key).branch()
 
     def known(self, nodes):
         cl = self.changelog
         nm = cl.nodemap
         filtered = cl.filteredrevs
         result = []
         for n in nodes:
             r = nm.get(n)
             resp = not (r is None or r in filtered)
             result.append(resp)
         return result
 
     def local(self):
         return self
 
     def publishing(self):
         # it's safe (and desirable) to trust the publish flag unconditionally
         # so that we don't finalize changes shared between users via ssh or nfs
         return self.ui.configbool('phases', 'publish', untrusted=True)
 
     def cancopy(self):
         # so statichttprepo's override of local() works
         if not self.local():
             return False
         if not self.publishing():
             return True
         # if publishing we can't copy if there is filtered content
         return not self.filtered('visible').changelog.filteredrevs
 
     def shared(self):
         '''the type of shared repository (None if not shared)'''
         if self.sharedpath != self.path:
             return 'store'
         return None
 
     def wjoin(self, f, *insidef):
         return self.vfs.reljoin(self.root, f, *insidef)
 
     def setparents(self, p1, p2=nullid):
         with self.dirstate.parentchange():
             copies = self.dirstate.setparents(p1, p2)
             pctx = self[p1]
             if copies:
                 # Adjust copy records, the dirstate cannot do it, it
                 # requires access to parents manifests. Preserve them
                 # only for entries added to first parent.
                 for f in copies:
                     if f not in pctx and copies[f] in pctx:
                         self.dirstate.copy(copies[f], f)
             if p2 == nullid:
                 for f, s in sorted(self.dirstate.copies().items()):
                     if f not in pctx and s not in pctx:
                         self.dirstate.copy(None, f)
 
     def filectx(self, path, changeid=None, fileid=None, changectx=None):
         """changeid must be a changeset revision, if specified.
            fileid can be a file revision or node."""
         return context.filectx(self, path, changeid, fileid,
                                changectx=changectx)
 
     def getcwd(self):
         return self.dirstate.getcwd()
 
     def pathto(self, f, cwd=None):
         return self.dirstate.pathto(f, cwd)
 
     def _loadfilter(self, filter):
         if filter not in self._filterpats:
             l = []
             for pat, cmd in self.ui.configitems(filter):
                 if cmd == '!':
                     continue
                 mf = matchmod.match(self.root, '', [pat])
                 fn = None
                 params = cmd
                 for name, filterfn in self._datafilters.iteritems():
                     if cmd.startswith(name):
                         fn = filterfn
                         params = cmd[len(name):].lstrip()
                         break
                 if not fn:
                     fn = lambda s, c, **kwargs: procutil.filter(s, c)
                 # Wrap old filters not supporting keyword arguments
                 if not pycompat.getargspec(fn)[2]:
                     oldfn = fn
                     fn = lambda s, c, **kwargs: oldfn(s, c)
                 l.append((mf, fn, params))
             self._filterpats[filter] = l
         return self._filterpats[filter]
 
     def _filter(self, filterpats, filename, data):
         for mf, fn, cmd in filterpats:
             if mf(filename):
                 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
                 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
                 break
 
         return data
 
     @unfilteredpropertycache
     def _encodefilterpats(self):
         return self._loadfilter('encode')
 
     @unfilteredpropertycache
     def _decodefilterpats(self):
         return self._loadfilter('decode')
 
     def adddatafilter(self, name, filter):
         self._datafilters[name] = filter
 
     def wread(self, filename):
         if self.wvfs.islink(filename):
             data = self.wvfs.readlink(filename)
         else:
             data = self.wvfs.read(filename)
         return self._filter(self._encodefilterpats, filename, data)
 
     def wwrite(self, filename, data, flags, backgroundclose=False, **kwargs):
         """write ``data`` into ``filename`` in the working directory
 
         This returns length of written (maybe decoded) data.
         """
         data = self._filter(self._decodefilterpats, filename, data)
         if 'l' in flags:
             self.wvfs.symlink(data, filename)
         else:
             self.wvfs.write(filename, data, backgroundclose=backgroundclose,
                             **kwargs)
             if 'x' in flags:
                 self.wvfs.setflags(filename, False, True)
             else:
                 self.wvfs.setflags(filename, False, False)
         return len(data)
 
     def wwritedata(self, filename, data):
         return self._filter(self._decodefilterpats, filename, data)
 
     def currenttransaction(self):
         """return the current transaction or None if non exists"""
         if self._transref:
             tr = self._transref()
         else:
             tr = None
 
         if tr and tr.running():
             return tr
         return None
 
     def transaction(self, desc, report=None):
         if (self.ui.configbool('devel', 'all-warnings')
                 or self.ui.configbool('devel', 'check-locks')):
             if self._currentlock(self._lockref) is None:
                 raise error.ProgrammingError('transaction requires locking')
         tr = self.currenttransaction()
         if tr is not None:
             return tr.nest(name=desc)
 
         # abort here if the journal already exists
         if self.svfs.exists("journal"):
             raise error.RepoError(
                 _("abandoned transaction found"),
                 hint=_("run 'hg recover' to clean up transaction"))
 
         idbase = "%.40f#%f" % (random.random(), time.time())
         ha = hex(hashlib.sha1(idbase).digest())
         txnid = 'TXN:' + ha
         self.hook('pretxnopen', throw=True, txnname=desc, txnid=txnid)
 
         self._writejournal(desc)
         renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
         if report:
             rp = report
         else:
             rp = self.ui.warn
         vfsmap = {'plain': self.vfs, 'store': self.svfs} # root of .hg/
         # we must avoid cyclic reference between repo and transaction.
         reporef = weakref.ref(self)
         # Code to track tag movement
         #
         # Since tags are all handled as file content, it is actually quite hard
         # to track these movement from a code perspective. So we fallback to a
         # tracking at the repository level. One could envision to track changes
         # to the '.hgtags' file through changegroup apply but that fails to
         # cope with case where transaction expose new heads without changegroup
         # being involved (eg: phase movement).
         #
         # For now, We gate the feature behind a flag since this likely comes
         # with performance impacts. The current code run more often than needed
         # and do not use caches as much as it could.  The current focus is on
         # the behavior of the feature so we disable it by default. The flag
         # will be removed when we are happy with the performance impact.
         #
         # Once this feature is no longer experimental move the following
         # documentation to the appropriate help section:
         #
         # The ``HG_TAG_MOVED`` variable will be set if the transaction touched
         # tags (new or changed or deleted tags). In addition the details of
         # these changes are made available in a file at:
         #     ``REPOROOT/.hg/changes/tags.changes``.
         # Make sure you check for HG_TAG_MOVED before reading that file as it
         # might exist from a previous transaction even if no tag were touched
         # in this one. Changes are recorded in a line base format::
         #
         #     <action> <hex-node> <tag-name>\n
         #
         # Actions are defined as follow:
         #   "-R": tag is removed,
         #   "+A": tag is added,
         #   "-M": tag is moved (old value),
         #   "+M": tag is moved (new value),
         tracktags = lambda x: None
         # experimental config: experimental.hook-track-tags
         shouldtracktags = self.ui.configbool('experimental', 'hook-track-tags')
         if desc != 'strip' and shouldtracktags:
             oldheads = self.changelog.headrevs()
             def tracktags(tr2):
                 repo = reporef()
                 oldfnodes = tagsmod.fnoderevs(repo.ui, repo, oldheads)
                 newheads = repo.changelog.headrevs()
                 newfnodes = tagsmod.fnoderevs(repo.ui, repo, newheads)
                 # notes: we compare lists here.
                 # As we do it only once buiding set would not be cheaper
                 changes = tagsmod.difftags(repo.ui, repo, oldfnodes, newfnodes)
                 if changes:
                     tr2.hookargs['tag_moved'] = '1'
                     with repo.vfs('changes/tags.changes', 'w',
                                   atomictemp=True) as changesfile:
                         # note: we do not register the file to the transaction
                         # because we needs it to still exist on the transaction
                         # is close (for txnclose hooks)
                         tagsmod.writediff(changesfile, changes)
         def validate(tr2):
             """will run pre-closing hooks"""
             # XXX the transaction API is a bit lacking here so we take a hacky
             # path for now
             #
             # We cannot add this as a "pending" hooks since the 'tr.hookargs'
             # dict is copied before these run. In addition we needs the data
             # available to in memory hooks too.
             #
             # Moreover, we also need to make sure this runs before txnclose
             # hooks and there is no "pending" mechanism that would execute
             # logic only if hooks are about to run.
             #
             # Fixing this limitation of the transaction is also needed to track
             # other families of changes (bookmarks, phases, obsolescence).
             #
             # This will have to be fixed before we remove the experimental
             # gating.
             tracktags(tr2)
             repo = reporef()
             if repo.ui.configbool('experimental', 'single-head-per-branch'):
                 scmutil.enforcesinglehead(repo, tr2, desc)
             if hook.hashook(repo.ui, 'pretxnclose-bookmark'):
                 for name, (old, new) in sorted(tr.changes['bookmarks'].items()):
                     args = tr.hookargs.copy()
                     args.update(bookmarks.preparehookargs(name, old, new))
                     repo.hook('pretxnclose-bookmark', throw=True,
                               **pycompat.strkwargs(args))
             if hook.hashook(repo.ui, 'pretxnclose-phase'):
                 cl = repo.unfiltered().changelog
                 for rev, (old, new) in tr.changes['phases'].items():
                     args = tr.hookargs.copy()
                     node = hex(cl.node(rev))
                     args.update(phases.preparehookargs(node, old, new))
                     repo.hook('pretxnclose-phase', throw=True,
                               **pycompat.strkwargs(args))
 
             repo.hook('pretxnclose', throw=True,
                       **pycompat.strkwargs(tr.hookargs))
         def releasefn(tr, success):
             repo = reporef()
             if success:
                 # this should be explicitly invoked here, because
                 # in-memory changes aren't written out at closing
                 # transaction, if tr.addfilegenerator (via
                 # dirstate.write or so) isn't invoked while
                 # transaction running
                 repo.dirstate.write(None)
             else:
                 # discard all changes (including ones already written
                 # out) in this transaction
                 narrowspec.restorebackup(self, 'journal.narrowspec')
                 narrowspec.restorewcbackup(self, 'journal.narrowspec.dirstate')
                 repo.dirstate.restorebackup(None, 'journal.dirstate')
 
                 repo.invalidate(clearfilecache=True)
 
         tr = transaction.transaction(rp, self.svfs, vfsmap,
                                      "journal",
                                      "undo",
                                      aftertrans(renames),
                                      self.store.createmode,
                                      validator=validate,
                                      releasefn=releasefn,
                                      checkambigfiles=_cachedfiles,
                                      name=desc)
         tr.changes['origrepolen'] = len(self)
         tr.changes['obsmarkers'] = set()
         tr.changes['phases'] = {}
         tr.changes['bookmarks'] = {}
 
         tr.hookargs['txnid'] = txnid
         tr.hookargs['txnname'] = desc
         # note: writing the fncache only during finalize mean that the file is
         # outdated when running hooks. As fncache is used for streaming clone,
         # this is not expected to break anything that happen during the hooks.
         tr.addfinalize('flush-fncache', self.store.write)
         def txnclosehook(tr2):
             """To be run if transaction is successful, will schedule a hook run
             """
             # Don't reference tr2 in hook() so we don't hold a reference.
             # This reduces memory consumption when there are multiple
             # transactions per lock. This can likely go away if issue5045
             # fixes the function accumulation.
             hookargs = tr2.hookargs
 
             def hookfunc():
                 repo = reporef()
                 if hook.hashook(repo.ui, 'txnclose-bookmark'):
                     bmchanges = sorted(tr.changes['bookmarks'].items())
                     for name, (old, new) in bmchanges:
                         args = tr.hookargs.copy()
                         args.update(bookmarks.preparehookargs(name, old, new))
                         repo.hook('txnclose-bookmark', throw=False,
                                   **pycompat.strkwargs(args))
 
                 if hook.hashook(repo.ui, 'txnclose-phase'):
                     cl = repo.unfiltered().changelog
                     phasemv = sorted(tr.changes['phases'].items())
                     for rev, (old, new) in phasemv:
                         args = tr.hookargs.copy()
                         node = hex(cl.node(rev))
                         args.update(phases.preparehookargs(node, old, new))
                         repo.hook('txnclose-phase', throw=False,
                                   **pycompat.strkwargs(args))
 
                 repo.hook('txnclose', throw=False,
                           **pycompat.strkwargs(hookargs))
             reporef()._afterlock(hookfunc)
         tr.addfinalize('txnclose-hook', txnclosehook)
         # Include a leading "-" to make it happen before the transaction summary
         # reports registered via scmutil.registersummarycallback() whose names
         # are 00-txnreport etc. That way, the caches will be warm when the
         # callbacks run.
         tr.addpostclose('-warm-cache', self._buildcacheupdater(tr))
         def txnaborthook(tr2):
             """To be run if transaction is aborted
             """
             reporef().hook('txnabort', throw=False,
                            **pycompat.strkwargs(tr2.hookargs))
         tr.addabort('txnabort-hook', txnaborthook)
         # avoid eager cache invalidation. in-memory data should be identical
         # to stored data if transaction has no error.
         tr.addpostclose('refresh-filecachestats', self._refreshfilecachestats)
         self._transref = weakref.ref(tr)
         scmutil.registersummarycallback(self, tr, desc)
         return tr
 
     def _journalfiles(self):
         return ((self.svfs, 'journal'),
                 (self.svfs, 'journal.narrowspec'),
                 (self.vfs, 'journal.narrowspec.dirstate'),
                 (self.vfs, 'journal.dirstate'),
                 (self.vfs, 'journal.branch'),
                 (self.vfs, 'journal.desc'),
                 (self.vfs, 'journal.bookmarks'),
                 (self.svfs, 'journal.phaseroots'))
 
     def undofiles(self):
         return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
 
     @unfilteredmethod
     def _writejournal(self, desc):
         self.dirstate.savebackup(None, 'journal.dirstate')
         narrowspec.savewcbackup(self, 'journal.narrowspec.dirstate')
         narrowspec.savebackup(self, 'journal.narrowspec')
         self.vfs.write("journal.branch",
                           encoding.fromlocal(self.dirstate.branch()))
         self.vfs.write("journal.desc",
                           "%d\n%s\n" % (len(self), desc))
         self.vfs.write("journal.bookmarks",
                           self.vfs.tryread("bookmarks"))
         self.svfs.write("journal.phaseroots",
                            self.svfs.tryread("phaseroots"))
 
     def recover(self):
         with self.lock():
             if self.svfs.exists("journal"):
                 self.ui.status(_("rolling back interrupted transaction\n"))
                 vfsmap = {'': self.svfs,
                           'plain': self.vfs,}
                 transaction.rollback(self.svfs, vfsmap, "journal",
                                      self.ui.warn,
                                      checkambigfiles=_cachedfiles)
                 self.invalidate()
                 return True
             else:
                 self.ui.warn(_("no interrupted transaction available\n"))
                 return False
 
     def rollback(self, dryrun=False, force=False):
         wlock = lock = dsguard = None
         try:
             wlock = self.wlock()
             lock = self.lock()
             if self.svfs.exists("undo"):
                 dsguard = dirstateguard.dirstateguard(self, 'rollback')
 
                 return self._rollback(dryrun, force, dsguard)
             else:
                 self.ui.warn(_("no rollback information available\n"))
                 return 1
         finally:
             release(dsguard, lock, wlock)
 
     @unfilteredmethod # Until we get smarter cache management
     def _rollback(self, dryrun, force, dsguard):
         ui = self.ui
         try:
             args = self.vfs.read('undo.desc').splitlines()
             (oldlen, desc, detail) = (int(args[0]), args[1], None)
             if len(args) >= 3:
                 detail = args[2]
             oldtip = oldlen - 1
 
             if detail and ui.verbose:
                 msg = (_('repository tip rolled back to revision %d'
                          ' (undo %s: %s)\n')
                        % (oldtip, desc, detail))
             else:
                 msg = (_('repository tip rolled back to revision %d'
                          ' (undo %s)\n')
                        % (oldtip, desc))
         except IOError:
             msg = _('rolling back unknown transaction\n')
             desc = None
 
         if not force and self['.'] != self['tip'] and desc == 'commit':
             raise error.Abort(
                 _('rollback of last commit while not checked out '
                   'may lose data'), hint=_('use -f to force'))
 
         ui.status(msg)
         if dryrun:
             return 0
 
         parents = self.dirstate.parents()
         self.destroying()
         vfsmap = {'plain': self.vfs, '': self.svfs}
         transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn,
                              checkambigfiles=_cachedfiles)
         if self.vfs.exists('undo.bookmarks'):
             self.vfs.rename('undo.bookmarks', 'bookmarks', checkambig=True)
         if self.svfs.exists('undo.phaseroots'):
             self.svfs.rename('undo.phaseroots', 'phaseroots', checkambig=True)
         self.invalidate()
 
         parentgone = any(p not in self.changelog.nodemap for p in parents)
         if parentgone:
             # prevent dirstateguard from overwriting already restored one
             dsguard.close()
 
             narrowspec.restorebackup(self, 'undo.narrowspec')
             narrowspec.restorewcbackup(self, 'undo.narrowspec.dirstate')
             self.dirstate.restorebackup(None, 'undo.dirstate')
             try:
                 branch = self.vfs.read('undo.branch')
                 self.dirstate.setbranch(encoding.tolocal(branch))
             except IOError:
                 ui.warn(_('named branch could not be reset: '
                           'current branch is still \'%s\'\n')
                         % self.dirstate.branch())
 
             parents = tuple([p.rev() for p in self[None].parents()])
             if len(parents) > 1:
                 ui.status(_('working directory now based on '
                             'revisions %d and %d\n') % parents)
             else:
                 ui.status(_('working directory now based on '
                             'revision %d\n') % parents)
             mergemod.mergestate.clean(self, self['.'].node())
 
         # TODO: if we know which new heads may result from this rollback, pass
         # them to destroy(), which will prevent the branchhead cache from being
         # invalidated.
         self.destroyed()
         return 0
 
     def _buildcacheupdater(self, newtransaction):
         """called during transaction to build the callback updating cache
 
         Lives on the repository to help extension who might want to augment
         this logic. For this purpose, the created transaction is passed to the
         method.
         """
         # we must avoid cyclic reference between repo and transaction.
         reporef = weakref.ref(self)
         def updater(tr):
             repo = reporef()
             repo.updatecaches(tr)
         return updater
 
     @unfilteredmethod
     def updatecaches(self, tr=None, full=False):
         """warm appropriate caches
 
         If this function is called after a transaction closed. The transaction
         will be available in the 'tr' argument. This can be used to selectively
         update caches relevant to the changes in that transaction.
 
         If 'full' is set, make sure all caches the function knows about have
         up-to-date data. Even the ones usually loaded more lazily.
         """
         if tr is not None and tr.hookargs.get('source') == 'strip':
             # During strip, many caches are invalid but
             # later call to `destroyed` will refresh them.
             return
 
         if tr is None or tr.changes['origrepolen'] < len(self):
             # accessing the 'ser ved' branchmap should refresh all the others,
             self.ui.debug('updating the branch cache\n')
             self.filtered('served').branchmap()
 
         if full:
             unfi = self.unfiltered()
             rbc = unfi.revbranchcache()
             for r in unfi.changelog:
                 rbc.branchinfo(r)
             rbc.write()
 
             # ensure the working copy parents are in the manifestfulltextcache
             for ctx in self['.'].parents():
                 ctx.manifest()  # accessing the manifest is enough
 
             # accessing tags warm the cache
             self.tags()
             self.filtered('served').tags()
 
     def invalidatecaches(self):
 
         if r'_tagscache' in vars(self):
             # can't use delattr on proxy
             del self.__dict__[r'_tagscache']
 
         self._branchcaches.clear()
         self.invalidatevolatilesets()
         self._sparsesignaturecache.clear()
 
     def invalidatevolatilesets(self):
         self.filteredrevcache.clear()
         obsolete.clearobscaches(self)
 
     def invalidatedirstate(self):
         '''Invalidates the dirstate, causing the next call to dirstate
         to check if it was modified since the last time it was read,
         rereading it if it has.
 
         This is different to dirstate.invalidate() that it doesn't always
         rereads the dirstate. Use dirstate.invalidate() if you want to
         explicitly read the dirstate again (i.e. restoring it to a previous
         known good state).'''
         if hasunfilteredcache(self, r'dirstate'):
             for k in self.dirstate._filecache:
                 try:
                     delattr(self.dirstate, k)
                 except AttributeError:
                     pass
             delattr(self.unfiltered(), r'dirstate')
 
     def invalidate(self, clearfilecache=False):
         '''Invalidates both store and non-store parts other than dirstate
 
         If a transaction is running, invalidation of store is omitted,
         because discarding in-memory changes might cause inconsistency
         (e.g. incomplete fncache causes unintentional failure, but
         redundant one doesn't).
         '''
         unfiltered = self.unfiltered() # all file caches are stored unfiltered
         for k in list(self._filecache.keys()):
             # dirstate is invalidated separately in invalidatedirstate()
             if k == 'dirstate':
                 continue
             if (k == 'changelog' and
                 self.currenttransaction() and
                 self.changelog._delayed):
                 # The changelog object may store unwritten revisions. We don't
                 # want to lose them.
                 # TODO: Solve the problem instead of working around it.
                 continue
 
             if clearfilecache:
                 del self._filecache[k]
             try:
                 delattr(unfiltered, k)
             except AttributeError:
                 pass
         self.invalidatecaches()
         if not self.currenttransaction():
             # TODO: Changing contents of store outside transaction
             # causes inconsistency. We should make in-memory store
             # changes detectable, and abort if changed.
             self.store.invalidatecaches()
 
     def invalidateall(self):
         '''Fully invalidates both store and non-store parts, causing the
         subsequent operation to reread any outside changes.'''
         # extension should hook this to invalidate its caches
         self.invalidate()
         self.invalidatedirstate()
 
     @unfilteredmethod
     def _refreshfilecachestats(self, tr):
         """Reload stats of cached files so that they are flagged as valid"""
         for k, ce in self._filecache.items():
             k = pycompat.sysstr(k)
             if k == r'dirstate' or k not in self.__dict__:
                 continue
             ce.refresh()
 
     def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc,
               inheritchecker=None, parentenvvar=None):
         parentlock = None
         # the contents of parentenvvar are used by the underlying lock to
         # determine whether it can be inherited
         if parentenvvar is not None:
             parentlock = encoding.environ.get(parentenvvar)
 
         timeout = 0
         warntimeout = 0
         if wait:
             timeout = self.ui.configint("ui", "timeout")
             warntimeout = self.ui.configint("ui", "timeout.warn")
         # internal config: ui.signal-safe-lock
         signalsafe = self.ui.configbool('ui', 'signal-safe-lock')
 
         l = lockmod.trylock(self.ui, vfs, lockname, timeout, warntimeout,
                             releasefn=releasefn,
                             acquirefn=acquirefn, desc=desc,
                             inheritchecker=inheritchecker,
                             parentlock=parentlock,
                             signalsafe=signalsafe)
         return l
 
     def _afterlock(self, callback):
         """add a callback to be run when the repository is fully unlocked
 
         The callback will be executed when the outermost lock is released
         (with wlock being higher level than 'lock')."""
         for ref in (self._wlockref, self._lockref):
             l = ref and ref()
             if l and l.held:
                 l.postrelease.append(callback)
                 break
         else: # no lock have been found.
             callback()
 
     def lock(self, wait=True):
         '''Lock the repository store (.hg/store) and return a weak reference
         to the lock. Use this before modifying the store (e.g. committing or
         stripping). If you are opening a transaction, get a lock as well.)
 
         If both 'lock' and 'wlock' must be acquired, ensure you always acquires
         'wlock' first to avoid a dead-lock hazard.'''
         l = self._currentlock(self._lockref)
         if l is not None:
             l.lock()
             return l
 
         l = self._lock(vfs=self.svfs,
                        lockname="lock",
                        wait=wait,
                        releasefn=None,
                        acquirefn=self.invalidate,
                        desc=_('repository %s') % self.origroot)
         self._lockref = weakref.ref(l)
         return l
 
     def _wlockchecktransaction(self):
         if self.currenttransaction() is not None:
             raise error.LockInheritanceContractViolation(
                 'wlock cannot be inherited in the middle of a transaction')
 
     def wlock(self, wait=True):
         '''Lock the non-store parts of the repository (everything under
         .hg except .hg/store) and return a weak reference to the lock.
 
         Use this before modifying files in .hg.
 
         If both 'lock' and 'wlock' must be acquired, ensure you always acquires
         'wlock' first to avoid a dead-lock hazard.'''
         l = self._wlockref and self._wlockref()
         if l is not None and l.held:
             l.lock()
             return l
 
         # We do not need to check for non-waiting lock acquisition.  Such
         # acquisition would not cause dead-lock as they would just fail.
         if wait and (self.ui.configbool('devel', 'all-warnings')
                      or self.ui.configbool('devel', 'check-locks')):
             if self._currentlock(self._lockref) is not None:
                 self.ui.develwarn('"wlock" acquired after "lock"')
 
         def unlock():
             if self.dirstate.pendingparentchange():
                 self.dirstate.invalidate()
             else:
                 self.dirstate.write(None)
 
             self._filecache['dirstate'].refresh()
 
         l = self._lock(self.vfs, "wlock", wait, unlock,
                        self.invalidatedirstate, _('working directory of %s') %
                        self.origroot,
                        inheritchecker=self._wlockchecktransaction,
                        parentenvvar='HG_WLOCK_LOCKER')
         self._wlockref = weakref.ref(l)
         return l
 
     def _currentlock(self, lockref):
         """Returns the lock if it's held, or None if it's not."""
         if lockref is None:
             return None
         l = lockref()
         if l is None or not l.held:
             return None
         return l
 
     def currentwlock(self):
         """Returns the wlock if it's held, or None if it's not."""
         return self._currentlock(self._wlockref)
 
     def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
         """
         commit an individual file as part of a larger transaction
         """
 
         fname = fctx.path()
         fparent1 = manifest1.get(fname, nullid)
         fparent2 = manifest2.get(fname, nullid)
         if isinstance(fctx, context.filectx):
             node = fctx.filenode()
             if node in [fparent1, fparent2]:
                 self.ui.debug('reusing %s filelog entry\n' % fname)
                 if manifest1.flags(fname) != fctx.flags():
                     changelist.append(fname)
                 return node
 
         flog = self.file(fname)
         meta = {}
         cfname = fctx.copysource()
         if cfname and cfname != fname:
             # Mark the new revision of this file as a copy of another
             # file.  This copy data will effectively act as a parent
             # of this new revision.  If this is a merge, the first
             # parent will be the nullid (meaning "look up the copy data")
             # and the second one will be the other parent.  For example:
             #
             # 0 --- 1 --- 3   rev1 changes file foo
             #   \       /     rev2 renames foo to bar and changes it
             #    \- 2 -/      rev3 should have bar with all changes and
             #                      should record that bar descends from
             #                      bar in rev2 and foo in rev1
             #
             # this allows this merge to succeed:
             #
             # 0 --- 1 --- 3   rev4 reverts the content change from rev2
             #   \       /     merging rev3 and rev4 should use bar@rev2
             #    \- 2 --- 4        as the merge base
             #
 
             crev = manifest1.get(cfname)
             newfparent = fparent2
 
             if manifest2: # branch merge
                 if fparent2 == nullid or crev is None: # copied on remote side
                     if cfname in manifest2:
                         crev = manifest2[cfname]
                         newfparent = fparent1
 
             # Here, we used to search backwards through history to try to find
             # where the file copy came from if the source of a copy was not in
             # the parent directory. However, this doesn't actually make sense to
             # do (what does a copy from something not in your working copy even
             # mean?) and it causes bugs (eg, issue4476). Instead, we will warn
             # the user that copy information was dropped, so if they didn't
             # expect this outcome it can be fixed, but this is the correct
             # behavior in this circumstance.
 
             if crev:
                 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
                 meta["copy"] = cfname
                 meta["copyrev"] = hex(crev)
                 fparent1, fparent2 = nullid, newfparent
             else:
                 self.ui.warn(_("warning: can't find ancestor for '%s' "
                                "copied from '%s'!\n") % (fname, cfname))
 
         elif fparent1 == nullid:
             fparent1, fparent2 = fparent2, nullid
         elif fparent2 != nullid:
             # is one parent an ancestor of the other?
             fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
             if fparent1 in fparentancestors:
                 fparent1, fparent2 = fparent2, nullid
             elif fparent2 in fparentancestors:
                 fparent2 = nullid
 
         # is the file changed?
         text = fctx.data()
         if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
             changelist.append(fname)
             return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
         # are just the flags changed during merge?
         elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
             changelist.append(fname)
 
         return fparent1
 
     def checkcommitpatterns(self, wctx, vdirs, match, status, fail):
         """check for commit arguments that aren't committable"""
         if match.isexact() or match.prefix():
             matched = set(status.modified + status.added + status.removed)
 
             for f in match.files():
                 f = self.dirstate.normalize(f)
                 if f == '.' or f in matched or f in wctx.substate:
                     continue
                 if f in status.deleted:
                     fail(f, _('file not found!'))
                 if f in vdirs: # visited directory
                     d = f + '/'
                     for mf in matched:
                         if mf.startswith(d):
                             break
                     else:
                         fail(f, _("no match under directory!"))
                 elif f not in self.dirstate:
                     fail(f, _("file not tracked!"))
 
     @unfilteredmethod
     def commit(self, text="", user=None, date=None, match=None, force=False,
                editor=False, extra=None):
         """Add a new revision to current repository.
 
         Revision information is gathered from the working directory,
         match can be used to filter the committed files. If editor is
         supplied, it is called to get a commit message.
         """
         if extra is None:
             extra = {}
 
         def fail(f, msg):
             raise error.Abort('%s: %s' % (f, msg))
 
         if not match:
             match = matchmod.always()
 
         if not force:
             vdirs = []
             match.explicitdir = vdirs.append
             match.bad = fail
 
         # lock() for recent changelog (see issue4368)
         with self.wlock(), self.lock():
             wctx = self[None]
             merge = len(wctx.parents()) > 1
 
             if not force and merge and not match.always():
                 raise error.Abort(_('cannot partially commit a merge '
                                    '(do not specify files or patterns)'))
 
             status = self.status(match=match, clean=force)
             if force:
                 status.modified.extend(status.clean) # mq may commit clean files
 
             # check subrepos
             subs, commitsubs, newstate = subrepoutil.precommit(
                 self.ui, wctx, status, match, force=force)
 
             # make sure all explicit patterns are matched
             if not force:
                 self.checkcommitpatterns(wctx, vdirs, match, status, fail)
 
             cctx = context.workingcommitctx(self, status,
                                             text, user, date, extra)
 
             # internal config: ui.allowemptycommit
             allowemptycommit = (wctx.branch() != wctx.p1().branch()
                                 or extra.get('close') or merge or cctx.files()
                                 or self.ui.configbool('ui', 'allowemptycommit'))
             if not allowemptycommit:
                 return None
 
             if merge and cctx.deleted():
                 raise error.Abort(_("cannot commit merge with missing files"))
 
             ms = mergemod.mergestate.read(self)
             mergeutil.checkunresolved(ms)
 
             if editor:
                 cctx._text = editor(self, cctx, subs)
             edited = (text != cctx._text)
 
             # Save commit message in case this transaction gets rolled back
             # (e.g. by a pretxncommit hook).  Leave the content alone on
             # the assumption that the user will use the same editor again.
             msgfn = self.savecommitmessage(cctx._text)
 
             # commit subs and write new state
             if subs:
                 uipathfn = scmutil.getuipathfn(self)
                 for s in sorted(commitsubs):
                     sub = wctx.sub(s)
                     self.ui.status(_('committing subrepository %s\n') %
                                    uipathfn(subrepoutil.subrelpath(sub)))
                     sr = sub.commit(cctx._text, user, date)
                     newstate[s] = (newstate[s][0], sr)
                 subrepoutil.writestate(self, newstate)
 
             p1, p2 = self.dirstate.parents()
             hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
             try:
                 self.hook("precommit", throw=True, parent1=hookp1,
                           parent2=hookp2)
                 with self.transaction('commit'):
                     ret = self.commitctx(cctx, True)
                     # update bookmarks, dirstate and mergestate
                     bookmarks.update(self, [p1, p2], ret)
                     cctx.markcommitted(ret)
                     ms.reset()
             except: # re-raises
                 if edited:
                     self.ui.write(
                         _('note: commit message saved in %s\n') % msgfn)
                 raise
 
         def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
             # hack for command that use a temporary commit (eg: histedit)
             # temporary commit got stripped before hook release
             if self.changelog.hasnode(ret):
                 self.hook("commit", node=node, parent1=parent1,
                           parent2=parent2)
         self._afterlock(commithook)
         return ret
 
     @unfilteredmethod
     def commitctx(self, ctx, error=False):
         """Add a new revision to current repository.
         Revision information is passed via the context argument.
 
         ctx.files() should list all files involved in this commit, i.e.
         modified/added/removed files. On merge, it may be wider than the
         ctx.files() to be committed, since any file nodes derived directly
         from p1 or p2 are excluded from the committed ctx.files().
         """
 
         p1, p2 = ctx.p1(), ctx.p2()
         user = ctx.user()
 
         with self.lock(), self.transaction("commit") as tr:
             trp = weakref.proxy(tr)
 
             if ctx.manifestnode():
                 # reuse an existing manifest revision
                 self.ui.debug('reusing known manifest\n')
                 mn = ctx.manifestnode()
                 files = ctx.files()
             elif ctx.files():
                 m1ctx = p1.manifestctx()
                 m2ctx = p2.manifestctx()
                 mctx = m1ctx.copy()
 
                 m = mctx.read()
                 m1 = m1ctx.read()
                 m2 = m2ctx.read()
 
                 # check in files
                 added = []
                 changed = []
                 removed = list(ctx.removed())
                 linkrev = len(self)
                 self.ui.note(_("committing files:\n"))
                 uipathfn = scmutil.getuipathfn(self)
                 for f in sorted(ctx.modified() + ctx.added()):
                     self.ui.note(uipathfn(f) + "\n")
                     try:
                         fctx = ctx[f]
                         if fctx is None:
                             removed.append(f)
                         else:
                             added.append(f)
                             m[f] = self._filecommit(fctx, m1, m2, linkrev,
                                                     trp, changed)
                             m.setflag(f, fctx.flags())
                     except OSError:
                         self.ui.warn(_("trouble committing %s!\n") %
                                      uipathfn(f))
                         raise
                     except IOError as inst:
                         errcode = getattr(inst, 'errno', errno.ENOENT)
                         if error or errcode and errcode != errno.ENOENT:
                             self.ui.warn(_("trouble committing %s!\n") %
                                          uipathfn(f))
                         raise
 
                 # update manifest
                 removed = [f for f in sorted(removed) if f in m1 or f in m2]
                 drop = [f for f in removed if f in m]
                 for f in drop:
                     del m[f]
                 files = changed + removed
                 md = None
                 if not files:
                     # if no "files" actually changed in terms of the changelog,
                     # try hard to detect unmodified manifest entry so that the
                     # exact same commit can be reproduced later on convert.
                     md = m1.diff(m, scmutil.matchfiles(self, ctx.files()))
                 if not files and md:
                     self.ui.debug('not reusing manifest (no file change in '
                                   'changelog, but manifest differs)\n')
                 if files or md:
                     self.ui.note(_("committing manifest\n"))
                     # we're using narrowmatch here since it's already applied at
                     # other stages (such as dirstate.walk), so we're already
                     # ignoring things outside of narrowspec in most cases. The
                     # one case where we might have files outside the narrowspec
                     # at this point is merges, and we already error out in the
                     # case where the merge has files outside of the narrowspec,
                     # so this is safe.
                     mn = mctx.write(trp, linkrev,
                                     p1.manifestnode(), p2.manifestnode(),
                                     added, drop, match=self.narrowmatch())
                 else:
                     self.ui.debug('reusing manifest form p1 (listed files '
                                   'actually unchanged)\n')
                     mn = p1.manifestnode()
             else:
                 self.ui.debug('reusing manifest from p1 (no file change)\n')
                 mn = p1.manifestnode()
                 files = []
 
             # update changelog
             self.ui.note(_("committing changelog\n"))
             self.changelog.delayupdate(tr)
             n = self.changelog.add(mn, files, ctx.description(),
                                    trp, p1.node(), p2.node(),
                                    user, ctx.date(), ctx.extra().copy())
             xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
             self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
                       parent2=xp2)
             # set the new commit is proper phase
             targetphase = subrepoutil.newcommitphase(self.ui, ctx)
             if targetphase:
                 # retract boundary do not alter parent changeset.
                 # if a parent have higher the resulting phase will
                 # be compliant anyway
                 #
                 # if minimal phase was 0 we don't need to retract anything
                 phases.registernew(self, tr, targetphase, [n])
             return n
 
     @unfilteredmethod
     def destroying(self):
         '''Inform the repository that nodes are about to be destroyed.
         Intended for use by strip and rollback, so there's a common
         place for anything that has to be done before destroying history.
 
         This is mostly useful for saving state that is in memory and waiting
         to be flushed when the current lock is released. Because a call to
         destroyed is imminent, the repo will be invalidated causing those
         changes to stay in memory (waiting for the next unlock), or vanish
         completely.
         '''
         # When using the same lock to commit and strip, the phasecache is left
         # dirty after committing. Then when we strip, the repo is invalidated,
         # causing those changes to disappear.
         if '_phasecache' in vars(self):
             self._phasecache.write()
 
     @unfilteredmethod
     def destroyed(self):
         '''Inform the repository that nodes have been destroyed.
         Intended for use by strip and rollback, so there's a common
         place for anything that has to be done after destroying history.
         '''
         # When one tries to:
         # 1) destroy nodes thus calling this method (e.g. strip)
         # 2) use phasecache somewhere (e.g. commit)
         #
         # then 2) will fail because the phasecache contains nodes that were
         # removed. We can either remove phasecache from the filecache,
         # causing it to reload next time it is accessed, or simply filter
         # the removed nodes now and write the updated cache.
         self._phasecache.filterunknown(self)
         self._phasecache.write()
 
         # refresh all repository caches
         self.updatecaches()
 
         # Ensure the persistent tag cache is updated.  Doing it now
         # means that the tag cache only has to worry about destroyed
         # heads immediately after a strip/rollback.  That in turn
         # guarantees that "cachetip == currenttip" (comparing both rev
         # and node) always means no nodes have been added or destroyed.
 
         # XXX this is suboptimal when qrefresh'ing: we strip the current
         # head, refresh the tag cache, then immediately add a new head.
         # But I think doing it this way is necessary for the "instant
         # tag cache retrieval" case to work.
         self.invalidate()
 
     def status(self, node1='.', node2=None, match=None,
                ignored=False, clean=False, unknown=False,
                listsubrepos=False):
         '''a convenience method that calls node1.status(node2)'''
         return self[node1].status(node2, match, ignored, clean, unknown,
                                   listsubrepos)
 
     def addpostdsstatus(self, ps):
         """Add a callback to run within the wlock, at the point at which status
         fixups happen.
 
         On status completion, callback(wctx, status) will be called with the
         wlock held, unless the dirstate has changed from underneath or the wlock
         couldn't be grabbed.
 
         Callbacks should not capture and use a cached copy of the dirstate --
         it might change in the meanwhile. Instead, they should access the
         dirstate via wctx.repo().dirstate.
 
         This list is emptied out after each status run -- extensions should
         make sure it adds to this list each time dirstate.status is called.
         Extensions should also make sure they don't call this for statuses
         that don't involve the dirstate.
         """
 
         # The list is located here for uniqueness reasons -- it is actually
         # managed by the workingctx, but that isn't unique per-repo.
         self._postdsstatus.append(ps)
 
     def postdsstatus(self):
         """Used by workingctx to get the list of post-dirstate-status hooks."""
         return self._postdsstatus
 
     def clearpostdsstatus(self):
         """Used by workingctx to clear post-dirstate-status hooks."""
         del self._postdsstatus[:]
 
     def heads(self, start=None):
         if start is None:
             cl = self.changelog
             headrevs = reversed(cl.headrevs())
             return [cl.node(rev) for rev in headrevs]
 
         heads = self.changelog.heads(start)
         # sort the output in rev descending order
         return sorted(heads, key=self.changelog.rev, reverse=True)
 
     def branchheads(self, branch=None, start=None, closed=False):
         '''return a (possibly filtered) list of heads for the given branch
 
         Heads are returned in topological order, from newest to oldest.
         If branch is None, use the dirstate branch.
         If start is not None, return only heads reachable from start.
         If closed is True, return heads that are marked as closed as well.
         '''
         if branch is None:
             branch = self[None].branch()
         branches = self.branchmap()
-        if branch not in branches.entries:
+        if not branches.hasbranch(branch):
             return []
         # the cache returns heads ordered lowest to highest
         bheads = list(reversed(branches.branchheads(branch, closed=closed)))
         if start is not None:
             # filter out the heads that cannot be reached from startrev
             fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
             bheads = [h for h in bheads if h in fbheads]
         return bheads
 
     def branches(self, nodes):
         if not nodes:
             nodes = [self.changelog.tip()]
         b = []
         for n in nodes:
             t = n
             while True:
                 p = self.changelog.parents(n)
                 if p[1] != nullid or p[0] == nullid:
                     b.append((t, n, p[0], p[1]))
                     break
                 n = p[0]
         return b
 
     def between(self, pairs):
         r = []
 
         for top, bottom in pairs:
             n, l, i = top, [], 0
             f = 1
 
             while n != bottom and n != nullid:
                 p = self.changelog.parents(n)[0]
                 if i == f:
                     l.append(n)
                     f = f * 2
                 n = p
                 i += 1
 
             r.append(l)
 
         return r
 
     def checkpush(self, pushop):
         """Extensions can override this function if additional checks have
         to be performed before pushing, or call it if they override push
         command.
         """
 
     @unfilteredpropertycache
     def prepushoutgoinghooks(self):
         """Return util.hooks consists of a pushop with repo, remote, outgoing
         methods, which are called before pushing changesets.
         """
         return util.hooks()
 
     def pushkey(self, namespace, key, old, new):
         try:
             tr = self.currenttransaction()
             hookargs = {}
             if tr is not None:
                 hookargs.update(tr.hookargs)
             hookargs = pycompat.strkwargs(hookargs)
             hookargs[r'namespace'] = namespace
             hookargs[r'key'] = key
             hookargs[r'old'] = old
             hookargs[r'new'] = new
             self.hook('prepushkey', throw=True, **hookargs)
         except error.HookAbort as exc:
             self.ui.write_err(_("pushkey-abort: %s\n") % exc)
             if exc.hint:
                 self.ui.write_err(_("(%s)\n") % exc.hint)
             return False
         self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
         ret = pushkey.push(self, namespace, key, old, new)
         def runhook():
             self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
                       ret=ret)
         self._afterlock(runhook)
         return ret
 
     def listkeys(self, namespace):
         self.hook('prelistkeys', throw=True, namespace=namespace)
         self.ui.debug('listing keys for "%s"\n' % namespace)
         values = pushkey.list(self, namespace)
         self.hook('listkeys', namespace=namespace, values=values)
         return values
 
     def debugwireargs(self, one, two, three=None, four=None, five=None):
         '''used to test argument passing over the wire'''
         return "%s %s %s %s %s" % (one, two, pycompat.bytestr(three),
                                    pycompat.bytestr(four),
                                    pycompat.bytestr(five))
 
     def savecommitmessage(self, text):
         fp = self.vfs('last-message.txt', 'wb')
         try:
             fp.write(text)
         finally:
             fp.close()
         return self.pathto(fp.name[len(self.root) + 1:])
 
 # used to avoid circular references so destructors work
 def aftertrans(files):
     renamefiles = [tuple(t) for t in files]
     def a():
         for vfs, src, dest in renamefiles:
             # if src and dest refer to a same file, vfs.rename is a no-op,
             # leaving both src and dest on disk. delete dest to make sure
             # the rename couldn't be such a no-op.
             vfs.tryunlink(dest)
             try:
                 vfs.rename(src, dest)
             except OSError: # journal file does not yet exist
                 pass
     return a
 
 def undoname(fn):
     base, name = os.path.split(fn)
     assert name.startswith('journal')
     return os.path.join(base, name.replace('journal', 'undo', 1))
 
 def instance(ui, path, create, intents=None, createopts=None):
     localpath = util.urllocalpath(path)
     if create:
         createrepository(ui, localpath, createopts=createopts)
 
     return makelocalrepository(ui, localpath, intents=intents)
 
 def islocal(path):
     return True
 
 def defaultcreateopts(ui, createopts=None):
     """Populate the default creation options for a repository.
 
     A dictionary of explicitly requested creation options can be passed
     in. Missing keys will be populated.
     """
     createopts = dict(createopts or {})
 
     if 'backend' not in createopts:
         # experimental config: storage.new-repo-backend
         createopts['backend'] = ui.config('storage', 'new-repo-backend')
 
     return createopts
 
 def newreporequirements(ui, createopts):
     """Determine the set of requirements for a new local repository.
 
     Extensions can wrap this function to specify custom requirements for
     new repositories.
     """
     # If the repo is being created from a shared repository, we copy
     # its requirements.
     if 'sharedrepo' in createopts:
         requirements = set(createopts['sharedrepo'].requirements)
         if createopts.get('sharedrelative'):
             requirements.add('relshared')
         else:
             requirements.add('shared')
 
         return requirements
 
     if 'backend' not in createopts:
         raise error.ProgrammingError('backend key not present in createopts; '
                                      'was defaultcreateopts() called?')
 
     if createopts['backend'] != 'revlogv1':
         raise error.Abort(_('unable to determine repository requirements for '
                             'storage backend: %s') % createopts['backend'])
 
     requirements = {'revlogv1'}
     if ui.configbool('format', 'usestore'):
         requirements.add('store')
         if ui.configbool('format', 'usefncache'):
             requirements.add('fncache')
             if ui.configbool('format', 'dotencode'):
                 requirements.add('dotencode')
 
     compengine = ui.config('experimental', 'format.compression')
     if compengine not in util.compengines:
         raise error.Abort(_('compression engine %s defined by '
                             'experimental.format.compression not available') %
                           compengine,
                           hint=_('run "hg debuginstall" to list available '
                                  'compression engines'))
 
     # zlib is the historical default and doesn't need an explicit requirement.
     if compengine != 'zlib':
         requirements.add('exp-compression-%s' % compengine)
 
     if scmutil.gdinitconfig(ui):
         requirements.add('generaldelta')
         if ui.configbool('format', 'sparse-revlog'):
             requirements.add(SPARSEREVLOG_REQUIREMENT)
     if ui.configbool('experimental', 'treemanifest'):
         requirements.add('treemanifest')
 
     revlogv2 = ui.config('experimental', 'revlogv2')
     if revlogv2 == 'enable-unstable-format-and-corrupt-my-data':
         requirements.remove('revlogv1')
         # generaldelta is implied by revlogv2.
         requirements.discard('generaldelta')
         requirements.add(REVLOGV2_REQUIREMENT)
     # experimental config: format.internal-phase
     if ui.configbool('format', 'internal-phase'):
         requirements.add('internal-phase')
 
     if createopts.get('narrowfiles'):
         requirements.add(repository.NARROW_REQUIREMENT)
 
     if createopts.get('lfs'):
         requirements.add('lfs')
 
     return requirements
 
 def filterknowncreateopts(ui, createopts):
     """Filters a dict of repo creation options against options that are known.
 
     Receives a dict of repo creation options and returns a dict of those
     options that we don't know how to handle.
 
     This function is called as part of repository creation. If the
     returned dict contains any items, repository creation will not
     be allowed, as it means there was a request to create a repository
     with options not recognized by loaded code.
 
     Extensions can wrap this function to filter out creation options
     they know how to handle.
     """
     known = {
         'backend',
         'lfs',
         'narrowfiles',
         'sharedrepo',
         'sharedrelative',
         'shareditems',
         'shallowfilestore',
     }
 
     return {k: v for k, v in createopts.items() if k not in known}
 
 def createrepository(ui, path, createopts=None):
     """Create a new repository in a vfs.
 
     ``path`` path to the new repo's working directory.
     ``createopts`` options for the new repository.
 
     The following keys for ``createopts`` are recognized:
 
     backend
        The storage backend to use.
     lfs
        Repository will be created with ``lfs`` requirement. The lfs extension
        will automatically be loaded when the repository is accessed.
     narrowfiles
        Set up repository to support narrow file storage.
     sharedrepo
        Repository object from which storage should be shared.
     sharedrelative
        Boolean indicating if the path to the shared repo should be
        stored as relative. By default, the pointer to the "parent" repo
        is stored as an absolute path.
     shareditems
        Set of items to share to the new repository (in addition to storage).
     shallowfilestore
        Indicates that storage for files should be shallow (not all ancestor
        revisions are known).
     """
     createopts = defaultcreateopts(ui, createopts=createopts)
 
     unknownopts = filterknowncreateopts(ui, createopts)
 
     if not isinstance(unknownopts, dict):
         raise error.ProgrammingError('filterknowncreateopts() did not return '
                                      'a dict')
 
     if unknownopts:
         raise error.Abort(_('unable to create repository because of unknown '
                             'creation option: %s') %
                           ', '.join(sorted(unknownopts)),
                           hint=_('is a required extension not loaded?'))
 
     requirements = newreporequirements(ui, createopts=createopts)
 
     wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
 
     hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg'))
     if hgvfs.exists():
         raise error.RepoError(_('repository %s already exists') % path)
 
     if 'sharedrepo' in createopts:
         sharedpath = createopts['sharedrepo'].sharedpath
 
         if createopts.get('sharedrelative'):
             try:
                 sharedpath = os.path.relpath(sharedpath, hgvfs.base)
             except (IOError, ValueError) as e:
                 # ValueError is raised on Windows if the drive letters differ
                 # on each path.
                 raise error.Abort(_('cannot calculate relative path'),
                                   hint=stringutil.forcebytestr(e))
 
     if not wdirvfs.exists():
         wdirvfs.makedirs()
 
     hgvfs.makedir(notindexed=True)
     if 'sharedrepo' not in createopts:
         hgvfs.mkdir(b'cache')
     hgvfs.mkdir(b'wcache')
 
     if b'store' in requirements and 'sharedrepo' not in createopts:
         hgvfs.mkdir(b'store')
 
         # We create an invalid changelog outside the store so very old
         # Mercurial versions (which didn't know about the requirements
         # file) encounter an error on reading the changelog. This
         # effectively locks out old clients and prevents them from
         # mucking with a repo in an unknown format.
         #
         # The revlog header has version 2, which won't be recognized by
         # such old clients.
         hgvfs.append(b'00changelog.i',
                      b'\0\0\0\2 dummy changelog to prevent using the old repo '
                      b'layout')
 
     scmutil.writerequires(hgvfs, requirements)
 
     # Write out file telling readers where to find the shared store.
     if 'sharedrepo' in createopts:
         hgvfs.write(b'sharedpath', sharedpath)
 
     if createopts.get('shareditems'):
         shared = b'\n'.join(sorted(createopts['shareditems'])) + b'\n'
         hgvfs.write(b'shared', shared)
 
 def poisonrepository(repo):
     """Poison a repository instance so it can no longer be used."""
     # Perform any cleanup on the instance.
     repo.close()
 
     # Our strategy is to replace the type of the object with one that
     # has all attribute lookups result in error.
     #
     # But we have to allow the close() method because some constructors
     # of repos call close() on repo references.
     class poisonedrepository(object):
         def __getattribute__(self, item):
             if item == r'close':
                 return object.__getattribute__(self, item)
 
             raise error.ProgrammingError('repo instances should not be used '
                                          'after unshare')
 
         def close(self):
             pass
 
     # We may have a repoview, which intercepts __setattr__. So be sure
     # we operate at the lowest level possible.
     object.__setattr__(repo, r'__class__', poisonedrepository)

mercurial/revset.py

@@ -1,2409 +1,2409 b''
 # revset.py - revision set queries for mercurial
 #
 # Copyright 2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
 
 from .i18n import _
 from . import (
     dagop,
     destutil,
     diffutil,
     encoding,
     error,
     hbisect,
     match as matchmod,
     node,
     obsolete as obsmod,
     obsutil,
     pathutil,
     phases,
     pycompat,
     registrar,
     repoview,
     revsetlang,
     scmutil,
     smartset,
     stack as stackmod,
     util,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 # helpers for processing parsed tree
 getsymbol = revsetlang.getsymbol
 getstring = revsetlang.getstring
 getinteger = revsetlang.getinteger
 getboolean = revsetlang.getboolean
 getlist = revsetlang.getlist
 getintrange = revsetlang.getintrange
 getargs = revsetlang.getargs
 getargsdict = revsetlang.getargsdict
 
 baseset = smartset.baseset
 generatorset = smartset.generatorset
 spanset = smartset.spanset
 fullreposet = smartset.fullreposet
 
 # Constants for ordering requirement, used in getset():
 #
 # If 'define', any nested functions and operations MAY change the ordering of
 # the entries in the set (but if changes the ordering, it MUST ALWAYS change
 # it). If 'follow', any nested functions and operations MUST take the ordering
 # specified by the first operand to the '&' operator.
 #
 # For instance,
 #
 #   X & (Y | Z)
 #   ^   ^^^^^^^
 #   |   follow
 #   define
 #
 # will be evaluated as 'or(y(x()), z(x()))', where 'x()' can change the order
 # of the entries in the set, but 'y()', 'z()' and 'or()' shouldn't.
 #
 # 'any' means the order doesn't matter. For instance,
 #
 #   (X & !Y) | ancestors(Z)
 #         ^              ^
 #         any            any
 #
 # For 'X & !Y', 'X' decides the order and 'Y' is subtracted from 'X', so the
 # order of 'Y' does not matter. For 'ancestors(Z)', Z's order does not matter
 # since 'ancestors' does not care about the order of its argument.
 #
 # Currently, most revsets do not care about the order, so 'define' is
 # equivalent to 'follow' for them, and the resulting order is based on the
 # 'subset' parameter passed down to them:
 #
 #   m = revset.match(...)
 #   m(repo, subset, order=defineorder)
 #           ^^^^^^
 #      For most revsets, 'define' means using the order this subset provides
 #
 # There are a few revsets that always redefine the order if 'define' is
 # specified: 'sort(X)', 'reverse(X)', 'x:y'.
 anyorder = 'any'        # don't care the order, could be even random-shuffled
 defineorder = 'define'  # ALWAYS redefine, or ALWAYS follow the current order
 followorder = 'follow'  # MUST follow the current order
 
 # helpers
 
 def getset(repo, subset, x, order=defineorder):
     if not x:
         raise error.ParseError(_("missing argument"))
     return methods[x[0]](repo, subset, *x[1:], order=order)
 
 def _getrevsource(repo, r):
     extra = repo[r].extra()
     for label in ('source', 'transplant_source', 'rebase_source'):
         if label in extra:
             try:
                 return repo[extra[label]].rev()
             except error.RepoLookupError:
                 pass
     return None
 
 def _sortedb(xs):
     return sorted(pycompat.rapply(pycompat.maybebytestr, xs))
 
 # operator methods
 
 def stringset(repo, subset, x, order):
     if not x:
         raise error.ParseError(_("empty string is not a valid revision"))
     x = scmutil.intrev(scmutil.revsymbol(repo, x))
     if (x in subset
         or x == node.nullrev and isinstance(subset, fullreposet)):
         return baseset([x])
     return baseset()
 
 def rawsmartset(repo, subset, x, order):
     """argument is already a smartset, use that directly"""
     if order == followorder:
         return subset & x
     else:
         return x & subset
 
 def rangeset(repo, subset, x, y, order):
     m = getset(repo, fullreposet(repo), x)
     n = getset(repo, fullreposet(repo), y)
 
     if not m or not n:
         return baseset()
     return _makerangeset(repo, subset, m.first(), n.last(), order)
 
 def rangeall(repo, subset, x, order):
     assert x is None
     return _makerangeset(repo, subset, 0, repo.changelog.tiprev(), order)
 
 def rangepre(repo, subset, y, order):
     # ':y' can't be rewritten to '0:y' since '0' may be hidden
     n = getset(repo, fullreposet(repo), y)
     if not n:
         return baseset()
     return _makerangeset(repo, subset, 0, n.last(), order)
 
 def rangepost(repo, subset, x, order):
     m = getset(repo, fullreposet(repo), x)
     if not m:
         return baseset()
     return _makerangeset(repo, subset, m.first(), repo.changelog.tiprev(),
                          order)
 
 def _makerangeset(repo, subset, m, n, order):
     if m == n:
         r = baseset([m])
     elif n == node.wdirrev:
         r = spanset(repo, m, len(repo)) + baseset([n])
     elif m == node.wdirrev:
         r = baseset([m]) + spanset(repo, repo.changelog.tiprev(), n - 1)
     elif m < n:
         r = spanset(repo, m, n + 1)
     else:
         r = spanset(repo, m, n - 1)
 
     if order == defineorder:
         return r & subset
     else:
         # carrying the sorting over when possible would be more efficient
         return subset & r
 
 def dagrange(repo, subset, x, y, order):
     r = fullreposet(repo)
     xs = dagop.reachableroots(repo, getset(repo, r, x), getset(repo, r, y),
                               includepath=True)
     return subset & xs
 
 def andset(repo, subset, x, y, order):
     if order == anyorder:
         yorder = anyorder
     else:
         yorder = followorder
     return getset(repo, getset(repo, subset, x, order), y, yorder)
 
 def andsmallyset(repo, subset, x, y, order):
     # 'andsmally(x, y)' is equivalent to 'and(x, y)', but faster when y is small
     if order == anyorder:
         yorder = anyorder
     else:
         yorder = followorder
     return getset(repo, getset(repo, subset, y, yorder), x, order)
 
 def differenceset(repo, subset, x, y, order):
     return getset(repo, subset, x, order) - getset(repo, subset, y, anyorder)
 
 def _orsetlist(repo, subset, xs, order):
     assert xs
     if len(xs) == 1:
         return getset(repo, subset, xs[0], order)
     p = len(xs) // 2
     a = _orsetlist(repo, subset, xs[:p], order)
     b = _orsetlist(repo, subset, xs[p:], order)
     return a + b
 
 def orset(repo, subset, x, order):
     xs = getlist(x)
     if not xs:
         return baseset()
     if order == followorder:
         # slow path to take the subset order
         return subset & _orsetlist(repo, fullreposet(repo), xs, anyorder)
     else:
         return _orsetlist(repo, subset, xs, order)
 
 def notset(repo, subset, x, order):
     return subset - getset(repo, subset, x, anyorder)
 
 def relationset(repo, subset, x, y, order):
     raise error.ParseError(_("can't use a relation in this context"))
 
 def _splitrange(a, b):
     """Split range with bounds a and b into two ranges at 0 and return two
     tuples of numbers for use as startdepth and stopdepth arguments of
     revancestors and revdescendants.
 
     >>> _splitrange(-10, -5)     # [-10:-5]
     ((5, 11), (None, None))
     >>> _splitrange(5, 10)       # [5:10]
     ((None, None), (5, 11))
     >>> _splitrange(-10, 10)     # [-10:10]
     ((0, 11), (0, 11))
     >>> _splitrange(-10, 0)      # [-10:0]
     ((0, 11), (None, None))
     >>> _splitrange(0, 10)       # [0:10]
     ((None, None), (0, 11))
     >>> _splitrange(0, 0)        # [0:0]
     ((0, 1), (None, None))
     >>> _splitrange(1, -1)       # [1:-1]
     ((None, None), (None, None))
     """
     ancdepths = (None, None)
     descdepths = (None, None)
     if a == b == 0:
         ancdepths = (0, 1)
     if a < 0:
         ancdepths = (-min(b, 0), -a + 1)
     if b > 0:
         descdepths = (max(a, 0), b + 1)
     return ancdepths, descdepths
 
 def generationsrel(repo, subset, x, rel, z, order):
     # TODO: rewrite tests, and drop startdepth argument from ancestors() and
     # descendants() predicates
     a, b = getintrange(z,
                        _('relation subscript must be an integer or a range'),
                        _('relation subscript bounds must be integers'),
                        deffirst=-(dagop.maxlogdepth - 1),
                        deflast=+(dagop.maxlogdepth - 1))
     (ancstart, ancstop), (descstart, descstop) = _splitrange(a, b)
 
     if ancstart is None and descstart is None:
         return baseset()
 
     revs = getset(repo, fullreposet(repo), x)
     if not revs:
         return baseset()
 
     if ancstart is not None and descstart is not None:
         s = dagop.revancestors(repo, revs, False, ancstart, ancstop)
         s += dagop.revdescendants(repo, revs, False, descstart, descstop)
     elif ancstart is not None:
         s = dagop.revancestors(repo, revs, False, ancstart, ancstop)
     elif descstart is not None:
         s = dagop.revdescendants(repo, revs, False, descstart, descstop)
 
     return subset & s
 
 def relsubscriptset(repo, subset, x, y, z, order):
     # this is pretty basic implementation of 'x#y[z]' operator, still
     # experimental so undocumented. see the wiki for further ideas.
     # https://www.mercurial-scm.org/wiki/RevsetOperatorPlan
     rel = getsymbol(y)
     if rel in subscriptrelations:
         return subscriptrelations[rel](repo, subset, x, rel, z, order)
 
     relnames = [r for r in subscriptrelations.keys() if len(r) > 1]
     raise error.UnknownIdentifier(rel, relnames)
 
 def subscriptset(repo, subset, x, y, order):
     raise error.ParseError(_("can't use a subscript in this context"))
 
 def listset(repo, subset, *xs, **opts):
     raise error.ParseError(_("can't use a list in this context"),
                            hint=_('see \'hg help "revsets.x or y"\''))
 
 def keyvaluepair(repo, subset, k, v, order):
     raise error.ParseError(_("can't use a key-value pair in this context"))
 
 def func(repo, subset, a, b, order):
     f = getsymbol(a)
     if f in symbols:
         func = symbols[f]
         if getattr(func, '_takeorder', False):
             return func(repo, subset, b, order)
         return func(repo, subset, b)
 
     keep = lambda fn: getattr(fn, '__doc__', None) is not None
 
     syms = [s for (s, fn) in symbols.items() if keep(fn)]
     raise error.UnknownIdentifier(f, syms)
 
 # functions
 
 # symbols are callables like:
 #   fn(repo, subset, x)
 # with:
 #   repo - current repository instance
 #   subset - of revisions to be examined
 #   x - argument in tree form
 symbols = revsetlang.symbols
 
 # symbols which can't be used for a DoS attack for any given input
 # (e.g. those which accept regexes as plain strings shouldn't be included)
 # functions that just return a lot of changesets (like all) don't count here
 safesymbols = set()
 
 predicate = registrar.revsetpredicate()
 
 @predicate('_destupdate')
 def _destupdate(repo, subset, x):
     # experimental revset for update destination
     args = getargsdict(x, 'limit', 'clean')
     return subset & baseset([destutil.destupdate(repo,
                             **pycompat.strkwargs(args))[0]])
 
 @predicate('_destmerge')
 def _destmerge(repo, subset, x):
     # experimental revset for merge destination
     sourceset = None
     if x is not None:
         sourceset = getset(repo, fullreposet(repo), x)
     return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])
 
 @predicate('adds(pattern)', safe=True, weight=30)
 def adds(repo, subset, x):
     """Changesets that add a file matching pattern.
 
     The pattern without explicit kind like ``glob:`` is expected to be
     relative to the current directory and match against a file or a
     directory.
     """
     # i18n: "adds" is a keyword
     pat = getstring(x, _("adds requires a pattern"))
     return checkstatus(repo, subset, pat, 1)
 
 @predicate('ancestor(*changeset)', safe=True, weight=0.5)
 def ancestor(repo, subset, x):
     """A greatest common ancestor of the changesets.
 
     Accepts 0 or more changesets.
     Will return empty list when passed no args.
     Greatest common ancestor of a single changeset is that changeset.
     """
     reviter = iter(orset(repo, fullreposet(repo), x, order=anyorder))
     try:
         anc = repo[next(reviter)]
     except StopIteration:
         return baseset()
     for r in reviter:
         anc = anc.ancestor(repo[r])
 
     r = scmutil.intrev(anc)
     if r in subset:
         return baseset([r])
     return baseset()
 
 def _ancestors(repo, subset, x, followfirst=False, startdepth=None,
                stopdepth=None):
     heads = getset(repo, fullreposet(repo), x)
     if not heads:
         return baseset()
     s = dagop.revancestors(repo, heads, followfirst, startdepth, stopdepth)
     return subset & s
 
 @predicate('ancestors(set[, depth])', safe=True)
 def ancestors(repo, subset, x):
     """Changesets that are ancestors of changesets in set, including the
     given changesets themselves.
 
     If depth is specified, the result only includes changesets up to
     the specified generation.
     """
     # startdepth is for internal use only until we can decide the UI
     args = getargsdict(x, 'ancestors', 'set depth startdepth')
     if 'set' not in args:
         # i18n: "ancestors" is a keyword
         raise error.ParseError(_('ancestors takes at least 1 argument'))
     startdepth = stopdepth = None
     if 'startdepth' in args:
         n = getinteger(args['startdepth'],
                        "ancestors expects an integer startdepth")
         if n < 0:
             raise error.ParseError("negative startdepth")
         startdepth = n
     if 'depth' in args:
         # i18n: "ancestors" is a keyword
         n = getinteger(args['depth'], _("ancestors expects an integer depth"))
         if n < 0:
             raise error.ParseError(_("negative depth"))
         stopdepth = n + 1
     return _ancestors(repo, subset, args['set'],
                       startdepth=startdepth, stopdepth=stopdepth)
 
 @predicate('_firstancestors', safe=True)
 def _firstancestors(repo, subset, x):
     # ``_firstancestors(set)``
     # Like ``ancestors(set)`` but follows only the first parents.
     return _ancestors(repo, subset, x, followfirst=True)
 
 def _childrenspec(repo, subset, x, n, order):
     """Changesets that are the Nth child of a changeset
     in set.
     """
     cs = set()
     for r in getset(repo, fullreposet(repo), x):
         for i in range(n):
             c = repo[r].children()
             if len(c) == 0:
                 break
             if len(c) > 1:
                 raise error.RepoLookupError(
                     _("revision in set has more than one child"))
             r = c[0].rev()
         else:
             cs.add(r)
     return subset & cs
 
 def ancestorspec(repo, subset, x, n, order):
     """``set~n``
     Changesets that are the Nth ancestor (first parents only) of a changeset
     in set.
     """
     n = getinteger(n, _("~ expects a number"))
     if n < 0:
         # children lookup
         return _childrenspec(repo, subset, x, -n, order)
     ps = set()
     cl = repo.changelog
     for r in getset(repo, fullreposet(repo), x):
         for i in range(n):
             try:
                 r = cl.parentrevs(r)[0]
             except error.WdirUnsupported:
                 r = repo[r].p1().rev()
         ps.add(r)
     return subset & ps
 
 @predicate('author(string)', safe=True, weight=10)
 def author(repo, subset, x):
     """Alias for ``user(string)``.
     """
     # i18n: "author" is a keyword
     n = getstring(x, _("author requires a string"))
     kind, pattern, matcher = _substringmatcher(n, casesensitive=False)
     return subset.filter(lambda x: matcher(repo[x].user()),
                          condrepr=('<user %r>', n))
 
 @predicate('bisect(string)', safe=True)
 def bisect(repo, subset, x):
     """Changesets marked in the specified bisect status:
 
     - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
     - ``goods``, ``bads``      : csets topologically good/bad
     - ``range``              : csets taking part in the bisection
     - ``pruned``             : csets that are goods, bads or skipped
     - ``untested``           : csets whose fate is yet unknown
     - ``ignored``            : csets ignored due to DAG topology
     - ``current``            : the cset currently being bisected
     """
     # i18n: "bisect" is a keyword
     status = getstring(x, _("bisect requires a string")).lower()
     state = set(hbisect.get(repo, status))
     return subset & state
 
 # Backward-compatibility
 # - no help entry so that we do not advertise it any more
 @predicate('bisected', safe=True)
 def bisected(repo, subset, x):
     return bisect(repo, subset, x)
 
 @predicate('bookmark([name])', safe=True)
 def bookmark(repo, subset, x):
     """The named bookmark or all bookmarks.
 
     Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
     """
     # i18n: "bookmark" is a keyword
     args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
     if args:
         bm = getstring(args[0],
                        # i18n: "bookmark" is a keyword
                        _('the argument to bookmark must be a string'))
         kind, pattern, matcher = stringutil.stringmatcher(bm)
         bms = set()
         if kind == 'literal':
             if bm == pattern:
                 pattern = repo._bookmarks.expandname(pattern)
             bmrev = repo._bookmarks.get(pattern, None)
             if not bmrev:
                 raise error.RepoLookupError(_("bookmark '%s' does not exist")
                                             % pattern)
             bms.add(repo[bmrev].rev())
         else:
             matchrevs = set()
             for name, bmrev in repo._bookmarks.iteritems():
                 if matcher(name):
                     matchrevs.add(bmrev)
             for bmrev in matchrevs:
                 bms.add(repo[bmrev].rev())
     else:
         bms = {repo[r].rev() for r in repo._bookmarks.values()}
     bms -= {node.nullrev}
     return subset & bms
 
 @predicate('branch(string or set)', safe=True, weight=10)
 def branch(repo, subset, x):
     """
     All changesets belonging to the given branch or the branches of the given
     changesets.
 
     Pattern matching is supported for `string`. See
     :hg:`help revisions.patterns`.
     """
     getbi = repo.revbranchcache().branchinfo
     def getbranch(r):
         try:
             return getbi(r)[0]
         except error.WdirUnsupported:
             return repo[r].branch()
 
     try:
         b = getstring(x, '')
     except error.ParseError:
         # not a string, but another revspec, e.g. tip()
         pass
     else:
         kind, pattern, matcher = stringutil.stringmatcher(b)
         if kind == 'literal':
             # note: falls through to the revspec case if no branch with
             # this name exists and pattern kind is not specified explicitly
-            if pattern in repo.branchmap():
+            if repo.branchmap().hasbranch(pattern):
                 return subset.filter(lambda r: matcher(getbranch(r)),
                                      condrepr=('<branch %r>', b))
             if b.startswith('literal:'):
                 raise error.RepoLookupError(_("branch '%s' does not exist")
                                             % pattern)
         else:
             return subset.filter(lambda r: matcher(getbranch(r)),
                                  condrepr=('<branch %r>', b))
 
     s = getset(repo, fullreposet(repo), x)
     b = set()
     for r in s:
         b.add(getbranch(r))
     c = s.__contains__
     return subset.filter(lambda r: c(r) or getbranch(r) in b,
                          condrepr=lambda: '<branch %r>' % _sortedb(b))
 
 @predicate('phasedivergent()', safe=True)
 def phasedivergent(repo, subset, x):
     """Mutable changesets marked as successors of public changesets.
 
     Only non-public and non-obsolete changesets can be `phasedivergent`.
     (EXPERIMENTAL)
     """
     # i18n: "phasedivergent" is a keyword
     getargs(x, 0, 0, _("phasedivergent takes no arguments"))
     phasedivergent = obsmod.getrevs(repo, 'phasedivergent')
     return subset & phasedivergent
 
 @predicate('bundle()', safe=True)
 def bundle(repo, subset, x):
     """Changesets in the bundle.
 
     Bundle must be specified by the -R option."""
 
     try:
         bundlerevs = repo.changelog.bundlerevs
     except AttributeError:
         raise error.Abort(_("no bundle provided - specify with -R"))
     return subset & bundlerevs
 
 def checkstatus(repo, subset, pat, field):
     hasset = matchmod.patkind(pat) == 'set'
 
     mcache = [None]
     def matches(x):
         c = repo[x]
         if not mcache[0] or hasset:
             mcache[0] = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
         m = mcache[0]
         fname = None
         if not m.anypats() and len(m.files()) == 1:
             fname = m.files()[0]
         if fname is not None:
             if fname not in c.files():
                 return False
         else:
             for f in c.files():
                 if m(f):
                     break
             else:
                 return False
         files = repo.status(c.p1().node(), c.node())[field]
         if fname is not None:
             if fname in files:
                 return True
         else:
             for f in files:
                 if m(f):
                     return True
 
     return subset.filter(matches, condrepr=('<status[%r] %r>', field, pat))
 
 def _children(repo, subset, parentset):
     if not parentset:
         return baseset()
     cs = set()
     pr = repo.changelog.parentrevs
     minrev = parentset.min()
     nullrev = node.nullrev
     for r in subset:
         if r <= minrev:
             continue
         p1, p2 = pr(r)
         if p1 in parentset:
             cs.add(r)
         if p2 != nullrev and p2 in parentset:
             cs.add(r)
     return baseset(cs)
 
 @predicate('children(set)', safe=True)
 def children(repo, subset, x):
     """Child changesets of changesets in set.
     """
     s = getset(repo, fullreposet(repo), x)
     cs = _children(repo, subset, s)
     return subset & cs
 
 @predicate('closed()', safe=True, weight=10)
 def closed(repo, subset, x):
     """Changeset is closed.
     """
     # i18n: "closed" is a keyword
     getargs(x, 0, 0, _("closed takes no arguments"))
     return subset.filter(lambda r: repo[r].closesbranch(),
                          condrepr='<branch closed>')
 
 # for internal use
 @predicate('_commonancestorheads(set)', safe=True)
 def _commonancestorheads(repo, subset, x):
     # This is an internal method is for quickly calculating "heads(::x and
     # ::y)"
 
     # These greatest common ancestors are the same ones that the consensus bid
     # merge will find.
     startrevs = getset(repo, fullreposet(repo), x, order=anyorder)
 
     ancs = repo.changelog._commonancestorsheads(*list(startrevs))
     return subset & baseset(ancs)
 
 @predicate('commonancestors(set)', safe=True)
 def commonancestors(repo, subset, x):
     """Changesets that are ancestors of every changeset in set.
     """
     startrevs = getset(repo, fullreposet(repo), x, order=anyorder)
     if not startrevs:
         return baseset()
     for r in startrevs:
         subset &= dagop.revancestors(repo, baseset([r]))
     return subset
 
 @predicate('contains(pattern)', weight=100)
 def contains(repo, subset, x):
     """The revision's manifest contains a file matching pattern (but might not
     modify it). See :hg:`help patterns` for information about file patterns.
 
     The pattern without explicit kind like ``glob:`` is expected to be
     relative to the current directory and match against a file exactly
     for efficiency.
     """
     # i18n: "contains" is a keyword
     pat = getstring(x, _("contains requires a pattern"))
 
     def matches(x):
         if not matchmod.patkind(pat):
             pats = pathutil.canonpath(repo.root, repo.getcwd(), pat)
             if pats in repo[x]:
                 return True
         else:
             c = repo[x]
             m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
             for f in c.manifest():
                 if m(f):
                     return True
         return False
 
     return subset.filter(matches, condrepr=('<contains %r>', pat))
 
 @predicate('converted([id])', safe=True)
 def converted(repo, subset, x):
     """Changesets converted from the given identifier in the old repository if
     present, or all converted changesets if no identifier is specified.
     """
 
     # There is exactly no chance of resolving the revision, so do a simple
     # string compare and hope for the best
 
     rev = None
     # i18n: "converted" is a keyword
     l = getargs(x, 0, 1, _('converted takes one or no arguments'))
     if l:
         # i18n: "converted" is a keyword
         rev = getstring(l[0], _('converted requires a revision'))
 
     def _matchvalue(r):
         source = repo[r].extra().get('convert_revision', None)
         return source is not None and (rev is None or source.startswith(rev))
 
     return subset.filter(lambda r: _matchvalue(r),
                          condrepr=('<converted %r>', rev))
 
 @predicate('date(interval)', safe=True, weight=10)
 def date(repo, subset, x):
     """Changesets within the interval, see :hg:`help dates`.
     """
     # i18n: "date" is a keyword
     ds = getstring(x, _("date requires a string"))
     dm = dateutil.matchdate(ds)
     return subset.filter(lambda x: dm(repo[x].date()[0]),
                          condrepr=('<date %r>', ds))
 
 @predicate('desc(string)', safe=True, weight=10)
 def desc(repo, subset, x):
     """Search commit message for string. The match is case-insensitive.
 
     Pattern matching is supported for `string`. See
     :hg:`help revisions.patterns`.
     """
     # i18n: "desc" is a keyword
     ds = getstring(x, _("desc requires a string"))
 
     kind, pattern, matcher = _substringmatcher(ds, casesensitive=False)
 
     return subset.filter(lambda r: matcher(repo[r].description()),
                          condrepr=('<desc %r>', ds))
 
 def _descendants(repo, subset, x, followfirst=False, startdepth=None,
                  stopdepth=None):
     roots = getset(repo, fullreposet(repo), x)
     if not roots:
         return baseset()
     s = dagop.revdescendants(repo, roots, followfirst, startdepth, stopdepth)
     return subset & s
 
 @predicate('descendants(set[, depth])', safe=True)
 def descendants(repo, subset, x):
     """Changesets which are descendants of changesets in set, including the
     given changesets themselves.
 
     If depth is specified, the result only includes changesets up to
     the specified generation.
     """
     # startdepth is for internal use only until we can decide the UI
     args = getargsdict(x, 'descendants', 'set depth startdepth')
     if 'set' not in args:
         # i18n: "descendants" is a keyword
         raise error.ParseError(_('descendants takes at least 1 argument'))
     startdepth = stopdepth = None
     if 'startdepth' in args:
         n = getinteger(args['startdepth'],
                        "descendants expects an integer startdepth")
         if n < 0:
             raise error.ParseError("negative startdepth")
         startdepth = n
     if 'depth' in args:
         # i18n: "descendants" is a keyword
         n = getinteger(args['depth'], _("descendants expects an integer depth"))
         if n < 0:
             raise error.ParseError(_("negative depth"))
         stopdepth = n + 1
     return _descendants(repo, subset, args['set'],
                         startdepth=startdepth, stopdepth=stopdepth)
 
 @predicate('_firstdescendants', safe=True)
 def _firstdescendants(repo, subset, x):
     # ``_firstdescendants(set)``
     # Like ``descendants(set)`` but follows only the first parents.
     return _descendants(repo, subset, x, followfirst=True)
 
 @predicate('destination([set])', safe=True, weight=10)
 def destination(repo, subset, x):
     """Changesets that were created by a graft, transplant or rebase operation,
     with the given revisions specified as the source.  Omitting the optional set
     is the same as passing all().
     """
     if x is not None:
         sources = getset(repo, fullreposet(repo), x)
     else:
         sources = fullreposet(repo)
 
     dests = set()
 
     # subset contains all of the possible destinations that can be returned, so
     # iterate over them and see if their source(s) were provided in the arg set.
     # Even if the immediate src of r is not in the arg set, src's source (or
     # further back) may be.  Scanning back further than the immediate src allows
     # transitive transplants and rebases to yield the same results as transitive
     # grafts.
     for r in subset:
         src = _getrevsource(repo, r)
         lineage = None
 
         while src is not None:
             if lineage is None:
                 lineage = list()
 
             lineage.append(r)
 
             # The visited lineage is a match if the current source is in the arg
             # set.  Since every candidate dest is visited by way of iterating
             # subset, any dests further back in the lineage will be tested by a
             # different iteration over subset.  Likewise, if the src was already
             # selected, the current lineage can be selected without going back
             # further.
             if src in sources or src in dests:
                 dests.update(lineage)
                 break
 
             r = src
             src = _getrevsource(repo, r)
 
     return subset.filter(dests.__contains__,
                          condrepr=lambda: '<destination %r>' % _sortedb(dests))
 
 @predicate('contentdivergent()', safe=True)
 def contentdivergent(repo, subset, x):
     """
     Final successors of changesets with an alternative set of final
     successors. (EXPERIMENTAL)
     """
     # i18n: "contentdivergent" is a keyword
     getargs(x, 0, 0, _("contentdivergent takes no arguments"))
     contentdivergent = obsmod.getrevs(repo, 'contentdivergent')
     return subset & contentdivergent
 
 @predicate('expectsize(set[, size])', safe=True, takeorder=True)
 def expectsize(repo, subset, x, order):
     """Return the given revset if size matches the revset size.
     Abort if the revset doesn't expect given size.
     size can either be an integer range or an integer.
 
     For example, ``expectsize(0:1, 3:5)`` will abort as revset size is 2 and
     2 is not between 3 and 5 inclusive."""
 
     args = getargsdict(x, 'expectsize', 'set size')
     minsize = 0
     maxsize = len(repo) + 1
     err = ''
     if 'size' not in args or 'set' not in args:
         raise error.ParseError(_('invalid set of arguments'))
     minsize, maxsize = getintrange(args['size'],
                                    _('expectsize requires a size range'
                                      ' or a positive integer'),
                                    _('size range bounds must be integers'),
                                    minsize, maxsize)
     if minsize < 0 or maxsize < 0:
         raise error.ParseError(_('negative size'))
     rev = getset(repo, fullreposet(repo), args['set'], order=order)
     if minsize != maxsize and (len(rev) < minsize or len(rev) > maxsize):
         err = _('revset size mismatch.'
                 ' expected between %d and %d, got %d') % (minsize, maxsize,
                                                           len(rev))
     elif minsize == maxsize and len(rev) != minsize:
         err = _('revset size mismatch.'
                 ' expected %d, got %d') % (minsize, len(rev))
     if err:
         raise error.RepoLookupError(err)
     if order == followorder:
         return subset & rev
     else:
         return rev & subset
 
 @predicate('extdata(source)', safe=False, weight=100)
 def extdata(repo, subset, x):
     """Changesets in the specified extdata source. (EXPERIMENTAL)"""
     # i18n: "extdata" is a keyword
     args = getargsdict(x, 'extdata', 'source')
     source = getstring(args.get('source'),
                        # i18n: "extdata" is a keyword
                        _('extdata takes at least 1 string argument'))
     data = scmutil.extdatasource(repo, source)
     return subset & baseset(data)
 
 @predicate('extinct()', safe=True)
 def extinct(repo, subset, x):
     """Obsolete changesets with obsolete descendants only.
     """
     # i18n: "extinct" is a keyword
     getargs(x, 0, 0, _("extinct takes no arguments"))
     extincts = obsmod.getrevs(repo, 'extinct')
     return subset & extincts
 
 @predicate('extra(label, [value])', safe=True)
 def extra(repo, subset, x):
     """Changesets with the given label in the extra metadata, with the given
     optional value.
 
     Pattern matching is supported for `value`. See
     :hg:`help revisions.patterns`.
     """
     args = getargsdict(x, 'extra', 'label value')
     if 'label' not in args:
         # i18n: "extra" is a keyword
         raise error.ParseError(_('extra takes at least 1 argument'))
     # i18n: "extra" is a keyword
     label = getstring(args['label'], _('first argument to extra must be '
                                        'a string'))
     value = None
 
     if 'value' in args:
         # i18n: "extra" is a keyword
         value = getstring(args['value'], _('second argument to extra must be '
                                            'a string'))
         kind, value, matcher = stringutil.stringmatcher(value)
 
     def _matchvalue(r):
         extra = repo[r].extra()
         return label in extra and (value is None or matcher(extra[label]))
 
     return subset.filter(lambda r: _matchvalue(r),
                          condrepr=('<extra[%r] %r>', label, value))
 
 @predicate('filelog(pattern)', safe=True)
 def filelog(repo, subset, x):
     """Changesets connected to the specified filelog.
 
     For performance reasons, visits only revisions mentioned in the file-level
     filelog, rather than filtering through all changesets (much faster, but
     doesn't include deletes or duplicate changes). For a slower, more accurate
     result, use ``file()``.
 
     The pattern without explicit kind like ``glob:`` is expected to be
     relative to the current directory and match against a file exactly
     for efficiency.
 
     If some linkrev points to revisions filtered by the current repoview, we'll
     work around it to return a non-filtered value.
     """
 
     # i18n: "filelog" is a keyword
     pat = getstring(x, _("filelog requires a pattern"))
     s = set()
     cl = repo.changelog
 
     if not matchmod.patkind(pat):
         f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
         files = [f]
     else:
         m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
         files = (f for f in repo[None] if m(f))
 
     for f in files:
         fl = repo.file(f)
         known = {}
         scanpos = 0
         for fr in list(fl):
             fn = fl.node(fr)
             if fn in known:
                 s.add(known[fn])
                 continue
 
             lr = fl.linkrev(fr)
             if lr in cl:
                 s.add(lr)
             elif scanpos is not None:
                 # lowest matching changeset is filtered, scan further
                 # ahead in changelog
                 start = max(lr, scanpos) + 1
                 scanpos = None
                 for r in cl.revs(start):
                     # minimize parsing of non-matching entries
                     if f in cl.revision(r) and f in cl.readfiles(r):
                         try:
                             # try to use manifest delta fastpath
                             n = repo[r].filenode(f)
                             if n not in known:
                                 if n == fn:
                                     s.add(r)
                                     scanpos = r
                                     break
                                 else:
                                     known[n] = r
                         except error.ManifestLookupError:
                             # deletion in changelog
                             continue
 
     return subset & s
 
 @predicate('first(set, [n])', safe=True, takeorder=True, weight=0)
 def first(repo, subset, x, order):
     """An alias for limit().
     """
     return limit(repo, subset, x, order)
 
 def _follow(repo, subset, x, name, followfirst=False):
     args = getargsdict(x, name, 'file startrev')
     revs = None
     if 'startrev' in args:
         revs = getset(repo, fullreposet(repo), args['startrev'])
     if 'file' in args:
         x = getstring(args['file'], _("%s expected a pattern") % name)
         if revs is None:
             revs = [None]
         fctxs = []
         for r in revs:
             ctx = mctx = repo[r]
             if r is None:
                 ctx = repo['.']
             m = matchmod.match(repo.root, repo.getcwd(), [x],
                                ctx=mctx, default='path')
             fctxs.extend(ctx[f].introfilectx() for f in ctx.manifest().walk(m))
         s = dagop.filerevancestors(fctxs, followfirst)
     else:
         if revs is None:
             revs = baseset([repo['.'].rev()])
         s = dagop.revancestors(repo, revs, followfirst)
 
     return subset & s
 
 @predicate('follow([file[, startrev]])', safe=True)
 def follow(repo, subset, x):
     """
     An alias for ``::.`` (ancestors of the working directory's first parent).
     If file pattern is specified, the histories of files matching given
     pattern in the revision given by startrev are followed, including copies.
     """
     return _follow(repo, subset, x, 'follow')
 
 @predicate('_followfirst', safe=True)
 def _followfirst(repo, subset, x):
     # ``followfirst([file[, startrev]])``
     # Like ``follow([file[, startrev]])`` but follows only the first parent
     # of every revisions or files revisions.
     return _follow(repo, subset, x, '_followfirst', followfirst=True)
 
 @predicate('followlines(file, fromline:toline[, startrev=., descend=False])',
            safe=True)
 def followlines(repo, subset, x):
     """Changesets modifying `file` in line range ('fromline', 'toline').
 
     Line range corresponds to 'file' content at 'startrev' and should hence be
     consistent with file size. If startrev is not specified, working directory's
     parent is used.
 
     By default, ancestors of 'startrev' are returned. If 'descend' is True,
     descendants of 'startrev' are returned though renames are (currently) not
     followed in this direction.
     """
     args = getargsdict(x, 'followlines', 'file *lines startrev descend')
     if len(args['lines']) != 1:
         raise error.ParseError(_("followlines requires a line range"))
 
     rev = '.'
     if 'startrev' in args:
         revs = getset(repo, fullreposet(repo), args['startrev'])
         if len(revs) != 1:
             raise error.ParseError(
                 # i18n: "followlines" is a keyword
                 _("followlines expects exactly one revision"))
         rev = revs.last()
 
     pat = getstring(args['file'], _("followlines requires a pattern"))
     # i18n: "followlines" is a keyword
     msg = _("followlines expects exactly one file")
     fname = scmutil.parsefollowlinespattern(repo, rev, pat, msg)
     fromline, toline = util.processlinerange(
         *getintrange(args['lines'][0],
                      # i18n: "followlines" is a keyword
                      _("followlines expects a line number or a range"),
                      _("line range bounds must be integers")))
 
     fctx = repo[rev].filectx(fname)
     descend = False
     if 'descend' in args:
         descend = getboolean(args['descend'],
                              # i18n: "descend" is a keyword
                              _("descend argument must be a boolean"))
     if descend:
         rs = generatorset(
             (c.rev() for c, _linerange
              in dagop.blockdescendants(fctx, fromline, toline)),
             iterasc=True)
     else:
         rs = generatorset(
             (c.rev() for c, _linerange
              in dagop.blockancestors(fctx, fromline, toline)),
             iterasc=False)
     return subset & rs
 
 @predicate('all()', safe=True)
 def getall(repo, subset, x):
     """All changesets, the same as ``0:tip``.
     """
     # i18n: "all" is a keyword
     getargs(x, 0, 0, _("all takes no arguments"))
     return subset & spanset(repo)  # drop "null" if any
 
 @predicate('grep(regex)', weight=10)
 def grep(repo, subset, x):
     """Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
     to ensure special escape characters are handled correctly. Unlike
     ``keyword(string)``, the match is case-sensitive.
     """
     try:
         # i18n: "grep" is a keyword
         gr = re.compile(getstring(x, _("grep requires a string")))
     except re.error as e:
         raise error.ParseError(
             _('invalid match pattern: %s') % stringutil.forcebytestr(e))
 
     def matches(x):
         c = repo[x]
         for e in c.files() + [c.user(), c.description()]:
             if gr.search(e):
                 return True
         return False
 
     return subset.filter(matches, condrepr=('<grep %r>', gr.pattern))
 
 @predicate('_matchfiles', safe=True)
 def _matchfiles(repo, subset, x):
     # _matchfiles takes a revset list of prefixed arguments:
     #
     #   [p:foo, i:bar, x:baz]
     #
     # builds a match object from them and filters subset. Allowed
     # prefixes are 'p:' for regular patterns, 'i:' for include
     # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
     # a revision identifier, or the empty string to reference the
     # working directory, from which the match object is
     # initialized. Use 'd:' to set the default matching mode, default
     # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
 
     l = getargs(x, 1, -1, "_matchfiles requires at least one argument")
     pats, inc, exc = [], [], []
     rev, default = None, None
     for arg in l:
         s = getstring(arg, "_matchfiles requires string arguments")
         prefix, value = s[:2], s[2:]
         if prefix == 'p:':
             pats.append(value)
         elif prefix == 'i:':
             inc.append(value)
         elif prefix == 'x:':
             exc.append(value)
         elif prefix == 'r:':
             if rev is not None:
                 raise error.ParseError('_matchfiles expected at most one '
                                        'revision')
             if value == '': # empty means working directory
                 rev = node.wdirrev
             else:
                 rev = value
         elif prefix == 'd:':
             if default is not None:
                 raise error.ParseError('_matchfiles expected at most one '
                                        'default mode')
             default = value
         else:
             raise error.ParseError('invalid _matchfiles prefix: %s' % prefix)
     if not default:
         default = 'glob'
     hasset = any(matchmod.patkind(p) == 'set' for p in pats + inc + exc)
 
     mcache = [None]
 
     # This directly read the changelog data as creating changectx for all
     # revisions is quite expensive.
     getfiles = repo.changelog.readfiles
     wdirrev = node.wdirrev
     def matches(x):
         if x == wdirrev:
             files = repo[x].files()
         else:
             files = getfiles(x)
 
         if not mcache[0] or (hasset and rev is None):
             r = x if rev is None else rev
             mcache[0] = matchmod.match(repo.root, repo.getcwd(), pats,
                                        include=inc, exclude=exc, ctx=repo[r],
                                        default=default)
         m = mcache[0]
 
         for f in files:
             if m(f):
                 return True
         return False
 
     return subset.filter(matches,
                          condrepr=('<matchfiles patterns=%r, include=%r '
                                    'exclude=%r, default=%r, rev=%r>',
                                    pats, inc, exc, default, rev))
 
 @predicate('file(pattern)', safe=True, weight=10)
 def hasfile(repo, subset, x):
     """Changesets affecting files matched by pattern.
 
     For a faster but less accurate result, consider using ``filelog()``
     instead.
 
     This predicate uses ``glob:`` as the default kind of pattern.
     """
     # i18n: "file" is a keyword
     pat = getstring(x, _("file requires a pattern"))
     return _matchfiles(repo, subset, ('string', 'p:' + pat))
 
 @predicate('head()', safe=True)
 def head(repo, subset, x):
     """Changeset is a named branch head.
     """
     # i18n: "head" is a keyword
     getargs(x, 0, 0, _("head takes no arguments"))
     hs = set()
     cl = repo.changelog
     for ls in repo.branchmap().iterheads():
         hs.update(cl.rev(h) for h in ls)
     return subset & baseset(hs)
 
 @predicate('heads(set)', safe=True, takeorder=True)
 def heads(repo, subset, x, order):
     """Members of set with no children in set.
     """
     # argument set should never define order
     if order == defineorder:
         order = followorder
     inputset = getset(repo, fullreposet(repo), x, order=order)
     wdirparents = None
     if node.wdirrev in inputset:
         # a bit slower, but not common so good enough for now
         wdirparents = [p.rev() for p in repo[None].parents()]
         inputset = set(inputset)
         inputset.discard(node.wdirrev)
     heads = repo.changelog.headrevs(inputset)
     if wdirparents is not None:
         heads.difference_update(wdirparents)
         heads.add(node.wdirrev)
     heads = baseset(heads)
     return subset & heads
 
 @predicate('hidden()', safe=True)
 def hidden(repo, subset, x):
     """Hidden changesets.
     """
     # i18n: "hidden" is a keyword
     getargs(x, 0, 0, _("hidden takes no arguments"))
     hiddenrevs = repoview.filterrevs(repo, 'visible')
     return subset & hiddenrevs
 
 @predicate('keyword(string)', safe=True, weight=10)
 def keyword(repo, subset, x):
     """Search commit message, user name, and names of changed files for
     string. The match is case-insensitive.
 
     For a regular expression or case sensitive search of these fields, use
     ``grep(regex)``.
     """
     # i18n: "keyword" is a keyword
     kw = encoding.lower(getstring(x, _("keyword requires a string")))
 
     def matches(r):
         c = repo[r]
         return any(kw in encoding.lower(t)
                    for t in c.files() + [c.user(), c.description()])
 
     return subset.filter(matches, condrepr=('<keyword %r>', kw))
 
 @predicate('limit(set[, n[, offset]])', safe=True, takeorder=True, weight=0)
 def limit(repo, subset, x, order):
     """First n members of set, defaulting to 1, starting from offset.
     """
     args = getargsdict(x, 'limit', 'set n offset')
     if 'set' not in args:
         # i18n: "limit" is a keyword
         raise error.ParseError(_("limit requires one to three arguments"))
     # i18n: "limit" is a keyword
     lim = getinteger(args.get('n'), _("limit expects a number"), default=1)
     if lim < 0:
         raise error.ParseError(_("negative number to select"))
     # i18n: "limit" is a keyword
     ofs = getinteger(args.get('offset'), _("limit expects a number"), default=0)
     if ofs < 0:
         raise error.ParseError(_("negative offset"))
     os = getset(repo, fullreposet(repo), args['set'])
     ls = os.slice(ofs, ofs + lim)
     if order == followorder and lim > 1:
         return subset & ls
     return ls & subset
 
 @predicate('last(set, [n])', safe=True, takeorder=True)
 def last(repo, subset, x, order):
     """Last n members of set, defaulting to 1.
     """
     # i18n: "last" is a keyword
     l = getargs(x, 1, 2, _("last requires one or two arguments"))
     lim = 1
     if len(l) == 2:
         # i18n: "last" is a keyword
         lim = getinteger(l[1], _("last expects a number"))
     if lim < 0:
         raise error.ParseError(_("negative number to select"))
     os = getset(repo, fullreposet(repo), l[0])
     os.reverse()
     ls = os.slice(0, lim)
     if order == followorder and lim > 1:
         return subset & ls
     ls.reverse()
     return ls & subset
 
 @predicate('max(set)', safe=True)
 def maxrev(repo, subset, x):
     """Changeset with highest revision number in set.
     """
     os = getset(repo, fullreposet(repo), x)
     try:
         m = os.max()
         if m in subset:
             return baseset([m], datarepr=('<max %r, %r>', subset, os))
     except ValueError:
         # os.max() throws a ValueError when the collection is empty.
         # Same as python's max().
         pass
     return baseset(datarepr=('<max %r, %r>', subset, os))
 
 @predicate('merge()', safe=True)
 def merge(repo, subset, x):
     """Changeset is a merge changeset.
     """
     # i18n: "merge" is a keyword
     getargs(x, 0, 0, _("merge takes no arguments"))
     cl = repo.changelog
     return subset.filter(lambda r: cl.parentrevs(r)[1] != -1,
                          condrepr='<merge>')
 
 @predicate('branchpoint()', safe=True)
 def branchpoint(repo, subset, x):
     """Changesets with more than one child.
     """
     # i18n: "branchpoint" is a keyword
     getargs(x, 0, 0, _("branchpoint takes no arguments"))
     cl = repo.changelog
     if not subset:
         return baseset()
     # XXX this should be 'parentset.min()' assuming 'parentset' is a smartset
     # (and if it is not, it should.)
     baserev = min(subset)
     parentscount = [0]*(len(repo) - baserev)
     for r in cl.revs(start=baserev + 1):
         for p in cl.parentrevs(r):
             if p >= baserev:
                 parentscount[p - baserev] += 1
     return subset.filter(lambda r: parentscount[r - baserev] > 1,
                          condrepr='<branchpoint>')
 
 @predicate('min(set)', safe=True)
 def minrev(repo, subset, x):
     """Changeset with lowest revision number in set.
     """
     os = getset(repo, fullreposet(repo), x)
     try:
         m = os.min()
         if m in subset:
             return baseset([m], datarepr=('<min %r, %r>', subset, os))
     except ValueError:
         # os.min() throws a ValueError when the collection is empty.
         # Same as python's min().
         pass
     return baseset(datarepr=('<min %r, %r>', subset, os))
 
 @predicate('modifies(pattern)', safe=True, weight=30)
 def modifies(repo, subset, x):
     """Changesets modifying files matched by pattern.
 
     The pattern without explicit kind like ``glob:`` is expected to be
     relative to the current directory and match against a file or a
     directory.
     """
     # i18n: "modifies" is a keyword
     pat = getstring(x, _("modifies requires a pattern"))
     return checkstatus(repo, subset, pat, 0)
 
 @predicate('named(namespace)')
 def named(repo, subset, x):
     """The changesets in a given namespace.
 
     Pattern matching is supported for `namespace`. See
     :hg:`help revisions.patterns`.
     """
     # i18n: "named" is a keyword
     args = getargs(x, 1, 1, _('named requires a namespace argument'))
 
     ns = getstring(args[0],
                    # i18n: "named" is a keyword
                    _('the argument to named must be a string'))
     kind, pattern, matcher = stringutil.stringmatcher(ns)
     namespaces = set()
     if kind == 'literal':
         if pattern not in repo.names:
             raise error.RepoLookupError(_("namespace '%s' does not exist")
                                         % ns)
         namespaces.add(repo.names[pattern])
     else:
         for name, ns in repo.names.iteritems():
             if matcher(name):
                 namespaces.add(ns)
 
     names = set()
     for ns in namespaces:
         for name in ns.listnames(repo):
             if name not in ns.deprecated:
                 names.update(repo[n].rev() for n in ns.nodes(repo, name))
 
     names -= {node.nullrev}
     return subset & names
 
 @predicate('id(string)', safe=True)
 def node_(repo, subset, x):
     """Revision non-ambiguously specified by the given hex string prefix.
     """
     # i18n: "id" is a keyword
     l = getargs(x, 1, 1, _("id requires one argument"))
     # i18n: "id" is a keyword
     n = getstring(l[0], _("id requires a string"))
     if len(n) == 40:
         try:
             rn = repo.changelog.rev(node.bin(n))
         except error.WdirUnsupported:
             rn = node.wdirrev
         except (LookupError, TypeError):
             rn = None
     else:
         rn = None
         try:
             pm = scmutil.resolvehexnodeidprefix(repo, n)
             if pm is not None:
                 rn = repo.changelog.rev(pm)
         except LookupError:
             pass
         except error.WdirUnsupported:
             rn = node.wdirrev
 
     if rn is None:
         return baseset()
     result = baseset([rn])
     return result & subset
 
 @predicate('none()', safe=True)
 def none(repo, subset, x):
     """No changesets.
     """
     # i18n: "none" is a keyword
     getargs(x, 0, 0, _("none takes no arguments"))
     return baseset()
 
 @predicate('obsolete()', safe=True)
 def obsolete(repo, subset, x):
     """Mutable changeset with a newer version."""
     # i18n: "obsolete" is a keyword
     getargs(x, 0, 0, _("obsolete takes no arguments"))
     obsoletes = obsmod.getrevs(repo, 'obsolete')
     return subset & obsoletes
 
 @predicate('only(set, [set])', safe=True)
 def only(repo, subset, x):
     """Changesets that are ancestors of the first set that are not ancestors
     of any other head in the repo. If a second set is specified, the result
     is ancestors of the first set that are not ancestors of the second set
     (i.e. ::<set1> - ::<set2>).
     """
     cl = repo.changelog
     # i18n: "only" is a keyword
     args = getargs(x, 1, 2, _('only takes one or two arguments'))
     include = getset(repo, fullreposet(repo), args[0])
     if len(args) == 1:
         if not include:
             return baseset()
 
         descendants = set(dagop.revdescendants(repo, include, False))
         exclude = [rev for rev in cl.headrevs()
             if not rev in descendants and not rev in include]
     else:
         exclude = getset(repo, fullreposet(repo), args[1])
 
     results = set(cl.findmissingrevs(common=exclude, heads=include))
     # XXX we should turn this into a baseset instead of a set, smartset may do
     # some optimizations from the fact this is a baseset.
     return subset & results
 
 @predicate('origin([set])', safe=True)
 def origin(repo, subset, x):
     """
     Changesets that were specified as a source for the grafts, transplants or
     rebases that created the given revisions.  Omitting the optional set is the
     same as passing all().  If a changeset created by these operations is itself
     specified as a source for one of these operations, only the source changeset
     for the first operation is selected.
     """
     if x is not None:
         dests = getset(repo, fullreposet(repo), x)
     else:
         dests = fullreposet(repo)
 
     def _firstsrc(rev):
         src = _getrevsource(repo, rev)
         if src is None:
             return None
 
         while True:
             prev = _getrevsource(repo, src)
 
             if prev is None:
                 return src
             src = prev
 
     o = {_firstsrc(r) for r in dests}
     o -= {None}
     # XXX we should turn this into a baseset instead of a set, smartset may do
     # some optimizations from the fact this is a baseset.
     return subset & o
 
 @predicate('outgoing([path])', safe=False, weight=10)
 def outgoing(repo, subset, x):
     """Changesets not found in the specified destination repository, or the
     default push location.
     """
     # Avoid cycles.
     from . import (
         discovery,
         hg,
     )
     # i18n: "outgoing" is a keyword
     l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
     # i18n: "outgoing" is a keyword
     dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
     if not dest:
         # ui.paths.getpath() explicitly tests for None, not just a boolean
         dest = None
     path = repo.ui.paths.getpath(dest, default=('default-push', 'default'))
     if not path:
         raise error.Abort(_('default repository not configured!'),
                 hint=_("see 'hg help config.paths'"))
     dest = path.pushloc or path.loc
     branches = path.branch, []
 
     revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
     other = hg.peer(repo, {}, dest)
     repo.ui.pushbuffer()
     outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
     repo.ui.popbuffer()
     cl = repo.changelog
     o = {cl.rev(r) for r in outgoing.missing}
     return subset & o
 
 @predicate('p1([set])', safe=True)
 def p1(repo, subset, x):
     """First parent of changesets in set, or the working directory.
     """
     if x is None:
         p = repo[x].p1().rev()
         if p >= 0:
             return subset & baseset([p])
         return baseset()
 
     ps = set()
     cl = repo.changelog
     for r in getset(repo, fullreposet(repo), x):
         try:
             ps.add(cl.parentrevs(r)[0])
         except error.WdirUnsupported:
             ps.add(repo[r].p1().rev())
     ps -= {node.nullrev}
     # XXX we should turn this into a baseset instead of a set, smartset may do
     # some optimizations from the fact this is a baseset.
     return subset & ps
 
 @predicate('p2([set])', safe=True)
 def p2(repo, subset, x):
     """Second parent of changesets in set, or the working directory.
     """
     if x is None:
         ps = repo[x].parents()
         try:
             p = ps[1].rev()
             if p >= 0:
                 return subset & baseset([p])
             return baseset()
         except IndexError:
             return baseset()
 
     ps = set()
     cl = repo.changelog
     for r in getset(repo, fullreposet(repo), x):
         try:
             ps.add(cl.parentrevs(r)[1])
         except error.WdirUnsupported:
             parents = repo[r].parents()
             if len(parents) == 2:
                 ps.add(parents[1])
     ps -= {node.nullrev}
     # XXX we should turn this into a baseset instead of a set, smartset may do
     # some optimizations from the fact this is a baseset.
     return subset & ps
 
 def parentpost(repo, subset, x, order):
     return p1(repo, subset, x)
 
 @predicate('parents([set])', safe=True)
 def parents(repo, subset, x):
     """
     The set of all parents for all changesets in set, or the working directory.
     """
     if x is None:
         ps = set(p.rev() for p in repo[x].parents())
     else:
         ps = set()
         cl = repo.changelog
         up = ps.update
         parentrevs = cl.parentrevs
         for r in getset(repo, fullreposet(repo), x):
             try:
                 up(parentrevs(r))
             except error.WdirUnsupported:
                 up(p.rev() for p in repo[r].parents())
     ps -= {node.nullrev}
     return subset & ps
 
 def _phase(repo, subset, *targets):
     """helper to select all rev in <targets> phases"""
     return repo._phasecache.getrevset(repo, targets, subset)
 
 @predicate('_phase(idx)', safe=True)
 def phase(repo, subset, x):
     l = getargs(x, 1, 1, ("_phase requires one argument"))
     target = getinteger(l[0], ("_phase expects a number"))
     return _phase(repo, subset, target)
 
 @predicate('draft()', safe=True)
 def draft(repo, subset, x):
     """Changeset in draft phase."""
     # i18n: "draft" is a keyword
     getargs(x, 0, 0, _("draft takes no arguments"))
     target = phases.draft
     return _phase(repo, subset, target)
 
 @predicate('secret()', safe=True)
 def secret(repo, subset, x):
     """Changeset in secret phase."""
     # i18n: "secret" is a keyword
     getargs(x, 0, 0, _("secret takes no arguments"))
     target = phases.secret
     return _phase(repo, subset, target)
 
 @predicate('stack([revs])', safe=True)
 def stack(repo, subset, x):
     """Experimental revset for the stack of changesets or working directory
     parent. (EXPERIMENTAL)
     """
     if x is None:
         stacks = stackmod.getstack(repo, x)
     else:
         stacks = smartset.baseset([])
         for revision in getset(repo, fullreposet(repo), x):
             currentstack = stackmod.getstack(repo, revision)
             stacks = stacks + currentstack
 
     return subset & stacks
 
 def parentspec(repo, subset, x, n, order):
     """``set^0``
     The set.
     ``set^1`` (or ``set^``), ``set^2``
     First or second parent, respectively, of all changesets in set.
     """
     try:
         n = int(n[1])
         if n not in (0, 1, 2):
             raise ValueError
     except (TypeError, ValueError):
         raise error.ParseError(_("^ expects a number 0, 1, or 2"))
     ps = set()
     cl = repo.changelog
     for r in getset(repo, fullreposet(repo), x):
         if n == 0:
             ps.add(r)
         elif n == 1:
             try:
                 ps.add(cl.parentrevs(r)[0])
             except error.WdirUnsupported:
                 ps.add(repo[r].p1().rev())
         else:
             try:
                 parents = cl.parentrevs(r)
                 if parents[1] != node.nullrev:
                     ps.add(parents[1])
             except error.WdirUnsupported:
                 parents = repo[r].parents()
                 if len(parents) == 2:
                     ps.add(parents[1].rev())
     return subset & ps
 
 @predicate('present(set)', safe=True, takeorder=True)
 def present(repo, subset, x, order):
     """An empty set, if any revision in set isn't found; otherwise,
     all revisions in set.
 
     If any of specified revisions is not present in the local repository,
     the query is normally aborted. But this predicate allows the query
     to continue even in such cases.
     """
     try:
         return getset(repo, subset, x, order)
     except error.RepoLookupError:
         return baseset()
 
 # for internal use
 @predicate('_notpublic', safe=True)
 def _notpublic(repo, subset, x):
     getargs(x, 0, 0, "_notpublic takes no arguments")
     return _phase(repo, subset, phases.draft, phases.secret)
 
 # for internal use
 @predicate('_phaseandancestors(phasename, set)', safe=True)
 def _phaseandancestors(repo, subset, x):
     # equivalent to (phasename() & ancestors(set)) but more efficient
     # phasename could be one of 'draft', 'secret', or '_notpublic'
     args = getargs(x, 2, 2, "_phaseandancestors requires two arguments")
     phasename = getsymbol(args[0])
     s = getset(repo, fullreposet(repo), args[1])
 
     draft = phases.draft
     secret = phases.secret
     phasenamemap = {
         '_notpublic': draft,
         'draft': draft, # follow secret's ancestors
         'secret': secret,
     }
     if phasename not in phasenamemap:
         raise error.ParseError('%r is not a valid phasename' % phasename)
 
     minimalphase = phasenamemap[phasename]
     getphase = repo._phasecache.phase
 
     def cutfunc(rev):
         return getphase(repo, rev) < minimalphase
 
     revs = dagop.revancestors(repo, s, cutfunc=cutfunc)
 
     if phasename == 'draft': # need to remove secret changesets
         revs = revs.filter(lambda r: getphase(repo, r) == draft)
     return subset & revs
 
 @predicate('public()', safe=True)
 def public(repo, subset, x):
     """Changeset in public phase."""
     # i18n: "public" is a keyword
     getargs(x, 0, 0, _("public takes no arguments"))
     return _phase(repo, subset, phases.public)
 
 @predicate('remote([id [,path]])', safe=False)
 def remote(repo, subset, x):
     """Local revision that corresponds to the given identifier in a
     remote repository, if present. Here, the '.' identifier is a
     synonym for the current local branch.
     """
 
     from . import hg # avoid start-up nasties
     # i18n: "remote" is a keyword
     l = getargs(x, 0, 2, _("remote takes zero, one, or two arguments"))
 
     q = '.'
     if len(l) > 0:
     # i18n: "remote" is a keyword
         q = getstring(l[0], _("remote requires a string id"))
     if q == '.':
         q = repo['.'].branch()
 
     dest = ''
     if len(l) > 1:
         # i18n: "remote" is a keyword
         dest = getstring(l[1], _("remote requires a repository path"))
     dest = repo.ui.expandpath(dest or 'default')
     dest, branches = hg.parseurl(dest)
     revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
     other = hg.peer(repo, {}, dest)
     n = other.lookup(q)
     if n in repo:
         r = repo[n].rev()
         if r in subset:
             return baseset([r])
     return baseset()
 
 @predicate('removes(pattern)', safe=True, weight=30)
 def removes(repo, subset, x):
     """Changesets which remove files matching pattern.
 
     The pattern without explicit kind like ``glob:`` is expected to be
     relative to the current directory and match against a file or a
     directory.
     """
     # i18n: "removes" is a keyword
     pat = getstring(x, _("removes requires a pattern"))
     return checkstatus(repo, subset, pat, 2)
 
 @predicate('rev(number)', safe=True)
 def rev(repo, subset, x):
     """Revision with the given numeric identifier.
     """
     # i18n: "rev" is a keyword
     l = getargs(x, 1, 1, _("rev requires one argument"))
     try:
         # i18n: "rev" is a keyword
         l = int(getstring(l[0], _("rev requires a number")))
     except (TypeError, ValueError):
         # i18n: "rev" is a keyword
         raise error.ParseError(_("rev expects a number"))
     if l not in repo.changelog and l not in (node.nullrev, node.wdirrev):
         return baseset()
     return subset & baseset([l])
 
 @predicate('_rev(number)', safe=True)
 def _rev(repo, subset, x):
     # internal version of "rev(x)" that raise error if "x" is invalid
     # i18n: "rev" is a keyword
     l = getargs(x, 1, 1, _("rev requires one argument"))
     try:
         # i18n: "rev" is a keyword
         l = int(getstring(l[0], _("rev requires a number")))
     except (TypeError, ValueError):
         # i18n: "rev" is a keyword
         raise error.ParseError(_("rev expects a number"))
     repo.changelog.node(l) # check that the rev exists
     return subset & baseset([l])
 
 @predicate('revset(set)', safe=True, takeorder=True)
 def revsetpredicate(repo, subset, x, order):
     """Strictly interpret the content as a revset.
 
     The content of this special predicate will be strictly interpreted as a
     revset. For example, ``revset(id(0))`` will be interpreted as "id(0)"
     without possible ambiguity with a "id(0)" bookmark or tag.
     """
     return getset(repo, subset, x, order)
 
 @predicate('matching(revision [, field])', safe=True)
 def matching(repo, subset, x):
     """Changesets in which a given set of fields match the set of fields in the
     selected revision or set.
 
     To match more than one field pass the list of fields to match separated
     by spaces (e.g. ``author description``).
 
     Valid fields are most regular revision fields and some special fields.
 
     Regular revision fields are ``description``, ``author``, ``branch``,
     ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
     and ``diff``.
     Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
     contents of the revision. Two revisions matching their ``diff`` will
     also match their ``files``.
 
     Special fields are ``summary`` and ``metadata``:
     ``summary`` matches the first line of the description.
     ``metadata`` is equivalent to matching ``description user date``
     (i.e. it matches the main metadata fields).
 
     ``metadata`` is the default field which is used when no fields are
     specified. You can match more than one field at a time.
     """
     # i18n: "matching" is a keyword
     l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
 
     revs = getset(repo, fullreposet(repo), l[0])
 
     fieldlist = ['metadata']
     if len(l) > 1:
             fieldlist = getstring(l[1],
                 # i18n: "matching" is a keyword
                 _("matching requires a string "
                 "as its second argument")).split()
 
     # Make sure that there are no repeated fields,
     # expand the 'special' 'metadata' field type
     # and check the 'files' whenever we check the 'diff'
     fields = []
     for field in fieldlist:
         if field == 'metadata':
             fields += ['user', 'description', 'date']
         elif field == 'diff':
             # a revision matching the diff must also match the files
             # since matching the diff is very costly, make sure to
             # also match the files first
             fields += ['files', 'diff']
         else:
             if field == 'author':
                 field = 'user'
             fields.append(field)
     fields = set(fields)
     if 'summary' in fields and 'description' in fields:
         # If a revision matches its description it also matches its summary
         fields.discard('summary')
 
     # We may want to match more than one field
     # Not all fields take the same amount of time to be matched
     # Sort the selected fields in order of increasing matching cost
     fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
         'files', 'description', 'substate', 'diff']
     def fieldkeyfunc(f):
         try:
             return fieldorder.index(f)
         except ValueError:
             # assume an unknown field is very costly
             return len(fieldorder)
     fields = list(fields)
     fields.sort(key=fieldkeyfunc)
 
     # Each field will be matched with its own "getfield" function
     # which will be added to the getfieldfuncs array of functions
     getfieldfuncs = []
     _funcs = {
         'user': lambda r: repo[r].user(),
         'branch': lambda r: repo[r].branch(),
         'date': lambda r: repo[r].date(),
         'description': lambda r: repo[r].description(),
         'files': lambda r: repo[r].files(),
         'parents': lambda r: repo[r].parents(),
         'phase': lambda r: repo[r].phase(),
         'substate': lambda r: repo[r].substate,
         'summary': lambda r: repo[r].description().splitlines()[0],
         'diff': lambda r: list(repo[r].diff(
             opts=diffutil.diffallopts(repo.ui, {'git': True}))),
     }
     for info in fields:
         getfield = _funcs.get(info, None)
         if getfield is None:
             raise error.ParseError(
                 # i18n: "matching" is a keyword
                 _("unexpected field name passed to matching: %s") % info)
         getfieldfuncs.append(getfield)
     # convert the getfield array of functions into a "getinfo" function
     # which returns an array of field values (or a single value if there
     # is only one field to match)
     getinfo = lambda r: [f(r) for f in getfieldfuncs]
 
     def matches(x):
         for rev in revs:
             target = getinfo(rev)
             match = True
             for n, f in enumerate(getfieldfuncs):
                 if target[n] != f(x):
                     match = False
             if match:
                 return True
         return False
 
     return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))
 
 @predicate('reverse(set)', safe=True, takeorder=True, weight=0)
 def reverse(repo, subset, x, order):
     """Reverse order of set.
     """
     l = getset(repo, subset, x, order)
     if order == defineorder:
         l.reverse()
     return l
 
 @predicate('roots(set)', safe=True)
 def roots(repo, subset, x):
     """Changesets in set with no parent changeset in set.
     """
     s = getset(repo, fullreposet(repo), x)
     parents = repo.changelog.parentrevs
     def filter(r):
         for p in parents(r):
             if 0 <= p and p in s:
                 return False
         return True
     return subset & s.filter(filter, condrepr='<roots>')
 
 _sortkeyfuncs = {
     'rev': lambda c: c.rev(),
     'branch': lambda c: c.branch(),
     'desc': lambda c: c.description(),
     'user': lambda c: c.user(),
     'author': lambda c: c.user(),
     'date': lambda c: c.date()[0],
 }
 
 def _getsortargs(x):
     """Parse sort options into (set, [(key, reverse)], opts)"""
     args = getargsdict(x, 'sort', 'set keys topo.firstbranch')
     if 'set' not in args:
         # i18n: "sort" is a keyword
         raise error.ParseError(_('sort requires one or two arguments'))
     keys = "rev"
     if 'keys' in args:
         # i18n: "sort" is a keyword
         keys = getstring(args['keys'], _("sort spec must be a string"))
 
     keyflags = []
     for k in keys.split():
         fk = k
         reverse = (k.startswith('-'))
         if reverse:
             k = k[1:]
         if k not in _sortkeyfuncs and k != 'topo':
             raise error.ParseError(
                 _("unknown sort key %r") % pycompat.bytestr(fk))
         keyflags.append((k, reverse))
 
     if len(keyflags) > 1 and any(k == 'topo' for k, reverse in keyflags):
         # i18n: "topo" is a keyword
         raise error.ParseError(_('topo sort order cannot be combined '
                                  'with other sort keys'))
 
     opts = {}
     if 'topo.firstbranch' in args:
         if any(k == 'topo' for k, reverse in keyflags):
             opts['topo.firstbranch'] = args['topo.firstbranch']
         else:
             # i18n: "topo" and "topo.firstbranch" are keywords
             raise error.ParseError(_('topo.firstbranch can only be used '
                                      'when using the topo sort key'))
 
     return args['set'], keyflags, opts
 
 @predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True,
            weight=10)
 def sort(repo, subset, x, order):
     """Sort set by keys. The default sort order is ascending, specify a key
     as ``-key`` to sort in descending order.
 
     The keys can be:
 
     - ``rev`` for the revision number,
     - ``branch`` for the branch name,
     - ``desc`` for the commit message (description),
     - ``user`` for user name (``author`` can be used as an alias),
     - ``date`` for the commit date
     - ``topo`` for a reverse topographical sort
 
     The ``topo`` sort order cannot be combined with other sort keys. This sort
     takes one optional argument, ``topo.firstbranch``, which takes a revset that
     specifies what topographical branches to prioritize in the sort.
 
     """
     s, keyflags, opts = _getsortargs(x)
     revs = getset(repo, subset, s, order)
 
     if not keyflags or order != defineorder:
         return revs
     if len(keyflags) == 1 and keyflags[0][0] == "rev":
         revs.sort(reverse=keyflags[0][1])
         return revs
     elif keyflags[0][0] == "topo":
         firstbranch = ()
         if 'topo.firstbranch' in opts:
             firstbranch = getset(repo, subset, opts['topo.firstbranch'])
         revs = baseset(dagop.toposort(revs, repo.changelog.parentrevs,
                                       firstbranch),
                        istopo=True)
         if keyflags[0][1]:
             revs.reverse()
         return revs
 
     # sort() is guaranteed to be stable
     ctxs = [repo[r] for r in revs]
     for k, reverse in reversed(keyflags):
         ctxs.sort(key=_sortkeyfuncs[k], reverse=reverse)
     return baseset([c.rev() for c in ctxs])
 
 @predicate('subrepo([pattern])')
 def subrepo(repo, subset, x):
     """Changesets that add, modify or remove the given subrepo.  If no subrepo
     pattern is named, any subrepo changes are returned.
     """
     # i18n: "subrepo" is a keyword
     args = getargs(x, 0, 1, _('subrepo takes at most one argument'))
     pat = None
     if len(args) != 0:
         pat = getstring(args[0], _("subrepo requires a pattern"))
 
     m = matchmod.exact(['.hgsubstate'])
 
     def submatches(names):
         k, p, m = stringutil.stringmatcher(pat)
         for name in names:
             if m(name):
                 yield name
 
     def matches(x):
         c = repo[x]
         s = repo.status(c.p1().node(), c.node(), match=m)
 
         if pat is None:
             return s.added or s.modified or s.removed
 
         if s.added:
             return any(submatches(c.substate.keys()))
 
         if s.modified:
             subs = set(c.p1().substate.keys())
             subs.update(c.substate.keys())
 
             for path in submatches(subs):
                 if c.p1().substate.get(path) != c.substate.get(path):
                     return True
 
         if s.removed:
             return any(submatches(c.p1().substate.keys()))
 
         return False
 
     return subset.filter(matches, condrepr=('<subrepo %r>', pat))
 
 def _mapbynodefunc(repo, s, f):
     """(repo, smartset, [node] -> [node]) -> smartset
 
     Helper method to map a smartset to another smartset given a function only
     talking about nodes. Handles converting between rev numbers and nodes, and
     filtering.
     """
     cl = repo.unfiltered().changelog
     torev = cl.rev
     tonode = cl.node
     nodemap = cl.nodemap
     result = set(torev(n) for n in f(tonode(r) for r in s) if n in nodemap)
     return smartset.baseset(result - repo.changelog.filteredrevs)
 
 @predicate('successors(set)', safe=True)
 def successors(repo, subset, x):
     """All successors for set, including the given set themselves"""
     s = getset(repo, fullreposet(repo), x)
     f = lambda nodes: obsutil.allsuccessors(repo.obsstore, nodes)
     d = _mapbynodefunc(repo, s, f)
     return subset & d
 
 def _substringmatcher(pattern, casesensitive=True):
     kind, pattern, matcher = stringutil.stringmatcher(
         pattern, casesensitive=casesensitive)
     if kind == 'literal':
         if not casesensitive:
             pattern = encoding.lower(pattern)
             matcher = lambda s: pattern in encoding.lower(s)
         else:
             matcher = lambda s: pattern in s
     return kind, pattern, matcher
 
 @predicate('tag([name])', safe=True)
 def tag(repo, subset, x):
     """The specified tag by name, or all tagged revisions if no name is given.
 
     Pattern matching is supported for `name`. See
     :hg:`help revisions.patterns`.
     """
     # i18n: "tag" is a keyword
     args = getargs(x, 0, 1, _("tag takes one or no arguments"))
     cl = repo.changelog
     if args:
         pattern = getstring(args[0],
                             # i18n: "tag" is a keyword
                             _('the argument to tag must be a string'))
         kind, pattern, matcher = stringutil.stringmatcher(pattern)
         if kind == 'literal':
             # avoid resolving all tags
             tn = repo._tagscache.tags.get(pattern, None)
             if tn is None:
                 raise error.RepoLookupError(_("tag '%s' does not exist")
                                             % pattern)
             s = {repo[tn].rev()}
         else:
             s = {cl.rev(n) for t, n in repo.tagslist() if matcher(t)}
     else:
         s = {cl.rev(n) for t, n in repo.tagslist() if t != 'tip'}
     return subset & s
 
 @predicate('tagged', safe=True)
 def tagged(repo, subset, x):
     return tag(repo, subset, x)
 
 @predicate('orphan()', safe=True)
 def orphan(repo, subset, x):
     """Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)
     """
     # i18n: "orphan" is a keyword
     getargs(x, 0, 0, _("orphan takes no arguments"))
     orphan = obsmod.getrevs(repo, 'orphan')
     return subset & orphan
 
 
 @predicate('user(string)', safe=True, weight=10)
 def user(repo, subset, x):
     """User name contains string. The match is case-insensitive.
 
     Pattern matching is supported for `string`. See
     :hg:`help revisions.patterns`.
     """
     return author(repo, subset, x)
 
 @predicate('wdir()', safe=True, weight=0)
 def wdir(repo, subset, x):
     """Working directory. (EXPERIMENTAL)"""
     # i18n: "wdir" is a keyword
     getargs(x, 0, 0, _("wdir takes no arguments"))
     if node.wdirrev in subset or isinstance(subset, fullreposet):
         return baseset([node.wdirrev])
     return baseset()
 
 def _orderedlist(repo, subset, x):
     s = getstring(x, "internal error")
     if not s:
         return baseset()
     # remove duplicates here. it's difficult for caller to deduplicate sets
     # because different symbols can point to the same rev.
     cl = repo.changelog
     ls = []
     seen = set()
     for t in s.split('\0'):
         try:
             # fast path for integer revision
             r = int(t)
             if ('%d' % r) != t or r not in cl:
                 raise ValueError
             revs = [r]
         except ValueError:
             revs = stringset(repo, subset, t, defineorder)
 
         for r in revs:
             if r in seen:
                 continue
             if (r in subset
                 or r == node.nullrev and isinstance(subset, fullreposet)):
                 ls.append(r)
             seen.add(r)
     return baseset(ls)
 
 # for internal use
 @predicate('_list', safe=True, takeorder=True)
 def _list(repo, subset, x, order):
     if order == followorder:
         # slow path to take the subset order
         return subset & _orderedlist(repo, fullreposet(repo), x)
     else:
         return _orderedlist(repo, subset, x)
 
 def _orderedintlist(repo, subset, x):
     s = getstring(x, "internal error")
     if not s:
         return baseset()
     ls = [int(r) for r in s.split('\0')]
     s = subset
     return baseset([r for r in ls if r in s])
 
 # for internal use
 @predicate('_intlist', safe=True, takeorder=True, weight=0)
 def _intlist(repo, subset, x, order):
     if order == followorder:
         # slow path to take the subset order
         return subset & _orderedintlist(repo, fullreposet(repo), x)
     else:
         return _orderedintlist(repo, subset, x)
 
 def _orderedhexlist(repo, subset, x):
     s = getstring(x, "internal error")
     if not s:
         return baseset()
     cl = repo.changelog
     ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
     s = subset
     return baseset([r for r in ls if r in s])
 
 # for internal use
 @predicate('_hexlist', safe=True, takeorder=True)
 def _hexlist(repo, subset, x, order):
     if order == followorder:
         # slow path to take the subset order
         return subset & _orderedhexlist(repo, fullreposet(repo), x)
     else:
         return _orderedhexlist(repo, subset, x)
 
 methods = {
     "range": rangeset,
     "rangeall": rangeall,
     "rangepre": rangepre,
     "rangepost": rangepost,
     "dagrange": dagrange,
     "string": stringset,
     "symbol": stringset,
     "and": andset,
     "andsmally": andsmallyset,
     "or": orset,
     "not": notset,
     "difference": differenceset,
     "relation": relationset,
     "relsubscript": relsubscriptset,
     "subscript": subscriptset,
     "list": listset,
     "keyvalue": keyvaluepair,
     "func": func,
     "ancestor": ancestorspec,
     "parent": parentspec,
     "parentpost": parentpost,
     "smartset": rawsmartset,
 }
 
 subscriptrelations = {
     "g": generationsrel,
     "generations": generationsrel,
 }
 
 def lookupfn(repo):
     return lambda symbol: scmutil.isrevsymbol(repo, symbol)
 
 def match(ui, spec, lookup=None):
     """Create a matcher for a single revision spec"""
     return matchany(ui, [spec], lookup=lookup)
 
 def matchany(ui, specs, lookup=None, localalias=None):
     """Create a matcher that will include any revisions matching one of the
     given specs
 
     If lookup function is not None, the parser will first attempt to handle
     old-style ranges, which may contain operator characters.
 
     If localalias is not None, it is a dict {name: definitionstring}. It takes
     precedence over [revsetalias] config section.
     """
     if not specs:
         def mfunc(repo, subset=None):
             return baseset()
         return mfunc
     if not all(specs):
         raise error.ParseError(_("empty query"))
     if len(specs) == 1:
         tree = revsetlang.parse(specs[0], lookup)
     else:
         tree = ('or',
                 ('list',) + tuple(revsetlang.parse(s, lookup) for s in specs))
 
     aliases = []
     warn = None
     if ui:
         aliases.extend(ui.configitems('revsetalias'))
         warn = ui.warn
     if localalias:
         aliases.extend(localalias.items())
     if aliases:
         tree = revsetlang.expandaliases(tree, aliases, warn=warn)
     tree = revsetlang.foldconcat(tree)
     tree = revsetlang.analyze(tree)
     tree = revsetlang.optimize(tree)
     return makematcher(tree)
 
 def makematcher(tree):
     """Create a matcher from an evaluatable tree"""
     def mfunc(repo, subset=None, order=None):
         if order is None:
             if subset is None:
                 order = defineorder  # 'x'
             else:
                 order = followorder  # 'subset & x'
         if subset is None:
             subset = fullreposet(repo)
         return getset(repo, subset, tree, order)
     return mfunc
 
 def loadpredicate(ui, extname, registrarobj):
     """Load revset predicates from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         symbols[name] = func
         if func._safe:
             safesymbols.add(name)
 
 # load built-in predicates explicitly to setup safesymbols
 loadpredicate(None, None, predicate)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = symbols.values()