dirstate: remove v1_* methods from Python/C/Rust shared API

These methods are used for v1 parsing by their respective implementations, but
do not need to be shared between them.

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

hgext/fsmonitor/__init__.py

@@ -1,1000 +1,1000 b''
 # __init__.py - fsmonitor initialization and overrides
 #
 # Copyright 2013-2016 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''Faster status operations with the Watchman file monitor (EXPERIMENTAL)
 
 Integrates the file-watching program Watchman with Mercurial to produce faster
 status results.
 
 On a particular Linux system, for a real-world repository with over 400,000
 files hosted on ext4, vanilla `hg status` takes 1.3 seconds. On the same
 system, with fsmonitor it takes about 0.3 seconds.
 
 fsmonitor requires no configuration -- it will tell Watchman about your
 repository as necessary. You'll need to install Watchman from
 https://facebook.github.io/watchman/ and make sure it is in your PATH.
 
 fsmonitor is incompatible with the largefiles and eol extensions, and
 will disable itself if any of those are active.
 
 The following configuration options exist:
 
 ::
 
     [fsmonitor]
     mode = {off, on, paranoid}
 
 When `mode = off`, fsmonitor will disable itself (similar to not loading the
 extension at all). When `mode = on`, fsmonitor will be enabled (the default).
 When `mode = paranoid`, fsmonitor will query both Watchman and the filesystem,
 and ensure that the results are consistent.
 
 ::
 
     [fsmonitor]
     timeout = (float)
 
 A value, in seconds, that determines how long fsmonitor will wait for Watchman
 to return results. Defaults to `2.0`.
 
 ::
 
     [fsmonitor]
     blacklistusers = (list of userids)
 
 A list of usernames for which fsmonitor will disable itself altogether.
 
 ::
 
     [fsmonitor]
     walk_on_invalidate = (boolean)
 
 Whether or not to walk the whole repo ourselves when our cached state has been
 invalidated, for example when Watchman has been restarted or .hgignore rules
 have been changed. Walking the repo in that case can result in competing for
 I/O with Watchman. For large repos it is recommended to set this value to
 false. You may wish to set this to true if you have a very fast filesystem
 that can outpace the IPC overhead of getting the result data for the full repo
 from Watchman. Defaults to false.
 
 ::
 
     [fsmonitor]
     warn_when_unused = (boolean)
 
 Whether to print a warning during certain operations when fsmonitor would be
 beneficial to performance but isn't enabled.
 
 ::
 
     [fsmonitor]
     warn_update_file_count = (integer)
     # or when mercurial is built with rust support
     warn_update_file_count_rust = (integer)
 
 If ``warn_when_unused`` is set and fsmonitor isn't enabled, a warning will
 be printed during working directory updates if this many files will be
 created.
 '''
 
 # Platforms Supported
 # ===================
 #
 # **Linux:** *Stable*. Watchman and fsmonitor are both known to work reliably,
 #   even under severe loads.
 #
 # **Mac OS X:** *Stable*. The Mercurial test suite passes with fsmonitor
 #   turned on, on case-insensitive HFS+. There has been a reasonable amount of
 #   user testing under normal loads.
 #
 # **Solaris, BSD:** *Alpha*. watchman and fsmonitor are believed to work, but
 #   very little testing has been done.
 #
 # **Windows:** *Alpha*. Not in a release version of watchman or fsmonitor yet.
 #
 # Known Issues
 # ============
 #
 # * fsmonitor will disable itself if any of the following extensions are
 #   enabled: largefiles, inotify, eol; or if the repository has subrepos.
 # * fsmonitor will produce incorrect results if nested repos that are not
 #   subrepos exist. *Workaround*: add nested repo paths to your `.hgignore`.
 #
 # The issues related to nested repos and subrepos are probably not fundamental
 # ones. Patches to fix them are welcome.
 
 
 import codecs
 import os
 import stat
 import sys
 import tempfile
 import weakref
 
 from mercurial.i18n import _
 from mercurial.node import hex
 from mercurial.pycompat import open
 from mercurial import (
     context,
     encoding,
     error,
     extensions,
     localrepo,
     merge,
     pathutil,
     pycompat,
     registrar,
     scmutil,
     util,
 )
 from mercurial import match as matchmod
 from mercurial.utils import (
     hashutil,
     stringutil,
 )
 
 from . import (
     pywatchman,
     state,
     watchmanclient,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 configitem(
     b'fsmonitor',
     b'mode',
     default=b'on',
 )
 configitem(
     b'fsmonitor',
     b'walk_on_invalidate',
     default=False,
 )
 configitem(
     b'fsmonitor',
     b'timeout',
     default=b'2',
 )
 configitem(
     b'fsmonitor',
     b'blacklistusers',
     default=list,
 )
 configitem(
     b'fsmonitor',
     b'watchman_exe',
     default=b'watchman',
 )
 configitem(
     b'fsmonitor',
     b'verbose',
     default=True,
     experimental=True,
 )
 configitem(
     b'experimental',
     b'fsmonitor.transaction_notify',
     default=False,
 )
 
 # This extension is incompatible with the following blacklisted extensions
 # and will disable itself when encountering one of these:
 _blacklist = [b'largefiles', b'eol']
 
 
 def debuginstall(ui, fm):
     fm.write(
         b"fsmonitor-watchman",
         _(b"fsmonitor checking for watchman binary... (%s)\n"),
         ui.configpath(b"fsmonitor", b"watchman_exe"),
     )
     root = tempfile.mkdtemp()
     c = watchmanclient.client(ui, root)
     err = None
     try:
         v = c.command(b"version")
         fm.write(
             b"fsmonitor-watchman-version",
             _(b" watchman binary version %s\n"),
             pycompat.bytestr(v["version"]),
         )
     except watchmanclient.Unavailable as e:
         err = stringutil.forcebytestr(e)
     fm.condwrite(
         err,
         b"fsmonitor-watchman-error",
         _(b" watchman binary missing or broken: %s\n"),
         err,
     )
     return 1 if err else 0
 
 
 def _handleunavailable(ui, state, ex):
     """Exception handler for Watchman interaction exceptions"""
     if isinstance(ex, watchmanclient.Unavailable):
         # experimental config: fsmonitor.verbose
         if ex.warn and ui.configbool(b'fsmonitor', b'verbose'):
             if b'illegal_fstypes' not in stringutil.forcebytestr(ex):
                 ui.warn(stringutil.forcebytestr(ex) + b'\n')
         if ex.invalidate:
             state.invalidate()
         # experimental config: fsmonitor.verbose
         if ui.configbool(b'fsmonitor', b'verbose'):
             ui.log(
                 b'fsmonitor',
                 b'Watchman unavailable: %s\n',
                 stringutil.forcebytestr(ex.msg),
             )
     else:
         ui.log(
             b'fsmonitor',
             b'Watchman exception: %s\n',
             stringutil.forcebytestr(ex),
         )
 
 
 def _hashignore(ignore):
     """Calculate hash for ignore patterns and filenames
 
     If this information changes between Mercurial invocations, we can't
     rely on Watchman information anymore and have to re-scan the working
     copy.
 
     """
     sha1 = hashutil.sha1()
     sha1.update(pycompat.byterepr(ignore))
     return pycompat.sysbytes(sha1.hexdigest())
 
 
 _watchmanencoding = pywatchman.encoding.get_local_encoding()
 _fsencoding = sys.getfilesystemencoding() or sys.getdefaultencoding()
 _fixencoding = codecs.lookup(_watchmanencoding) != codecs.lookup(_fsencoding)
 
 
 def _watchmantofsencoding(path):
     """Fix path to match watchman and local filesystem encoding
 
     watchman's paths encoding can differ from filesystem encoding. For example,
     on Windows, it's always utf-8.
     """
     try:
         decoded = path.decode(_watchmanencoding)
     except UnicodeDecodeError as e:
         raise error.Abort(
             stringutil.forcebytestr(e), hint=b'watchman encoding error'
         )
 
     try:
         encoded = decoded.encode(_fsencoding, 'strict')
     except UnicodeEncodeError as e:
         raise error.Abort(stringutil.forcebytestr(e))
 
     return encoded
 
 
 def overridewalk(orig, self, match, subrepos, unknown, ignored, full=True):
     """Replacement for dirstate.walk, hooking into Watchman.
 
     Whenever full is False, ignored is False, and the Watchman client is
     available, use Watchman combined with saved state to possibly return only a
     subset of files."""
 
     def bail(reason):
         self._ui.debug(b'fsmonitor: fallback to core status, %s\n' % reason)
         return orig(match, subrepos, unknown, ignored, full=True)
 
     if full:
         return bail(b'full rewalk requested')
     if ignored:
         return bail(b'listing ignored files')
     if not self._watchmanclient.available():
         return bail(b'client unavailable')
     state = self._fsmonitorstate
     clock, ignorehash, notefiles = state.get()
     if not clock:
         if state.walk_on_invalidate:
             return bail(b'no clock')
         # Initial NULL clock value, see
         # https://facebook.github.io/watchman/docs/clockspec.html
         clock = b'c:0:0'
         notefiles = []
 
     ignore = self._ignore
     dirignore = self._dirignore
     if unknown:
         if _hashignore(ignore) != ignorehash and clock != b'c:0:0':
             # ignore list changed -- can't rely on Watchman state any more
             if state.walk_on_invalidate:
                 return bail(b'ignore rules changed')
             notefiles = []
             clock = b'c:0:0'
     else:
         # always ignore
         ignore = util.always
         dirignore = util.always
 
     matchfn = match.matchfn
     matchalways = match.always()
     dmap = self._map
     if util.safehasattr(dmap, b'_map'):
         # for better performance, directly access the inner dirstate map if the
         # standard dirstate implementation is in use.
         dmap = dmap._map
     nonnormalset = {
         f
         for f, e in self._map.items()
-        if e.v1_state() != b"n" or e.v1_mtime() == -1
+        if e._v1_state() != b"n" or e._v1_mtime() == -1
     }
 
     copymap = self._map.copymap
     getkind = stat.S_IFMT
     dirkind = stat.S_IFDIR
     regkind = stat.S_IFREG
     lnkkind = stat.S_IFLNK
     join = self._join
     normcase = util.normcase
     fresh_instance = False
 
     exact = skipstep3 = False
     if match.isexact():  # match.exact
         exact = True
         dirignore = util.always  # skip step 2
     elif match.prefix():  # match.match, no patterns
         skipstep3 = True
 
     if not exact and self._checkcase:
         # note that even though we could receive directory entries, we're only
         # interested in checking if a file with the same name exists. So only
         # normalize files if possible.
         normalize = self._normalizefile
         skipstep3 = False
     else:
         normalize = None
 
     # step 1: find all explicit files
     results, work, dirsnotfound = self._walkexplicit(match, subrepos)
 
     skipstep3 = skipstep3 and not (work or dirsnotfound)
     work = [d for d in work if not dirignore(d[0])]
 
     if not work and (exact or skipstep3):
         for s in subrepos:
             del results[s]
         del results[b'.hg']
         return results
 
     # step 2: query Watchman
     try:
         # Use the user-configured timeout for the query.
         # Add a little slack over the top of the user query to allow for
         # overheads while transferring the data
         self._watchmanclient.settimeout(state.timeout + 0.1)
         result = self._watchmanclient.command(
             b'query',
             {
                 b'fields': [b'mode', b'mtime', b'size', b'exists', b'name'],
                 b'since': clock,
                 b'expression': [
                     b'not',
                     [
                         b'anyof',
                         [b'dirname', b'.hg'],
                         [b'name', b'.hg', b'wholename'],
                     ],
                 ],
                 b'sync_timeout': int(state.timeout * 1000),
                 b'empty_on_fresh_instance': state.walk_on_invalidate,
             },
         )
     except Exception as ex:
         _handleunavailable(self._ui, state, ex)
         self._watchmanclient.clearconnection()
         return bail(b'exception during run')
     else:
         # We need to propagate the last observed clock up so that we
         # can use it for our next query
         state.setlastclock(pycompat.sysbytes(result[b'clock']))
         if result[b'is_fresh_instance']:
             if state.walk_on_invalidate:
                 state.invalidate()
                 return bail(b'fresh instance')
             fresh_instance = True
             # Ignore any prior noteable files from the state info
             notefiles = []
 
     # for file paths which require normalization and we encounter a case
     # collision, we store our own foldmap
     if normalize:
         foldmap = {normcase(k): k for k in results}
 
     switch_slashes = pycompat.ossep == b'\\'
     # The order of the results is, strictly speaking, undefined.
     # For case changes on a case insensitive filesystem we may receive
     # two entries, one with exists=True and another with exists=False.
     # The exists=True entries in the same response should be interpreted
     # as being happens-after the exists=False entries due to the way that
     # Watchman tracks files.  We use this property to reconcile deletes
     # for name case changes.
     for entry in result[b'files']:
         fname = entry[b'name']
 
         # Watchman always give us a str. Normalize to bytes on Python 3
         # using Watchman's encoding, if needed.
         if not isinstance(fname, bytes):
             fname = fname.encode(_watchmanencoding)
 
         if _fixencoding:
             fname = _watchmantofsencoding(fname)
 
         if switch_slashes:
             fname = fname.replace(b'\\', b'/')
         if normalize:
             normed = normcase(fname)
             fname = normalize(fname, True, True)
             foldmap[normed] = fname
         fmode = entry[b'mode']
         fexists = entry[b'exists']
         kind = getkind(fmode)
 
         if b'/.hg/' in fname or fname.endswith(b'/.hg'):
             return bail(b'nested-repo-detected')
 
         if not fexists:
             # if marked as deleted and we don't already have a change
             # record, mark it as deleted.  If we already have an entry
             # for fname then it was either part of walkexplicit or was
             # an earlier result that was a case change
             if (
                 fname not in results
                 and fname in dmap
                 and (matchalways or matchfn(fname))
             ):
                 results[fname] = None
         elif kind == dirkind:
             if fname in dmap and (matchalways or matchfn(fname)):
                 results[fname] = None
         elif kind == regkind or kind == lnkkind:
             if fname in dmap:
                 if matchalways or matchfn(fname):
                     results[fname] = entry
             elif (matchalways or matchfn(fname)) and not ignore(fname):
                 results[fname] = entry
         elif fname in dmap and (matchalways or matchfn(fname)):
             results[fname] = None
 
     # step 3: query notable files we don't already know about
     # XXX try not to iterate over the entire dmap
     if normalize:
         # any notable files that have changed case will already be handled
         # above, so just check membership in the foldmap
         notefiles = {
             normalize(f, True, True)
             for f in notefiles
             if normcase(f) not in foldmap
         }
     visit = {
         f
         for f in notefiles
         if (f not in results and matchfn(f) and (f in dmap or not ignore(f)))
     }
 
     if not fresh_instance:
         if matchalways:
             visit.update(f for f in nonnormalset if f not in results)
             visit.update(f for f in copymap if f not in results)
         else:
             visit.update(
                 f for f in nonnormalset if f not in results and matchfn(f)
             )
             visit.update(f for f in copymap if f not in results and matchfn(f))
     else:
         if matchalways:
             visit.update(f for f, st in dmap.items() if f not in results)
             visit.update(f for f in copymap if f not in results)
         else:
             visit.update(
                 f for f, st in dmap.items() if f not in results and matchfn(f)
             )
             visit.update(f for f in copymap if f not in results and matchfn(f))
 
     audit = pathutil.pathauditor(self._root, cached=True).check
     auditpass = [f for f in visit if audit(f)]
     auditpass.sort()
     auditfail = visit.difference(auditpass)
     for f in auditfail:
         results[f] = None
 
     nf = iter(auditpass)
     for st in util.statfiles([join(f) for f in auditpass]):
         f = next(nf)
         if st or f in dmap:
             results[f] = st
 
     for s in subrepos:
         del results[s]
     del results[b'.hg']
     return results
 
 
 def overridestatus(
     orig,
     self,
     node1=b'.',
     node2=None,
     match=None,
     ignored=False,
     clean=False,
     unknown=False,
     listsubrepos=False,
 ):
     listignored = ignored
     listclean = clean
     listunknown = unknown
 
     def _cmpsets(l1, l2):
         try:
             if b'FSMONITOR_LOG_FILE' in encoding.environ:
                 fn = encoding.environ[b'FSMONITOR_LOG_FILE']
                 f = open(fn, b'wb')
             else:
                 fn = b'fsmonitorfail.log'
                 f = self.vfs.open(fn, b'wb')
         except (IOError, OSError):
             self.ui.warn(_(b'warning: unable to write to %s\n') % fn)
             return
 
         try:
             for i, (s1, s2) in enumerate(zip(l1, l2)):
                 if set(s1) != set(s2):
                     f.write(b'sets at position %d are unequal\n' % i)
                     f.write(b'watchman returned: %r\n' % s1)
                     f.write(b'stat returned: %r\n' % s2)
         finally:
             f.close()
 
     if isinstance(node1, context.changectx):
         ctx1 = node1
     else:
         ctx1 = self[node1]
     if isinstance(node2, context.changectx):
         ctx2 = node2
     else:
         ctx2 = self[node2]
 
     working = ctx2.rev() is None
     parentworking = working and ctx1 == self[b'.']
     match = match or matchmod.always()
 
     # Maybe we can use this opportunity to update Watchman's state.
     # Mercurial uses workingcommitctx and/or memctx to represent the part of
     # the workingctx that is to be committed. So don't update the state in
     # that case.
     # HG_PENDING is set in the environment when the dirstate is being updated
     # in the middle of a transaction; we must not update our state in that
     # case, or we risk forgetting about changes in the working copy.
     updatestate = (
         parentworking
         and match.always()
         and not isinstance(ctx2, (context.workingcommitctx, context.memctx))
         and b'HG_PENDING' not in encoding.environ
     )
 
     try:
         if self._fsmonitorstate.walk_on_invalidate:
             # Use a short timeout to query the current clock.  If that
             # takes too long then we assume that the service will be slow
             # to answer our query.
             # walk_on_invalidate indicates that we prefer to walk the
             # tree ourselves because we can ignore portions that Watchman
             # cannot and we tend to be faster in the warmer buffer cache
             # cases.
             self._watchmanclient.settimeout(0.1)
         else:
             # Give Watchman more time to potentially complete its walk
             # and return the initial clock.  In this mode we assume that
             # the filesystem will be slower than parsing a potentially
             # very large Watchman result set.
             self._watchmanclient.settimeout(self._fsmonitorstate.timeout + 0.1)
         startclock = self._watchmanclient.getcurrentclock()
     except Exception as ex:
         self._watchmanclient.clearconnection()
         _handleunavailable(self.ui, self._fsmonitorstate, ex)
         # boo, Watchman failed. bail
         return orig(
             node1,
             node2,
             match,
             listignored,
             listclean,
             listunknown,
             listsubrepos,
         )
 
     if updatestate:
         # We need info about unknown files. This may make things slower the
         # first time, but whatever.
         stateunknown = True
     else:
         stateunknown = listunknown
 
     if updatestate:
         ps = poststatus(startclock)
         self.addpostdsstatus(ps)
 
     r = orig(
         node1, node2, match, listignored, listclean, stateunknown, listsubrepos
     )
     modified, added, removed, deleted, unknown, ignored, clean = r
 
     if not listunknown:
         unknown = []
 
     # don't do paranoid checks if we're not going to query Watchman anyway
     full = listclean or match.traversedir is not None
     if self._fsmonitorstate.mode == b'paranoid' and not full:
         # run status again and fall back to the old walk this time
         self.dirstate._fsmonitordisable = True
 
         # shut the UI up
         quiet = self.ui.quiet
         self.ui.quiet = True
         fout, ferr = self.ui.fout, self.ui.ferr
         self.ui.fout = self.ui.ferr = open(os.devnull, b'wb')
 
         try:
             rv2 = orig(
                 node1,
                 node2,
                 match,
                 listignored,
                 listclean,
                 listunknown,
                 listsubrepos,
             )
         finally:
             self.dirstate._fsmonitordisable = False
             self.ui.quiet = quiet
             self.ui.fout, self.ui.ferr = fout, ferr
 
         # clean isn't tested since it's set to True above
         with self.wlock():
             _cmpsets(
                 [modified, added, removed, deleted, unknown, ignored, clean],
                 rv2,
             )
         modified, added, removed, deleted, unknown, ignored, clean = rv2
 
     return scmutil.status(
         modified, added, removed, deleted, unknown, ignored, clean
     )
 
 
 class poststatus:
     def __init__(self, startclock):
         self._startclock = pycompat.sysbytes(startclock)
 
     def __call__(self, wctx, status):
         clock = wctx.repo()._fsmonitorstate.getlastclock() or self._startclock
         hashignore = _hashignore(wctx.repo().dirstate._ignore)
         notefiles = (
             status.modified
             + status.added
             + status.removed
             + status.deleted
             + status.unknown
         )
         wctx.repo()._fsmonitorstate.set(clock, hashignore, notefiles)
 
 
 def makedirstate(repo, dirstate):
     class fsmonitordirstate(dirstate.__class__):
         def _fsmonitorinit(self, repo):
             # _fsmonitordisable is used in paranoid mode
             self._fsmonitordisable = False
             self._fsmonitorstate = repo._fsmonitorstate
             self._watchmanclient = repo._watchmanclient
             self._repo = weakref.proxy(repo)
 
         def walk(self, *args, **kwargs):
             orig = super(fsmonitordirstate, self).walk
             if self._fsmonitordisable:
                 return orig(*args, **kwargs)
             return overridewalk(orig, self, *args, **kwargs)
 
         def rebuild(self, *args, **kwargs):
             self._fsmonitorstate.invalidate()
             return super(fsmonitordirstate, self).rebuild(*args, **kwargs)
 
         def invalidate(self, *args, **kwargs):
             self._fsmonitorstate.invalidate()
             return super(fsmonitordirstate, self).invalidate(*args, **kwargs)
 
     dirstate.__class__ = fsmonitordirstate
     dirstate._fsmonitorinit(repo)
 
 
 def wrapdirstate(orig, self):
     ds = orig(self)
     # only override the dirstate when Watchman is available for the repo
     if util.safehasattr(self, b'_fsmonitorstate'):
         makedirstate(self, ds)
     return ds
 
 
 def extsetup(ui):
     extensions.wrapfilecache(
         localrepo.localrepository, b'dirstate', wrapdirstate
     )
     if pycompat.isdarwin:
         # An assist for avoiding the dangling-symlink fsevents bug
         extensions.wrapfunction(os, b'symlink', wrapsymlink)
 
     extensions.wrapfunction(merge, b'_update', wrapupdate)
 
 
 def wrapsymlink(orig, source, link_name):
     """if we create a dangling symlink, also touch the parent dir
     to encourage fsevents notifications to work more correctly"""
     try:
         return orig(source, link_name)
     finally:
         try:
             os.utime(os.path.dirname(link_name), None)
         except OSError:
             pass
 
 
 class state_update:
     """This context manager is responsible for dispatching the state-enter
     and state-leave signals to the watchman service. The enter and leave
     methods can be invoked manually (for scenarios where context manager
     semantics are not possible). If parameters oldnode and newnode are None,
     they will be populated based on current working copy in enter and
     leave, respectively. Similarly, if the distance is none, it will be
     calculated based on the oldnode and newnode in the leave method."""
 
     def __init__(
         self,
         repo,
         name,
         oldnode=None,
         newnode=None,
         distance=None,
         partial=False,
     ):
         self.repo = repo.unfiltered()
         self.name = name
         self.oldnode = oldnode
         self.newnode = newnode
         self.distance = distance
         self.partial = partial
         self._lock = None
         self.need_leave = False
 
     def __enter__(self):
         self.enter()
 
     def enter(self):
         # Make sure we have a wlock prior to sending notifications to watchman.
         # We don't want to race with other actors. In the update case,
         # merge.update is going to take the wlock almost immediately. We are
         # effectively extending the lock around several short sanity checks.
         if self.oldnode is None:
             self.oldnode = self.repo[b'.'].node()
 
         if self.repo.currentwlock() is None:
             if util.safehasattr(self.repo, b'wlocknostateupdate'):
                 self._lock = self.repo.wlocknostateupdate()
             else:
                 self._lock = self.repo.wlock()
         self.need_leave = self._state(b'state-enter', hex(self.oldnode))
         return self
 
     def __exit__(self, type_, value, tb):
         abort = True if type_ else False
         self.exit(abort=abort)
 
     def exit(self, abort=False):
         try:
             if self.need_leave:
                 status = b'failed' if abort else b'ok'
                 if self.newnode is None:
                     self.newnode = self.repo[b'.'].node()
                 if self.distance is None:
                     self.distance = calcdistance(
                         self.repo, self.oldnode, self.newnode
                     )
                 self._state(b'state-leave', hex(self.newnode), status=status)
         finally:
             self.need_leave = False
             if self._lock:
                 self._lock.release()
 
     def _state(self, cmd, commithash, status=b'ok'):
         if not util.safehasattr(self.repo, b'_watchmanclient'):
             return False
         try:
             self.repo._watchmanclient.command(
                 cmd,
                 {
                     b'name': self.name,
                     b'metadata': {
                         # the target revision
                         b'rev': commithash,
                         # approximate number of commits between current and target
                         b'distance': self.distance if self.distance else 0,
                         # success/failure (only really meaningful for state-leave)
                         b'status': status,
                         # whether the working copy parent is changing
                         b'partial': self.partial,
                     },
                 },
             )
             return True
         except Exception as e:
             # Swallow any errors; fire and forget
             self.repo.ui.log(
                 b'watchman', b'Exception %s while running %s\n', e, cmd
             )
             return False
 
 
 # Estimate the distance between two nodes
 def calcdistance(repo, oldnode, newnode):
     anc = repo.changelog.ancestor(oldnode, newnode)
     ancrev = repo[anc].rev()
     distance = abs(repo[oldnode].rev() - ancrev) + abs(
         repo[newnode].rev() - ancrev
     )
     return distance
 
 
 # Bracket working copy updates with calls to the watchman state-enter
 # and state-leave commands.  This allows clients to perform more intelligent
 # settling during bulk file change scenarios
 # https://facebook.github.io/watchman/docs/cmd/subscribe.html#advanced-settling
 def wrapupdate(
     orig,
     repo,
     node,
     branchmerge,
     force,
     ancestor=None,
     mergeancestor=False,
     labels=None,
     matcher=None,
     **kwargs
 ):
 
     distance = 0
     partial = True
     oldnode = repo[b'.'].node()
     newnode = repo[node].node()
     if matcher is None or matcher.always():
         partial = False
         distance = calcdistance(repo.unfiltered(), oldnode, newnode)
 
     with state_update(
         repo,
         name=b"hg.update",
         oldnode=oldnode,
         newnode=newnode,
         distance=distance,
         partial=partial,
     ):
         return orig(
             repo,
             node,
             branchmerge,
             force,
             ancestor,
             mergeancestor,
             labels,
             matcher,
             **kwargs
         )
 
 
 def repo_has_depth_one_nested_repo(repo):
     for f in repo.wvfs.listdir():
         if os.path.isdir(os.path.join(repo.root, f, b'.hg')):
             msg = b'fsmonitor: sub-repository %r detected, fsmonitor disabled\n'
             repo.ui.debug(msg % f)
             return True
     return False
 
 
 def reposetup(ui, repo):
     # We don't work with largefiles or inotify
     exts = extensions.enabled()
     for ext in _blacklist:
         if ext in exts:
             ui.warn(
                 _(
                     b'The fsmonitor extension is incompatible with the %s '
                     b'extension and has been disabled.\n'
                 )
                 % ext
             )
             return
 
     if repo.local():
         # We don't work with subrepos either.
         #
         # if repo[None].substate can cause a dirstate parse, which is too
         # slow. Instead, look for a file called hgsubstate,
         if repo.wvfs.exists(b'.hgsubstate') or repo.wvfs.exists(b'.hgsub'):
             return
 
         if repo_has_depth_one_nested_repo(repo):
             return
 
         fsmonitorstate = state.state(repo)
         if fsmonitorstate.mode == b'off':
             return
 
         try:
             client = watchmanclient.client(repo.ui, repo.root)
         except Exception as ex:
             _handleunavailable(ui, fsmonitorstate, ex)
             return
 
         repo._fsmonitorstate = fsmonitorstate
         repo._watchmanclient = client
 
         dirstate, cached = localrepo.isfilecached(repo, b'dirstate')
         if cached:
             # at this point since fsmonitorstate wasn't present,
             # repo.dirstate is not a fsmonitordirstate
             makedirstate(repo, dirstate)
 
         class fsmonitorrepo(repo.__class__):
             def status(self, *args, **kwargs):
                 orig = super(fsmonitorrepo, self).status
                 return overridestatus(orig, self, *args, **kwargs)
 
             def wlocknostateupdate(self, *args, **kwargs):
                 return super(fsmonitorrepo, self).wlock(*args, **kwargs)
 
             def wlock(self, *args, **kwargs):
                 l = super(fsmonitorrepo, self).wlock(*args, **kwargs)
                 if not ui.configbool(
                     b"experimental", b"fsmonitor.transaction_notify"
                 ):
                     return l
                 if l.held != 1:
                     return l
                 origrelease = l.releasefn
 
                 def staterelease():
                     if origrelease:
                         origrelease()
                     if l.stateupdate:
                         l.stateupdate.exit()
                         l.stateupdate = None
 
                 try:
                     l.stateupdate = None
                     l.stateupdate = state_update(self, name=b"hg.transaction")
                     l.stateupdate.enter()
                     l.releasefn = staterelease
                 except Exception as e:
                     # Swallow any errors; fire and forget
                     self.ui.log(
                         b'watchman', b'Exception in state update %s\n', e
                     )
                 return l
 
         repo.__class__ = fsmonitorrepo

mercurial/cext/parsers.c

@@ -1,1306 +1,1261 b''
 /*
  parsers.c - efficient content parsing
 
  Copyright 2008 Olivia Mackall <[e-mail]> and others
 
  This software may be used and distributed according to the terms of
  the GNU General Public License, incorporated herein by reference.
 */
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 #include <ctype.h>
 #include <stddef.h>
 #include <string.h>
 
 #include "bitmanipulation.h"
 #include "charencode.h"
 #include "util.h"
 
 static const char *const versionerrortext = "Python minor version mismatch";
 
 static const int dirstate_v1_from_p2 = -2;
 static const int dirstate_v1_nonnormal = -1;
 static const int ambiguous_time = -1;
 
 static PyObject *dict_new_presized(PyObject *self, PyObject *args)
 {
 	Py_ssize_t expected_size;
 
 	if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size)) {
 		return NULL;
 	}
 
 	return _dict_new_presized(expected_size);
 }
 
 static PyObject *dirstate_item_new(PyTypeObject *subtype, PyObject *args,
                                    PyObject *kwds)
 {
 	/* We do all the initialization here and not a tp_init function because
 	 * dirstate_item is immutable. */
 	dirstateItemObject *t;
 	int wc_tracked;
 	int p1_tracked;
 	int p2_info;
 	int has_meaningful_data;
 	int has_meaningful_mtime;
 	int mtime_second_ambiguous;
 	int mode;
 	int size;
 	int mtime_s;
 	int mtime_ns;
 	PyObject *parentfiledata;
 	PyObject *mtime;
 	PyObject *fallback_exec;
 	PyObject *fallback_symlink;
 	static char *keywords_name[] = {
 	    "wc_tracked",          "p1_tracked",           "p2_info",
 	    "has_meaningful_data", "has_meaningful_mtime", "parentfiledata",
 	    "fallback_exec",       "fallback_symlink",     NULL,
 	};
 	wc_tracked = 0;
 	p1_tracked = 0;
 	p2_info = 0;
 	has_meaningful_mtime = 1;
 	has_meaningful_data = 1;
 	mtime_second_ambiguous = 0;
 	parentfiledata = Py_None;
 	fallback_exec = Py_None;
 	fallback_symlink = Py_None;
 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiiiOOO", keywords_name,
 	                                 &wc_tracked, &p1_tracked, &p2_info,
 	                                 &has_meaningful_data,
 	                                 &has_meaningful_mtime, &parentfiledata,
 	                                 &fallback_exec, &fallback_symlink)) {
 		return NULL;
 	}
 	t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
 	if (!t) {
 		return NULL;
 	}
 
 	t->flags = 0;
 	if (wc_tracked) {
 		t->flags |= dirstate_flag_wc_tracked;
 	}
 	if (p1_tracked) {
 		t->flags |= dirstate_flag_p1_tracked;
 	}
 	if (p2_info) {
 		t->flags |= dirstate_flag_p2_info;
 	}
 
 	if (fallback_exec != Py_None) {
 		t->flags |= dirstate_flag_has_fallback_exec;
 		if (PyObject_IsTrue(fallback_exec)) {
 			t->flags |= dirstate_flag_fallback_exec;
 		}
 	}
 	if (fallback_symlink != Py_None) {
 		t->flags |= dirstate_flag_has_fallback_symlink;
 		if (PyObject_IsTrue(fallback_symlink)) {
 			t->flags |= dirstate_flag_fallback_symlink;
 		}
 	}
 
 	if (parentfiledata != Py_None) {
 		if (!PyArg_ParseTuple(parentfiledata, "iiO", &mode, &size,
 		                      &mtime)) {
 			return NULL;
 		}
 		if (mtime != Py_None) {
 			if (!PyArg_ParseTuple(mtime, "iii", &mtime_s, &mtime_ns,
 			                      &mtime_second_ambiguous)) {
 				return NULL;
 			}
 		} else {
 			has_meaningful_mtime = 0;
 		}
 	} else {
 		has_meaningful_data = 0;
 		has_meaningful_mtime = 0;
 	}
 	if (has_meaningful_data) {
 		t->flags |= dirstate_flag_has_meaningful_data;
 		t->mode = mode;
 		t->size = size;
 		if (mtime_second_ambiguous) {
 			t->flags |= dirstate_flag_mtime_second_ambiguous;
 		}
 	} else {
 		t->mode = 0;
 		t->size = 0;
 	}
 	if (has_meaningful_mtime) {
 		t->flags |= dirstate_flag_has_mtime;
 		t->mtime_s = mtime_s;
 		t->mtime_ns = mtime_ns;
 	} else {
 		t->mtime_s = 0;
 		t->mtime_ns = 0;
 	}
 	return (PyObject *)t;
 }
 
 static void dirstate_item_dealloc(PyObject *o)
 {
 	PyObject_Del(o);
 }
 
 static inline bool dirstate_item_c_tracked(dirstateItemObject *self)
 {
 	return (self->flags & dirstate_flag_wc_tracked);
 }
 
 static inline bool dirstate_item_c_any_tracked(dirstateItemObject *self)
 {
 	const int mask = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 	                 dirstate_flag_p2_info;
 	return (self->flags & mask);
 }
 
 static inline bool dirstate_item_c_added(dirstateItemObject *self)
 {
 	const int mask = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 	                  dirstate_flag_p2_info);
 	const int target = dirstate_flag_wc_tracked;
 	return (self->flags & mask) == target;
 }
 
 static inline bool dirstate_item_c_removed(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_wc_tracked) {
 		return false;
 	}
 	return (self->flags &
 	        (dirstate_flag_p1_tracked | dirstate_flag_p2_info));
 }
 
 static inline bool dirstate_item_c_merged(dirstateItemObject *self)
 {
 	return ((self->flags & dirstate_flag_wc_tracked) &&
 	        (self->flags & dirstate_flag_p1_tracked) &&
 	        (self->flags & dirstate_flag_p2_info));
 }
 
 static inline bool dirstate_item_c_from_p2(dirstateItemObject *self)
 {
 	return ((self->flags & dirstate_flag_wc_tracked) &&
 	        !(self->flags & dirstate_flag_p1_tracked) &&
 	        (self->flags & dirstate_flag_p2_info));
 }
 
 static inline char dirstate_item_c_v1_state(dirstateItemObject *self)
 {
 	if (dirstate_item_c_removed(self)) {
 		return 'r';
 	} else if (dirstate_item_c_merged(self)) {
 		return 'm';
 	} else if (dirstate_item_c_added(self)) {
 		return 'a';
 	} else {
 		return 'n';
 	}
 }
 
 static inline bool dirstate_item_c_has_fallback_exec(dirstateItemObject *self)
 {
 	return (bool)self->flags & dirstate_flag_has_fallback_exec;
 }
 
 static inline bool
 dirstate_item_c_has_fallback_symlink(dirstateItemObject *self)
 {
 	return (bool)self->flags & dirstate_flag_has_fallback_symlink;
 }
 
 static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_has_meaningful_data) {
 		return self->mode;
 	} else {
 		return 0;
 	}
 }
 
 static inline int dirstate_item_c_v1_size(dirstateItemObject *self)
 {
 	if (!(self->flags & dirstate_flag_wc_tracked) &&
 	    (self->flags & dirstate_flag_p2_info)) {
 		if (self->flags & dirstate_flag_p1_tracked) {
 			return dirstate_v1_nonnormal;
 		} else {
 			return dirstate_v1_from_p2;
 		}
 	} else if (dirstate_item_c_removed(self)) {
 		return 0;
 	} else if (self->flags & dirstate_flag_p2_info) {
 		return dirstate_v1_from_p2;
 	} else if (dirstate_item_c_added(self)) {
 		return dirstate_v1_nonnormal;
 	} else if (self->flags & dirstate_flag_has_meaningful_data) {
 		return self->size;
 	} else {
 		return dirstate_v1_nonnormal;
 	}
 }
 
 static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)
 {
 	if (dirstate_item_c_removed(self)) {
 		return 0;
 	} else if (!(self->flags & dirstate_flag_has_mtime) ||
 	           !(self->flags & dirstate_flag_p1_tracked) ||
 	           !(self->flags & dirstate_flag_wc_tracked) ||
 	           (self->flags & dirstate_flag_p2_info) ||
 	           (self->flags & dirstate_flag_mtime_second_ambiguous)) {
 		return ambiguous_time;
 	} else {
 		return self->mtime_s;
 	}
 }
 
 static PyObject *dirstate_item_v2_data(dirstateItemObject *self)
 {
 	int flags = self->flags;
 	int mode = dirstate_item_c_v1_mode(self);
 #ifdef S_IXUSR
 	/* This is for platforms with an exec bit */
 	if ((mode & S_IXUSR) != 0) {
 		flags |= dirstate_flag_mode_exec_perm;
 	} else {
 		flags &= ~dirstate_flag_mode_exec_perm;
 	}
 #else
 	flags &= ~dirstate_flag_mode_exec_perm;
 #endif
 #ifdef S_ISLNK
 	/* This is for platforms with support for symlinks */
 	if (S_ISLNK(mode)) {
 		flags |= dirstate_flag_mode_is_symlink;
 	} else {
 		flags &= ~dirstate_flag_mode_is_symlink;
 	}
 #else
 	flags &= ~dirstate_flag_mode_is_symlink;
 #endif
 	return Py_BuildValue("iiii", flags, self->size, self->mtime_s,
 	                     self->mtime_ns);
 };
 
-static PyObject *dirstate_item_v1_state(dirstateItemObject *self)
-{
-	char state = dirstate_item_c_v1_state(self);
-	return PyBytes_FromStringAndSize(&state, 1);
-};
-
-static PyObject *dirstate_item_v1_mode(dirstateItemObject *self)
-{
-	return PyLong_FromLong(dirstate_item_c_v1_mode(self));
-};
-
-static PyObject *dirstate_item_v1_size(dirstateItemObject *self)
-{
-	return PyLong_FromLong(dirstate_item_c_v1_size(self));
-};
-
-static PyObject *dirstate_item_v1_mtime(dirstateItemObject *self)
-{
-	return PyLong_FromLong(dirstate_item_c_v1_mtime(self));
-};
-
 static PyObject *dirstate_item_mtime_likely_equal_to(dirstateItemObject *self,
                                                      PyObject *other)
 {
 	int other_s;
 	int other_ns;
 	int other_second_ambiguous;
 	if (!PyArg_ParseTuple(other, "iii", &other_s, &other_ns,
 	                      &other_second_ambiguous)) {
 		return NULL;
 	}
 	if (!(self->flags & dirstate_flag_has_mtime)) {
 		Py_RETURN_FALSE;
 	}
 	if (self->mtime_s != other_s) {
 		Py_RETURN_FALSE;
 	}
 	if (self->mtime_ns == 0 || other_ns == 0) {
 		if (self->flags & dirstate_flag_mtime_second_ambiguous) {
 			Py_RETURN_FALSE;
 		} else {
 			Py_RETURN_TRUE;
 		}
 	}
 	if (self->mtime_ns == other_ns) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 /* This will never change since it's bound to V1
  */
 static inline dirstateItemObject *
 dirstate_item_from_v1_data(char state, int mode, int size, int mtime)
 {
 	dirstateItemObject *t =
 	    PyObject_New(dirstateItemObject, &dirstateItemType);
 	if (!t) {
 		return NULL;
 	}
 	t->flags = 0;
 	t->mode = 0;
 	t->size = 0;
 	t->mtime_s = 0;
 	t->mtime_ns = 0;
 
 	if (state == 'm') {
 		t->flags = (dirstate_flag_wc_tracked |
 		            dirstate_flag_p1_tracked | dirstate_flag_p2_info);
 	} else if (state == 'a') {
 		t->flags = dirstate_flag_wc_tracked;
 	} else if (state == 'r') {
 		if (size == dirstate_v1_nonnormal) {
 			t->flags =
 			    dirstate_flag_p1_tracked | dirstate_flag_p2_info;
 		} else if (size == dirstate_v1_from_p2) {
 			t->flags = dirstate_flag_p2_info;
 		} else {
 			t->flags = dirstate_flag_p1_tracked;
 		}
 	} else if (state == 'n') {
 		if (size == dirstate_v1_from_p2) {
 			t->flags =
 			    dirstate_flag_wc_tracked | dirstate_flag_p2_info;
 		} else if (size == dirstate_v1_nonnormal) {
 			t->flags =
 			    dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;
 		} else if (mtime == ambiguous_time) {
 			t->flags = (dirstate_flag_wc_tracked |
 			            dirstate_flag_p1_tracked |
 			            dirstate_flag_has_meaningful_data);
 			t->mode = mode;
 			t->size = size;
 		} else {
 			t->flags = (dirstate_flag_wc_tracked |
 			            dirstate_flag_p1_tracked |
 			            dirstate_flag_has_meaningful_data |
 			            dirstate_flag_has_mtime);
 			t->mode = mode;
 			t->size = size;
 			t->mtime_s = mtime;
 		}
 	} else {
 		PyErr_Format(PyExc_RuntimeError,
 		             "unknown state: `%c` (%d, %d, %d)", state, mode,
 		             size, mtime, NULL);
 		Py_DECREF(t);
 		return NULL;
 	}
 
 	return t;
 }
 
-/* This will never change since it's bound to V1, unlike `dirstate_item_new` */
-static PyObject *dirstate_item_from_v1_meth(PyTypeObject *subtype,
-                                            PyObject *args)
-{
-	/* We do all the initialization here and not a tp_init function because
-	 * dirstate_item is immutable. */
-	char state;
-	int size, mode, mtime;
-	if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) {
-		return NULL;
-	}
-	return (PyObject *)dirstate_item_from_v1_data(state, mode, size, mtime);
-};
-
 static PyObject *dirstate_item_from_v2_meth(PyTypeObject *subtype,
                                             PyObject *args)
 {
 	dirstateItemObject *t =
 	    PyObject_New(dirstateItemObject, &dirstateItemType);
 	if (!t) {
 		return NULL;
 	}
 	if (!PyArg_ParseTuple(args, "iiii", &t->flags, &t->size, &t->mtime_s,
 	                      &t->mtime_ns)) {
 		return NULL;
 	}
 	if (t->flags & dirstate_flag_expected_state_is_modified) {
 		t->flags &= ~(dirstate_flag_expected_state_is_modified |
 		              dirstate_flag_has_meaningful_data |
 		              dirstate_flag_has_mtime);
 	}
 	t->mode = 0;
 	if (t->flags & dirstate_flag_has_meaningful_data) {
 		if (t->flags & dirstate_flag_mode_exec_perm) {
 			t->mode = 0755;
 		} else {
 			t->mode = 0644;
 		}
 		if (t->flags & dirstate_flag_mode_is_symlink) {
 			t->mode |= S_IFLNK;
 		} else {
 			t->mode |= S_IFREG;
 		}
 	}
 	return (PyObject *)t;
 };
 
 /* This means the next status call will have to actually check its content
    to make sure it is correct. */
 static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
 {
 	self->flags &= ~dirstate_flag_has_mtime;
 	Py_RETURN_NONE;
 }
 
 /* See docstring of the python implementation for details */
 static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
                                          PyObject *args)
 {
 	int size, mode, mtime_s, mtime_ns, mtime_second_ambiguous;
 	PyObject *mtime;
 	mtime_s = 0;
 	mtime_ns = 0;
 	mtime_second_ambiguous = 0;
 	if (!PyArg_ParseTuple(args, "iiO", &mode, &size, &mtime)) {
 		return NULL;
 	}
 	if (mtime != Py_None) {
 		if (!PyArg_ParseTuple(mtime, "iii", &mtime_s, &mtime_ns,
 		                      &mtime_second_ambiguous)) {
 			return NULL;
 		}
 	} else {
 		self->flags &= ~dirstate_flag_has_mtime;
 	}
 	self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 	              dirstate_flag_has_meaningful_data |
 	              dirstate_flag_has_mtime;
 	if (mtime_second_ambiguous) {
 		self->flags |= dirstate_flag_mtime_second_ambiguous;
 	}
 	self->mode = mode;
 	self->size = size;
 	self->mtime_s = mtime_s;
 	self->mtime_ns = mtime_ns;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_set_tracked(dirstateItemObject *self)
 {
 	self->flags |= dirstate_flag_wc_tracked;
 	self->flags &= ~dirstate_flag_has_mtime;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
 {
 	self->flags &= ~dirstate_flag_wc_tracked;
 	self->flags &= ~dirstate_flag_has_meaningful_data;
 	self->flags &= ~dirstate_flag_has_mtime;
 	self->mode = 0;
 	self->size = 0;
 	self->mtime_s = 0;
 	self->mtime_ns = 0;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_p2_info) {
 		self->flags &= ~(dirstate_flag_p2_info |
 		                 dirstate_flag_has_meaningful_data |
 		                 dirstate_flag_has_mtime);
 		self->mode = 0;
 		self->size = 0;
 		self->mtime_s = 0;
 		self->mtime_ns = 0;
 	}
 	Py_RETURN_NONE;
 }
 static PyMethodDef dirstate_item_methods[] = {
     {"v2_data", (PyCFunction)dirstate_item_v2_data, METH_NOARGS,
      "return data suitable for v2 serialization"},
-    {"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS,
-     "return a \"state\" suitable for v1 serialization"},
-    {"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS,
-     "return a \"mode\" suitable for v1 serialization"},
-    {"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS,
-     "return a \"size\" suitable for v1 serialization"},
-    {"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS,
-     "return a \"mtime\" suitable for v1 serialization"},
     {"mtime_likely_equal_to", (PyCFunction)dirstate_item_mtime_likely_equal_to,
      METH_O, "True if the stored mtime is likely equal to the given mtime"},
-    {"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth,
-     METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"},
     {"from_v2_data", (PyCFunction)dirstate_item_from_v2_meth,
      METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V2 data"},
     {"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,
      METH_NOARGS, "mark a file as \"possibly dirty\""},
     {"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,
      "mark a file as \"clean\""},
     {"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS,
      "mark a file as \"tracked\""},
     {"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS,
      "mark a file as \"untracked\""},
     {"drop_merge_data", (PyCFunction)dirstate_item_drop_merge_data, METH_NOARGS,
      "remove all \"merge-only\" from a DirstateItem"},
     {NULL} /* Sentinel */
 };
 
 static PyObject *dirstate_item_get_mode(dirstateItemObject *self)
 {
 	return PyLong_FromLong(dirstate_item_c_v1_mode(self));
 };
 
 static PyObject *dirstate_item_get_size(dirstateItemObject *self)
 {
 	return PyLong_FromLong(dirstate_item_c_v1_size(self));
 };
 
 static PyObject *dirstate_item_get_mtime(dirstateItemObject *self)
 {
 	return PyLong_FromLong(dirstate_item_c_v1_mtime(self));
 };
 
 static PyObject *dirstate_item_get_state(dirstateItemObject *self)
 {
 	char state = dirstate_item_c_v1_state(self);
 	return PyBytes_FromStringAndSize(&state, 1);
 };
 
 static PyObject *dirstate_item_get_has_fallback_exec(dirstateItemObject *self)
 {
 	if (dirstate_item_c_has_fallback_exec(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_fallback_exec(dirstateItemObject *self)
 {
 	if (dirstate_item_c_has_fallback_exec(self)) {
 		if (self->flags & dirstate_flag_fallback_exec) {
 			Py_RETURN_TRUE;
 		} else {
 			Py_RETURN_FALSE;
 		}
 	} else {
 		Py_RETURN_NONE;
 	}
 };
 
 static int dirstate_item_set_fallback_exec(dirstateItemObject *self,
                                            PyObject *value)
 {
 	if ((value == Py_None) || (value == NULL)) {
 		self->flags &= ~dirstate_flag_has_fallback_exec;
 	} else {
 		self->flags |= dirstate_flag_has_fallback_exec;
 		if (PyObject_IsTrue(value)) {
 			self->flags |= dirstate_flag_fallback_exec;
 		} else {
 			self->flags &= ~dirstate_flag_fallback_exec;
 		}
 	}
 	return 0;
 };
 
 static PyObject *
 dirstate_item_get_has_fallback_symlink(dirstateItemObject *self)
 {
 	if (dirstate_item_c_has_fallback_symlink(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_fallback_symlink(dirstateItemObject *self)
 {
 	if (dirstate_item_c_has_fallback_symlink(self)) {
 		if (self->flags & dirstate_flag_fallback_symlink) {
 			Py_RETURN_TRUE;
 		} else {
 			Py_RETURN_FALSE;
 		}
 	} else {
 		Py_RETURN_NONE;
 	}
 };
 
 static int dirstate_item_set_fallback_symlink(dirstateItemObject *self,
                                               PyObject *value)
 {
 	if ((value == Py_None) || (value == NULL)) {
 		self->flags &= ~dirstate_flag_has_fallback_symlink;
 	} else {
 		self->flags |= dirstate_flag_has_fallback_symlink;
 		if (PyObject_IsTrue(value)) {
 			self->flags |= dirstate_flag_fallback_symlink;
 		} else {
 			self->flags &= ~dirstate_flag_fallback_symlink;
 		}
 	}
 	return 0;
 };
 
 static PyObject *dirstate_item_get_tracked(dirstateItemObject *self)
 {
 	if (dirstate_item_c_tracked(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 static PyObject *dirstate_item_get_p1_tracked(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_p1_tracked) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_added(dirstateItemObject *self)
 {
 	if (dirstate_item_c_added(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_p2_info(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_wc_tracked &&
 	    self->flags & dirstate_flag_p2_info) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_merged(dirstateItemObject *self)
 {
 	if (dirstate_item_c_merged(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_from_p2(dirstateItemObject *self)
 {
 	if (dirstate_item_c_from_p2(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_maybe_clean(dirstateItemObject *self)
 {
 	if (!(self->flags & dirstate_flag_wc_tracked)) {
 		Py_RETURN_FALSE;
 	} else if (!(self->flags & dirstate_flag_p1_tracked)) {
 		Py_RETURN_FALSE;
 	} else if (self->flags & dirstate_flag_p2_info) {
 		Py_RETURN_FALSE;
 	} else {
 		Py_RETURN_TRUE;
 	}
 };
 
 static PyObject *dirstate_item_get_any_tracked(dirstateItemObject *self)
 {
 	if (dirstate_item_c_any_tracked(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_removed(dirstateItemObject *self)
 {
 	if (dirstate_item_c_removed(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyGetSetDef dirstate_item_getset[] = {
     {"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL},
     {"size", (getter)dirstate_item_get_size, NULL, "size", NULL},
     {"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL},
     {"state", (getter)dirstate_item_get_state, NULL, "state", NULL},
     {"has_fallback_exec", (getter)dirstate_item_get_has_fallback_exec, NULL,
      "has_fallback_exec", NULL},
     {"fallback_exec", (getter)dirstate_item_get_fallback_exec,
      (setter)dirstate_item_set_fallback_exec, "fallback_exec", NULL},
     {"has_fallback_symlink", (getter)dirstate_item_get_has_fallback_symlink,
      NULL, "has_fallback_symlink", NULL},
     {"fallback_symlink", (getter)dirstate_item_get_fallback_symlink,
      (setter)dirstate_item_set_fallback_symlink, "fallback_symlink", NULL},
     {"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},
     {"p1_tracked", (getter)dirstate_item_get_p1_tracked, NULL, "p1_tracked",
      NULL},
     {"added", (getter)dirstate_item_get_added, NULL, "added", NULL},
     {"p2_info", (getter)dirstate_item_get_p2_info, NULL, "p2_info", NULL},
     {"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL},
     {"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL},
     {"maybe_clean", (getter)dirstate_item_get_maybe_clean, NULL, "maybe_clean",
      NULL},
     {"any_tracked", (getter)dirstate_item_get_any_tracked, NULL, "any_tracked",
      NULL},
     {"removed", (getter)dirstate_item_get_removed, NULL, "removed", NULL},
     {NULL} /* Sentinel */
 };
 
 PyTypeObject dirstateItemType = {
     PyVarObject_HEAD_INIT(NULL, 0)     /* header */
     "dirstate_tuple",                  /* tp_name */
     sizeof(dirstateItemObject),        /* tp_basicsize */
     0,                                 /* tp_itemsize */
     (destructor)dirstate_item_dealloc, /* tp_dealloc */
     0,                                 /* tp_print */
     0,                                 /* tp_getattr */
     0,                                 /* tp_setattr */
     0,                                 /* tp_compare */
     0,                                 /* tp_repr */
     0,                                 /* tp_as_number */
     0,                                 /* tp_as_sequence */
     0,                                 /* tp_as_mapping */
     0,                                 /* tp_hash  */
     0,                                 /* tp_call */
     0,                                 /* tp_str */
     0,                                 /* tp_getattro */
     0,                                 /* tp_setattro */
     0,                                 /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT,                /* tp_flags */
     "dirstate tuple",                  /* tp_doc */
     0,                                 /* tp_traverse */
     0,                                 /* tp_clear */
     0,                                 /* tp_richcompare */
     0,                                 /* tp_weaklistoffset */
     0,                                 /* tp_iter */
     0,                                 /* tp_iternext */
     dirstate_item_methods,             /* tp_methods */
     0,                                 /* tp_members */
     dirstate_item_getset,              /* tp_getset */
     0,                                 /* tp_base */
     0,                                 /* tp_dict */
     0,                                 /* tp_descr_get */
     0,                                 /* tp_descr_set */
     0,                                 /* tp_dictoffset */
     0,                                 /* tp_init */
     0,                                 /* tp_alloc */
     dirstate_item_new,                 /* tp_new */
 };
 
 static PyObject *parse_dirstate(PyObject *self, PyObject *args)
 {
 	PyObject *dmap, *cmap, *parents = NULL, *ret = NULL;
 	PyObject *fname = NULL, *cname = NULL, *entry = NULL;
 	char state, *cur, *str, *cpos;
 	int mode, size, mtime;
 	unsigned int flen, pos = 40;
 	Py_ssize_t len = 40;
 	Py_ssize_t readlen;
 
 	if (!PyArg_ParseTuple(args, "O!O!y#:parse_dirstate", &PyDict_Type,
 	                      &dmap, &PyDict_Type, &cmap, &str, &readlen)) {
 		goto quit;
 	}
 
 	len = readlen;
 
 	/* read parents */
 	if (len < 40) {
 		PyErr_SetString(PyExc_ValueError,
 		                "too little data for parents");
 		goto quit;
 	}
 
 	parents = Py_BuildValue("y#y#", str, (Py_ssize_t)20, str + 20,
 	                        (Py_ssize_t)20);
 	if (!parents) {
 		goto quit;
 	}
 
 	/* read filenames */
 	while (pos >= 40 && pos < len) {
 		if (pos + 17 > len) {
 			PyErr_SetString(PyExc_ValueError,
 			                "overflow in dirstate");
 			goto quit;
 		}
 		cur = str + pos;
 		/* unpack header */
 		state = *cur;
 		mode = getbe32(cur + 1);
 		size = getbe32(cur + 5);
 		mtime = getbe32(cur + 9);
 		flen = getbe32(cur + 13);
 		pos += 17;
 		cur += 17;
 		if (flen > len - pos) {
 			PyErr_SetString(PyExc_ValueError,
 			                "overflow in dirstate");
 			goto quit;
 		}
 
 		entry = (PyObject *)dirstate_item_from_v1_data(state, mode,
 		                                               size, mtime);
 		if (!entry)
 			goto quit;
 		cpos = memchr(cur, 0, flen);
 		if (cpos) {
 			fname = PyBytes_FromStringAndSize(cur, cpos - cur);
 			cname = PyBytes_FromStringAndSize(
 			    cpos + 1, flen - (cpos - cur) - 1);
 			if (!fname || !cname ||
 			    PyDict_SetItem(cmap, fname, cname) == -1 ||
 			    PyDict_SetItem(dmap, fname, entry) == -1) {
 				goto quit;
 			}
 			Py_DECREF(cname);
 		} else {
 			fname = PyBytes_FromStringAndSize(cur, flen);
 			if (!fname ||
 			    PyDict_SetItem(dmap, fname, entry) == -1) {
 				goto quit;
 			}
 		}
 		Py_DECREF(fname);
 		Py_DECREF(entry);
 		fname = cname = entry = NULL;
 		pos += flen;
 	}
 
 	ret = parents;
 	Py_INCREF(ret);
 quit:
 	Py_XDECREF(fname);
 	Py_XDECREF(cname);
 	Py_XDECREF(entry);
 	Py_XDECREF(parents);
 	return ret;
 }
 
 /*
  * Efficiently pack a dirstate object into its on-disk format.
  */
 static PyObject *pack_dirstate(PyObject *self, PyObject *args)
 {
 	PyObject *packobj = NULL;
 	PyObject *map, *copymap, *pl, *mtime_unset = NULL;
 	Py_ssize_t nbytes, pos, l;
 	PyObject *k, *v = NULL, *pn;
 	char *p, *s;
 
 	if (!PyArg_ParseTuple(args, "O!O!O!:pack_dirstate", &PyDict_Type, &map,
 	                      &PyDict_Type, &copymap, &PyTuple_Type, &pl)) {
 		return NULL;
 	}
 
 	if (PyTuple_Size(pl) != 2) {
 		PyErr_SetString(PyExc_TypeError, "expected 2-element tuple");
 		return NULL;
 	}
 
 	/* Figure out how much we need to allocate. */
 	for (nbytes = 40, pos = 0; PyDict_Next(map, &pos, &k, &v);) {
 		PyObject *c;
 		if (!PyBytes_Check(k)) {
 			PyErr_SetString(PyExc_TypeError, "expected string key");
 			goto bail;
 		}
 		nbytes += PyBytes_GET_SIZE(k) + 17;
 		c = PyDict_GetItem(copymap, k);
 		if (c) {
 			if (!PyBytes_Check(c)) {
 				PyErr_SetString(PyExc_TypeError,
 				                "expected string key");
 				goto bail;
 			}
 			nbytes += PyBytes_GET_SIZE(c) + 1;
 		}
 	}
 
 	packobj = PyBytes_FromStringAndSize(NULL, nbytes);
 	if (packobj == NULL) {
 		goto bail;
 	}
 
 	p = PyBytes_AS_STRING(packobj);
 
 	pn = PyTuple_GET_ITEM(pl, 0);
 	if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {
 		PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");
 		goto bail;
 	}
 	memcpy(p, s, l);
 	p += 20;
 	pn = PyTuple_GET_ITEM(pl, 1);
 	if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {
 		PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");
 		goto bail;
 	}
 	memcpy(p, s, l);
 	p += 20;
 
 	for (pos = 0; PyDict_Next(map, &pos, &k, &v);) {
 		dirstateItemObject *tuple;
 		char state;
 		int mode, size, mtime;
 		Py_ssize_t len, l;
 		PyObject *o;
 		char *t;
 
 		if (!dirstate_tuple_check(v)) {
 			PyErr_SetString(PyExc_TypeError,
 			                "expected a dirstate tuple");
 			goto bail;
 		}
 		tuple = (dirstateItemObject *)v;
 
 		state = dirstate_item_c_v1_state(tuple);
 		mode = dirstate_item_c_v1_mode(tuple);
 		size = dirstate_item_c_v1_size(tuple);
 		mtime = dirstate_item_c_v1_mtime(tuple);
 		*p++ = state;
 		putbe32((uint32_t)mode, p);
 		putbe32((uint32_t)size, p + 4);
 		putbe32((uint32_t)mtime, p + 8);
 		t = p + 12;
 		p += 16;
 		len = PyBytes_GET_SIZE(k);
 		memcpy(p, PyBytes_AS_STRING(k), len);
 		p += len;
 		o = PyDict_GetItem(copymap, k);
 		if (o) {
 			*p++ = '\0';
 			l = PyBytes_GET_SIZE(o);
 			memcpy(p, PyBytes_AS_STRING(o), l);
 			p += l;
 			len += l + 1;
 		}
 		putbe32((uint32_t)len, t);
 	}
 
 	pos = p - PyBytes_AS_STRING(packobj);
 	if (pos != nbytes) {
 		PyErr_Format(PyExc_SystemError, "bad dirstate size: %ld != %ld",
 		             (long)pos, (long)nbytes);
 		goto bail;
 	}
 
 	return packobj;
 bail:
 	Py_XDECREF(mtime_unset);
 	Py_XDECREF(packobj);
 	Py_XDECREF(v);
 	return NULL;
 }
 
 #define BUMPED_FIX 1
 #define USING_SHA_256 2
 #define FM1_HEADER_SIZE (4 + 8 + 2 + 2 + 1 + 1 + 1)
 
 static PyObject *readshas(const char *source, unsigned char num,
                           Py_ssize_t hashwidth)
 {
 	int i;
 	PyObject *list = PyTuple_New(num);
 	if (list == NULL) {
 		return NULL;
 	}
 	for (i = 0; i < num; i++) {
 		PyObject *hash = PyBytes_FromStringAndSize(source, hashwidth);
 		if (hash == NULL) {
 			Py_DECREF(list);
 			return NULL;
 		}
 		PyTuple_SET_ITEM(list, i, hash);
 		source += hashwidth;
 	}
 	return list;
 }
 
 static PyObject *fm1readmarker(const char *databegin, const char *dataend,
                                uint32_t *msize)
 {
 	const char *data = databegin;
 	const char *meta;
 
 	double mtime;
 	int16_t tz;
 	uint16_t flags;
 	unsigned char nsuccs, nparents, nmetadata;
 	Py_ssize_t hashwidth = 20;
 
 	PyObject *prec = NULL, *parents = NULL, *succs = NULL;
 	PyObject *metadata = NULL, *ret = NULL;
 	int i;
 
 	if (data + FM1_HEADER_SIZE > dataend) {
 		goto overflow;
 	}
 
 	*msize = getbe32(data);
 	data += 4;
 	mtime = getbefloat64(data);
 	data += 8;
 	tz = getbeint16(data);
 	data += 2;
 	flags = getbeuint16(data);
 	data += 2;
 
 	if (flags & USING_SHA_256) {
 		hashwidth = 32;
 	}
 
 	nsuccs = (unsigned char)(*data++);
 	nparents = (unsigned char)(*data++);
 	nmetadata = (unsigned char)(*data++);
 
 	if (databegin + *msize > dataend) {
 		goto overflow;
 	}
 	dataend = databegin + *msize; /* narrow down to marker size */
 
 	if (data + hashwidth > dataend) {
 		goto overflow;
 	}
 	prec = PyBytes_FromStringAndSize(data, hashwidth);
 	data += hashwidth;
 	if (prec == NULL) {
 		goto bail;
 	}
 
 	if (data + nsuccs * hashwidth > dataend) {
 		goto overflow;
 	}
 	succs = readshas(data, nsuccs, hashwidth);
 	if (succs == NULL) {
 		goto bail;
 	}
 	data += nsuccs * hashwidth;
 
 	if (nparents == 1 || nparents == 2) {
 		if (data + nparents * hashwidth > dataend) {
 			goto overflow;
 		}
 		parents = readshas(data, nparents, hashwidth);
 		if (parents == NULL) {
 			goto bail;
 		}
 		data += nparents * hashwidth;
 	} else {
 		parents = Py_None;
 		Py_INCREF(parents);
 	}
 
 	if (data + 2 * nmetadata > dataend) {
 		goto overflow;
 	}
 	meta = data + (2 * nmetadata);
 	metadata = PyTuple_New(nmetadata);
 	if (metadata == NULL) {
 		goto bail;
 	}
 	for (i = 0; i < nmetadata; i++) {
 		PyObject *tmp, *left = NULL, *right = NULL;
 		Py_ssize_t leftsize = (unsigned char)(*data++);
 		Py_ssize_t rightsize = (unsigned char)(*data++);
 		if (meta + leftsize + rightsize > dataend) {
 			goto overflow;
 		}
 		left = PyBytes_FromStringAndSize(meta, leftsize);
 		meta += leftsize;
 		right = PyBytes_FromStringAndSize(meta, rightsize);
 		meta += rightsize;
 		tmp = PyTuple_New(2);
 		if (!left || !right || !tmp) {
 			Py_XDECREF(left);
 			Py_XDECREF(right);
 			Py_XDECREF(tmp);
 			goto bail;
 		}
 		PyTuple_SET_ITEM(tmp, 0, left);
 		PyTuple_SET_ITEM(tmp, 1, right);
 		PyTuple_SET_ITEM(metadata, i, tmp);
 	}
 	ret = Py_BuildValue("(OOHO(di)O)", prec, succs, flags, metadata, mtime,
 	                    (int)tz * 60, parents);
 	goto bail; /* return successfully */
 
 overflow:
 	PyErr_SetString(PyExc_ValueError, "overflow in obsstore");
 bail:
 	Py_XDECREF(prec);
 	Py_XDECREF(succs);
 	Py_XDECREF(metadata);
 	Py_XDECREF(parents);
 	return ret;
 }
 
 static PyObject *fm1readmarkers(PyObject *self, PyObject *args)
 {
 	const char *data, *dataend;
 	Py_ssize_t datalen, offset, stop;
 	PyObject *markers = NULL;
 
 	if (!PyArg_ParseTuple(args, "y#nn", &data, &datalen, &offset, &stop)) {
 		return NULL;
 	}
 	if (offset < 0) {
 		PyErr_SetString(PyExc_ValueError,
 		                "invalid negative offset in fm1readmarkers");
 		return NULL;
 	}
 	if (stop > datalen) {
 		PyErr_SetString(
 		    PyExc_ValueError,
 		    "stop longer than data length in fm1readmarkers");
 		return NULL;
 	}
 	dataend = data + datalen;
 	data += offset;
 	markers = PyList_New(0);
 	if (!markers) {
 		return NULL;
 	}
 	while (offset < stop) {
 		uint32_t msize;
 		int error;
 		PyObject *record = fm1readmarker(data, dataend, &msize);
 		if (!record) {
 			goto bail;
 		}
 		error = PyList_Append(markers, record);
 		Py_DECREF(record);
 		if (error) {
 			goto bail;
 		}
 		data += msize;
 		offset += msize;
 	}
 	return markers;
 bail:
 	Py_DECREF(markers);
 	return NULL;
 }
 
 static char parsers_doc[] = "Efficient content parsing.";
 
 PyObject *encodedir(PyObject *self, PyObject *args);
 PyObject *pathencode(PyObject *self, PyObject *args);
 PyObject *lowerencode(PyObject *self, PyObject *args);
 PyObject *parse_index2(PyObject *self, PyObject *args, PyObject *kwargs);
 
 static PyMethodDef methods[] = {
     {"pack_dirstate", pack_dirstate, METH_VARARGS, "pack a dirstate\n"},
     {"parse_dirstate", parse_dirstate, METH_VARARGS, "parse a dirstate\n"},
     {"parse_index2", (PyCFunction)parse_index2, METH_VARARGS | METH_KEYWORDS,
      "parse a revlog index\n"},
     {"isasciistr", isasciistr, METH_VARARGS, "check if an ASCII string\n"},
     {"asciilower", asciilower, METH_VARARGS, "lowercase an ASCII string\n"},
     {"asciiupper", asciiupper, METH_VARARGS, "uppercase an ASCII string\n"},
     {"dict_new_presized", dict_new_presized, METH_VARARGS,
      "construct a dict with an expected size\n"},
     {"make_file_foldmap", make_file_foldmap, METH_VARARGS,
      "make file foldmap\n"},
     {"jsonescapeu8fast", jsonescapeu8fast, METH_VARARGS,
      "escape a UTF-8 byte string to JSON (fast path)\n"},
     {"encodedir", encodedir, METH_VARARGS, "encodedir a path\n"},
     {"pathencode", pathencode, METH_VARARGS, "fncache-encode a path\n"},
     {"lowerencode", lowerencode, METH_VARARGS, "lower-encode a path\n"},
     {"fm1readmarkers", fm1readmarkers, METH_VARARGS,
      "parse v1 obsolete markers\n"},
     {NULL, NULL}};
 
 void dirs_module_init(PyObject *mod);
 void manifest_module_init(PyObject *mod);
 void revlog_module_init(PyObject *mod);
 
 static const int version = 20;
 
 static void module_init(PyObject *mod)
 {
 	PyModule_AddIntConstant(mod, "version", version);
 
 	/* This module constant has two purposes.  First, it lets us unit test
 	 * the ImportError raised without hard-coding any error text.  This
 	 * means we can change the text in the future without breaking tests,
 	 * even across changesets without a recompile.  Second, its presence
 	 * can be used to determine whether the version-checking logic is
 	 * present, which also helps in testing across changesets without a
 	 * recompile.  Note that this means the pure-Python version of parsers
 	 * should not have this module constant. */
 	PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext);
 
 	dirs_module_init(mod);
 	manifest_module_init(mod);
 	revlog_module_init(mod);
 
 	if (PyType_Ready(&dirstateItemType) < 0) {
 		return;
 	}
 	Py_INCREF(&dirstateItemType);
 	PyModule_AddObject(mod, "DirstateItem", (PyObject *)&dirstateItemType);
 }
 
 static int check_python_version(void)
 {
 	PyObject *sys = PyImport_ImportModule("sys"), *ver;
 	long hexversion;
 	if (!sys) {
 		return -1;
 	}
 	ver = PyObject_GetAttrString(sys, "hexversion");
 	Py_DECREF(sys);
 	if (!ver) {
 		return -1;
 	}
 	hexversion = PyLong_AsLong(ver);
 	Py_DECREF(ver);
 	/* sys.hexversion is a 32-bit number by default, so the -1 case
 	 * should only occur in unusual circumstances (e.g. if sys.hexversion
 	 * is manually set to an invalid value). */
 	if ((hexversion == -1) || (hexversion >> 16 != PY_VERSION_HEX >> 16)) {
 		PyErr_Format(PyExc_ImportError,
 		             "%s: The Mercurial extension "
 		             "modules were compiled with Python " PY_VERSION
 		             ", but "
 		             "Mercurial is currently using Python with "
 		             "sys.hexversion=%ld: "
 		             "Python %s\n at: %s",
 		             versionerrortext, hexversion, Py_GetVersion(),
 		             Py_GetProgramFullPath());
 		return -1;
 	}
 	return 0;
 }
 
 static struct PyModuleDef parsers_module = {PyModuleDef_HEAD_INIT, "parsers",
                                             parsers_doc, -1, methods};
 
 PyMODINIT_FUNC PyInit_parsers(void)
 {
 	PyObject *mod;
 
 	if (check_python_version() == -1)
 		return NULL;
 	mod = PyModule_Create(&parsers_module);
 	module_init(mod);
 	return mod;
 }

mercurial/pure/parsers.py

@@ -1,974 +1,974 b''
 # parsers.py - Python implementation of parsers.c
 #
 # Copyright 2009 Olivia Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import io
 import stat
 import struct
 import zlib
 
 from ..node import (
     nullrev,
     sha1nodeconstants,
 )
 from ..thirdparty import attr
 from .. import (
     error,
     revlogutils,
     util,
 )
 
 from ..revlogutils import nodemap as nodemaputil
 from ..revlogutils import constants as revlog_constants
 
 stringio = io.BytesIO
 
 
 _pack = struct.pack
 _unpack = struct.unpack
 _compress = zlib.compress
 _decompress = zlib.decompress
 
 
 # a special value used internally for `size` if the file come from the other parent
 FROM_P2 = -2
 
 # a special value used internally for `size` if the file is modified/merged/added
 NONNORMAL = -1
 
 # a special value used internally for `time` if the time is ambigeous
 AMBIGUOUS_TIME = -1
 
 # Bits of the `flags` byte inside a node in the file format
 DIRSTATE_V2_WDIR_TRACKED = 1 << 0
 DIRSTATE_V2_P1_TRACKED = 1 << 1
 DIRSTATE_V2_P2_INFO = 1 << 2
 DIRSTATE_V2_MODE_EXEC_PERM = 1 << 3
 DIRSTATE_V2_MODE_IS_SYMLINK = 1 << 4
 DIRSTATE_V2_HAS_FALLBACK_EXEC = 1 << 5
 DIRSTATE_V2_FALLBACK_EXEC = 1 << 6
 DIRSTATE_V2_HAS_FALLBACK_SYMLINK = 1 << 7
 DIRSTATE_V2_FALLBACK_SYMLINK = 1 << 8
 DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED = 1 << 9
 DIRSTATE_V2_HAS_MODE_AND_SIZE = 1 << 10
 DIRSTATE_V2_HAS_MTIME = 1 << 11
 DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS = 1 << 12
 DIRSTATE_V2_DIRECTORY = 1 << 13
 DIRSTATE_V2_ALL_UNKNOWN_RECORDED = 1 << 14
 DIRSTATE_V2_ALL_IGNORED_RECORDED = 1 << 15
 
 
 @attr.s(slots=True, init=False)
 class DirstateItem:
     """represent a dirstate entry
 
     It hold multiple attributes
 
     # about file tracking
     - wc_tracked: is the file tracked by the working copy
     - p1_tracked: is the file tracked in working copy first parent
     - p2_info: the file has been involved in some merge operation. Either
                because it was actually merged, or because the p2 version was
                ahead, or because some rename moved it there. In either case
                `hg status` will want it displayed as modified.
 
     # about the file state expected from p1 manifest:
     - mode: the file mode in p1
     - size: the file size in p1
 
     These value can be set to None, which mean we don't have a meaningful value
     to compare with. Either because we don't really care about them as there
     `status` is known without having to look at the disk or because we don't
     know these right now and a full comparison will be needed to find out if
     the file is clean.
 
     # about the file state on disk last time we saw it:
     - mtime: the last known clean mtime for the file.
 
     This value can be set to None if no cachable state exist. Either because we
     do not care (see previous section) or because we could not cache something
     yet.
     """
 
     _wc_tracked = attr.ib()
     _p1_tracked = attr.ib()
     _p2_info = attr.ib()
     _mode = attr.ib()
     _size = attr.ib()
     _mtime_s = attr.ib()
     _mtime_ns = attr.ib()
     _fallback_exec = attr.ib()
     _fallback_symlink = attr.ib()
     _mtime_second_ambiguous = attr.ib()
 
     def __init__(
         self,
         wc_tracked=False,
         p1_tracked=False,
         p2_info=False,
         has_meaningful_data=True,
         has_meaningful_mtime=True,
         parentfiledata=None,
         fallback_exec=None,
         fallback_symlink=None,
     ):
         self._wc_tracked = wc_tracked
         self._p1_tracked = p1_tracked
         self._p2_info = p2_info
 
         self._fallback_exec = fallback_exec
         self._fallback_symlink = fallback_symlink
 
         self._mode = None
         self._size = None
         self._mtime_s = None
         self._mtime_ns = None
         self._mtime_second_ambiguous = False
         if parentfiledata is None:
             has_meaningful_mtime = False
             has_meaningful_data = False
         elif parentfiledata[2] is None:
             has_meaningful_mtime = False
         if has_meaningful_data:
             self._mode = parentfiledata[0]
             self._size = parentfiledata[1]
         if has_meaningful_mtime:
             (
                 self._mtime_s,
                 self._mtime_ns,
                 self._mtime_second_ambiguous,
             ) = parentfiledata[2]
 
     @classmethod
     def from_v2_data(cls, flags, size, mtime_s, mtime_ns):
         """Build a new DirstateItem object from V2 data"""
         has_mode_size = bool(flags & DIRSTATE_V2_HAS_MODE_AND_SIZE)
         has_meaningful_mtime = bool(flags & DIRSTATE_V2_HAS_MTIME)
         mode = None
 
         if flags & +DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED:
             # we do not have support for this flag in the code yet,
             # force a lookup for this file.
             has_mode_size = False
             has_meaningful_mtime = False
 
         fallback_exec = None
         if flags & DIRSTATE_V2_HAS_FALLBACK_EXEC:
             fallback_exec = flags & DIRSTATE_V2_FALLBACK_EXEC
 
         fallback_symlink = None
         if flags & DIRSTATE_V2_HAS_FALLBACK_SYMLINK:
             fallback_symlink = flags & DIRSTATE_V2_FALLBACK_SYMLINK
 
         if has_mode_size:
             assert stat.S_IXUSR == 0o100
             if flags & DIRSTATE_V2_MODE_EXEC_PERM:
                 mode = 0o755
             else:
                 mode = 0o644
             if flags & DIRSTATE_V2_MODE_IS_SYMLINK:
                 mode |= stat.S_IFLNK
             else:
                 mode |= stat.S_IFREG
 
         second_ambiguous = flags & DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS
         return cls(
             wc_tracked=bool(flags & DIRSTATE_V2_WDIR_TRACKED),
             p1_tracked=bool(flags & DIRSTATE_V2_P1_TRACKED),
             p2_info=bool(flags & DIRSTATE_V2_P2_INFO),
             has_meaningful_data=has_mode_size,
             has_meaningful_mtime=has_meaningful_mtime,
             parentfiledata=(mode, size, (mtime_s, mtime_ns, second_ambiguous)),
             fallback_exec=fallback_exec,
             fallback_symlink=fallback_symlink,
         )
 
     @classmethod
     def from_v1_data(cls, state, mode, size, mtime):
         """Build a new DirstateItem object from V1 data
 
         Since the dirstate-v1 format is frozen, the signature of this function
         is not expected to change, unlike the __init__ one.
         """
         if state == b'm':
             return cls(wc_tracked=True, p1_tracked=True, p2_info=True)
         elif state == b'a':
             return cls(wc_tracked=True)
         elif state == b'r':
             if size == NONNORMAL:
                 p1_tracked = True
                 p2_info = True
             elif size == FROM_P2:
                 p1_tracked = False
                 p2_info = True
             else:
                 p1_tracked = True
                 p2_info = False
             return cls(p1_tracked=p1_tracked, p2_info=p2_info)
         elif state == b'n':
             if size == FROM_P2:
                 return cls(wc_tracked=True, p2_info=True)
             elif size == NONNORMAL:
                 return cls(wc_tracked=True, p1_tracked=True)
             elif mtime == AMBIGUOUS_TIME:
                 return cls(
                     wc_tracked=True,
                     p1_tracked=True,
                     has_meaningful_mtime=False,
                     parentfiledata=(mode, size, (42, 0, False)),
                 )
             else:
                 return cls(
                     wc_tracked=True,
                     p1_tracked=True,
                     parentfiledata=(mode, size, (mtime, 0, False)),
                 )
         else:
             raise RuntimeError(b'unknown state: %s' % state)
 
     def set_possibly_dirty(self):
         """Mark a file as "possibly dirty"
 
         This means the next status call will have to actually check its content
         to make sure it is correct.
         """
         self._mtime_s = None
         self._mtime_ns = None
 
     def set_clean(self, mode, size, mtime):
         """mark a file as "clean" cancelling potential "possibly dirty call"
 
         Note: this function is a descendant of `dirstate.normal` and is
         currently expected to be call on "normal" entry only. There are not
         reason for this to not change in the future as long as the ccode is
         updated to preserve the proper state of the non-normal files.
         """
         self._wc_tracked = True
         self._p1_tracked = True
         self._mode = mode
         self._size = size
         self._mtime_s, self._mtime_ns, self._mtime_second_ambiguous = mtime
 
     def set_tracked(self):
         """mark a file as tracked in the working copy
 
         This will ultimately be called by command like `hg add`.
         """
         self._wc_tracked = True
         # `set_tracked` is replacing various `normallookup` call. So we mark
         # the files as needing lookup
         #
         # Consider dropping this in the future in favor of something less broad.
         self._mtime_s = None
         self._mtime_ns = None
 
     def set_untracked(self):
         """mark a file as untracked in the working copy
 
         This will ultimately be called by command like `hg remove`.
         """
         self._wc_tracked = False
         self._mode = None
         self._size = None
         self._mtime_s = None
         self._mtime_ns = None
 
     def drop_merge_data(self):
         """remove all "merge-only" from a DirstateItem
 
         This is to be call by the dirstatemap code when the second parent is dropped
         """
         if self._p2_info:
             self._p2_info = False
             self._mode = None
             self._size = None
             self._mtime_s = None
             self._mtime_ns = None
 
     @property
     def mode(self):
-        return self.v1_mode()
+        return self._v1_mode()
 
     @property
     def size(self):
-        return self.v1_size()
+        return self._v1_size()
 
     @property
     def mtime(self):
-        return self.v1_mtime()
+        return self._v1_mtime()
 
     def mtime_likely_equal_to(self, other_mtime):
         self_sec = self._mtime_s
         if self_sec is None:
             return False
         self_ns = self._mtime_ns
         other_sec, other_ns, second_ambiguous = other_mtime
         if self_sec != other_sec:
             # seconds are different theses mtime are definitly not equal
             return False
         elif other_ns == 0 or self_ns == 0:
             # at least one side as no nano-seconds information
 
             if self._mtime_second_ambiguous:
                 # We cannot trust the mtime in this case
                 return False
             else:
                 # the "seconds" value was reliable on its own. We are good to go.
                 return True
         else:
             # We have nano second information, let us use them !
             return self_ns == other_ns
 
     @property
     def state(self):
         """
         States are:
           n  normal
           m  needs merging
           r  marked for removal
           a  marked for addition
 
         XXX This "state" is a bit obscure and mostly a direct expression of the
         dirstatev1 format. It would make sense to ultimately deprecate it in
         favor of the more "semantic" attributes.
         """
         if not self.any_tracked:
             return b'?'
-        return self.v1_state()
+        return self._v1_state()
 
     @property
     def has_fallback_exec(self):
         """True if "fallback" information are available for the "exec" bit
 
         Fallback information can be stored in the dirstate to keep track of
         filesystem attribute tracked by Mercurial when the underlying file
         system or operating system does not support that property, (e.g.
         Windows).
 
         Not all version of the dirstate on-disk storage support preserving this
         information.
         """
         return self._fallback_exec is not None
 
     @property
     def fallback_exec(self):
         """ "fallback" information for the executable bit
 
         True if the file should be considered executable when we cannot get
         this information from the files system. False if it should be
         considered non-executable.
 
         See has_fallback_exec for details."""
         return self._fallback_exec
 
     @fallback_exec.setter
     def set_fallback_exec(self, value):
         """control "fallback" executable bit
 
         Set to:
         - True if the file should be considered executable,
         - False if the file should be considered non-executable,
         - None if we do not have valid fallback data.
 
         See has_fallback_exec for details."""
         if value is None:
             self._fallback_exec = None
         else:
             self._fallback_exec = bool(value)
 
     @property
     def has_fallback_symlink(self):
         """True if "fallback" information are available for symlink status
 
         Fallback information can be stored in the dirstate to keep track of
         filesystem attribute tracked by Mercurial when the underlying file
         system or operating system does not support that property, (e.g.
         Windows).
 
         Not all version of the dirstate on-disk storage support preserving this
         information."""
         return self._fallback_symlink is not None
 
     @property
     def fallback_symlink(self):
         """ "fallback" information for symlink status
 
         True if the file should be considered executable when we cannot get
         this information from the files system. False if it should be
         considered non-executable.
 
         See has_fallback_exec for details."""
         return self._fallback_symlink
 
     @fallback_symlink.setter
     def set_fallback_symlink(self, value):
         """control "fallback" symlink status
 
         Set to:
         - True if the file should be considered a symlink,
         - False if the file should be considered not a symlink,
         - None if we do not have valid fallback data.
 
         See has_fallback_symlink for details."""
         if value is None:
             self._fallback_symlink = None
         else:
             self._fallback_symlink = bool(value)
 
     @property
     def tracked(self):
         """True is the file is tracked in the working copy"""
         return self._wc_tracked
 
     @property
     def any_tracked(self):
         """True is the file is tracked anywhere (wc or parents)"""
         return self._wc_tracked or self._p1_tracked or self._p2_info
 
     @property
     def added(self):
         """True if the file has been added"""
         return self._wc_tracked and not (self._p1_tracked or self._p2_info)
 
     @property
     def maybe_clean(self):
         """True if the file has a chance to be in the "clean" state"""
         if not self._wc_tracked:
             return False
         elif not self._p1_tracked:
             return False
         elif self._p2_info:
             return False
         return True
 
     @property
     def p1_tracked(self):
         """True if the file is tracked in the first parent manifest"""
         return self._p1_tracked
 
     @property
     def p2_info(self):
         """True if the file needed to merge or apply any input from p2
 
         See the class documentation for details.
         """
         return self._wc_tracked and self._p2_info
 
     @property
     def removed(self):
         """True if the file has been removed"""
         return not self._wc_tracked and (self._p1_tracked or self._p2_info)
 
     def v2_data(self):
         """Returns (flags, mode, size, mtime) for v2 serialization"""
         flags = 0
         if self._wc_tracked:
             flags |= DIRSTATE_V2_WDIR_TRACKED
         if self._p1_tracked:
             flags |= DIRSTATE_V2_P1_TRACKED
         if self._p2_info:
             flags |= DIRSTATE_V2_P2_INFO
         if self._mode is not None and self._size is not None:
             flags |= DIRSTATE_V2_HAS_MODE_AND_SIZE
             if self.mode & stat.S_IXUSR:
                 flags |= DIRSTATE_V2_MODE_EXEC_PERM
             if stat.S_ISLNK(self.mode):
                 flags |= DIRSTATE_V2_MODE_IS_SYMLINK
         if self._mtime_s is not None:
             flags |= DIRSTATE_V2_HAS_MTIME
         if self._mtime_second_ambiguous:
             flags |= DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS
 
         if self._fallback_exec is not None:
             flags |= DIRSTATE_V2_HAS_FALLBACK_EXEC
             if self._fallback_exec:
                 flags |= DIRSTATE_V2_FALLBACK_EXEC
 
         if self._fallback_symlink is not None:
             flags |= DIRSTATE_V2_HAS_FALLBACK_SYMLINK
             if self._fallback_symlink:
                 flags |= DIRSTATE_V2_FALLBACK_SYMLINK
 
         # Note: we do not need to do anything regarding
         # DIRSTATE_V2_ALL_UNKNOWN_RECORDED and DIRSTATE_V2_ALL_IGNORED_RECORDED
         # since we never set _DIRSTATE_V2_HAS_DIRCTORY_MTIME
         return (flags, self._size or 0, self._mtime_s or 0, self._mtime_ns or 0)
 
-    def v1_state(self):
+    def _v1_state(self):
         """return a "state" suitable for v1 serialization"""
         if not self.any_tracked:
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed:
             return b'r'
         elif self._p1_tracked and self._p2_info:
             return b'm'
         elif self.added:
             return b'a'
         else:
             return b'n'
 
-    def v1_mode(self):
+    def _v1_mode(self):
         """return a "mode" suitable for v1 serialization"""
         return self._mode if self._mode is not None else 0
 
-    def v1_size(self):
+    def _v1_size(self):
         """return a "size" suitable for v1 serialization"""
         if not self.any_tracked:
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed and self._p1_tracked and self._p2_info:
             return NONNORMAL
         elif self._p2_info:
             return FROM_P2
         elif self.removed:
             return 0
         elif self.added:
             return NONNORMAL
         elif self._size is None:
             return NONNORMAL
         else:
             return self._size
 
-    def v1_mtime(self):
+    def _v1_mtime(self):
         """return a "mtime" suitable for v1 serialization"""
         if not self.any_tracked:
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed:
             return 0
         elif self._mtime_s is None:
             return AMBIGUOUS_TIME
         elif self._p2_info:
             return AMBIGUOUS_TIME
         elif not self._p1_tracked:
             return AMBIGUOUS_TIME
         elif self._mtime_second_ambiguous:
             return AMBIGUOUS_TIME
         else:
             return self._mtime_s
 
 
 def gettype(q):
     return int(q & 0xFFFF)
 
 
 class BaseIndexObject:
     # Can I be passed to an algorithme implemented in Rust ?
     rust_ext_compat = 0
     # Format of an index entry according to Python's `struct` language
     index_format = revlog_constants.INDEX_ENTRY_V1
     # Size of a C unsigned long long int, platform independent
     big_int_size = struct.calcsize(b'>Q')
     # Size of a C long int, platform independent
     int_size = struct.calcsize(b'>i')
     # An empty index entry, used as a default value to be overridden, or nullrev
     null_item = (
         0,
         0,
         0,
         -1,
         -1,
         -1,
         -1,
         sha1nodeconstants.nullid,
         0,
         0,
         revlog_constants.COMP_MODE_INLINE,
         revlog_constants.COMP_MODE_INLINE,
         revlog_constants.RANK_UNKNOWN,
     )
 
     @util.propertycache
     def entry_size(self):
         return self.index_format.size
 
     @util.propertycache
     def _nodemap(self):
         nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
         for r in range(0, len(self)):
             n = self[r][7]
             nodemap[n] = r
         return nodemap
 
     def has_node(self, node):
         """return True if the node exist in the index"""
         return node in self._nodemap
 
     def rev(self, node):
         """return a revision for a node
 
         If the node is unknown, raise a RevlogError"""
         return self._nodemap[node]
 
     def get_rev(self, node):
         """return a revision for a node
 
         If the node is unknown, return None"""
         return self._nodemap.get(node)
 
     def _stripnodes(self, start):
         if '_nodemap' in vars(self):
             for r in range(start, len(self)):
                 n = self[r][7]
                 del self._nodemap[n]
 
     def clearcaches(self):
         self.__dict__.pop('_nodemap', None)
 
     def __len__(self):
         return self._lgt + len(self._extra)
 
     def append(self, tup):
         if '_nodemap' in vars(self):
             self._nodemap[tup[7]] = len(self)
         data = self._pack_entry(len(self), tup)
         self._extra.append(data)
 
     def _pack_entry(self, rev, entry):
         assert entry[8] == 0
         assert entry[9] == 0
         return self.index_format.pack(*entry[:8])
 
     def _check_index(self, i):
         if not isinstance(i, int):
             raise TypeError(b"expecting int indexes")
         if i < 0 or i >= len(self):
             raise IndexError(i)
 
     def __getitem__(self, i):
         if i == -1:
             return self.null_item
         self._check_index(i)
         if i >= self._lgt:
             data = self._extra[i - self._lgt]
         else:
             index = self._calculate_index(i)
             data = self._data[index : index + self.entry_size]
         r = self._unpack_entry(i, data)
         if self._lgt and i == 0:
             offset = revlogutils.offset_type(0, gettype(r[0]))
             r = (offset,) + r[1:]
         return r
 
     def _unpack_entry(self, rev, data):
         r = self.index_format.unpack(data)
         r = r + (
             0,
             0,
             revlog_constants.COMP_MODE_INLINE,
             revlog_constants.COMP_MODE_INLINE,
             revlog_constants.RANK_UNKNOWN,
         )
         return r
 
     def pack_header(self, header):
         """pack header information as binary"""
         v_fmt = revlog_constants.INDEX_HEADER
         return v_fmt.pack(header)
 
     def entry_binary(self, rev):
         """return the raw binary string representing a revision"""
         entry = self[rev]
         p = revlog_constants.INDEX_ENTRY_V1.pack(*entry[:8])
         if rev == 0:
             p = p[revlog_constants.INDEX_HEADER.size :]
         return p
 
 
 class IndexObject(BaseIndexObject):
     def __init__(self, data):
         assert len(data) % self.entry_size == 0, (
             len(data),
             self.entry_size,
             len(data) % self.entry_size,
         )
         self._data = data
         self._lgt = len(data) // self.entry_size
         self._extra = []
 
     def _calculate_index(self, i):
         return i * self.entry_size
 
     def __delitem__(self, i):
         if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
             raise ValueError(b"deleting slices only supports a:-1 with step 1")
         i = i.start
         self._check_index(i)
         self._stripnodes(i)
         if i < self._lgt:
             self._data = self._data[: i * self.entry_size]
             self._lgt = i
             self._extra = []
         else:
             self._extra = self._extra[: i - self._lgt]
 
 
 class PersistentNodeMapIndexObject(IndexObject):
     """a Debug oriented class to test persistent nodemap
 
     We need a simple python object to test API and higher level behavior. See
     the Rust implementation for  more serious usage. This should be used only
     through the dedicated `devel.persistent-nodemap` config.
     """
 
     def nodemap_data_all(self):
         """Return bytes containing a full serialization of a nodemap
 
         The nodemap should be valid for the full set of revisions in the
         index."""
         return nodemaputil.persistent_data(self)
 
     def nodemap_data_incremental(self):
         """Return bytes containing a incremental update to persistent nodemap
 
         This containst the data for an append-only update of the data provided
         in the last call to `update_nodemap_data`.
         """
         if self._nm_root is None:
             return None
         docket = self._nm_docket
         changed, data = nodemaputil.update_persistent_data(
             self, self._nm_root, self._nm_max_idx, self._nm_docket.tip_rev
         )
 
         self._nm_root = self._nm_max_idx = self._nm_docket = None
         return docket, changed, data
 
     def update_nodemap_data(self, docket, nm_data):
         """provide full block of persisted binary data for a nodemap
 
         The data are expected to come from disk. See `nodemap_data_all` for a
         produceur of such data."""
         if nm_data is not None:
             self._nm_root, self._nm_max_idx = nodemaputil.parse_data(nm_data)
             if self._nm_root:
                 self._nm_docket = docket
             else:
                 self._nm_root = self._nm_max_idx = self._nm_docket = None
 
 
 class InlinedIndexObject(BaseIndexObject):
     def __init__(self, data, inline=0):
         self._data = data
         self._lgt = self._inline_scan(None)
         self._inline_scan(self._lgt)
         self._extra = []
 
     def _inline_scan(self, lgt):
         off = 0
         if lgt is not None:
             self._offsets = [0] * lgt
         count = 0
         while off <= len(self._data) - self.entry_size:
             start = off + self.big_int_size
             (s,) = struct.unpack(
                 b'>i',
                 self._data[start : start + self.int_size],
             )
             if lgt is not None:
                 self._offsets[count] = off
             count += 1
             off += self.entry_size + s
         if off != len(self._data):
             raise ValueError(b"corrupted data")
         return count
 
     def __delitem__(self, i):
         if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
             raise ValueError(b"deleting slices only supports a:-1 with step 1")
         i = i.start
         self._check_index(i)
         self._stripnodes(i)
         if i < self._lgt:
             self._offsets = self._offsets[:i]
             self._lgt = i
             self._extra = []
         else:
             self._extra = self._extra[: i - self._lgt]
 
     def _calculate_index(self, i):
         return self._offsets[i]
 
 
 def parse_index2(data, inline, format=revlog_constants.REVLOGV1):
     if format == revlog_constants.CHANGELOGV2:
         return parse_index_cl_v2(data)
     if not inline:
         if format == revlog_constants.REVLOGV2:
             cls = IndexObject2
         else:
             cls = IndexObject
         return cls(data), None
     cls = InlinedIndexObject
     return cls(data, inline), (0, data)
 
 
 def parse_index_cl_v2(data):
     return IndexChangelogV2(data), None
 
 
 class IndexObject2(IndexObject):
     index_format = revlog_constants.INDEX_ENTRY_V2
 
     def replace_sidedata_info(
         self,
         rev,
         sidedata_offset,
         sidedata_length,
         offset_flags,
         compression_mode,
     ):
         """
         Replace an existing index entry's sidedata offset and length with new
         ones.
         This cannot be used outside of the context of sidedata rewriting,
         inside the transaction that creates the revision `rev`.
         """
         if rev < 0:
             raise KeyError
         self._check_index(rev)
         if rev < self._lgt:
             msg = b"cannot rewrite entries outside of this transaction"
             raise KeyError(msg)
         else:
             entry = list(self[rev])
             entry[0] = offset_flags
             entry[8] = sidedata_offset
             entry[9] = sidedata_length
             entry[11] = compression_mode
             entry = tuple(entry)
             new = self._pack_entry(rev, entry)
             self._extra[rev - self._lgt] = new
 
     def _unpack_entry(self, rev, data):
         data = self.index_format.unpack(data)
         entry = data[:10]
         data_comp = data[10] & 3
         sidedata_comp = (data[10] & (3 << 2)) >> 2
         return entry + (data_comp, sidedata_comp, revlog_constants.RANK_UNKNOWN)
 
     def _pack_entry(self, rev, entry):
         data = entry[:10]
         data_comp = entry[10] & 3
         sidedata_comp = (entry[11] & 3) << 2
         data += (data_comp | sidedata_comp,)
 
         return self.index_format.pack(*data)
 
     def entry_binary(self, rev):
         """return the raw binary string representing a revision"""
         entry = self[rev]
         return self._pack_entry(rev, entry)
 
     def pack_header(self, header):
         """pack header information as binary"""
         msg = 'version header should go in the docket, not the index: %d'
         msg %= header
         raise error.ProgrammingError(msg)
 
 
 class IndexChangelogV2(IndexObject2):
     index_format = revlog_constants.INDEX_ENTRY_CL_V2
 
     null_item = (
         IndexObject2.null_item[: revlog_constants.ENTRY_RANK]
         + (0,)  # rank of null is 0
         + IndexObject2.null_item[revlog_constants.ENTRY_RANK :]
     )
 
     def _unpack_entry(self, rev, data, r=True):
         items = self.index_format.unpack(data)
         return (
             items[revlog_constants.INDEX_ENTRY_V2_IDX_OFFSET],
             items[revlog_constants.INDEX_ENTRY_V2_IDX_COMPRESSED_LENGTH],
             items[revlog_constants.INDEX_ENTRY_V2_IDX_UNCOMPRESSED_LENGTH],
             rev,
             rev,
             items[revlog_constants.INDEX_ENTRY_V2_IDX_PARENT_1],
             items[revlog_constants.INDEX_ENTRY_V2_IDX_PARENT_2],
             items[revlog_constants.INDEX_ENTRY_V2_IDX_NODEID],
             items[revlog_constants.INDEX_ENTRY_V2_IDX_SIDEDATA_OFFSET],
             items[
                 revlog_constants.INDEX_ENTRY_V2_IDX_SIDEDATA_COMPRESSED_LENGTH
             ],
             items[revlog_constants.INDEX_ENTRY_V2_IDX_COMPRESSION_MODE] & 3,
             (items[revlog_constants.INDEX_ENTRY_V2_IDX_COMPRESSION_MODE] >> 2)
             & 3,
             items[revlog_constants.INDEX_ENTRY_V2_IDX_RANK],
         )
 
     def _pack_entry(self, rev, entry):
 
         base = entry[revlog_constants.ENTRY_DELTA_BASE]
         link_rev = entry[revlog_constants.ENTRY_LINK_REV]
         assert base == rev, (base, rev)
         assert link_rev == rev, (link_rev, rev)
         data = (
             entry[revlog_constants.ENTRY_DATA_OFFSET],
             entry[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH],
             entry[revlog_constants.ENTRY_DATA_UNCOMPRESSED_LENGTH],
             entry[revlog_constants.ENTRY_PARENT_1],
             entry[revlog_constants.ENTRY_PARENT_2],
             entry[revlog_constants.ENTRY_NODE_ID],
             entry[revlog_constants.ENTRY_SIDEDATA_OFFSET],
             entry[revlog_constants.ENTRY_SIDEDATA_COMPRESSED_LENGTH],
             entry[revlog_constants.ENTRY_DATA_COMPRESSION_MODE] & 3
             | (entry[revlog_constants.ENTRY_SIDEDATA_COMPRESSION_MODE] & 3)
             << 2,
             entry[revlog_constants.ENTRY_RANK],
         )
         return self.index_format.pack(*data)
 
 
 def parse_index_devel_nodemap(data, inline):
     """like parse_index2, but alway return a PersistentNodeMapIndexObject"""
     return PersistentNodeMapIndexObject(data), None
 
 
 def parse_dirstate(dmap, copymap, st):
     parents = [st[:20], st[20:40]]
     # dereference fields so they will be local in loop
     format = b">cllll"
     e_size = struct.calcsize(format)
     pos1 = 40
     l = len(st)
 
     # the inner loop
     while pos1 < l:
         pos2 = pos1 + e_size
         e = _unpack(b">cllll", st[pos1:pos2])  # a literal here is faster
         pos1 = pos2 + e[4]
         f = st[pos2:pos1]
         if b'\0' in f:
             f, c = f.split(b'\0')
             copymap[f] = c
         dmap[f] = DirstateItem.from_v1_data(*e[:4])
     return parents
 
 
 def pack_dirstate(dmap, copymap, pl):
     cs = stringio()
     write = cs.write
     write(b"".join(pl))
     for f, e in dmap.items():
         if f in copymap:
             f = b"%s\0%s" % (f, copymap[f])
         e = _pack(
             b">cllll",
-            e.v1_state(),
-            e.v1_mode(),
-            e.v1_size(),
-            e.v1_mtime(),
+            e._v1_state(),
+            e._v1_mode(),
+            e._v1_size(),
+            e._v1_mtime(),
             len(f),
         )
         write(e)
         write(f)
     return cs.getvalue()

rust/hg-cpython/src/dirstate/item.rs

@@ -1,285 +1,246 b''
 use cpython::exc;
 use cpython::ObjectProtocol;
 use cpython::PyBytes;
 use cpython::PyErr;
 use cpython::PyNone;
 use cpython::PyObject;
 use cpython::PyResult;
 use cpython::Python;
 use cpython::PythonObject;
 use hg::dirstate::DirstateEntry;
-use hg::dirstate::EntryState;
 use hg::dirstate::TruncatedTimestamp;
 use std::cell::Cell;
-use std::convert::TryFrom;
 
 py_class!(pub class DirstateItem |py| {
     data entry: Cell<DirstateEntry>;
 
     def __new__(
         _cls,
         wc_tracked: bool = false,
         p1_tracked: bool = false,
         p2_info: bool = false,
         has_meaningful_data: bool = true,
         has_meaningful_mtime: bool = true,
         parentfiledata: Option<(u32, u32, Option<(u32, u32, bool)>)> = None,
         fallback_exec: Option<bool> = None,
         fallback_symlink: Option<bool> = None,
 
     ) -> PyResult<DirstateItem> {
         let mut mode_size_opt = None;
         let mut mtime_opt = None;
         if let Some((mode, size, mtime)) = parentfiledata {
             if has_meaningful_data {
                 mode_size_opt = Some((mode, size))
             }
             if has_meaningful_mtime {
                 if let Some(m) = mtime {
                     mtime_opt = Some(timestamp(py, m)?);
                 }
             }
         }
         let entry = DirstateEntry::from_v2_data(
             wc_tracked,
             p1_tracked,
             p2_info,
             mode_size_opt,
             mtime_opt,
             fallback_exec,
             fallback_symlink,
         );
         DirstateItem::create_instance(py, Cell::new(entry))
     }
 
     @property
     def state(&self) -> PyResult<PyBytes> {
         let state_byte: u8 = self.entry(py).get().state().into();
         Ok(PyBytes::new(py, &[state_byte]))
     }
 
     @property
     def mode(&self) -> PyResult<i32> {
         Ok(self.entry(py).get().mode())
     }
 
     @property
     def size(&self) -> PyResult<i32> {
         Ok(self.entry(py).get().size())
     }
 
     @property
     def mtime(&self) -> PyResult<i32> {
         Ok(self.entry(py).get().mtime())
     }
 
     @property
     def has_fallback_exec(&self) -> PyResult<bool> {
         match self.entry(py).get().get_fallback_exec() {
             Some(_) => Ok(true),
             None => Ok(false),
         }
     }
 
     @property
     def fallback_exec(&self) -> PyResult<Option<bool>> {
         match self.entry(py).get().get_fallback_exec() {
             Some(exec) => Ok(Some(exec)),
             None => Ok(None),
         }
     }
 
     @fallback_exec.setter
     def set_fallback_exec(&self, value: Option<PyObject>) -> PyResult<()> {
         match value {
             None => {self.entry(py).get().set_fallback_exec(None);},
             Some(value) => {
             if value.is_none(py) {
                 self.entry(py).get().set_fallback_exec(None);
             } else {
                 self.entry(py).get().set_fallback_exec(
                     Some(value.is_true(py)?)
                 );
             }},
         }
         Ok(())
     }
 
     @property
     def has_fallback_symlink(&self) -> PyResult<bool> {
         match self.entry(py).get().get_fallback_symlink() {
             Some(_) => Ok(true),
             None => Ok(false),
         }
     }
 
     @property
     def fallback_symlink(&self) -> PyResult<Option<bool>> {
         match self.entry(py).get().get_fallback_symlink() {
             Some(symlink) => Ok(Some(symlink)),
             None => Ok(None),
         }
     }
 
     @fallback_symlink.setter
     def set_fallback_symlink(&self, value: Option<PyObject>) -> PyResult<()> {
         match value {
             None => {self.entry(py).get().set_fallback_symlink(None);},
             Some(value) => {
             if value.is_none(py) {
                 self.entry(py).get().set_fallback_symlink(None);
             } else {
                 self.entry(py).get().set_fallback_symlink(
                     Some(value.is_true(py)?)
                 );
             }},
         }
         Ok(())
     }
 
     @property
     def tracked(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().tracked())
     }
 
     @property
     def p1_tracked(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().p1_tracked())
     }
 
     @property
     def added(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().added())
     }
 
 
     @property
     def p2_info(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().p2_info())
     }
 
     @property
     def removed(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().removed())
     }
 
     @property
     def maybe_clean(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().maybe_clean())
     }
 
     @property
     def any_tracked(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().any_tracked())
     }
 
-    def v1_state(&self) -> PyResult<PyBytes> {
-        let (state, _mode, _size, _mtime) = self.entry(py).get().v1_data();
-        let state_byte: u8 = state.into();
-        Ok(PyBytes::new(py, &[state_byte]))
-    }
-
-    def v1_mode(&self) -> PyResult<i32> {
-        let (_state, mode, _size, _mtime) = self.entry(py).get().v1_data();
-        Ok(mode)
-    }
-
-    def v1_size(&self) -> PyResult<i32> {
-        let (_state, _mode, size, _mtime) = self.entry(py).get().v1_data();
-        Ok(size)
-    }
-
-    def v1_mtime(&self) -> PyResult<i32> {
-        let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data();
-        Ok(mtime)
-    }
-
     def mtime_likely_equal_to(&self, other: (u32, u32, bool))
         -> PyResult<bool> {
         if let Some(mtime) = self.entry(py).get().truncated_mtime() {
             Ok(mtime.likely_equal(timestamp(py, other)?))
         } else {
             Ok(false)
         }
     }
 
-    @classmethod
-    def from_v1_data(
-        _cls,
-        state: PyBytes,
-        mode: i32,
-        size: i32,
-        mtime: i32,
-    ) -> PyResult<Self> {
-        let state = <[u8; 1]>::try_from(state.data(py))
-            .ok()
-            .and_then(|state| EntryState::try_from(state[0]).ok())
-            .ok_or_else(|| PyErr::new::<exc::ValueError, _>(py, "invalid state"))?;
-        let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
-        DirstateItem::create_instance(py, Cell::new(entry))
-    }
-
     def drop_merge_data(&self) -> PyResult<PyNone> {
         self.update(py, |entry| entry.drop_merge_data());
         Ok(PyNone)
     }
 
     def set_clean(
         &self,
         mode: u32,
         size: u32,
         mtime: (u32, u32, bool),
     ) -> PyResult<PyNone> {
         let mtime = timestamp(py, mtime)?;
         self.update(py, |entry| entry.set_clean(mode, size, mtime));
         Ok(PyNone)
     }
 
     def set_possibly_dirty(&self) -> PyResult<PyNone> {
         self.update(py, |entry| entry.set_possibly_dirty());
         Ok(PyNone)
     }
 
     def set_tracked(&self) -> PyResult<PyNone> {
         self.update(py, |entry| entry.set_tracked());
         Ok(PyNone)
     }
 
     def set_untracked(&self) -> PyResult<PyNone> {
         self.update(py, |entry| entry.set_untracked());
         Ok(PyNone)
     }
 });
 
 impl DirstateItem {
     pub fn new_as_pyobject(
         py: Python<'_>,
         entry: DirstateEntry,
     ) -> PyResult<PyObject> {
         Ok(DirstateItem::create_instance(py, Cell::new(entry))?.into_object())
     }
 
     pub fn get_entry(&self, py: Python<'_>) -> DirstateEntry {
         self.entry(py).get()
     }
 
     // TODO: Use https://doc.rust-lang.org/std/cell/struct.Cell.html#method.update instead when it’s stable
     pub fn update(&self, py: Python<'_>, f: impl FnOnce(&mut DirstateEntry)) {
         let mut entry = self.entry(py).get();
         f(&mut entry);
         self.entry(py).set(entry)
     }
 }
 
 pub(crate) fn timestamp(
     py: Python<'_>,
     (s, ns, second_ambiguous): (u32, u32, bool),
 ) -> PyResult<TruncatedTimestamp> {
     TruncatedTimestamp::from_already_truncated(s, ns, second_ambiguous)
         .map_err(|_| {
             PyErr::new::<exc::ValueError, _>(
                 py,
                 "expected mtime truncated to 31 bits",
             )
         })
 }