debug: add an option to display statistic about a unbundling operation

This will helps a lot to understand how the bundling decision have actually
impacted pull/unbundle on the other side.

mercurial/changegroup.py

@@ -1,2225 +1,2425 b''
 # changegroup.py - Mercurial changegroup manipulation functions
 #
 #  Copyright 2006 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import os
 import struct
 import weakref
 
 from .i18n import _
 from .node import (
     hex,
     nullrev,
     short,
 )
 from .pycompat import open
 
 from . import (
     error,
     match as matchmod,
     mdiff,
     phases,
     pycompat,
     requirements,
     scmutil,
     util,
 )
 
 from .interfaces import repository
 from .revlogutils import sidedata as sidedatamod
 from .revlogutils import constants as revlog_constants
 from .utils import storageutil
 
 _CHANGEGROUPV1_DELTA_HEADER = struct.Struct(b"20s20s20s20s")
 _CHANGEGROUPV2_DELTA_HEADER = struct.Struct(b"20s20s20s20s20s")
 _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(b">20s20s20s20s20sH")
 _CHANGEGROUPV4_DELTA_HEADER = struct.Struct(b">B20s20s20s20s20sH")
 
 LFS_REQUIREMENT = b'lfs'
 
 readexactly = util.readexactly
 
 
 def getchunk(stream):
     """return the next chunk from stream as a string"""
     d = readexactly(stream, 4)
     l = struct.unpack(b">l", d)[0]
     if l <= 4:
         if l:
             raise error.Abort(_(b"invalid chunk length %d") % l)
         return b""
     return readexactly(stream, l - 4)
 
 
 def chunkheader(length):
     """return a changegroup chunk header (string)"""
     return struct.pack(b">l", length + 4)
 
 
 def closechunk():
     """return a changegroup chunk header (string) for a zero-length chunk"""
     return struct.pack(b">l", 0)
 
 
 def _fileheader(path):
     """Obtain a changegroup chunk header for a named path."""
     return chunkheader(len(path)) + path
 
 
 def writechunks(ui, chunks, filename, vfs=None):
     """Write chunks to a file and return its filename.
 
     The stream is assumed to be a bundle file.
     Existing files will not be overwritten.
     If no filename is specified, a temporary file is created.
     """
     fh = None
     cleanup = None
     try:
         if filename:
             if vfs:
                 fh = vfs.open(filename, b"wb")
             else:
                 # Increase default buffer size because default is usually
                 # small (4k is common on Linux).
                 fh = open(filename, b"wb", 131072)
         else:
             fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg")
             fh = os.fdopen(fd, "wb")
         cleanup = filename
         for c in chunks:
             fh.write(c)
         cleanup = None
         return filename
     finally:
         if fh is not None:
             fh.close()
         if cleanup is not None:
             if filename and vfs:
                 vfs.unlink(cleanup)
             else:
                 os.unlink(cleanup)
 
 
+def _dbg_ubdl_line(
+    ui,
+    indent,
+    key,
+    base_value=None,
+    percentage_base=None,
+    percentage_key=None,
+):
+    """Print one line of debug_unbundle_debug_info"""
+    line = b"DEBUG-UNBUNDLING: "
+    line += b' ' * (2 * indent)
+    key += b":"
+    padding = b''
+    if base_value is not None:
+        assert len(key) + 1 + (2 * indent) <= _KEY_PART_WIDTH
+        line += key.ljust(_KEY_PART_WIDTH - (2 * indent))
+        if isinstance(base_value, float):
+            line += b"%14.3f seconds" % base_value
+        else:
+            line += b"%10d" % base_value
+            padding = b'            '
+    else:
+        line += key
+
+    if percentage_base is not None:
+        line += padding
+        padding = b''
+        assert base_value is not None
+        percentage = base_value * 100 // percentage_base
+        if percentage_key is not None:
+            line += b" (%3d%% of %s)" % (
+                percentage,
+                percentage_key,
+            )
+        else:
+            line += b" (%3d%%)" % percentage
+
+    line += b'\n'
+    ui.write_err(line)
+
+
+def _sumf(items):
+    # python < 3.8 does not support a `start=0.0` argument to sum
+    # So we have to cheat a bit until we drop support for those version
+    if not items:
+        return 0.0
+    return sum(items)
+
+
+def display_unbundle_debug_info(ui, debug_info):
+    """display an unbundling report from debug information"""
+    cl_info = []
+    mn_info = []
+    fl_info = []
+    _dispatch = [
+        (b'CHANGELOG:', cl_info),
+        (b'MANIFESTLOG:', mn_info),
+        (b'FILELOG:', fl_info),
+    ]
+    for e in debug_info:
+        for prefix, info in _dispatch:
+            if e["target-revlog"].startswith(prefix):
+                info.append(e)
+                break
+        else:
+            assert False, 'unreachable'
+    each_info = [
+        (b'changelog', cl_info),
+        (b'manifests', mn_info),
+        (b'files', fl_info),
+    ]
+
+    # General Revision Countss
+    _dbg_ubdl_line(ui, 0, b'revisions', len(debug_info))
+    for key, info in each_info:
+        if not info:
+            continue
+        _dbg_ubdl_line(ui, 1, key, len(info), len(debug_info))
+
+    # General Time spent
+    all_durations = [e['duration'] for e in debug_info]
+    all_durations.sort()
+    total_duration = _sumf(all_durations)
+    _dbg_ubdl_line(ui, 0, b'total-time', total_duration)
+
+    for key, info in each_info:
+        if not info:
+            continue
+        durations = [e['duration'] for e in info]
+        durations.sort()
+        _dbg_ubdl_line(ui, 1, key, _sumf(durations), total_duration)
+
+    # Count and cache reuse per delta types
+    each_types = {}
+    for key, info in each_info:
+        each_types[key] = types = {
+            b'full': 0,
+            b'full-cached': 0,
+            b'snapshot': 0,
+            b'snapshot-cached': 0,
+            b'delta': 0,
+            b'delta-cached': 0,
+            b'unknown': 0,
+            b'unknown-cached': 0,
+        }
+        for e in info:
+            types[e['type']] += 1
+            if e['using-cached-base']:
+                types[e['type'] + b'-cached'] += 1
+
+    EXPECTED_TYPES = (b'full', b'snapshot', b'delta', b'unknown')
+    if debug_info:
+        _dbg_ubdl_line(ui, 0, b'type-count')
+    for key, info in each_info:
+        if info:
+            _dbg_ubdl_line(ui, 1, key)
+        t = each_types[key]
+        for tn in EXPECTED_TYPES:
+            if t[tn]:
+                tc = tn + b'-cached'
+                _dbg_ubdl_line(ui, 2, tn, t[tn])
+                _dbg_ubdl_line(ui, 3, b'cached', t[tc], t[tn])
+
+    # time perf delta types and reuse
+    each_type_time = {}
+    for key, info in each_info:
+        each_type_time[key] = t = {
+            b'full': [],
+            b'full-cached': [],
+            b'snapshot': [],
+            b'snapshot-cached': [],
+            b'delta': [],
+            b'delta-cached': [],
+            b'unknown': [],
+            b'unknown-cached': [],
+        }
+        for e in info:
+            t[e['type']].append(e['duration'])
+            if e['using-cached-base']:
+                t[e['type'] + b'-cached'].append(e['duration'])
+        for t_key, value in list(t.items()):
+            value.sort()
+            t[t_key] = _sumf(value)
+
+    if debug_info:
+        _dbg_ubdl_line(ui, 0, b'type-time')
+    for key, info in each_info:
+        if info:
+            _dbg_ubdl_line(ui, 1, key)
+        t = each_type_time[key]
+        td = total_duration  # to same space on next lines
+        for tn in EXPECTED_TYPES:
+            if t[tn]:
+                tc = tn + b'-cached'
+                _dbg_ubdl_line(ui, 2, tn, t[tn], td, b"total")
+                _dbg_ubdl_line(ui, 3, b'cached', t[tc], td, b"total")
+
+
 class cg1unpacker:
     """Unpacker for cg1 changegroup streams.
 
     A changegroup unpacker handles the framing of the revision data in
     the wire format. Most consumers will want to use the apply()
     method to add the changes from the changegroup to a repository.
 
     If you're forwarding a changegroup unmodified to another consumer,
     use getchunks(), which returns an iterator of changegroup
     chunks. This is mostly useful for cases where you need to know the
     data stream has ended by observing the end of the changegroup.
 
     deltachunk() is useful only if you're applying delta data. Most
     consumers should prefer apply() instead.
 
     A few other public methods exist. Those are used only for
     bundlerepo and some debug commands - their use is discouraged.
     """
 
     deltaheader = _CHANGEGROUPV1_DELTA_HEADER
     deltaheadersize = deltaheader.size
     version = b'01'
     _grouplistcount = 1  # One list of files after the manifests
 
     def __init__(self, fh, alg, extras=None):
         if alg is None:
             alg = b'UN'
         if alg not in util.compengines.supportedbundletypes:
             raise error.Abort(_(b'unknown stream compression type: %s') % alg)
         if alg == b'BZ':
             alg = b'_truncatedBZ'
 
         compengine = util.compengines.forbundletype(alg)
         self._stream = compengine.decompressorreader(fh)
         self._type = alg
         self.extras = extras or {}
         self.callback = None
 
     # These methods (compressed, read, seek, tell) all appear to only
     # be used by bundlerepo, but it's a little hard to tell.
     def compressed(self):
         return self._type is not None and self._type != b'UN'
 
     def read(self, l):
         return self._stream.read(l)
 
     def seek(self, pos):
         return self._stream.seek(pos)
 
     def tell(self):
         return self._stream.tell()
 
     def close(self):
         return self._stream.close()
 
     def _chunklength(self):
         d = readexactly(self._stream, 4)
         l = struct.unpack(b">l", d)[0]
         if l <= 4:
             if l:
                 raise error.Abort(_(b"invalid chunk length %d") % l)
             return 0
         if self.callback:
             self.callback()
         return l - 4
 
     def changelogheader(self):
         """v10 does not have a changelog header chunk"""
         return {}
 
     def manifestheader(self):
         """v10 does not have a manifest header chunk"""
         return {}
 
     def filelogheader(self):
         """return the header of the filelogs chunk, v10 only has the filename"""
         l = self._chunklength()
         if not l:
             return {}
         fname = readexactly(self._stream, l)
         return {b'filename': fname}
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, cs = headertuple
         if prevnode is None:
             deltabase = p1
         else:
             deltabase = prevnode
         flags = 0
         protocol_flags = 0
         return node, p1, p2, deltabase, cs, flags, protocol_flags
 
     def deltachunk(self, prevnode):
         # Chunkdata: (node, p1, p2, cs, deltabase, delta, flags, sidedata, proto_flags)
         l = self._chunklength()
         if not l:
             return {}
         headerdata = readexactly(self._stream, self.deltaheadersize)
         header = self.deltaheader.unpack(headerdata)
         delta = readexactly(self._stream, l - self.deltaheadersize)
         header = self._deltaheader(header, prevnode)
         node, p1, p2, deltabase, cs, flags, protocol_flags = header
         return node, p1, p2, cs, deltabase, delta, flags, {}, protocol_flags
 
     def getchunks(self):
         """returns all the chunks contains in the bundle
 
         Used when you need to forward the binary stream to a file or another
         network API. To do so, it parse the changegroup data, otherwise it will
         block in case of sshrepo because it don't know the end of the stream.
         """
         # For changegroup 1 and 2, we expect 3 parts: changelog, manifestlog,
         # and a list of filelogs. For changegroup 3, we expect 4 parts:
         # changelog, manifestlog, a list of tree manifestlogs, and a list of
         # filelogs.
         #
         # Changelog and manifestlog parts are terminated with empty chunks. The
         # tree and file parts are a list of entry sections. Each entry section
         # is a series of chunks terminating in an empty chunk. The list of these
         # entry sections is terminated in yet another empty chunk, so we know
         # we've reached the end of the tree/file list when we reach an empty
         # chunk that was proceeded by no non-empty chunks.
 
         parts = 0
         while parts < 2 + self._grouplistcount:
             noentries = True
             while True:
                 chunk = getchunk(self)
                 if not chunk:
                     # The first two empty chunks represent the end of the
                     # changelog and the manifestlog portions. The remaining
                     # empty chunks represent either A) the end of individual
                     # tree or file entries in the file list, or B) the end of
                     # the entire list. It's the end of the entire list if there
                     # were no entries (i.e. noentries is True).
                     if parts < 2:
                         parts += 1
                     elif noentries:
                         parts += 1
                     break
                 noentries = False
                 yield chunkheader(len(chunk))
                 pos = 0
                 while pos < len(chunk):
                     next = pos + 2 ** 20
                     yield chunk[pos:next]
                     pos = next
             yield closechunk()
 
-    def _unpackmanifests(self, repo, revmap, trp, prog, addrevisioncb=None):
+    def _unpackmanifests(
+        self,
+        repo,
+        revmap,
+        trp,
+        prog,
+        addrevisioncb=None,
+        debug_info=None,
+    ):
         self.callback = prog.increment
         # no need to check for empty manifest group here:
         # if the result of the merge of 1 and 2 is the same in 3 and 4,
         # no new manifest will be created and the manifest group will
         # be empty during the pull
         self.manifestheader()
         deltas = self.deltaiter()
         storage = repo.manifestlog.getstorage(b'')
-        storage.addgroup(deltas, revmap, trp, addrevisioncb=addrevisioncb)
+        storage.addgroup(
+            deltas,
+            revmap,
+            trp,
+            addrevisioncb=addrevisioncb,
+            debug_info=debug_info,
+        )
         prog.complete()
         self.callback = None
 
     def apply(
         self,
         repo,
         tr,
         srctype,
         url,
         targetphase=phases.draft,
         expectedtotal=None,
         sidedata_categories=None,
     ):
         """Add the changegroup returned by source.read() to this repo.
         srctype is a string like 'push', 'pull', or 'unbundle'.  url is
         the URL of the repo where this changegroup is coming from.
 
         Return an integer summarizing the change to this repo:
         - nothing changed or no source: 0
         - more heads than before: 1+added heads (2..n)
         - fewer heads than before: -1-removed heads (-2..-n)
         - number of heads stays the same: 1
 
         `sidedata_categories` is an optional set of the remote's sidedata wanted
         categories.
         """
         repo = repo.unfiltered()
 
+        debug_info = None
+        if repo.ui.configbool(b'debug', b'unbundling-stats'):
+            debug_info = []
+
         # Only useful if we're adding sidedata categories. If both peers have
         # the same categories, then we simply don't do anything.
         adding_sidedata = (
             (
                 requirements.REVLOGV2_REQUIREMENT in repo.requirements
                 or requirements.CHANGELOGV2_REQUIREMENT in repo.requirements
             )
             and self.version == b'04'
             and srctype == b'pull'
         )
         if adding_sidedata:
             sidedata_helpers = sidedatamod.get_sidedata_helpers(
                 repo,
                 sidedata_categories or set(),
                 pull=True,
             )
         else:
             sidedata_helpers = None
 
         def csmap(x):
             repo.ui.debug(b"add changeset %s\n" % short(x))
             return len(cl)
 
         def revmap(x):
             return cl.rev(x)
 
         try:
             # The transaction may already carry source information. In this
             # case we use the top level data. We overwrite the argument
             # because we need to use the top level value (if they exist)
             # in this function.
             srctype = tr.hookargs.setdefault(b'source', srctype)
             tr.hookargs.setdefault(b'url', url)
             repo.hook(
                 b'prechangegroup', throw=True, **pycompat.strkwargs(tr.hookargs)
             )
 
             # write changelog data to temp files so concurrent readers
             # will not see an inconsistent view
             cl = repo.changelog
             cl.delayupdate(tr)
             oldheads = set(cl.heads())
 
             trp = weakref.proxy(tr)
             # pull off the changeset group
             repo.ui.status(_(b"adding changesets\n"))
             clstart = len(cl)
             progress = repo.ui.makeprogress(
                 _(b'changesets'), unit=_(b'chunks'), total=expectedtotal
             )
             self.callback = progress.increment
 
             efilesset = set()
             duprevs = []
 
             def ondupchangelog(cl, rev):
                 if rev < clstart:
                     duprevs.append(rev)  # pytype: disable=attribute-error
 
             def onchangelog(cl, rev):
                 ctx = cl.changelogrevision(rev)
                 assert efilesset is not None  # help pytype
                 efilesset.update(ctx.files)
                 repo.register_changeset(rev, ctx)
 
             self.changelogheader()
             deltas = self.deltaiter()
             if not cl.addgroup(
                 deltas,
                 csmap,
                 trp,
                 alwayscache=True,
                 addrevisioncb=onchangelog,
                 duplicaterevisioncb=ondupchangelog,
+                debug_info=debug_info,
             ):
                 repo.ui.develwarn(
                     b'applied empty changelog from changegroup',
                     config=b'warn-empty-changegroup',
                 )
             efiles = len(efilesset)
             clend = len(cl)
             changesets = clend - clstart
             progress.complete()
             del deltas
             # TODO Python 2.7 removal
             # del efilesset
             efilesset = None
             self.callback = None
 
             # Keep track of the (non-changelog) revlogs we've updated and their
             # range of new revisions for sidedata rewrite.
             # TODO do something more efficient than keeping the reference to
             # the revlogs, especially memory-wise.
             touched_manifests = {}
             touched_filelogs = {}
 
             # pull off the manifest group
             repo.ui.status(_(b"adding manifests\n"))
             # We know that we'll never have more manifests than we had
             # changesets.
             progress = repo.ui.makeprogress(
                 _(b'manifests'), unit=_(b'chunks'), total=changesets
             )
             on_manifest_rev = None
             if sidedata_helpers:
                 if revlog_constants.KIND_MANIFESTLOG in sidedata_helpers[1]:
 
                     def on_manifest_rev(manifest, rev):
                         range = touched_manifests.get(manifest)
                         if not range:
                             touched_manifests[manifest] = (rev, rev)
                         else:
                             assert rev == range[1] + 1
                             touched_manifests[manifest] = (range[0], rev)
 
             self._unpackmanifests(
                 repo,
                 revmap,
                 trp,
                 progress,
                 addrevisioncb=on_manifest_rev,
+                debug_info=debug_info,
             )
 
             needfiles = {}
             if repo.ui.configbool(b'server', b'validate'):
                 cl = repo.changelog
                 ml = repo.manifestlog
                 # validate incoming csets have their manifests
                 for cset in range(clstart, clend):
                     mfnode = cl.changelogrevision(cset).manifest
                     mfest = ml[mfnode].readdelta()
                     # store file nodes we must see
                     for f, n in mfest.items():
                         needfiles.setdefault(f, set()).add(n)
 
             on_filelog_rev = None
             if sidedata_helpers:
                 if revlog_constants.KIND_FILELOG in sidedata_helpers[1]:
 
                     def on_filelog_rev(filelog, rev):
                         range = touched_filelogs.get(filelog)
                         if not range:
                             touched_filelogs[filelog] = (rev, rev)
                         else:
                             assert rev == range[1] + 1
                             touched_filelogs[filelog] = (range[0], rev)
 
             # process the files
             repo.ui.status(_(b"adding file changes\n"))
             newrevs, newfiles = _addchangegroupfiles(
                 repo,
                 self,
                 revmap,
                 trp,
                 efiles,
                 needfiles,
                 addrevisioncb=on_filelog_rev,
+                debug_info=debug_info,
             )
 
             if sidedata_helpers:
                 if revlog_constants.KIND_CHANGELOG in sidedata_helpers[1]:
                     cl.rewrite_sidedata(
                         trp, sidedata_helpers, clstart, clend - 1
                     )
                 for mf, (startrev, endrev) in touched_manifests.items():
                     mf.rewrite_sidedata(trp, sidedata_helpers, startrev, endrev)
                 for fl, (startrev, endrev) in touched_filelogs.items():
                     fl.rewrite_sidedata(trp, sidedata_helpers, startrev, endrev)
 
             # making sure the value exists
             tr.changes.setdefault(b'changegroup-count-changesets', 0)
             tr.changes.setdefault(b'changegroup-count-revisions', 0)
             tr.changes.setdefault(b'changegroup-count-files', 0)
             tr.changes.setdefault(b'changegroup-count-heads', 0)
 
             # some code use bundle operation for internal purpose. They usually
             # set `ui.quiet` to do this outside of user sight. Size the report
             # of such operation now happens at the end of the transaction, that
             # ui.quiet has not direct effect on the output.
             #
             # To preserve this intend use an inelegant hack, we fail to report
             # the change if `quiet` is set. We should probably move to
             # something better, but this is a good first step to allow the "end
             # of transaction report" to pass tests.
             if not repo.ui.quiet:
                 tr.changes[b'changegroup-count-changesets'] += changesets
                 tr.changes[b'changegroup-count-revisions'] += newrevs
                 tr.changes[b'changegroup-count-files'] += newfiles
 
             deltaheads = 0
             if oldheads:
                 heads = cl.heads()
                 deltaheads += len(heads) - len(oldheads)
                 for h in heads:
                     if h not in oldheads and repo[h].closesbranch():
                         deltaheads -= 1
 
             # see previous comment about checking ui.quiet
             if not repo.ui.quiet:
                 tr.changes[b'changegroup-count-heads'] += deltaheads
             repo.invalidatevolatilesets()
 
             if changesets > 0:
                 if b'node' not in tr.hookargs:
                     tr.hookargs[b'node'] = hex(cl.node(clstart))
                     tr.hookargs[b'node_last'] = hex(cl.node(clend - 1))
                     hookargs = dict(tr.hookargs)
                 else:
                     hookargs = dict(tr.hookargs)
                     hookargs[b'node'] = hex(cl.node(clstart))
                     hookargs[b'node_last'] = hex(cl.node(clend - 1))
                 repo.hook(
                     b'pretxnchangegroup',
                     throw=True,
                     **pycompat.strkwargs(hookargs)
                 )
 
             added = range(clstart, clend)
             phaseall = None
             if srctype in (b'push', b'serve'):
                 # Old servers can not push the boundary themselves.
                 # New servers won't push the boundary if changeset already
                 # exists locally as secret
                 #
                 # We should not use added here but the list of all change in
                 # the bundle
                 if repo.publishing():
                     targetphase = phaseall = phases.public
                 else:
                     # closer target phase computation
 
                     # Those changesets have been pushed from the
                     # outside, their phases are going to be pushed
                     # alongside. Therefor `targetphase` is
                     # ignored.
                     targetphase = phaseall = phases.draft
             if added:
                 phases.registernew(repo, tr, targetphase, added)
             if phaseall is not None:
                 if duprevs:
                     duprevs.extend(added)
                 else:
                     duprevs = added
                 phases.advanceboundary(repo, tr, phaseall, [], revs=duprevs)
                 duprevs = []
 
             if changesets > 0:
 
                 def runhooks(unused_success):
                     # These hooks run when the lock releases, not when the
                     # transaction closes. So it's possible for the changelog
                     # to have changed since we last saw it.
                     if clstart >= len(repo):
                         return
 
                     repo.hook(b"changegroup", **pycompat.strkwargs(hookargs))
 
                     for rev in added:
                         args = hookargs.copy()
                         args[b'node'] = hex(cl.node(rev))
                         del args[b'node_last']
                         repo.hook(b"incoming", **pycompat.strkwargs(args))
 
                     newheads = [h for h in repo.heads() if h not in oldheads]
                     repo.ui.log(
                         b"incoming",
                         b"%d incoming changes - new heads: %s\n",
                         len(added),
                         b', '.join([hex(c[:6]) for c in newheads]),
                     )
 
                 tr.addpostclose(
                     b'changegroup-runhooks-%020i' % clstart,
                     lambda tr: repo._afterlock(runhooks),
                 )
+            if debug_info is not None:
+                display_unbundle_debug_info(repo.ui, debug_info)
         finally:
             repo.ui.flush()
         # never return 0 here:
         if deltaheads < 0:
             ret = deltaheads - 1
         else:
             ret = deltaheads + 1
         return ret
 
     def deltaiter(self):
         """
         returns an iterator of the deltas in this changegroup
 
         Useful for passing to the underlying storage system to be stored.
         """
         chain = None
         for chunkdata in iter(lambda: self.deltachunk(chain), {}):
             # Chunkdata: (node, p1, p2, cs, deltabase, delta, flags, sidedata, proto_flags)
             yield chunkdata[:8]
             chain = chunkdata[0]
 
 
 class cg2unpacker(cg1unpacker):
     """Unpacker for cg2 streams.
 
     cg2 streams add support for generaldelta, so the delta header
     format is slightly different. All other features about the data
     remain the same.
     """
 
     deltaheader = _CHANGEGROUPV2_DELTA_HEADER
     deltaheadersize = deltaheader.size
     version = b'02'
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, deltabase, cs = headertuple
         flags = 0
         protocol_flags = 0
         return node, p1, p2, deltabase, cs, flags, protocol_flags
 
 
 class cg3unpacker(cg2unpacker):
     """Unpacker for cg3 streams.
 
     cg3 streams add support for exchanging treemanifests and revlog
     flags. It adds the revlog flags to the delta header and an empty chunk
     separating manifests and files.
     """
 
     deltaheader = _CHANGEGROUPV3_DELTA_HEADER
     deltaheadersize = deltaheader.size
     version = b'03'
     _grouplistcount = 2  # One list of manifests and one list of files
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, deltabase, cs, flags = headertuple
         protocol_flags = 0
         return node, p1, p2, deltabase, cs, flags, protocol_flags
 
-    def _unpackmanifests(self, repo, revmap, trp, prog, addrevisioncb=None):
+    def _unpackmanifests(
+        self,
+        repo,
+        revmap,
+        trp,
+        prog,
+        addrevisioncb=None,
+        debug_info=None,
+    ):
         super(cg3unpacker, self)._unpackmanifests(
-            repo, revmap, trp, prog, addrevisioncb=addrevisioncb
+            repo,
+            revmap,
+            trp,
+            prog,
+            addrevisioncb=addrevisioncb,
+            debug_info=debug_info,
         )
         for chunkdata in iter(self.filelogheader, {}):
             # If we get here, there are directory manifests in the changegroup
             d = chunkdata[b"filename"]
             repo.ui.debug(b"adding %s revisions\n" % d)
             deltas = self.deltaiter()
             if not repo.manifestlog.getstorage(d).addgroup(
-                deltas, revmap, trp, addrevisioncb=addrevisioncb
+                deltas,
+                revmap,
+                trp,
+                addrevisioncb=addrevisioncb,
+                debug_info=debug_info,
             ):
                 raise error.Abort(_(b"received dir revlog group is empty"))
 
 
 class cg4unpacker(cg3unpacker):
     """Unpacker for cg4 streams.
 
     cg4 streams add support for exchanging sidedata.
     """
 
     deltaheader = _CHANGEGROUPV4_DELTA_HEADER
     deltaheadersize = deltaheader.size
     version = b'04'
 
     def _deltaheader(self, headertuple, prevnode):
         protocol_flags, node, p1, p2, deltabase, cs, flags = headertuple
         return node, p1, p2, deltabase, cs, flags, protocol_flags
 
     def deltachunk(self, prevnode):
         res = super(cg4unpacker, self).deltachunk(prevnode)
         if not res:
             return res
 
         (
             node,
             p1,
             p2,
             cs,
             deltabase,
             delta,
             flags,
             sidedata,
             protocol_flags,
         ) = res
         assert not sidedata
 
         sidedata = {}
         if protocol_flags & storageutil.CG_FLAG_SIDEDATA:
             sidedata_raw = getchunk(self._stream)
             sidedata = sidedatamod.deserialize_sidedata(sidedata_raw)
 
         return (
             node,
             p1,
             p2,
             cs,
             deltabase,
             delta,
             flags,
             sidedata,
             protocol_flags,
         )
 
 
 class headerlessfixup:
     def __init__(self, fh, h):
         self._h = h
         self._fh = fh
 
     def read(self, n):
         if self._h:
             d, self._h = self._h[:n], self._h[n:]
             if len(d) < n:
                 d += readexactly(self._fh, n - len(d))
             return d
         return readexactly(self._fh, n)
 
 
 def _revisiondeltatochunks(repo, delta, headerfn):
     """Serialize a revisiondelta to changegroup chunks."""
 
     # The captured revision delta may be encoded as a delta against
     # a base revision or as a full revision. The changegroup format
     # requires that everything on the wire be deltas. So for full
     # revisions, we need to invent a header that says to rewrite
     # data.
 
     if delta.delta is not None:
         prefix, data = b'', delta.delta
     elif delta.basenode == repo.nullid:
         data = delta.revision
         prefix = mdiff.trivialdiffheader(len(data))
     else:
         data = delta.revision
         prefix = mdiff.replacediffheader(delta.baserevisionsize, len(data))
 
     meta = headerfn(delta)
 
     yield chunkheader(len(meta) + len(prefix) + len(data))
     yield meta
     if prefix:
         yield prefix
     yield data
 
     if delta.protocol_flags & storageutil.CG_FLAG_SIDEDATA:
         # Need a separate chunk for sidedata to be able to differentiate
         # "raw delta" length and sidedata length
         sidedata = delta.sidedata
         yield chunkheader(len(sidedata))
         yield sidedata
 
 
 def _sortnodesellipsis(store, nodes, cl, lookup):
     """Sort nodes for changegroup generation."""
     # Ellipses serving mode.
     #
     # In a perfect world, we'd generate better ellipsis-ified graphs
     # for non-changelog revlogs. In practice, we haven't started doing
     # that yet, so the resulting DAGs for the manifestlog and filelogs
     # are actually full of bogus parentage on all the ellipsis
     # nodes. This has the side effect that, while the contents are
     # correct, the individual DAGs might be completely out of whack in
     # a case like 882681bc3166 and its ancestors (back about 10
     # revisions or so) in the main hg repo.
     #
     # The one invariant we *know* holds is that the new (potentially
     # bogus) DAG shape will be valid if we order the nodes in the
     # order that they're introduced in dramatis personae by the
     # changelog, so what we do is we sort the non-changelog histories
     # by the order in which they are used by the changelog.
     key = lambda n: cl.rev(lookup(n))
     return sorted(nodes, key=key)
 
 
 def _resolvenarrowrevisioninfo(
     cl,
     store,
     ischangelog,
     rev,
     linkrev,
     linknode,
     clrevtolocalrev,
     fullclnodes,
     precomputedellipsis,
 ):
     linkparents = precomputedellipsis[linkrev]
 
     def local(clrev):
         """Turn a changelog revnum into a local revnum.
 
         The ellipsis dag is stored as revnums on the changelog,
         but when we're producing ellipsis entries for
         non-changelog revlogs, we need to turn those numbers into
         something local. This does that for us, and during the
         changelog sending phase will also expand the stored
         mappings as needed.
         """
         if clrev == nullrev:
             return nullrev
 
         if ischangelog:
             return clrev
 
         # Walk the ellipsis-ized changelog breadth-first looking for a
         # change that has been linked from the current revlog.
         #
         # For a flat manifest revlog only a single step should be necessary
         # as all relevant changelog entries are relevant to the flat
         # manifest.
         #
         # For a filelog or tree manifest dirlog however not every changelog
         # entry will have been relevant, so we need to skip some changelog
         # nodes even after ellipsis-izing.
         walk = [clrev]
         while walk:
             p = walk[0]
             walk = walk[1:]
             if p in clrevtolocalrev:
                 return clrevtolocalrev[p]
             elif p in fullclnodes:
                 walk.extend([pp for pp in cl.parentrevs(p) if pp != nullrev])
             elif p in precomputedellipsis:
                 walk.extend(
                     [pp for pp in precomputedellipsis[p] if pp != nullrev]
                 )
             else:
                 # In this case, we've got an ellipsis with parents
                 # outside the current bundle (likely an
                 # incremental pull). We "know" that we can use the
                 # value of this same revlog at whatever revision
                 # is pointed to by linknode. "Know" is in scare
                 # quotes because I haven't done enough examination
                 # of edge cases to convince myself this is really
                 # a fact - it works for all the (admittedly
                 # thorough) cases in our testsuite, but I would be
                 # somewhat unsurprised to find a case in the wild
                 # where this breaks down a bit. That said, I don't
                 # know if it would hurt anything.
                 for i in range(rev, 0, -1):
                     if store.linkrev(i) == clrev:
                         return i
                 # We failed to resolve a parent for this node, so
                 # we crash the changegroup construction.
                 if util.safehasattr(store, 'target'):
                     target = store.display_id
                 else:
                     # some revlog not actually a revlog
                     target = store._revlog.display_id
 
                 raise error.Abort(
                     b"unable to resolve parent while packing '%s' %r"
                     b' for changeset %r' % (target, rev, clrev)
                 )
 
         return nullrev
 
     if not linkparents or (store.parentrevs(rev) == (nullrev, nullrev)):
         p1, p2 = nullrev, nullrev
     elif len(linkparents) == 1:
         (p1,) = sorted(local(p) for p in linkparents)
         p2 = nullrev
     else:
         p1, p2 = sorted(local(p) for p in linkparents)
 
     p1node, p2node = store.node(p1), store.node(p2)
 
     return p1node, p2node, linknode
 
 
 def deltagroup(
     repo,
     store,
     nodes,
     ischangelog,
     lookup,
     forcedeltaparentprev,
     topic=None,
     ellipses=False,
     clrevtolocalrev=None,
     fullclnodes=None,
     precomputedellipsis=None,
     sidedata_helpers=None,
     debug_info=None,
 ):
     """Calculate deltas for a set of revisions.
 
     Is a generator of ``revisiondelta`` instances.
 
     If topic is not None, progress detail will be generated using this
     topic name (e.g. changesets, manifests, etc).
 
     See `revlogutil.sidedata.get_sidedata_helpers` for the doc on
     `sidedata_helpers`.
     """
     if not nodes:
         return
 
     cl = repo.changelog
 
     if ischangelog:
         # `hg log` shows changesets in storage order. To preserve order
         # across clones, send out changesets in storage order.
         nodesorder = b'storage'
     elif ellipses:
         nodes = _sortnodesellipsis(store, nodes, cl, lookup)
         nodesorder = b'nodes'
     else:
         nodesorder = None
 
     # Perform ellipses filtering and revision massaging. We do this before
     # emitrevisions() because a) filtering out revisions creates less work
     # for emitrevisions() b) dropping revisions would break emitrevisions()'s
     # assumptions about delta choices and we would possibly send a delta
     # referencing a missing base revision.
     #
     # Also, calling lookup() has side-effects with regards to populating
     # data structures. If we don't call lookup() for each node or if we call
     # lookup() after the first pass through each node, things can break -
     # possibly intermittently depending on the python hash seed! For that
     # reason, we store a mapping of all linknodes during the initial node
     # pass rather than use lookup() on the output side.
     if ellipses:
         filtered = []
         adjustedparents = {}
         linknodes = {}
 
         for node in nodes:
             rev = store.rev(node)
             linknode = lookup(node)
             linkrev = cl.rev(linknode)
             clrevtolocalrev[linkrev] = rev
 
             # If linknode is in fullclnodes, it means the corresponding
             # changeset was a full changeset and is being sent unaltered.
             if linknode in fullclnodes:
                 linknodes[node] = linknode
 
             # If the corresponding changeset wasn't in the set computed
             # as relevant to us, it should be dropped outright.
             elif linkrev not in precomputedellipsis:
                 continue
 
             else:
                 # We could probably do this later and avoid the dict
                 # holding state. But it likely doesn't matter.
                 p1node, p2node, linknode = _resolvenarrowrevisioninfo(
                     cl,
                     store,
                     ischangelog,
                     rev,
                     linkrev,
                     linknode,
                     clrevtolocalrev,
                     fullclnodes,
                     precomputedellipsis,
                 )
 
                 adjustedparents[node] = (p1node, p2node)
                 linknodes[node] = linknode
 
             filtered.append(node)
 
         nodes = filtered
 
     # We expect the first pass to be fast, so we only engage the progress
     # meter for constructing the revision deltas.
     progress = None
     if topic is not None:
         progress = repo.ui.makeprogress(
             topic, unit=_(b'chunks'), total=len(nodes)
         )
 
     configtarget = repo.ui.config(b'devel', b'bundle.delta')
     if configtarget not in (b'', b'p1', b'full'):
         msg = _(b"""config "devel.bundle.delta" as unknown value: %s""")
         repo.ui.warn(msg % configtarget)
 
     deltamode = repository.CG_DELTAMODE_STD
     if forcedeltaparentprev:
         deltamode = repository.CG_DELTAMODE_PREV
     elif configtarget == b'p1':
         deltamode = repository.CG_DELTAMODE_P1
     elif configtarget == b'full':
         deltamode = repository.CG_DELTAMODE_FULL
 
     revisions = store.emitrevisions(
         nodes,
         nodesorder=nodesorder,
         revisiondata=True,
         assumehaveparentrevisions=not ellipses,
         deltamode=deltamode,
         sidedata_helpers=sidedata_helpers,
         debug_info=debug_info,
     )
 
     for i, revision in enumerate(revisions):
         if progress:
             progress.update(i + 1)
 
         if ellipses:
             linknode = linknodes[revision.node]
 
             if revision.node in adjustedparents:
                 p1node, p2node = adjustedparents[revision.node]
                 revision.p1node = p1node
                 revision.p2node = p2node
                 revision.flags |= repository.REVISION_FLAG_ELLIPSIS
 
         else:
             linknode = lookup(revision.node)
 
         revision.linknode = linknode
         yield revision
 
     if progress:
         progress.complete()
 
 
 def make_debug_info():
     """ "build a "new" debug_info dictionnary
 
     That dictionnary can be used to gather information about the bundle process
     """
     return {
         'revision-total': 0,
         'revision-changelog': 0,
         'revision-manifest': 0,
         'revision-files': 0,
         'file-count': 0,
         'merge-total': 0,
         'available-delta': 0,
         'available-full': 0,
         'delta-against-prev': 0,
         'delta-full': 0,
         'delta-against-p1': 0,
         'denied-delta-candeltafn': 0,
         'denied-base-not-available': 0,
         'reused-storage-delta': 0,
         'computed-delta': 0,
     }
 
 
 def merge_debug_info(base, other):
     """merge the debug information from <other> into <base>
 
     This function can be used to gather lower level information into higher level ones.
     """
     for key in (
         'revision-total',
         'revision-changelog',
         'revision-manifest',
         'revision-files',
         'merge-total',
         'available-delta',
         'available-full',
         'delta-against-prev',
         'delta-full',
         'delta-against-p1',
         'denied-delta-candeltafn',
         'denied-base-not-available',
         'reused-storage-delta',
         'computed-delta',
     ):
         base[key] += other[key]
 
 
 _KEY_PART_WIDTH = 17
 
 
 def _dbg_bdl_line(
     ui,
     indent,
     key,
     base_value=None,
     percentage_base=None,
     percentage_key=None,
     percentage_ref=None,
     extra=None,
 ):
     """Print one line of debug_bundle_debug_info"""
     line = b"DEBUG-BUNDLING: "
     line += b' ' * (2 * indent)
     key += b":"
     if base_value is not None:
         assert len(key) + 1 + (2 * indent) <= _KEY_PART_WIDTH
         line += key.ljust(_KEY_PART_WIDTH - (2 * indent))
         line += b"%10d" % base_value
     else:
         line += key
 
     if percentage_base is not None:
         assert base_value is not None
         percentage = base_value * 100 // percentage_base
         if percentage_key is not None:
             line += b" (%d%% of %s %d)" % (
                 percentage,
                 percentage_key,
                 percentage_ref,
             )
         else:
             line += b" (%d%%)" % percentage
 
     if extra:
         line += b" "
         line += extra
 
     line += b'\n'
     ui.write_err(line)
 
 
 def display_bundling_debug_info(
     ui,
     debug_info,
     cl_debug_info,
     mn_debug_info,
     fl_debug_info,
 ):
     """display debug information gathered during a bundling through `ui`"""
     d = debug_info
     c = cl_debug_info
     m = mn_debug_info
     f = fl_debug_info
     all_info = [
         (b"changelog", b"cl", c),
         (b"manifests", b"mn", m),
         (b"files", b"fl", f),
     ]
     _dbg_bdl_line(ui, 0, b'revisions', d['revision-total'])
     _dbg_bdl_line(ui, 1, b'changelog', d['revision-changelog'])
     _dbg_bdl_line(ui, 1, b'manifest', d['revision-manifest'])
     extra = b'(for %d revlogs)' % d['file-count']
     _dbg_bdl_line(ui, 1, b'files', d['revision-files'], extra=extra)
     if d['merge-total']:
         _dbg_bdl_line(ui, 1, b'merge', d['merge-total'], d['revision-total'])
     for k, __, v in all_info:
         if v['merge-total']:
             _dbg_bdl_line(ui, 2, k, v['merge-total'], v['revision-total'])
 
     _dbg_bdl_line(ui, 0, b'deltas')
     _dbg_bdl_line(
         ui,
         1,
         b'from-storage',
         d['reused-storage-delta'],
         percentage_base=d['available-delta'],
         percentage_key=b"available",
         percentage_ref=d['available-delta'],
     )
 
     if d['denied-delta-candeltafn']:
         _dbg_bdl_line(ui, 2, b'denied-fn', d['denied-delta-candeltafn'])
     for __, k, v in all_info:
         if v['denied-delta-candeltafn']:
             _dbg_bdl_line(ui, 3, k, v['denied-delta-candeltafn'])
 
     if d['denied-base-not-available']:
         _dbg_bdl_line(ui, 2, b'denied-nb', d['denied-base-not-available'])
     for k, __, v in all_info:
         if v['denied-base-not-available']:
             _dbg_bdl_line(ui, 3, k, v['denied-base-not-available'])
 
     if d['computed-delta']:
         _dbg_bdl_line(ui, 1, b'computed', d['computed-delta'])
 
     if d['available-full']:
         _dbg_bdl_line(
             ui,
             2,
             b'full',
             d['delta-full'],
             percentage_base=d['available-full'],
             percentage_key=b"native",
             percentage_ref=d['available-full'],
         )
     for k, __, v in all_info:
         if v['available-full']:
             _dbg_bdl_line(
                 ui,
                 3,
                 k,
                 v['delta-full'],
                 percentage_base=v['available-full'],
                 percentage_key=b"native",
                 percentage_ref=v['available-full'],
             )
 
     if d['delta-against-prev']:
         _dbg_bdl_line(ui, 2, b'previous', d['delta-against-prev'])
     for k, __, v in all_info:
         if v['delta-against-prev']:
             _dbg_bdl_line(ui, 3, k, v['delta-against-prev'])
 
     if d['delta-against-p1']:
         _dbg_bdl_line(ui, 2, b'parent-1', d['delta-against-prev'])
     for k, __, v in all_info:
         if v['delta-against-p1']:
             _dbg_bdl_line(ui, 3, k, v['delta-against-p1'])
 
 
 class cgpacker:
     def __init__(
         self,
         repo,
         oldmatcher,
         matcher,
         version,
         builddeltaheader,
         manifestsend,
         forcedeltaparentprev=False,
         bundlecaps=None,
         ellipses=False,
         shallow=False,
         ellipsisroots=None,
         fullnodes=None,
         remote_sidedata=None,
     ):
         """Given a source repo, construct a bundler.
 
         oldmatcher is a matcher that matches on files the client already has.
         These will not be included in the changegroup.
 
         matcher is a matcher that matches on files to include in the
         changegroup. Used to facilitate sparse changegroups.
 
         forcedeltaparentprev indicates whether delta parents must be against
         the previous revision in a delta group. This should only be used for
         compatibility with changegroup version 1.
 
         builddeltaheader is a callable that constructs the header for a group
         delta.
 
         manifestsend is a chunk to send after manifests have been fully emitted.
 
         ellipses indicates whether ellipsis serving mode is enabled.
 
         bundlecaps is optional and can be used to specify the set of
         capabilities which can be used to build the bundle. While bundlecaps is
         unused in core Mercurial, extensions rely on this feature to communicate
         capabilities to customize the changegroup packer.
 
         shallow indicates whether shallow data might be sent. The packer may
         need to pack file contents not introduced by the changes being packed.
 
         fullnodes is the set of changelog nodes which should not be ellipsis
         nodes. We store this rather than the set of nodes that should be
         ellipsis because for very large histories we expect this to be
         significantly smaller.
 
         remote_sidedata is the set of sidedata categories wanted by the remote.
         """
         assert oldmatcher
         assert matcher
         self._oldmatcher = oldmatcher
         self._matcher = matcher
 
         self.version = version
         self._forcedeltaparentprev = forcedeltaparentprev
         self._builddeltaheader = builddeltaheader
         self._manifestsend = manifestsend
         self._ellipses = ellipses
 
         # Set of capabilities we can use to build the bundle.
         if bundlecaps is None:
             bundlecaps = set()
         self._bundlecaps = bundlecaps
         if remote_sidedata is None:
             remote_sidedata = set()
         self._remote_sidedata = remote_sidedata
         self._isshallow = shallow
         self._fullclnodes = fullnodes
 
         # Maps ellipsis revs to their roots at the changelog level.
         self._precomputedellipsis = ellipsisroots
 
         self._repo = repo
 
         if self._repo.ui.verbose and not self._repo.ui.debugflag:
             self._verbosenote = self._repo.ui.note
         else:
             self._verbosenote = lambda s: None
 
     def generate(
         self,
         commonrevs,
         clnodes,
         fastpathlinkrev,
         source,
         changelog=True,
     ):
         """Yield a sequence of changegroup byte chunks.
         If changelog is False, changelog data won't be added to changegroup
         """
 
         debug_info = None
         repo = self._repo
         if repo.ui.configbool(b'debug', b'bundling-stats'):
             debug_info = make_debug_info()
         cl = repo.changelog
 
         self._verbosenote(_(b'uncompressed size of bundle content:\n'))
         size = 0
 
         sidedata_helpers = None
         if self.version == b'04':
             remote_sidedata = self._remote_sidedata
             if source == b'strip':
                 # We're our own remote when stripping, get the no-op helpers
                 # TODO a better approach would be for the strip bundle to
                 # correctly advertise its sidedata categories directly.
                 remote_sidedata = repo._wanted_sidedata
             sidedata_helpers = sidedatamod.get_sidedata_helpers(
                 repo,
                 remote_sidedata,
             )
 
         cl_debug_info = None
         if debug_info is not None:
             cl_debug_info = make_debug_info()
         clstate, deltas = self._generatechangelog(
             cl,
             clnodes,
             generate=changelog,
             sidedata_helpers=sidedata_helpers,
             debug_info=cl_debug_info,
         )
         for delta in deltas:
             for chunk in _revisiondeltatochunks(
                 self._repo, delta, self._builddeltaheader
             ):
                 size += len(chunk)
                 yield chunk
 
         close = closechunk()
         size += len(close)
         yield closechunk()
         if debug_info is not None:
             merge_debug_info(debug_info, cl_debug_info)
             debug_info['revision-changelog'] = cl_debug_info['revision-total']
 
         self._verbosenote(_(b'%8.i (changelog)\n') % size)
 
         clrevorder = clstate[b'clrevorder']
         manifests = clstate[b'manifests']
         changedfiles = clstate[b'changedfiles']
 
         if debug_info is not None:
             debug_info['file-count'] = len(changedfiles)
 
         # We need to make sure that the linkrev in the changegroup refers to
         # the first changeset that introduced the manifest or file revision.
         # The fastpath is usually safer than the slowpath, because the filelogs
         # are walked in revlog order.
         #
         # When taking the slowpath when the manifest revlog uses generaldelta,
         # the manifest may be walked in the "wrong" order. Without 'clrevorder',
         # we would get an incorrect linkrev (see fix in cc0ff93d0c0c).
         #
         # When taking the fastpath, we are only vulnerable to reordering
         # of the changelog itself. The changelog never uses generaldelta and is
         # never reordered. To handle this case, we simply take the slowpath,
         # which already has the 'clrevorder' logic. This was also fixed in
         # cc0ff93d0c0c.
 
         # Treemanifests don't work correctly with fastpathlinkrev
         # either, because we don't discover which directory nodes to
         # send along with files. This could probably be fixed.
         fastpathlinkrev = fastpathlinkrev and not scmutil.istreemanifest(repo)
 
         fnodes = {}  # needed file nodes
 
         size = 0
         mn_debug_info = None
         if debug_info is not None:
             mn_debug_info = make_debug_info()
         it = self.generatemanifests(
             commonrevs,
             clrevorder,
             fastpathlinkrev,
             manifests,
             fnodes,
             source,
             clstate[b'clrevtomanifestrev'],
             sidedata_helpers=sidedata_helpers,
             debug_info=mn_debug_info,
         )
 
         for tree, deltas in it:
             if tree:
                 assert self.version in (b'03', b'04')
                 chunk = _fileheader(tree)
                 size += len(chunk)
                 yield chunk
 
             for delta in deltas:
                 chunks = _revisiondeltatochunks(
                     self._repo, delta, self._builddeltaheader
                 )
                 for chunk in chunks:
                     size += len(chunk)
                     yield chunk
 
             close = closechunk()
             size += len(close)
             yield close
         if debug_info is not None:
             merge_debug_info(debug_info, mn_debug_info)
             debug_info['revision-manifest'] = mn_debug_info['revision-total']
 
         self._verbosenote(_(b'%8.i (manifests)\n') % size)
         yield self._manifestsend
 
         mfdicts = None
         if self._ellipses and self._isshallow:
             mfdicts = [
                 (repo.manifestlog[n].read(), lr)
                 for (n, lr) in pycompat.iteritems(manifests)
             ]
 
         manifests.clear()
         clrevs = {cl.rev(x) for x in clnodes}
 
         fl_debug_info = None
         if debug_info is not None:
             fl_debug_info = make_debug_info()
         it = self.generatefiles(
             changedfiles,
             commonrevs,
             source,
             mfdicts,
             fastpathlinkrev,
             fnodes,
             clrevs,
             sidedata_helpers=sidedata_helpers,
             debug_info=fl_debug_info,
         )
 
         for path, deltas in it:
             h = _fileheader(path)
             size = len(h)
             yield h
 
             for delta in deltas:
                 chunks = _revisiondeltatochunks(
                     self._repo, delta, self._builddeltaheader
                 )
                 for chunk in chunks:
                     size += len(chunk)
                     yield chunk
 
             close = closechunk()
             size += len(close)
             yield close
 
             self._verbosenote(_(b'%8.i  %s\n') % (size, path))
 
         yield closechunk()
         if debug_info is not None:
             merge_debug_info(debug_info, fl_debug_info)
             debug_info['revision-files'] = fl_debug_info['revision-total']
 
         if debug_info is not None:
             display_bundling_debug_info(
                 repo.ui,
                 debug_info,
                 cl_debug_info,
                 mn_debug_info,
                 fl_debug_info,
             )
 
         if clnodes:
             repo.hook(b'outgoing', node=hex(clnodes[0]), source=source)
 
     def _generatechangelog(
         self,
         cl,
         nodes,
         generate=True,
         sidedata_helpers=None,
         debug_info=None,
     ):
         """Generate data for changelog chunks.
 
         Returns a 2-tuple of a dict containing state and an iterable of
         byte chunks. The state will not be fully populated until the
         chunk stream has been fully consumed.
 
         if generate is False, the state will be fully populated and no chunk
         stream will be yielded
 
         See `revlogutil.sidedata.get_sidedata_helpers` for the doc on
         `sidedata_helpers`.
         """
         clrevorder = {}
         manifests = {}
         mfl = self._repo.manifestlog
         changedfiles = set()
         clrevtomanifestrev = {}
 
         state = {
             b'clrevorder': clrevorder,
             b'manifests': manifests,
             b'changedfiles': changedfiles,
             b'clrevtomanifestrev': clrevtomanifestrev,
         }
 
         if not (generate or self._ellipses):
             # sort the nodes in storage order
             nodes = sorted(nodes, key=cl.rev)
             for node in nodes:
                 c = cl.changelogrevision(node)
                 clrevorder[node] = len(clrevorder)
                 # record the first changeset introducing this manifest version
                 manifests.setdefault(c.manifest, node)
                 # Record a complete list of potentially-changed files in
                 # this manifest.
                 changedfiles.update(c.files)
 
             return state, ()
 
         # Callback for the changelog, used to collect changed files and
         # manifest nodes.
         # Returns the linkrev node (identity in the changelog case).
         def lookupcl(x):
             c = cl.changelogrevision(x)
             clrevorder[x] = len(clrevorder)
 
             if self._ellipses:
                 # Only update manifests if x is going to be sent. Otherwise we
                 # end up with bogus linkrevs specified for manifests and
                 # we skip some manifest nodes that we should otherwise
                 # have sent.
                 if (
                     x in self._fullclnodes
                     or cl.rev(x) in self._precomputedellipsis
                 ):
 
                     manifestnode = c.manifest
                     # Record the first changeset introducing this manifest
                     # version.
                     manifests.setdefault(manifestnode, x)
                     # Set this narrow-specific dict so we have the lowest
                     # manifest revnum to look up for this cl revnum. (Part of
                     # mapping changelog ellipsis parents to manifest ellipsis
                     # parents)
                     clrevtomanifestrev.setdefault(
                         cl.rev(x), mfl.rev(manifestnode)
                     )
                 # We can't trust the changed files list in the changeset if the
                 # client requested a shallow clone.
                 if self._isshallow:
                     changedfiles.update(mfl[c.manifest].read().keys())
                 else:
                     changedfiles.update(c.files)
             else:
                 # record the first changeset introducing this manifest version
                 manifests.setdefault(c.manifest, x)
                 # Record a complete list of potentially-changed files in
                 # this manifest.
                 changedfiles.update(c.files)
 
             return x
 
         gen = deltagroup(
             self._repo,
             cl,
             nodes,
             True,
             lookupcl,
             self._forcedeltaparentprev,
             ellipses=self._ellipses,
             topic=_(b'changesets'),
             clrevtolocalrev={},
             fullclnodes=self._fullclnodes,
             precomputedellipsis=self._precomputedellipsis,
             sidedata_helpers=sidedata_helpers,
             debug_info=debug_info,
         )
 
         return state, gen
 
     def generatemanifests(
         self,
         commonrevs,
         clrevorder,
         fastpathlinkrev,
         manifests,
         fnodes,
         source,
         clrevtolocalrev,
         sidedata_helpers=None,
         debug_info=None,
     ):
         """Returns an iterator of changegroup chunks containing manifests.
 
         `source` is unused here, but is used by extensions like remotefilelog to
         change what is sent based in pulls vs pushes, etc.
 
         See `revlogutil.sidedata.get_sidedata_helpers` for the doc on
         `sidedata_helpers`.
         """
         repo = self._repo
         mfl = repo.manifestlog
         tmfnodes = {b'': manifests}
 
         # Callback for the manifest, used to collect linkrevs for filelog
         # revisions.
         # Returns the linkrev node (collected in lookupcl).
         def makelookupmflinknode(tree, nodes):
             if fastpathlinkrev:
                 assert not tree
 
                 # pytype: disable=unsupported-operands
                 return manifests.__getitem__
                 # pytype: enable=unsupported-operands
 
             def lookupmflinknode(x):
                 """Callback for looking up the linknode for manifests.
 
                 Returns the linkrev node for the specified manifest.
 
                 SIDE EFFECT:
 
                 1) fclnodes gets populated with the list of relevant
                    file nodes if we're not using fastpathlinkrev
                 2) When treemanifests are in use, collects treemanifest nodes
                    to send
 
                 Note that this means manifests must be completely sent to
                 the client before you can trust the list of files and
                 treemanifests to send.
                 """
                 clnode = nodes[x]
                 mdata = mfl.get(tree, x).readfast(shallow=True)
                 for p, n, fl in mdata.iterentries():
                     if fl == b't':  # subdirectory manifest
                         subtree = tree + p + b'/'
                         tmfclnodes = tmfnodes.setdefault(subtree, {})
                         tmfclnode = tmfclnodes.setdefault(n, clnode)
                         if clrevorder[clnode] < clrevorder[tmfclnode]:
                             tmfclnodes[n] = clnode
                     else:
                         f = tree + p
                         fclnodes = fnodes.setdefault(f, {})
                         fclnode = fclnodes.setdefault(n, clnode)
                         if clrevorder[clnode] < clrevorder[fclnode]:
                             fclnodes[n] = clnode
                 return clnode
 
             return lookupmflinknode
 
         while tmfnodes:
             tree, nodes = tmfnodes.popitem()
 
             should_visit = self._matcher.visitdir(tree[:-1])
             if tree and not should_visit:
                 continue
 
             store = mfl.getstorage(tree)
 
             if not should_visit:
                 # No nodes to send because this directory is out of
                 # the client's view of the repository (probably
                 # because of narrow clones). Do this even for the root
                 # directory (tree=='')
                 prunednodes = []
             else:
                 # Avoid sending any manifest nodes we can prove the
                 # client already has by checking linkrevs. See the
                 # related comment in generatefiles().
                 prunednodes = self._prunemanifests(store, nodes, commonrevs)
 
             if tree and not prunednodes:
                 continue
 
             lookupfn = makelookupmflinknode(tree, nodes)
 
             deltas = deltagroup(
                 self._repo,
                 store,
                 prunednodes,
                 False,
                 lookupfn,
                 self._forcedeltaparentprev,
                 ellipses=self._ellipses,
                 topic=_(b'manifests'),
                 clrevtolocalrev=clrevtolocalrev,
                 fullclnodes=self._fullclnodes,
                 precomputedellipsis=self._precomputedellipsis,
                 sidedata_helpers=sidedata_helpers,
                 debug_info=debug_info,
             )
 
             if not self._oldmatcher.visitdir(store.tree[:-1]):
                 yield tree, deltas
             else:
                 # 'deltas' is a generator and we need to consume it even if
                 # we are not going to send it because a side-effect is that
                 # it updates tmdnodes (via lookupfn)
                 for d in deltas:
                     pass
                 if not tree:
                     yield tree, []
 
     def _prunemanifests(self, store, nodes, commonrevs):
         if not self._ellipses:
             # In non-ellipses case and large repositories, it is better to
             # prevent calling of store.rev and store.linkrev on a lot of
             # nodes as compared to sending some extra data
             return nodes.copy()
         # This is split out as a separate method to allow filtering
         # commonrevs in extension code.
         #
         # TODO(augie): this shouldn't be required, instead we should
         # make filtering of revisions to send delegated to the store
         # layer.
         frev, flr = store.rev, store.linkrev
         return [n for n in nodes if flr(frev(n)) not in commonrevs]
 
     # The 'source' parameter is useful for extensions
     def generatefiles(
         self,
         changedfiles,
         commonrevs,
         source,
         mfdicts,
         fastpathlinkrev,
         fnodes,
         clrevs,
         sidedata_helpers=None,
         debug_info=None,
     ):
         changedfiles = [
             f
             for f in changedfiles
             if self._matcher(f) and not self._oldmatcher(f)
         ]
 
         if not fastpathlinkrev:
 
             def normallinknodes(unused, fname):
                 return fnodes.get(fname, {})
 
         else:
             cln = self._repo.changelog.node
 
             def normallinknodes(store, fname):
                 flinkrev = store.linkrev
                 fnode = store.node
                 revs = ((r, flinkrev(r)) for r in store)
                 return {fnode(r): cln(lr) for r, lr in revs if lr in clrevs}
 
         clrevtolocalrev = {}
 
         if self._isshallow:
             # In a shallow clone, the linknodes callback needs to also include
             # those file nodes that are in the manifests we sent but weren't
             # introduced by those manifests.
             commonctxs = [self._repo[c] for c in commonrevs]
             clrev = self._repo.changelog.rev
 
             def linknodes(flog, fname):
                 for c in commonctxs:
                     try:
                         fnode = c.filenode(fname)
                         clrevtolocalrev[c.rev()] = flog.rev(fnode)
                     except error.ManifestLookupError:
                         pass
                 links = normallinknodes(flog, fname)
                 if len(links) != len(mfdicts):
                     for mf, lr in mfdicts:
                         fnode = mf.get(fname, None)
                         if fnode in links:
                             links[fnode] = min(links[fnode], lr, key=clrev)
                         elif fnode:
                             links[fnode] = lr
                 return links
 
         else:
             linknodes = normallinknodes
 
         repo = self._repo
         progress = repo.ui.makeprogress(
             _(b'files'), unit=_(b'files'), total=len(changedfiles)
         )
         for i, fname in enumerate(sorted(changedfiles)):
             filerevlog = repo.file(fname)
             if not filerevlog:
                 raise error.Abort(
                     _(b"empty or missing file data for %s") % fname
                 )
 
             clrevtolocalrev.clear()
 
             linkrevnodes = linknodes(filerevlog, fname)
             # Lookup for filenodes, we collected the linkrev nodes above in the
             # fastpath case and with lookupmf in the slowpath case.
             def lookupfilelog(x):
                 return linkrevnodes[x]
 
             frev, flr = filerevlog.rev, filerevlog.linkrev
             # Skip sending any filenode we know the client already
             # has. This avoids over-sending files relatively
             # inexpensively, so it's not a problem if we under-filter
             # here.
             filenodes = [
                 n for n in linkrevnodes if flr(frev(n)) not in commonrevs
             ]
 
             if not filenodes:
                 continue
 
             progress.update(i + 1, item=fname)
 
             deltas = deltagroup(
                 self._repo,
                 filerevlog,
                 filenodes,
                 False,
                 lookupfilelog,
                 self._forcedeltaparentprev,
                 ellipses=self._ellipses,
                 clrevtolocalrev=clrevtolocalrev,
                 fullclnodes=self._fullclnodes,
                 precomputedellipsis=self._precomputedellipsis,
                 sidedata_helpers=sidedata_helpers,
                 debug_info=debug_info,
             )
 
             yield fname, deltas
 
         progress.complete()
 
 
 def _makecg1packer(
     repo,
     oldmatcher,
     matcher,
     bundlecaps,
     ellipses=False,
     shallow=False,
     ellipsisroots=None,
     fullnodes=None,
     remote_sidedata=None,
 ):
     builddeltaheader = lambda d: _CHANGEGROUPV1_DELTA_HEADER.pack(
         d.node, d.p1node, d.p2node, d.linknode
     )
 
     return cgpacker(
         repo,
         oldmatcher,
         matcher,
         b'01',
         builddeltaheader=builddeltaheader,
         manifestsend=b'',
         forcedeltaparentprev=True,
         bundlecaps=bundlecaps,
         ellipses=ellipses,
         shallow=shallow,
         ellipsisroots=ellipsisroots,
         fullnodes=fullnodes,
     )
 
 
 def _makecg2packer(
     repo,
     oldmatcher,
     matcher,
     bundlecaps,
     ellipses=False,
     shallow=False,
     ellipsisroots=None,
     fullnodes=None,
     remote_sidedata=None,
 ):
     builddeltaheader = lambda d: _CHANGEGROUPV2_DELTA_HEADER.pack(
         d.node, d.p1node, d.p2node, d.basenode, d.linknode
     )
 
     return cgpacker(
         repo,
         oldmatcher,
         matcher,
         b'02',
         builddeltaheader=builddeltaheader,
         manifestsend=b'',
         bundlecaps=bundlecaps,
         ellipses=ellipses,
         shallow=shallow,
         ellipsisroots=ellipsisroots,
         fullnodes=fullnodes,
     )
 
 
 def _makecg3packer(
     repo,
     oldmatcher,
     matcher,
     bundlecaps,
     ellipses=False,
     shallow=False,
     ellipsisroots=None,
     fullnodes=None,
     remote_sidedata=None,
 ):
     builddeltaheader = lambda d: _CHANGEGROUPV3_DELTA_HEADER.pack(
         d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags
     )
 
     return cgpacker(
         repo,
         oldmatcher,
         matcher,
         b'03',
         builddeltaheader=builddeltaheader,
         manifestsend=closechunk(),
         bundlecaps=bundlecaps,
         ellipses=ellipses,
         shallow=shallow,
         ellipsisroots=ellipsisroots,
         fullnodes=fullnodes,
     )
 
 
 def _makecg4packer(
     repo,
     oldmatcher,
     matcher,
     bundlecaps,
     ellipses=False,
     shallow=False,
     ellipsisroots=None,
     fullnodes=None,
     remote_sidedata=None,
 ):
     # Sidedata is in a separate chunk from the delta to differentiate
     # "raw delta" and sidedata.
     def builddeltaheader(d):
         return _CHANGEGROUPV4_DELTA_HEADER.pack(
             d.protocol_flags,
             d.node,
             d.p1node,
             d.p2node,
             d.basenode,
             d.linknode,
             d.flags,
         )
 
     return cgpacker(
         repo,
         oldmatcher,
         matcher,
         b'04',
         builddeltaheader=builddeltaheader,
         manifestsend=closechunk(),
         bundlecaps=bundlecaps,
         ellipses=ellipses,
         shallow=shallow,
         ellipsisroots=ellipsisroots,
         fullnodes=fullnodes,
         remote_sidedata=remote_sidedata,
     )
 
 
 _packermap = {
     b'01': (_makecg1packer, cg1unpacker),
     # cg2 adds support for exchanging generaldelta
     b'02': (_makecg2packer, cg2unpacker),
     # cg3 adds support for exchanging revlog flags and treemanifests
     b'03': (_makecg3packer, cg3unpacker),
     # ch4 adds support for exchanging sidedata
     b'04': (_makecg4packer, cg4unpacker),
 }
 
 
 def allsupportedversions(repo):
     versions = set(_packermap.keys())
     needv03 = False
     if (
         repo.ui.configbool(b'experimental', b'changegroup3')
         or repo.ui.configbool(b'experimental', b'treemanifest')
         or scmutil.istreemanifest(repo)
     ):
         # we keep version 03 because we need to to exchange treemanifest data
         #
         # we also keep vresion 01 and 02, because it is possible for repo to
         # contains both normal and tree manifest at the same time. so using
         # older version to pull data is viable
         #
         # (or even to push subset of history)
         needv03 = True
     if not needv03:
         versions.discard(b'03')
     want_v4 = (
         repo.ui.configbool(b'experimental', b'changegroup4')
         or requirements.REVLOGV2_REQUIREMENT in repo.requirements
         or requirements.CHANGELOGV2_REQUIREMENT in repo.requirements
     )
     if not want_v4:
         versions.discard(b'04')
     return versions
 
 
 # Changegroup versions that can be applied to the repo
 def supportedincomingversions(repo):
     return allsupportedversions(repo)
 
 
 # Changegroup versions that can be created from the repo
 def supportedoutgoingversions(repo):
     versions = allsupportedversions(repo)
     if scmutil.istreemanifest(repo):
         # Versions 01 and 02 support only flat manifests and it's just too
         # expensive to convert between the flat manifest and tree manifest on
         # the fly. Since tree manifests are hashed differently, all of history
         # would have to be converted. Instead, we simply don't even pretend to
         # support versions 01 and 02.
         versions.discard(b'01')
         versions.discard(b'02')
     if requirements.NARROW_REQUIREMENT in repo.requirements:
         # Versions 01 and 02 don't support revlog flags, and we need to
         # support that for stripping and unbundling to work.
         versions.discard(b'01')
         versions.discard(b'02')
     if LFS_REQUIREMENT in repo.requirements:
         # Versions 01 and 02 don't support revlog flags, and we need to
         # mark LFS entries with REVIDX_EXTSTORED.
         versions.discard(b'01')
         versions.discard(b'02')
 
     return versions
 
 
 def localversion(repo):
     # Finds the best version to use for bundles that are meant to be used
     # locally, such as those from strip and shelve, and temporary bundles.
     return max(supportedoutgoingversions(repo))
 
 
 def safeversion(repo):
     # Finds the smallest version that it's safe to assume clients of the repo
     # will support. For example, all hg versions that support generaldelta also
     # support changegroup 02.
     versions = supportedoutgoingversions(repo)
     if requirements.GENERALDELTA_REQUIREMENT in repo.requirements:
         versions.discard(b'01')
     assert versions
     return min(versions)
 
 
 def getbundler(
     version,
     repo,
     bundlecaps=None,
     oldmatcher=None,
     matcher=None,
     ellipses=False,
     shallow=False,
     ellipsisroots=None,
     fullnodes=None,
     remote_sidedata=None,
 ):
     assert version in supportedoutgoingversions(repo)
 
     if matcher is None:
         matcher = matchmod.always()
     if oldmatcher is None:
         oldmatcher = matchmod.never()
 
     if version == b'01' and not matcher.always():
         raise error.ProgrammingError(
             b'version 01 changegroups do not support sparse file matchers'
         )
 
     if ellipses and version in (b'01', b'02'):
         raise error.Abort(
             _(
                 b'ellipsis nodes require at least cg3 on client and server, '
                 b'but negotiated version %s'
             )
             % version
         )
 
     # Requested files could include files not in the local store. So
     # filter those out.
     matcher = repo.narrowmatch(matcher)
 
     fn = _packermap[version][0]
     return fn(
         repo,
         oldmatcher,
         matcher,
         bundlecaps,
         ellipses=ellipses,
         shallow=shallow,
         ellipsisroots=ellipsisroots,
         fullnodes=fullnodes,
         remote_sidedata=remote_sidedata,
     )
 
 
 def getunbundler(version, fh, alg, extras=None):
     return _packermap[version][1](fh, alg, extras=extras)
 
 
 def _changegroupinfo(repo, nodes, source):
     if repo.ui.verbose or source == b'bundle':
         repo.ui.status(_(b"%d changesets found\n") % len(nodes))
     if repo.ui.debugflag:
         repo.ui.debug(b"list of changesets:\n")
         for node in nodes:
             repo.ui.debug(b"%s\n" % hex(node))
 
 
 def makechangegroup(
     repo,
     outgoing,
     version,
     source,
     fastpath=False,
     bundlecaps=None,
 ):
     cgstream = makestream(
         repo,
         outgoing,
         version,
         source,
         fastpath=fastpath,
         bundlecaps=bundlecaps,
     )
     return getunbundler(
         version,
         util.chunkbuffer(cgstream),
         None,
         {b'clcount': len(outgoing.missing)},
     )
 
 
 def makestream(
     repo,
     outgoing,
     version,
     source,
     fastpath=False,
     bundlecaps=None,
     matcher=None,
     remote_sidedata=None,
 ):
     bundler = getbundler(
         version,
         repo,
         bundlecaps=bundlecaps,
         matcher=matcher,
         remote_sidedata=remote_sidedata,
     )
 
     repo = repo.unfiltered()
     commonrevs = outgoing.common
     csets = outgoing.missing
     heads = outgoing.ancestorsof
     # We go through the fast path if we get told to, or if all (unfiltered
     # heads have been requested (since we then know there all linkrevs will
     # be pulled by the client).
     heads.sort()
     fastpathlinkrev = fastpath or (
         repo.filtername is None and heads == sorted(repo.heads())
     )
 
     repo.hook(b'preoutgoing', throw=True, source=source)
     _changegroupinfo(repo, csets, source)
     return bundler.generate(
         commonrevs,
         csets,
         fastpathlinkrev,
         source,
     )
 
 
 def _addchangegroupfiles(
     repo,
     source,
     revmap,
     trp,
     expectedfiles,
     needfiles,
     addrevisioncb=None,
+    debug_info=None,
 ):
     revisions = 0
     files = 0
     progress = repo.ui.makeprogress(
         _(b'files'), unit=_(b'files'), total=expectedfiles
     )
     for chunkdata in iter(source.filelogheader, {}):
         files += 1
         f = chunkdata[b"filename"]
         repo.ui.debug(b"adding %s revisions\n" % f)
         progress.increment()
         fl = repo.file(f)
         o = len(fl)
         try:
             deltas = source.deltaiter()
             added = fl.addgroup(
                 deltas,
                 revmap,
                 trp,
                 addrevisioncb=addrevisioncb,
+                debug_info=debug_info,
             )
             if not added:
                 raise error.Abort(_(b"received file revlog group is empty"))
         except error.CensoredBaseError as e:
             raise error.Abort(_(b"received delta base is censored: %s") % e)
         revisions += len(fl) - o
         if f in needfiles:
             needs = needfiles[f]
             for new in range(o, len(fl)):
                 n = fl.node(new)
                 if n in needs:
                     needs.remove(n)
                 else:
                     raise error.Abort(_(b"received spurious file revlog entry"))
             if not needs:
                 del needfiles[f]
     progress.complete()
 
     for f, needs in needfiles.items():
         fl = repo.file(f)
         for n in needs:
             try:
                 fl.rev(n)
             except error.LookupError:
                 raise error.Abort(
                     _(b'missing file data for %s:%s - run hg verify')
                     % (f, hex(n))
                 )
 
     return revisions, files

mercurial/configitems.py

@@ -1,2883 +1,2889 b''
 # configitems.py - centralized declaration of configuration option
 #
 #  Copyright 2017 Pierre-Yves David <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import functools
 import re
 
 from . import (
     encoding,
     error,
 )
 
 
 def loadconfigtable(ui, extname, configtable):
     """update config item known to the ui with the extension ones"""
     for section, items in sorted(configtable.items()):
         knownitems = ui._knownconfig.setdefault(section, itemregister())
         knownkeys = set(knownitems)
         newkeys = set(items)
         for key in sorted(knownkeys & newkeys):
             msg = b"extension '%s' overwrite config item '%s.%s'"
             msg %= (extname, section, key)
             ui.develwarn(msg, config=b'warn-config')
 
         knownitems.update(items)
 
 
 class configitem:
     """represent a known config item
 
     :section: the official config section where to find this item,
        :name: the official name within the section,
     :default: default value for this item,
     :alias: optional list of tuples as alternatives,
     :generic: this is a generic definition, match name using regular expression.
     """
 
     def __init__(
         self,
         section,
         name,
         default=None,
         alias=(),
         generic=False,
         priority=0,
         experimental=False,
     ):
         self.section = section
         self.name = name
         self.default = default
         self.alias = list(alias)
         self.generic = generic
         self.priority = priority
         self.experimental = experimental
         self._re = None
         if generic:
             self._re = re.compile(self.name)
 
 
 class itemregister(dict):
     """A specialized dictionary that can handle wild-card selection"""
 
     def __init__(self):
         super(itemregister, self).__init__()
         self._generics = set()
 
     def update(self, other):
         super(itemregister, self).update(other)
         self._generics.update(other._generics)
 
     def __setitem__(self, key, item):
         super(itemregister, self).__setitem__(key, item)
         if item.generic:
             self._generics.add(item)
 
     def get(self, key):
         baseitem = super(itemregister, self).get(key)
         if baseitem is not None and not baseitem.generic:
             return baseitem
 
         # search for a matching generic item
         generics = sorted(self._generics, key=(lambda x: (x.priority, x.name)))
         for item in generics:
             # we use 'match' instead of 'search' to make the matching simpler
             # for people unfamiliar with regular expression. Having the match
             # rooted to the start of the string will produce less surprising
             # result for user writing simple regex for sub-attribute.
             #
             # For example using "color\..*" match produces an unsurprising
             # result, while using search could suddenly match apparently
             # unrelated configuration that happens to contains "color."
             # anywhere. This is a tradeoff where we favor requiring ".*" on
             # some match to avoid the need to prefix most pattern with "^".
             # The "^" seems more error prone.
             if item._re.match(key):
                 return item
 
         return None
 
 
 coreitems = {}
 
 
 def _register(configtable, *args, **kwargs):
     item = configitem(*args, **kwargs)
     section = configtable.setdefault(item.section, itemregister())
     if item.name in section:
         msg = b"duplicated config item registration for '%s.%s'"
         raise error.ProgrammingError(msg % (item.section, item.name))
     section[item.name] = item
 
 
 # special value for case where the default is derived from other values
 dynamicdefault = object()
 
 # Registering actual config items
 
 
 def getitemregister(configtable):
     f = functools.partial(_register, configtable)
     # export pseudo enum as configitem.*
     f.dynamicdefault = dynamicdefault
     return f
 
 
 coreconfigitem = getitemregister(coreitems)
 
 
 def _registerdiffopts(section, configprefix=b''):
     coreconfigitem(
         section,
         configprefix + b'nodates',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'showfunc',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'unified',
         default=None,
     )
     coreconfigitem(
         section,
         configprefix + b'git',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'ignorews',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'ignorewsamount',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'ignoreblanklines',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'ignorewseol',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'nobinary',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'noprefix',
         default=False,
     )
     coreconfigitem(
         section,
         configprefix + b'word-diff',
         default=False,
     )
 
 
 coreconfigitem(
     b'alias',
     b'.*',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem(
     b'auth',
     b'cookiefile',
     default=None,
 )
 _registerdiffopts(section=b'annotate')
 # bookmarks.pushing: internal hack for discovery
 coreconfigitem(
     b'bookmarks',
     b'pushing',
     default=list,
 )
 # bundle.mainreporoot: internal hack for bundlerepo
 coreconfigitem(
     b'bundle',
     b'mainreporoot',
     default=b'',
 )
 coreconfigitem(
     b'censor',
     b'policy',
     default=b'abort',
     experimental=True,
 )
 coreconfigitem(
     b'chgserver',
     b'idletimeout',
     default=3600,
 )
 coreconfigitem(
     b'chgserver',
     b'skiphash',
     default=False,
 )
 coreconfigitem(
     b'cmdserver',
     b'log',
     default=None,
 )
 coreconfigitem(
     b'cmdserver',
     b'max-log-files',
     default=7,
 )
 coreconfigitem(
     b'cmdserver',
     b'max-log-size',
     default=b'1 MB',
 )
 coreconfigitem(
     b'cmdserver',
     b'max-repo-cache',
     default=0,
     experimental=True,
 )
 coreconfigitem(
     b'cmdserver',
     b'message-encodings',
     default=list,
 )
 coreconfigitem(
     b'cmdserver',
     b'track-log',
     default=lambda: [b'chgserver', b'cmdserver', b'repocache'],
 )
 coreconfigitem(
     b'cmdserver',
     b'shutdown-on-interrupt',
     default=True,
 )
 coreconfigitem(
     b'color',
     b'.*',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'color',
     b'mode',
     default=b'auto',
 )
 coreconfigitem(
     b'color',
     b'pagermode',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'command-templates',
     b'graphnode',
     default=None,
     alias=[(b'ui', b'graphnodetemplate')],
 )
 coreconfigitem(
     b'command-templates',
     b'log',
     default=None,
     alias=[(b'ui', b'logtemplate')],
 )
 coreconfigitem(
     b'command-templates',
     b'mergemarker',
     default=(
         b'{node|short} '
         b'{ifeq(tags, "tip", "", '
         b'ifeq(tags, "", "", "{tags} "))}'
         b'{if(bookmarks, "{bookmarks} ")}'
         b'{ifeq(branch, "default", "", "{branch} ")}'
         b'- {author|user}: {desc|firstline}'
     ),
     alias=[(b'ui', b'mergemarkertemplate')],
 )
 coreconfigitem(
     b'command-templates',
     b'pre-merge-tool-output',
     default=None,
     alias=[(b'ui', b'pre-merge-tool-output-template')],
 )
 coreconfigitem(
     b'command-templates',
     b'oneline-summary',
     default=None,
 )
 coreconfigitem(
     b'command-templates',
     b'oneline-summary.*',
     default=dynamicdefault,
     generic=True,
 )
 _registerdiffopts(section=b'commands', configprefix=b'commit.interactive.')
 coreconfigitem(
     b'commands',
     b'commit.post-status',
     default=False,
 )
 coreconfigitem(
     b'commands',
     b'grep.all-files',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'commands',
     b'merge.require-rev',
     default=False,
 )
 coreconfigitem(
     b'commands',
     b'push.require-revs',
     default=False,
 )
 coreconfigitem(
     b'commands',
     b'resolve.confirm',
     default=False,
 )
 coreconfigitem(
     b'commands',
     b'resolve.explicit-re-merge',
     default=False,
 )
 coreconfigitem(
     b'commands',
     b'resolve.mark-check',
     default=b'none',
 )
 _registerdiffopts(section=b'commands', configprefix=b'revert.interactive.')
 coreconfigitem(
     b'commands',
     b'show.aliasprefix',
     default=list,
 )
 coreconfigitem(
     b'commands',
     b'status.relative',
     default=False,
 )
 coreconfigitem(
     b'commands',
     b'status.skipstates',
     default=[],
     experimental=True,
 )
 coreconfigitem(
     b'commands',
     b'status.terse',
     default=b'',
 )
 coreconfigitem(
     b'commands',
     b'status.verbose',
     default=False,
 )
 coreconfigitem(
     b'commands',
     b'update.check',
     default=None,
 )
 coreconfigitem(
     b'commands',
     b'update.requiredest',
     default=False,
 )
 coreconfigitem(
     b'committemplate',
     b'.*',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'convert',
     b'bzr.saverev',
     default=True,
 )
 coreconfigitem(
     b'convert',
     b'cvsps.cache',
     default=True,
 )
 coreconfigitem(
     b'convert',
     b'cvsps.fuzz',
     default=60,
 )
 coreconfigitem(
     b'convert',
     b'cvsps.logencoding',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'cvsps.mergefrom',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'cvsps.mergeto',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'git.committeractions',
     default=lambda: [b'messagedifferent'],
 )
 coreconfigitem(
     b'convert',
     b'git.extrakeys',
     default=list,
 )
 coreconfigitem(
     b'convert',
     b'git.findcopiesharder',
     default=False,
 )
 coreconfigitem(
     b'convert',
     b'git.remoteprefix',
     default=b'remote',
 )
 coreconfigitem(
     b'convert',
     b'git.renamelimit',
     default=400,
 )
 coreconfigitem(
     b'convert',
     b'git.saverev',
     default=True,
 )
 coreconfigitem(
     b'convert',
     b'git.similarity',
     default=50,
 )
 coreconfigitem(
     b'convert',
     b'git.skipsubmodules',
     default=False,
 )
 coreconfigitem(
     b'convert',
     b'hg.clonebranches',
     default=False,
 )
 coreconfigitem(
     b'convert',
     b'hg.ignoreerrors',
     default=False,
 )
 coreconfigitem(
     b'convert',
     b'hg.preserve-hash',
     default=False,
 )
 coreconfigitem(
     b'convert',
     b'hg.revs',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'hg.saverev',
     default=False,
 )
 coreconfigitem(
     b'convert',
     b'hg.sourcename',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'hg.startrev',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'hg.tagsbranch',
     default=b'default',
 )
 coreconfigitem(
     b'convert',
     b'hg.usebranchnames',
     default=True,
 )
 coreconfigitem(
     b'convert',
     b'ignoreancestorcheck',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'convert',
     b'localtimezone',
     default=False,
 )
 coreconfigitem(
     b'convert',
     b'p4.encoding',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'convert',
     b'p4.startrev',
     default=0,
 )
 coreconfigitem(
     b'convert',
     b'skiptags',
     default=False,
 )
 coreconfigitem(
     b'convert',
     b'svn.debugsvnlog',
     default=True,
 )
 coreconfigitem(
     b'convert',
     b'svn.trunk',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'svn.tags',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'svn.branches',
     default=None,
 )
 coreconfigitem(
     b'convert',
     b'svn.startrev',
     default=0,
 )
 coreconfigitem(
     b'convert',
     b'svn.dangerous-set-commit-dates',
     default=False,
 )
 coreconfigitem(
     b'debug',
     b'dirstate.delaywrite',
     default=0,
 )
 coreconfigitem(
     b'debug',
     b'revlog.verifyposition.changelog',
     default=b'',
 )
 coreconfigitem(
     b'debug',
     b'revlog.debug-delta',
     default=False,
 )
 # display extra information about the bundling process
 coreconfigitem(
     b'debug',
     b'bundling-stats',
     default=False,
 )
+# display extra information about the unbundling process
+coreconfigitem(
+    b'debug',
+    b'unbundling-stats',
+    default=False,
+)
 coreconfigitem(
     b'defaults',
     b'.*',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'devel',
     b'all-warnings',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'bundle2.debug',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'bundle.delta',
     default=b'',
 )
 coreconfigitem(
     b'devel',
     b'cache-vfs',
     default=None,
 )
 coreconfigitem(
     b'devel',
     b'check-locks',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'check-relroot',
     default=False,
 )
 # Track copy information for all file, not just "added" one (very slow)
 coreconfigitem(
     b'devel',
     b'copy-tracing.trace-all-files',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'default-date',
     default=None,
 )
 coreconfigitem(
     b'devel',
     b'deprec-warn',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'disableloaddefaultcerts',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'warn-empty-changegroup',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'legacy.exchange',
     default=list,
 )
 # When True, revlogs use a special reference version of the nodemap, that is not
 # performant but is "known" to behave properly.
 coreconfigitem(
     b'devel',
     b'persistent-nodemap',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'servercafile',
     default=b'',
 )
 coreconfigitem(
     b'devel',
     b'serverexactprotocol',
     default=b'',
 )
 coreconfigitem(
     b'devel',
     b'serverrequirecert',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'strip-obsmarkers',
     default=True,
 )
 coreconfigitem(
     b'devel',
     b'warn-config',
     default=None,
 )
 coreconfigitem(
     b'devel',
     b'warn-config-default',
     default=None,
 )
 coreconfigitem(
     b'devel',
     b'user.obsmarker',
     default=None,
 )
 coreconfigitem(
     b'devel',
     b'warn-config-unknown',
     default=None,
 )
 coreconfigitem(
     b'devel',
     b'debug.copies',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'copy-tracing.multi-thread',
     default=True,
 )
 coreconfigitem(
     b'devel',
     b'debug.extensions',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'debug.repo-filters',
     default=False,
 )
 coreconfigitem(
     b'devel',
     b'debug.peer-request',
     default=False,
 )
 # If discovery.exchange-heads is False, the discovery will not start with
 # remote head fetching and local head querying.
 coreconfigitem(
     b'devel',
     b'discovery.exchange-heads',
     default=True,
 )
 # If discovery.grow-sample is False, the sample size used in set discovery will
 # not be increased through the process
 coreconfigitem(
     b'devel',
     b'discovery.grow-sample',
     default=True,
 )
 # When discovery.grow-sample.dynamic is True, the default, the sample size is
 # adapted to the shape of the undecided set (it is set to the max of:
 # <target-size>, len(roots(undecided)), len(heads(undecided)
 coreconfigitem(
     b'devel',
     b'discovery.grow-sample.dynamic',
     default=True,
 )
 # discovery.grow-sample.rate control the rate at which the sample grow
 coreconfigitem(
     b'devel',
     b'discovery.grow-sample.rate',
     default=1.05,
 )
 # If discovery.randomize is False, random sampling during discovery are
 # deterministic. It is meant for integration tests.
 coreconfigitem(
     b'devel',
     b'discovery.randomize',
     default=True,
 )
 # Control the initial size of the discovery sample
 coreconfigitem(
     b'devel',
     b'discovery.sample-size',
     default=200,
 )
 # Control the initial size of the discovery for initial change
 coreconfigitem(
     b'devel',
     b'discovery.sample-size.initial',
     default=100,
 )
 _registerdiffopts(section=b'diff')
 coreconfigitem(
     b'diff',
     b'merge',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'email',
     b'bcc',
     default=None,
 )
 coreconfigitem(
     b'email',
     b'cc',
     default=None,
 )
 coreconfigitem(
     b'email',
     b'charsets',
     default=list,
 )
 coreconfigitem(
     b'email',
     b'from',
     default=None,
 )
 coreconfigitem(
     b'email',
     b'method',
     default=b'smtp',
 )
 coreconfigitem(
     b'email',
     b'reply-to',
     default=None,
 )
 coreconfigitem(
     b'email',
     b'to',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'archivemetatemplate',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'experimental',
     b'auto-publish',
     default=b'publish',
 )
 coreconfigitem(
     b'experimental',
     b'bundle-phases',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'bundle2-advertise',
     default=True,
 )
 coreconfigitem(
     b'experimental',
     b'bundle2-output-capture',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'bundle2.pushback',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'bundle2lazylocking',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecomplevel',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecomplevel.bzip2',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecomplevel.gzip',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecomplevel.none',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecomplevel.zstd',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecompthreads',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecompthreads.bzip2',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecompthreads.gzip',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecompthreads.none',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'bundlecompthreads.zstd',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'changegroup3',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'changegroup4',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'cleanup-as-archived',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'clientcompressionengines',
     default=list,
 )
 coreconfigitem(
     b'experimental',
     b'copytrace',
     default=b'on',
 )
 coreconfigitem(
     b'experimental',
     b'copytrace.movecandidateslimit',
     default=100,
 )
 coreconfigitem(
     b'experimental',
     b'copytrace.sourcecommitlimit',
     default=100,
 )
 coreconfigitem(
     b'experimental',
     b'copies.read-from',
     default=b"filelog-only",
 )
 coreconfigitem(
     b'experimental',
     b'copies.write-to',
     default=b'filelog-only',
 )
 coreconfigitem(
     b'experimental',
     b'crecordtest',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'directaccess',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'directaccess.revnums',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'editortmpinhg',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'evolution',
     default=list,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.allowdivergence',
     default=False,
     alias=[(b'experimental', b'allowdivergence')],
 )
 coreconfigitem(
     b'experimental',
     b'evolution.allowunstable',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.createmarkers',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.effect-flags',
     default=True,
     alias=[(b'experimental', b'effect-flags')],
 )
 coreconfigitem(
     b'experimental',
     b'evolution.exchange',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.bundle-obsmarker',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.bundle-obsmarker:mandatory',
     default=True,
 )
 coreconfigitem(
     b'experimental',
     b'log.topo',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.report-instabilities',
     default=True,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.track-operation',
     default=True,
 )
 # repo-level config to exclude a revset visibility
 #
 # The target use case is to use `share` to expose different subset of the same
 # repository, especially server side. See also `server.view`.
 coreconfigitem(
     b'experimental',
     b'extra-filter-revs',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'maxdeltachainspan',
     default=-1,
 )
 # tracks files which were undeleted (merge might delete them but we explicitly
 # kept/undeleted them) and creates new filenodes for them
 coreconfigitem(
     b'experimental',
     b'merge-track-salvaged',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'mmapindexthreshold',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'narrow',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'nonnormalparanoidcheck',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'exportableenviron',
     default=list,
 )
 coreconfigitem(
     b'experimental',
     b'extendedheader.index',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'extendedheader.similarity',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'graphshorten',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'graphstyle.parent',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'experimental',
     b'graphstyle.missing',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'experimental',
     b'graphstyle.grandparent',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'experimental',
     b'hook-track-tags',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'httppostargs',
     default=False,
 )
 coreconfigitem(b'experimental', b'nointerrupt', default=False)
 coreconfigitem(b'experimental', b'nointerrupt-interactiveonly', default=True)
 
 coreconfigitem(
     b'experimental',
     b'obsmarkers-exchange-debug',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'remotenames',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'removeemptydirs',
     default=True,
 )
 coreconfigitem(
     b'experimental',
     b'revert.interactive.select-to-keep',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'revisions.prefixhexnode',
     default=False,
 )
 # "out of experimental" todo list.
 #
 # * include management of a persistent nodemap in the main docket
 # * enforce a "no-truncate" policy for mmap safety
 #      - for censoring operation
 #      - for stripping operation
 #      - for rollback operation
 # * proper streaming (race free) of the docket file
 # * track garbage data to evemtually allow rewriting -existing- sidedata.
 # * Exchange-wise, we will also need to do something more efficient than
 #   keeping references to the affected revlogs, especially memory-wise when
 #   rewriting sidedata.
 # * introduce a proper solution to reduce the number of filelog related files.
 # * use caching for reading sidedata (similar to what we do for data).
 # * no longer set offset=0 if sidedata_size=0 (simplify cutoff computation).
 # * Improvement to consider
 #   - avoid compression header in chunk using the default compression?
 #   - forbid "inline" compression mode entirely?
 #   - split the data offset and flag field (the 2 bytes save are mostly trouble)
 #   - keep track of uncompressed -chunk- size (to preallocate memory better)
 #   - keep track of chain base or size (probably not that useful anymore)
 coreconfigitem(
     b'experimental',
     b'revlogv2',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'revisions.disambiguatewithin',
     default=None,
 )
 coreconfigitem(
     b'experimental',
     b'rust.index',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'server.filesdata.recommended-batch-size',
     default=50000,
 )
 coreconfigitem(
     b'experimental',
     b'server.manifestdata.recommended-batch-size',
     default=100000,
 )
 coreconfigitem(
     b'experimental',
     b'server.stream-narrow-clones',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'single-head-per-branch',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'single-head-per-branch:account-closed-heads',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'single-head-per-branch:public-changes-only',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'sparse-read',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'sparse-read.density-threshold',
     default=0.50,
 )
 coreconfigitem(
     b'experimental',
     b'sparse-read.min-gap-size',
     default=b'65K',
 )
 coreconfigitem(
     b'experimental',
     b'treemanifest',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'update.atomic-file',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'web.full-garbage-collection-rate',
     default=1,  # still forcing a full collection on each request
 )
 coreconfigitem(
     b'experimental',
     b'worker.wdir-get-thread-safe',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'worker.repository-upgrade',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'xdiff',
     default=False,
 )
 coreconfigitem(
     b'extensions',
     b'[^:]*',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'extensions',
     b'[^:]*:required',
     default=False,
     generic=True,
 )
 coreconfigitem(
     b'extdata',
     b'.*',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'format',
     b'bookmarks-in-store',
     default=False,
 )
 coreconfigitem(
     b'format',
     b'chunkcachesize',
     default=None,
     experimental=True,
 )
 coreconfigitem(
     # Enable this dirstate format *when creating a new repository*.
     # Which format to use for existing repos is controlled by .hg/requires
     b'format',
     b'use-dirstate-v2',
     default=False,
     experimental=True,
     alias=[(b'format', b'exp-rc-dirstate-v2')],
 )
 coreconfigitem(
     b'format',
     b'use-dirstate-v2.automatic-upgrade-of-mismatching-repositories',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'use-dirstate-v2.automatic-upgrade-of-mismatching-repositories:quiet',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'use-dirstate-tracked-hint',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'use-dirstate-tracked-hint.version',
     default=1,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'use-dirstate-tracked-hint.automatic-upgrade-of-mismatching-repositories',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'use-dirstate-tracked-hint.automatic-upgrade-of-mismatching-repositories:quiet',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'dotencode',
     default=True,
 )
 coreconfigitem(
     b'format',
     b'generaldelta',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'manifestcachesize',
     default=None,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'maxchainlen',
     default=dynamicdefault,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'obsstore-version',
     default=None,
 )
 coreconfigitem(
     b'format',
     b'sparse-revlog',
     default=True,
 )
 coreconfigitem(
     b'format',
     b'revlog-compression',
     default=lambda: [b'zstd', b'zlib'],
     alias=[(b'experimental', b'format.compression')],
 )
 # Experimental TODOs:
 #
 # * Same as for revlogv2 (but for the reduction of the number of files)
 # * Actually computing the rank of changesets
 # * Improvement to investigate
 #   - storing .hgtags fnode
 #   - storing branch related identifier
 
 coreconfigitem(
     b'format',
     b'exp-use-changelog-v2',
     default=None,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'usefncache',
     default=True,
 )
 coreconfigitem(
     b'format',
     b'usegeneraldelta',
     default=True,
 )
 coreconfigitem(
     b'format',
     b'usestore',
     default=True,
 )
 
 
 def _persistent_nodemap_default():
     """compute `use-persistent-nodemap` default value
 
     The feature is disabled unless a fast implementation is available.
     """
     from . import policy
 
     return policy.importrust('revlog') is not None
 
 
 coreconfigitem(
     b'format',
     b'use-persistent-nodemap',
     default=_persistent_nodemap_default,
 )
 coreconfigitem(
     b'format',
     b'exp-use-copies-side-data-changeset',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'use-share-safe',
     default=True,
 )
 coreconfigitem(
     b'format',
     b'use-share-safe.automatic-upgrade-of-mismatching-repositories',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format',
     b'use-share-safe.automatic-upgrade-of-mismatching-repositories:quiet',
     default=False,
     experimental=True,
 )
 
 # Moving this on by default means we are confident about the scaling of phases.
 # This is not garanteed to be the case at the time this message is written.
 coreconfigitem(
     b'format',
     b'use-internal-phase',
     default=False,
     experimental=True,
 )
 # The interaction between the archived phase and obsolescence markers needs to
 # be sorted out before wider usage of this are to be considered.
 #
 # At the time this message is written, behavior when archiving obsolete
 # changeset differ significantly from stripping. As part of stripping, we also
 # remove the obsolescence marker associated to the stripped changesets,
 # revealing the precedecessors changesets when applicable. When archiving, we
 # don't touch the obsolescence markers, keeping everything hidden. This can
 # result in quite confusing situation for people combining exchanging draft
 # with the archived phases. As some markers needed by others may be skipped
 # during exchange.
 coreconfigitem(
     b'format',
     b'exp-archived-phase',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'shelve',
     b'store',
     default=b'internal',
     experimental=True,
 )
 coreconfigitem(
     b'fsmonitor',
     b'warn_when_unused',
     default=True,
 )
 coreconfigitem(
     b'fsmonitor',
     b'warn_update_file_count',
     default=50000,
 )
 coreconfigitem(
     b'fsmonitor',
     b'warn_update_file_count_rust',
     default=400000,
 )
 coreconfigitem(
     b'help',
     br'hidden-command\..*',
     default=False,
     generic=True,
 )
 coreconfigitem(
     b'help',
     br'hidden-topic\..*',
     default=False,
     generic=True,
 )
 coreconfigitem(
     b'hooks',
     b'[^:]*',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem(
     b'hooks',
     b'.*:run-with-plain',
     default=True,
     generic=True,
 )
 coreconfigitem(
     b'hgweb-paths',
     b'.*',
     default=list,
     generic=True,
 )
 coreconfigitem(
     b'hostfingerprints',
     b'.*',
     default=list,
     generic=True,
 )
 coreconfigitem(
     b'hostsecurity',
     b'ciphers',
     default=None,
 )
 coreconfigitem(
     b'hostsecurity',
     b'minimumprotocol',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'hostsecurity',
     b'.*:minimumprotocol$',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem(
     b'hostsecurity',
     b'.*:ciphers$',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem(
     b'hostsecurity',
     b'.*:fingerprints$',
     default=list,
     generic=True,
 )
 coreconfigitem(
     b'hostsecurity',
     b'.*:verifycertsfile$',
     default=None,
     generic=True,
 )
 
 coreconfigitem(
     b'http_proxy',
     b'always',
     default=False,
 )
 coreconfigitem(
     b'http_proxy',
     b'host',
     default=None,
 )
 coreconfigitem(
     b'http_proxy',
     b'no',
     default=list,
 )
 coreconfigitem(
     b'http_proxy',
     b'passwd',
     default=None,
 )
 coreconfigitem(
     b'http_proxy',
     b'user',
     default=None,
 )
 
 coreconfigitem(
     b'http',
     b'timeout',
     default=None,
 )
 
 coreconfigitem(
     b'logtoprocess',
     b'commandexception',
     default=None,
 )
 coreconfigitem(
     b'logtoprocess',
     b'commandfinish',
     default=None,
 )
 coreconfigitem(
     b'logtoprocess',
     b'command',
     default=None,
 )
 coreconfigitem(
     b'logtoprocess',
     b'develwarn',
     default=None,
 )
 coreconfigitem(
     b'logtoprocess',
     b'uiblocked',
     default=None,
 )
 coreconfigitem(
     b'merge',
     b'checkunknown',
     default=b'abort',
 )
 coreconfigitem(
     b'merge',
     b'checkignored',
     default=b'abort',
 )
 coreconfigitem(
     b'experimental',
     b'merge.checkpathconflicts',
     default=False,
 )
 coreconfigitem(
     b'merge',
     b'followcopies',
     default=True,
 )
 coreconfigitem(
     b'merge',
     b'on-failure',
     default=b'continue',
 )
 coreconfigitem(
     b'merge',
     b'preferancestor',
     default=lambda: [b'*'],
     experimental=True,
 )
 coreconfigitem(
     b'merge',
     b'strict-capability-check',
     default=False,
 )
 coreconfigitem(
     b'merge',
     b'disable-partial-tools',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'partial-merge-tools',
     b'.*',
     default=None,
     generic=True,
     experimental=True,
 )
 coreconfigitem(
     b'partial-merge-tools',
     br'.*\.patterns',
     default=dynamicdefault,
     generic=True,
     priority=-1,
     experimental=True,
 )
 coreconfigitem(
     b'partial-merge-tools',
     br'.*\.executable$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
     experimental=True,
 )
 coreconfigitem(
     b'partial-merge-tools',
     br'.*\.order',
     default=0,
     generic=True,
     priority=-1,
     experimental=True,
 )
 coreconfigitem(
     b'partial-merge-tools',
     br'.*\.args',
     default=b"$local $base $other",
     generic=True,
     priority=-1,
     experimental=True,
 )
 coreconfigitem(
     b'partial-merge-tools',
     br'.*\.disable',
     default=False,
     generic=True,
     priority=-1,
     experimental=True,
 )
 coreconfigitem(
     b'merge-tools',
     b'.*',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.args$',
     default=b"$local $base $other",
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.binary$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.check$',
     default=list,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.checkchanged$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.executable$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.fixeol$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.gui$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.mergemarkers$',
     default=b'basic',
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.mergemarkertemplate$',
     default=dynamicdefault,  # take from command-templates.mergemarker
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.priority$',
     default=0,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.premerge$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.symlink$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'pager',
     b'attend-.*',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem(
     b'pager',
     b'ignore',
     default=list,
 )
 coreconfigitem(
     b'pager',
     b'pager',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'patch',
     b'eol',
     default=b'strict',
 )
 coreconfigitem(
     b'patch',
     b'fuzz',
     default=2,
 )
 coreconfigitem(
     b'paths',
     b'default',
     default=None,
 )
 coreconfigitem(
     b'paths',
     b'default-push',
     default=None,
 )
 coreconfigitem(
     b'paths',
     b'.*',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'paths',
     b'.*:bookmarks.mode',
     default='default',
     generic=True,
 )
 coreconfigitem(
     b'paths',
     b'.*:multi-urls',
     default=False,
     generic=True,
 )
 coreconfigitem(
     b'paths',
     b'.*:pushrev',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'paths',
     b'.*:pushurl',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'phases',
     b'checksubrepos',
     default=b'follow',
 )
 coreconfigitem(
     b'phases',
     b'new-commit',
     default=b'draft',
 )
 coreconfigitem(
     b'phases',
     b'publish',
     default=True,
 )
 coreconfigitem(
     b'profiling',
     b'enabled',
     default=False,
 )
 coreconfigitem(
     b'profiling',
     b'format',
     default=b'text',
 )
 coreconfigitem(
     b'profiling',
     b'freq',
     default=1000,
 )
 coreconfigitem(
     b'profiling',
     b'limit',
     default=30,
 )
 coreconfigitem(
     b'profiling',
     b'nested',
     default=0,
 )
 coreconfigitem(
     b'profiling',
     b'output',
     default=None,
 )
 coreconfigitem(
     b'profiling',
     b'showmax',
     default=0.999,
 )
 coreconfigitem(
     b'profiling',
     b'showmin',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'profiling',
     b'showtime',
     default=True,
 )
 coreconfigitem(
     b'profiling',
     b'sort',
     default=b'inlinetime',
 )
 coreconfigitem(
     b'profiling',
     b'statformat',
     default=b'hotpath',
 )
 coreconfigitem(
     b'profiling',
     b'time-track',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'profiling',
     b'type',
     default=b'stat',
 )
 coreconfigitem(
     b'progress',
     b'assume-tty',
     default=False,
 )
 coreconfigitem(
     b'progress',
     b'changedelay',
     default=1,
 )
 coreconfigitem(
     b'progress',
     b'clear-complete',
     default=True,
 )
 coreconfigitem(
     b'progress',
     b'debug',
     default=False,
 )
 coreconfigitem(
     b'progress',
     b'delay',
     default=3,
 )
 coreconfigitem(
     b'progress',
     b'disable',
     default=False,
 )
 coreconfigitem(
     b'progress',
     b'estimateinterval',
     default=60.0,
 )
 coreconfigitem(
     b'progress',
     b'format',
     default=lambda: [b'topic', b'bar', b'number', b'estimate'],
 )
 coreconfigitem(
     b'progress',
     b'refresh',
     default=0.1,
 )
 coreconfigitem(
     b'progress',
     b'width',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'pull',
     b'confirm',
     default=False,
 )
 coreconfigitem(
     b'push',
     b'pushvars.server',
     default=False,
 )
 coreconfigitem(
     b'rewrite',
     b'backup-bundle',
     default=True,
     alias=[(b'ui', b'history-editing-backup')],
 )
 coreconfigitem(
     b'rewrite',
     b'update-timestamp',
     default=False,
 )
 coreconfigitem(
     b'rewrite',
     b'empty-successor',
     default=b'skip',
     experimental=True,
 )
 # experimental as long as format.use-dirstate-v2 is.
 coreconfigitem(
     b'storage',
     b'dirstate-v2.slow-path',
     default=b"abort",
     experimental=True,
 )
 coreconfigitem(
     b'storage',
     b'new-repo-backend',
     default=b'revlogv1',
     experimental=True,
 )
 coreconfigitem(
     b'storage',
     b'revlog.optimize-delta-parent-choice',
     default=True,
     alias=[(b'format', b'aggressivemergedeltas')],
 )
 coreconfigitem(
     b'storage',
     b'revlog.issue6528.fix-incoming',
     default=True,
 )
 # experimental as long as rust is experimental (or a C version is implemented)
 coreconfigitem(
     b'storage',
     b'revlog.persistent-nodemap.mmap',
     default=True,
 )
 # experimental as long as format.use-persistent-nodemap is.
 coreconfigitem(
     b'storage',
     b'revlog.persistent-nodemap.slow-path',
     default=b"abort",
 )
 
 coreconfigitem(
     b'storage',
     b'revlog.reuse-external-delta',
     default=True,
 )
 coreconfigitem(
     b'storage',
     b'revlog.reuse-external-delta-parent',
     default=None,
 )
 coreconfigitem(
     b'storage',
     b'revlog.zlib.level',
     default=None,
 )
 coreconfigitem(
     b'storage',
     b'revlog.zstd.level',
     default=None,
 )
 coreconfigitem(
     b'server',
     b'bookmarks-pushkey-compat',
     default=True,
 )
 coreconfigitem(
     b'server',
     b'bundle1',
     default=True,
 )
 coreconfigitem(
     b'server',
     b'bundle1gd',
     default=None,
 )
 coreconfigitem(
     b'server',
     b'bundle1.pull',
     default=None,
 )
 coreconfigitem(
     b'server',
     b'bundle1gd.pull',
     default=None,
 )
 coreconfigitem(
     b'server',
     b'bundle1.push',
     default=None,
 )
 coreconfigitem(
     b'server',
     b'bundle1gd.push',
     default=None,
 )
 coreconfigitem(
     b'server',
     b'bundle2.stream',
     default=True,
     alias=[(b'experimental', b'bundle2.stream')],
 )
 coreconfigitem(
     b'server',
     b'compressionengines',
     default=list,
 )
 coreconfigitem(
     b'server',
     b'concurrent-push-mode',
     default=b'check-related',
 )
 coreconfigitem(
     b'server',
     b'disablefullbundle',
     default=False,
 )
 coreconfigitem(
     b'server',
     b'maxhttpheaderlen',
     default=1024,
 )
 coreconfigitem(
     b'server',
     b'pullbundle',
     default=True,
 )
 coreconfigitem(
     b'server',
     b'preferuncompressed',
     default=False,
 )
 coreconfigitem(
     b'server',
     b'streamunbundle',
     default=False,
 )
 coreconfigitem(
     b'server',
     b'uncompressed',
     default=True,
 )
 coreconfigitem(
     b'server',
     b'uncompressedallowsecret',
     default=False,
 )
 coreconfigitem(
     b'server',
     b'view',
     default=b'served',
 )
 coreconfigitem(
     b'server',
     b'validate',
     default=False,
 )
 coreconfigitem(
     b'server',
     b'zliblevel',
     default=-1,
 )
 coreconfigitem(
     b'server',
     b'zstdlevel',
     default=3,
 )
 coreconfigitem(
     b'share',
     b'pool',
     default=None,
 )
 coreconfigitem(
     b'share',
     b'poolnaming',
     default=b'identity',
 )
 coreconfigitem(
     b'share',
     b'safe-mismatch.source-not-safe',
     default=b'abort',
 )
 coreconfigitem(
     b'share',
     b'safe-mismatch.source-safe',
     default=b'abort',
 )
 coreconfigitem(
     b'share',
     b'safe-mismatch.source-not-safe.warn',
     default=True,
 )
 coreconfigitem(
     b'share',
     b'safe-mismatch.source-safe.warn',
     default=True,
 )
 coreconfigitem(
     b'share',
     b'safe-mismatch.source-not-safe:verbose-upgrade',
     default=True,
 )
 coreconfigitem(
     b'share',
     b'safe-mismatch.source-safe:verbose-upgrade',
     default=True,
 )
 coreconfigitem(
     b'shelve',
     b'maxbackups',
     default=10,
 )
 coreconfigitem(
     b'smtp',
     b'host',
     default=None,
 )
 coreconfigitem(
     b'smtp',
     b'local_hostname',
     default=None,
 )
 coreconfigitem(
     b'smtp',
     b'password',
     default=None,
 )
 coreconfigitem(
     b'smtp',
     b'port',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'smtp',
     b'tls',
     default=b'none',
 )
 coreconfigitem(
     b'smtp',
     b'username',
     default=None,
 )
 coreconfigitem(
     b'sparse',
     b'missingwarning',
     default=True,
     experimental=True,
 )
 coreconfigitem(
     b'subrepos',
     b'allowed',
     default=dynamicdefault,  # to make backporting simpler
 )
 coreconfigitem(
     b'subrepos',
     b'hg:allowed',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'subrepos',
     b'git:allowed',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'subrepos',
     b'svn:allowed',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'templates',
     b'.*',
     default=None,
     generic=True,
 )
 coreconfigitem(
     b'templateconfig',
     b'.*',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem(
     b'trusted',
     b'groups',
     default=list,
 )
 coreconfigitem(
     b'trusted',
     b'users',
     default=list,
 )
 coreconfigitem(
     b'ui',
     b'_usedassubrepo',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'allowemptycommit',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'archivemeta',
     default=True,
 )
 coreconfigitem(
     b'ui',
     b'askusername',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'available-memory',
     default=None,
 )
 
 coreconfigitem(
     b'ui',
     b'clonebundlefallback',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'clonebundleprefers',
     default=list,
 )
 coreconfigitem(
     b'ui',
     b'clonebundles',
     default=True,
 )
 coreconfigitem(
     b'ui',
     b'color',
     default=b'auto',
 )
 coreconfigitem(
     b'ui',
     b'commitsubrepos',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'debug',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'debugger',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'editor',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'ui',
     b'detailed-exit-code',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'ui',
     b'fallbackencoding',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'forcecwd',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'forcemerge',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'formatdebug',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'formatjson',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'formatted',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'interactive',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'interface',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'interface.chunkselector',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'large-file-limit',
     default=10 * (2 ** 20),
 )
 coreconfigitem(
     b'ui',
     b'logblockedtimes',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'merge',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'mergemarkers',
     default=b'basic',
 )
 coreconfigitem(
     b'ui',
     b'message-output',
     default=b'stdio',
 )
 coreconfigitem(
     b'ui',
     b'nontty',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'origbackuppath',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'paginate',
     default=True,
 )
 coreconfigitem(
     b'ui',
     b'patch',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'portablefilenames',
     default=b'warn',
 )
 coreconfigitem(
     b'ui',
     b'promptecho',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'quiet',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'quietbookmarkmove',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'relative-paths',
     default=b'legacy',
 )
 coreconfigitem(
     b'ui',
     b'remotecmd',
     default=b'hg',
 )
 coreconfigitem(
     b'ui',
     b'report_untrusted',
     default=True,
 )
 coreconfigitem(
     b'ui',
     b'rollback',
     default=True,
 )
 coreconfigitem(
     b'ui',
     b'signal-safe-lock',
     default=True,
 )
 coreconfigitem(
     b'ui',
     b'slash',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'ssh',
     default=b'ssh',
 )
 coreconfigitem(
     b'ui',
     b'ssherrorhint',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'statuscopies',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'strict',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'style',
     default=b'',
 )
 coreconfigitem(
     b'ui',
     b'supportcontact',
     default=None,
 )
 coreconfigitem(
     b'ui',
     b'textwidth',
     default=78,
 )
 coreconfigitem(
     b'ui',
     b'timeout',
     default=b'600',
 )
 coreconfigitem(
     b'ui',
     b'timeout.warn',
     default=0,
 )
 coreconfigitem(
     b'ui',
     b'timestamp-output',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'traceback',
     default=False,
 )
 coreconfigitem(
     b'ui',
     b'tweakdefaults',
     default=False,
 )
 coreconfigitem(b'ui', b'username', alias=[(b'ui', b'user')])
 coreconfigitem(
     b'ui',
     b'verbose',
     default=False,
 )
 coreconfigitem(
     b'verify',
     b'skipflags',
     default=0,
 )
 coreconfigitem(
     b'web',
     b'allowbz2',
     default=False,
 )
 coreconfigitem(
     b'web',
     b'allowgz',
     default=False,
 )
 coreconfigitem(
     b'web',
     b'allow-pull',
     alias=[(b'web', b'allowpull')],
     default=True,
 )
 coreconfigitem(
     b'web',
     b'allow-push',
     alias=[(b'web', b'allow_push')],
     default=list,
 )
 coreconfigitem(
     b'web',
     b'allowzip',
     default=False,
 )
 coreconfigitem(
     b'web',
     b'archivesubrepos',
     default=False,
 )
 coreconfigitem(
     b'web',
     b'cache',
     default=True,
 )
 coreconfigitem(
     b'web',
     b'comparisoncontext',
     default=5,
 )
 coreconfigitem(
     b'web',
     b'contact',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'deny_push',
     default=list,
 )
 coreconfigitem(
     b'web',
     b'guessmime',
     default=False,
 )
 coreconfigitem(
     b'web',
     b'hidden',
     default=False,
 )
 coreconfigitem(
     b'web',
     b'labels',
     default=list,
 )
 coreconfigitem(
     b'web',
     b'logoimg',
     default=b'hglogo.png',
 )
 coreconfigitem(
     b'web',
     b'logourl',
     default=b'https://mercurial-scm.org/',
 )
 coreconfigitem(
     b'web',
     b'accesslog',
     default=b'-',
 )
 coreconfigitem(
     b'web',
     b'address',
     default=b'',
 )
 coreconfigitem(
     b'web',
     b'allow-archive',
     alias=[(b'web', b'allow_archive')],
     default=list,
 )
 coreconfigitem(
     b'web',
     b'allow_read',
     default=list,
 )
 coreconfigitem(
     b'web',
     b'baseurl',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'cacerts',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'certificate',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'collapse',
     default=False,
 )
 coreconfigitem(
     b'web',
     b'csp',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'deny_read',
     default=list,
 )
 coreconfigitem(
     b'web',
     b'descend',
     default=True,
 )
 coreconfigitem(
     b'web',
     b'description',
     default=b"",
 )
 coreconfigitem(
     b'web',
     b'encoding',
     default=lambda: encoding.encoding,
 )
 coreconfigitem(
     b'web',
     b'errorlog',
     default=b'-',
 )
 coreconfigitem(
     b'web',
     b'ipv6',
     default=False,
 )
 coreconfigitem(
     b'web',
     b'maxchanges',
     default=10,
 )
 coreconfigitem(
     b'web',
     b'maxfiles',
     default=10,
 )
 coreconfigitem(
     b'web',
     b'maxshortchanges',
     default=60,
 )
 coreconfigitem(
     b'web',
     b'motd',
     default=b'',
 )
 coreconfigitem(
     b'web',
     b'name',
     default=dynamicdefault,
 )
 coreconfigitem(
     b'web',
     b'port',
     default=8000,
 )
 coreconfigitem(
     b'web',
     b'prefix',
     default=b'',
 )
 coreconfigitem(
     b'web',
     b'push_ssl',
     default=True,
 )
 coreconfigitem(
     b'web',
     b'refreshinterval',
     default=20,
 )
 coreconfigitem(
     b'web',
     b'server-header',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'static',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'staticurl',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'stripes',
     default=1,
 )
 coreconfigitem(
     b'web',
     b'style',
     default=b'paper',
 )
 coreconfigitem(
     b'web',
     b'templates',
     default=None,
 )
 coreconfigitem(
     b'web',
     b'view',
     default=b'served',
     experimental=True,
 )
 coreconfigitem(
     b'worker',
     b'backgroundclose',
     default=dynamicdefault,
 )
 # Windows defaults to a limit of 512 open files. A buffer of 128
 # should give us enough headway.
 coreconfigitem(
     b'worker',
     b'backgroundclosemaxqueue',
     default=384,
 )
 coreconfigitem(
     b'worker',
     b'backgroundcloseminfilecount',
     default=2048,
 )
 coreconfigitem(
     b'worker',
     b'backgroundclosethreadcount',
     default=4,
 )
 coreconfigitem(
     b'worker',
     b'enabled',
     default=True,
 )
 coreconfigitem(
     b'worker',
     b'numcpus',
     default=None,
 )
 
 # Rebase related configuration moved to core because other extension are doing
 # strange things. For example, shelve import the extensions to reuse some bit
 # without formally loading it.
 coreconfigitem(
     b'commands',
     b'rebase.requiredest',
     default=False,
 )
 coreconfigitem(
     b'experimental',
     b'rebaseskipobsolete',
     default=True,
 )
 coreconfigitem(
     b'rebase',
     b'singletransaction',
     default=False,
 )
 coreconfigitem(
     b'rebase',
     b'experimental.inmemory',
     default=False,
 )
 
 # This setting controls creation of a rebase_source extra field
 # during rebase. When False, no such field is created. This is
 # useful eg for incrementally converting changesets and then
 # rebasing them onto an existing repo.
 # WARNING: this is an advanced setting reserved for people who know
 # exactly what they are doing. Misuse of this setting can easily
 # result in obsmarker cycles and a vivid headache.
 coreconfigitem(
     b'rebase',
     b'store-source',
     default=True,
     experimental=True,
 )

mercurial/filelog.py

@@ -1,299 +1,301 b''
 # filelog.py - file history class for mercurial
 #
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 from .i18n import _
 from .node import nullrev
 from . import (
     error,
     revlog,
 )
 from .interfaces import (
     repository,
     util as interfaceutil,
 )
 from .utils import storageutil
 from .revlogutils import (
     constants as revlog_constants,
     rewrite,
 )
 
 
 @interfaceutil.implementer(repository.ifilestorage)
 class filelog:
     def __init__(self, opener, path):
         self._revlog = revlog.revlog(
             opener,
             # XXX should use the unencoded path
             target=(revlog_constants.KIND_FILELOG, path),
             radix=b'/'.join((b'data', path)),
             censorable=True,
             canonical_parent_order=False,  # see comment in revlog.py
         )
         # Full name of the user visible file, relative to the repository root.
         # Used by LFS.
         self._revlog.filename = path
         self.nullid = self._revlog.nullid
         opts = opener.options
         self._fix_issue6528 = opts.get(b'issue6528.fix-incoming', True)
 
     def __len__(self):
         return len(self._revlog)
 
     def __iter__(self):
         return self._revlog.__iter__()
 
     def hasnode(self, node):
         if node in (self.nullid, nullrev):
             return False
 
         try:
             self._revlog.rev(node)
             return True
         except (TypeError, ValueError, IndexError, error.LookupError):
             return False
 
     def revs(self, start=0, stop=None):
         return self._revlog.revs(start=start, stop=stop)
 
     def parents(self, node):
         return self._revlog.parents(node)
 
     def parentrevs(self, rev):
         return self._revlog.parentrevs(rev)
 
     def rev(self, node):
         return self._revlog.rev(node)
 
     def node(self, rev):
         return self._revlog.node(rev)
 
     def lookup(self, node):
         return storageutil.fileidlookup(
             self._revlog, node, self._revlog.display_id
         )
 
     def linkrev(self, rev):
         return self._revlog.linkrev(rev)
 
     def commonancestorsheads(self, node1, node2):
         return self._revlog.commonancestorsheads(node1, node2)
 
     # Used by dagop.blockdescendants().
     def descendants(self, revs):
         return self._revlog.descendants(revs)
 
     def heads(self, start=None, stop=None):
         return self._revlog.heads(start, stop)
 
     # Used by hgweb, children extension.
     def children(self, node):
         return self._revlog.children(node)
 
     def iscensored(self, rev):
         return self._revlog.iscensored(rev)
 
     def revision(self, node, _df=None):
         return self._revlog.revision(node, _df=_df)
 
     def rawdata(self, node, _df=None):
         return self._revlog.rawdata(node, _df=_df)
 
     def emitrevisions(
         self,
         nodes,
         nodesorder=None,
         revisiondata=False,
         assumehaveparentrevisions=False,
         deltamode=repository.CG_DELTAMODE_STD,
         sidedata_helpers=None,
         debug_info=None,
     ):
         return self._revlog.emitrevisions(
             nodes,
             nodesorder=nodesorder,
             revisiondata=revisiondata,
             assumehaveparentrevisions=assumehaveparentrevisions,
             deltamode=deltamode,
             sidedata_helpers=sidedata_helpers,
             debug_info=debug_info,
         )
 
     def addrevision(
         self,
         revisiondata,
         transaction,
         linkrev,
         p1,
         p2,
         node=None,
         flags=revlog.REVIDX_DEFAULT_FLAGS,
         cachedelta=None,
     ):
         return self._revlog.addrevision(
             revisiondata,
             transaction,
             linkrev,
             p1,
             p2,
             node=node,
             flags=flags,
             cachedelta=cachedelta,
         )
 
     def addgroup(
         self,
         deltas,
         linkmapper,
         transaction,
         addrevisioncb=None,
         duplicaterevisioncb=None,
         maybemissingparents=False,
+        debug_info=None,
     ):
         if maybemissingparents:
             raise error.Abort(
                 _(
                     b'revlog storage does not support missing '
                     b'parents write mode'
                 )
             )
 
         with self._revlog._writing(transaction):
 
             if self._fix_issue6528:
                 deltas = rewrite.filter_delta_issue6528(self._revlog, deltas)
 
             return self._revlog.addgroup(
                 deltas,
                 linkmapper,
                 transaction,
                 addrevisioncb=addrevisioncb,
                 duplicaterevisioncb=duplicaterevisioncb,
+                debug_info=debug_info,
             )
 
     def getstrippoint(self, minlink):
         return self._revlog.getstrippoint(minlink)
 
     def strip(self, minlink, transaction):
         return self._revlog.strip(minlink, transaction)
 
     def censorrevision(self, tr, node, tombstone=b''):
         return self._revlog.censorrevision(tr, node, tombstone=tombstone)
 
     def files(self):
         return self._revlog.files()
 
     def read(self, node):
         return storageutil.filtermetadata(self.revision(node))
 
     def add(self, text, meta, transaction, link, p1=None, p2=None):
         if meta or text.startswith(b'\1\n'):
             text = storageutil.packmeta(meta, text)
         rev = self.addrevision(text, transaction, link, p1, p2)
         return self.node(rev)
 
     def renamed(self, node):
         return storageutil.filerevisioncopied(self, node)
 
     def size(self, rev):
         """return the size of a given revision"""
 
         # for revisions with renames, we have to go the slow way
         node = self.node(rev)
         if self.iscensored(rev):
             return 0
         if self.renamed(node):
             return len(self.read(node))
 
         # XXX if self.read(node).startswith("\1\n"), this returns (size+4)
         # XXX See also basefilectx.cmp.
         return self._revlog.size(rev)
 
     def cmp(self, node, text):
         """compare text with a given file revision
 
         returns True if text is different than what is stored.
         """
         return not storageutil.filedataequivalent(self, node, text)
 
     def verifyintegrity(self, state):
         return self._revlog.verifyintegrity(state)
 
     def storageinfo(
         self,
         exclusivefiles=False,
         sharedfiles=False,
         revisionscount=False,
         trackedsize=False,
         storedsize=False,
     ):
         return self._revlog.storageinfo(
             exclusivefiles=exclusivefiles,
             sharedfiles=sharedfiles,
             revisionscount=revisionscount,
             trackedsize=trackedsize,
             storedsize=storedsize,
         )
 
     # Used by repo upgrade.
     def clone(self, tr, destrevlog, **kwargs):
         if not isinstance(destrevlog, filelog):
             msg = b'expected filelog to clone(), not %r'
             msg %= destrevlog
             raise error.ProgrammingError(msg)
 
         return self._revlog.clone(tr, destrevlog._revlog, **kwargs)
 
 
 class narrowfilelog(filelog):
     """Filelog variation to be used with narrow stores."""
 
     def __init__(self, opener, path, narrowmatch):
         super(narrowfilelog, self).__init__(opener, path)
         self._narrowmatch = narrowmatch
 
     def renamed(self, node):
         res = super(narrowfilelog, self).renamed(node)
 
         # Renames that come from outside the narrowspec are problematic
         # because we may lack the base text for the rename. This can result
         # in code attempting to walk the ancestry or compute a diff
         # encountering a missing revision. We address this by silently
         # removing rename metadata if the source file is outside the
         # narrow spec.
         #
         # A better solution would be to see if the base revision is available,
         # rather than assuming it isn't.
         #
         # An even better solution would be to teach all consumers of rename
         # metadata that the base revision may not be available.
         #
         # TODO consider better ways of doing this.
         if res and not self._narrowmatch(res[0]):
             return None
 
         return res
 
     def size(self, rev):
         # Because we have a custom renamed() that may lie, we need to call
         # the base renamed() to report accurate results.
         node = self.node(rev)
         if super(narrowfilelog, self).renamed(node):
             return len(self.read(node))
         else:
             return super(narrowfilelog, self).size(rev)
 
     def cmp(self, node, text):
         # We don't call `super` because narrow parents can be buggy in case of a
         # ambiguous dirstate. Always take the slow path until there is a better
         # fix, see issue6150.
 
         # Censored files compare against the empty file.
         if self.iscensored(self.rev(node)):
             return text != b''
 
         return self.read(node) != text

mercurial/manifest.py

@@ -1,2370 +1,2372 b''
 # manifest.py - manifest revision class for mercurial
 #
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import heapq
 import itertools
 import struct
 import weakref
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullrev,
 )
 from .pycompat import getattr
 from . import (
     encoding,
     error,
     match as matchmod,
     mdiff,
     pathutil,
     policy,
     pycompat,
     revlog,
     util,
 )
 from .interfaces import (
     repository,
     util as interfaceutil,
 )
 from .revlogutils import (
     constants as revlog_constants,
 )
 
 parsers = policy.importmod('parsers')
 propertycache = util.propertycache
 
 # Allow tests to more easily test the alternate path in manifestdict.fastdelta()
 FASTDELTA_TEXTDIFF_THRESHOLD = 1000
 
 
 def _parse(nodelen, data):
     # This method does a little bit of excessive-looking
     # precondition checking. This is so that the behavior of this
     # class exactly matches its C counterpart to try and help
     # prevent surprise breakage for anyone that develops against
     # the pure version.
     if data and data[-1:] != b'\n':
         raise ValueError(b'Manifest did not end in a newline.')
     prev = None
     for l in data.splitlines():
         if prev is not None and prev > l:
             raise ValueError(b'Manifest lines not in sorted order.')
         prev = l
         f, n = l.split(b'\0')
         nl = len(n)
         flags = n[-1:]
         if flags in _manifestflags:
             n = n[:-1]
             nl -= 1
         else:
             flags = b''
         if nl != 2 * nodelen:
             raise ValueError(b'Invalid manifest line')
 
         yield f, bin(n), flags
 
 
 def _text(it):
     files = []
     lines = []
     for f, n, fl in it:
         files.append(f)
         # if this is changed to support newlines in filenames,
         # be sure to check the templates/ dir again (especially *-raw.tmpl)
         lines.append(b"%s\0%s%s\n" % (f, hex(n), fl))
 
     _checkforbidden(files)
     return b''.join(lines)
 
 
 class lazymanifestiter:
     def __init__(self, lm):
         self.pos = 0
         self.lm = lm
 
     def __iter__(self):
         return self
 
     def next(self):
         try:
             data, pos = self.lm._get(self.pos)
         except IndexError:
             raise StopIteration
         if pos == -1:
             self.pos += 1
             return data[0]
         self.pos += 1
         zeropos = data.find(b'\x00', pos)
         return data[pos:zeropos]
 
     __next__ = next
 
 
 class lazymanifestiterentries:
     def __init__(self, lm):
         self.lm = lm
         self.pos = 0
 
     def __iter__(self):
         return self
 
     def next(self):
         try:
             data, pos = self.lm._get(self.pos)
         except IndexError:
             raise StopIteration
         if pos == -1:
             self.pos += 1
             return data
         zeropos = data.find(b'\x00', pos)
         nlpos = data.find(b'\n', pos)
         if zeropos == -1 or nlpos == -1 or nlpos < zeropos:
             raise error.StorageError(b'Invalid manifest line')
         flags = data[nlpos - 1 : nlpos]
         if flags in _manifestflags:
             hlen = nlpos - zeropos - 2
         else:
             hlen = nlpos - zeropos - 1
             flags = b''
         if hlen != 2 * self.lm._nodelen:
             raise error.StorageError(b'Invalid manifest line')
         hashval = unhexlify(
             data, self.lm.extrainfo[self.pos], zeropos + 1, hlen
         )
         self.pos += 1
         return (data[pos:zeropos], hashval, flags)
 
     __next__ = next
 
 
 def unhexlify(data, extra, pos, length):
     s = bin(data[pos : pos + length])
     if extra:
         s += chr(extra & 0xFF)
     return s
 
 
 def _cmp(a, b):
     return (a > b) - (a < b)
 
 
 _manifestflags = {b'', b'l', b't', b'x'}
 
 
 class _lazymanifest:
     """A pure python manifest backed by a byte string.  It is supplimented with
     internal lists as it is modified, until it is compacted back to a pure byte
     string.
 
     ``data`` is the initial manifest data.
 
     ``positions`` is a list of offsets, one per manifest entry.  Positive
     values are offsets into ``data``, negative values are offsets into the
     ``extradata`` list.  When an entry is removed, its entry is dropped from
     ``positions``.  The values are encoded such that when walking the list and
     indexing into ``data`` or ``extradata`` as appropriate, the entries are
     sorted by filename.
 
     ``extradata`` is a list of (key, hash, flags) for entries that were added or
     modified since the manifest was created or compacted.
     """
 
     def __init__(
         self,
         nodelen,
         data,
         positions=None,
         extrainfo=None,
         extradata=None,
         hasremovals=False,
     ):
         self._nodelen = nodelen
         if positions is None:
             self.positions = self.findlines(data)
             self.extrainfo = [0] * len(self.positions)
             self.data = data
             self.extradata = []
             self.hasremovals = False
         else:
             self.positions = positions[:]
             self.extrainfo = extrainfo[:]
             self.extradata = extradata[:]
             self.data = data
             self.hasremovals = hasremovals
 
     def findlines(self, data):
         if not data:
             return []
         pos = data.find(b"\n")
         if pos == -1 or data[-1:] != b'\n':
             raise ValueError(b"Manifest did not end in a newline.")
         positions = [0]
         prev = data[: data.find(b'\x00')]
         while pos < len(data) - 1 and pos != -1:
             positions.append(pos + 1)
             nexts = data[pos + 1 : data.find(b'\x00', pos + 1)]
             if nexts < prev:
                 raise ValueError(b"Manifest lines not in sorted order.")
             prev = nexts
             pos = data.find(b"\n", pos + 1)
         return positions
 
     def _get(self, index):
         # get the position encoded in pos:
         #   positive number is an index in 'data'
         #   negative number is in extrapieces
         pos = self.positions[index]
         if pos >= 0:
             return self.data, pos
         return self.extradata[-pos - 1], -1
 
     def _getkey(self, pos):
         if pos >= 0:
             return self.data[pos : self.data.find(b'\x00', pos + 1)]
         return self.extradata[-pos - 1][0]
 
     def bsearch(self, key):
         first = 0
         last = len(self.positions) - 1
 
         while first <= last:
             midpoint = (first + last) // 2
             nextpos = self.positions[midpoint]
             candidate = self._getkey(nextpos)
             r = _cmp(key, candidate)
             if r == 0:
                 return midpoint
             else:
                 if r < 0:
                     last = midpoint - 1
                 else:
                     first = midpoint + 1
         return -1
 
     def bsearch2(self, key):
         # same as the above, but will always return the position
         # done for performance reasons
         first = 0
         last = len(self.positions) - 1
 
         while first <= last:
             midpoint = (first + last) // 2
             nextpos = self.positions[midpoint]
             candidate = self._getkey(nextpos)
             r = _cmp(key, candidate)
             if r == 0:
                 return (midpoint, True)
             else:
                 if r < 0:
                     last = midpoint - 1
                 else:
                     first = midpoint + 1
         return (first, False)
 
     def __contains__(self, key):
         return self.bsearch(key) != -1
 
     def __getitem__(self, key):
         if not isinstance(key, bytes):
             raise TypeError(b"getitem: manifest keys must be a bytes.")
         needle = self.bsearch(key)
         if needle == -1:
             raise KeyError
         data, pos = self._get(needle)
         if pos == -1:
             return (data[1], data[2])
         zeropos = data.find(b'\x00', pos)
         nlpos = data.find(b'\n', zeropos)
         assert 0 <= needle <= len(self.positions)
         assert len(self.extrainfo) == len(self.positions)
         if zeropos == -1 or nlpos == -1 or nlpos < zeropos:
             raise error.StorageError(b'Invalid manifest line')
         hlen = nlpos - zeropos - 1
         flags = data[nlpos - 1 : nlpos]
         if flags in _manifestflags:
             hlen -= 1
         else:
             flags = b''
         if hlen != 2 * self._nodelen:
             raise error.StorageError(b'Invalid manifest line')
         hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, hlen)
         return (hashval, flags)
 
     def __delitem__(self, key):
         needle, found = self.bsearch2(key)
         if not found:
             raise KeyError
         cur = self.positions[needle]
         self.positions = self.positions[:needle] + self.positions[needle + 1 :]
         self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1 :]
         if cur >= 0:
             # This does NOT unsort the list as far as the search functions are
             # concerned, as they only examine lines mapped by self.positions.
             self.data = self.data[:cur] + b'\x00' + self.data[cur + 1 :]
             self.hasremovals = True
 
     def __setitem__(self, key, value):
         if not isinstance(key, bytes):
             raise TypeError(b"setitem: manifest keys must be a byte string.")
         if not isinstance(value, tuple) or len(value) != 2:
             raise TypeError(
                 b"Manifest values must be a tuple of (node, flags)."
             )
         hashval = value[0]
         if not isinstance(hashval, bytes) or len(hashval) not in (20, 32):
             raise TypeError(b"node must be a 20-byte or 32-byte byte string")
         flags = value[1]
         if not isinstance(flags, bytes) or len(flags) > 1:
             raise TypeError(b"flags must a 0 or 1 byte string, got %r", flags)
         needle, found = self.bsearch2(key)
         if found:
             # put the item
             pos = self.positions[needle]
             if pos < 0:
                 self.extradata[-pos - 1] = (key, hashval, value[1])
             else:
                 # just don't bother
                 self.extradata.append((key, hashval, value[1]))
                 self.positions[needle] = -len(self.extradata)
         else:
             # not found, put it in with extra positions
             self.extradata.append((key, hashval, value[1]))
             self.positions = (
                 self.positions[:needle]
                 + [-len(self.extradata)]
                 + self.positions[needle:]
             )
             self.extrainfo = (
                 self.extrainfo[:needle] + [0] + self.extrainfo[needle:]
             )
 
     def copy(self):
         # XXX call _compact like in C?
         return _lazymanifest(
             self._nodelen,
             self.data,
             self.positions,
             self.extrainfo,
             self.extradata,
             self.hasremovals,
         )
 
     def _compact(self):
         # hopefully not called TOO often
         if len(self.extradata) == 0 and not self.hasremovals:
             return
         l = []
         i = 0
         offset = 0
         self.extrainfo = [0] * len(self.positions)
         while i < len(self.positions):
             if self.positions[i] >= 0:
                 cur = self.positions[i]
                 last_cut = cur
 
                 # Collect all contiguous entries in the buffer at the current
                 # offset, breaking out only for added/modified items held in
                 # extradata, or a deleted line prior to the next position.
                 while True:
                     self.positions[i] = offset
                     i += 1
                     if i == len(self.positions) or self.positions[i] < 0:
                         break
 
                     # A removed file has no positions[] entry, but does have an
                     # overwritten first byte.  Break out and find the end of the
                     # current good entry/entries if there is a removed file
                     # before the next position.
                     if (
                         self.hasremovals
                         and self.data.find(b'\n\x00', cur, self.positions[i])
                         != -1
                     ):
                         break
 
                     offset += self.positions[i] - cur
                     cur = self.positions[i]
                 end_cut = self.data.find(b'\n', cur)
                 if end_cut != -1:
                     end_cut += 1
                 offset += end_cut - cur
                 l.append(self.data[last_cut:end_cut])
             else:
                 while i < len(self.positions) and self.positions[i] < 0:
                     cur = self.positions[i]
                     t = self.extradata[-cur - 1]
                     l.append(self._pack(t))
                     self.positions[i] = offset
                     # Hashes are either 20 bytes (old sha1s) or 32
                     # bytes (new non-sha1).
                     hlen = 20
                     if len(t[1]) > 25:
                         hlen = 32
                     if len(t[1]) > hlen:
                         self.extrainfo[i] = ord(t[1][hlen + 1])
                     offset += len(l[-1])
                     i += 1
         self.data = b''.join(l)
         self.hasremovals = False
         self.extradata = []
 
     def _pack(self, d):
         n = d[1]
         assert len(n) in (20, 32)
         return d[0] + b'\x00' + hex(n) + d[2] + b'\n'
 
     def text(self):
         self._compact()
         return self.data
 
     def diff(self, m2, clean=False):
         '''Finds changes between the current manifest and m2.'''
         # XXX think whether efficiency matters here
         diff = {}
 
         for fn, e1, flags in self.iterentries():
             if fn not in m2:
                 diff[fn] = (e1, flags), (None, b'')
             else:
                 e2 = m2[fn]
                 if (e1, flags) != e2:
                     diff[fn] = (e1, flags), e2
                 elif clean:
                     diff[fn] = None
 
         for fn, e2, flags in m2.iterentries():
             if fn not in self:
                 diff[fn] = (None, b''), (e2, flags)
 
         return diff
 
     def iterentries(self):
         return lazymanifestiterentries(self)
 
     def iterkeys(self):
         return lazymanifestiter(self)
 
     def __iter__(self):
         return lazymanifestiter(self)
 
     def __len__(self):
         return len(self.positions)
 
     def filtercopy(self, filterfn):
         # XXX should be optimized
         c = _lazymanifest(self._nodelen, b'')
         for f, n, fl in self.iterentries():
             if filterfn(f):
                 c[f] = n, fl
         return c
 
 
 try:
     _lazymanifest = parsers.lazymanifest
 except AttributeError:
     pass
 
 
 @interfaceutil.implementer(repository.imanifestdict)
 class manifestdict:
     def __init__(self, nodelen, data=b''):
         self._nodelen = nodelen
         self._lm = _lazymanifest(nodelen, data)
 
     def __getitem__(self, key):
         return self._lm[key][0]
 
     def find(self, key):
         return self._lm[key]
 
     def __len__(self):
         return len(self._lm)
 
     def __nonzero__(self):
         # nonzero is covered by the __len__ function, but implementing it here
         # makes it easier for extensions to override.
         return len(self._lm) != 0
 
     __bool__ = __nonzero__
 
     def __setitem__(self, key, node):
         self._lm[key] = node, self.flags(key)
 
     def __contains__(self, key):
         if key is None:
             return False
         return key in self._lm
 
     def __delitem__(self, key):
         del self._lm[key]
 
     def __iter__(self):
         return self._lm.__iter__()
 
     def iterkeys(self):
         return self._lm.iterkeys()
 
     def keys(self):
         return list(self.iterkeys())
 
     def filesnotin(self, m2, match=None):
         '''Set of files in this manifest that are not in the other'''
         if match is not None:
             match = matchmod.badmatch(match, lambda path, msg: None)
             sm2 = set(m2.walk(match))
             return {f for f in self.walk(match) if f not in sm2}
         return {f for f in self if f not in m2}
 
     @propertycache
     def _dirs(self):
         return pathutil.dirs(self)
 
     def dirs(self):
         return self._dirs
 
     def hasdir(self, dir):
         return dir in self._dirs
 
     def _filesfastpath(self, match):
         """Checks whether we can correctly and quickly iterate over matcher
         files instead of over manifest files."""
         files = match.files()
         return len(files) < 100 and (
             match.isexact()
             or (match.prefix() and all(fn in self for fn in files))
         )
 
     def walk(self, match):
         """Generates matching file names.
 
         Equivalent to manifest.matches(match).iterkeys(), but without creating
         an entirely new manifest.
 
         It also reports nonexistent files by marking them bad with match.bad().
         """
         if match.always():
             for f in iter(self):
                 yield f
             return
 
         fset = set(match.files())
 
         # avoid the entire walk if we're only looking for specific files
         if self._filesfastpath(match):
             for fn in sorted(fset):
                 if fn in self:
                     yield fn
             return
 
         for fn in self:
             if fn in fset:
                 # specified pattern is the exact name
                 fset.remove(fn)
             if match(fn):
                 yield fn
 
         # for dirstate.walk, files=[''] means "walk the whole tree".
         # follow that here, too
         fset.discard(b'')
 
         for fn in sorted(fset):
             if not self.hasdir(fn):
                 match.bad(fn, None)
 
     def _matches(self, match):
         '''generate a new manifest filtered by the match argument'''
         if match.always():
             return self.copy()
 
         if self._filesfastpath(match):
             m = manifestdict(self._nodelen)
             lm = self._lm
             for fn in match.files():
                 if fn in lm:
                     m._lm[fn] = lm[fn]
             return m
 
         m = manifestdict(self._nodelen)
         m._lm = self._lm.filtercopy(match)
         return m
 
     def diff(self, m2, match=None, clean=False):
         """Finds changes between the current manifest and m2.
 
         Args:
           m2: the manifest to which this manifest should be compared.
           clean: if true, include files unchanged between these manifests
                  with a None value in the returned dictionary.
 
         The result is returned as a dict with filename as key and
         values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the
         nodeid in the current/other manifest and fl1/fl2 is the flag
         in the current/other manifest. Where the file does not exist,
         the nodeid will be None and the flags will be the empty
         string.
         """
         if match:
             m1 = self._matches(match)
             m2 = m2._matches(match)
             return m1.diff(m2, clean=clean)
         return self._lm.diff(m2._lm, clean)
 
     def setflag(self, key, flag):
         if flag not in _manifestflags:
             raise TypeError(b"Invalid manifest flag set.")
         self._lm[key] = self[key], flag
 
     def get(self, key, default=None):
         try:
             return self._lm[key][0]
         except KeyError:
             return default
 
     def flags(self, key):
         try:
             return self._lm[key][1]
         except KeyError:
             return b''
 
     def copy(self):
         c = manifestdict(self._nodelen)
         c._lm = self._lm.copy()
         return c
 
     def items(self):
         return (x[:2] for x in self._lm.iterentries())
 
     def iteritems(self):
         return (x[:2] for x in self._lm.iterentries())
 
     def iterentries(self):
         return self._lm.iterentries()
 
     def text(self):
         # most likely uses native version
         return self._lm.text()
 
     def fastdelta(self, base, changes):
         """Given a base manifest text as a bytearray and a list of changes
         relative to that text, compute a delta that can be used by revlog.
         """
         delta = []
         dstart = None
         dend = None
         dline = [b""]
         start = 0
         # zero copy representation of base as a buffer
         addbuf = util.buffer(base)
 
         changes = list(changes)
         if len(changes) < FASTDELTA_TEXTDIFF_THRESHOLD:
             # start with a readonly loop that finds the offset of
             # each line and creates the deltas
             for f, todelete in changes:
                 # bs will either be the index of the item or the insert point
                 start, end = _msearch(addbuf, f, start)
                 if not todelete:
                     h, fl = self._lm[f]
                     l = b"%s\0%s%s\n" % (f, hex(h), fl)
                 else:
                     if start == end:
                         # item we want to delete was not found, error out
                         raise AssertionError(
                             _(b"failed to remove %s from manifest") % f
                         )
                     l = b""
                 if dstart is not None and dstart <= start and dend >= start:
                     if dend < end:
                         dend = end
                     if l:
                         dline.append(l)
                 else:
                     if dstart is not None:
                         delta.append([dstart, dend, b"".join(dline)])
                     dstart = start
                     dend = end
                     dline = [l]
 
             if dstart is not None:
                 delta.append([dstart, dend, b"".join(dline)])
             # apply the delta to the base, and get a delta for addrevision
             deltatext, arraytext = _addlistdelta(base, delta)
         else:
             # For large changes, it's much cheaper to just build the text and
             # diff it.
             arraytext = bytearray(self.text())
             deltatext = mdiff.textdiff(
                 util.buffer(base), util.buffer(arraytext)
             )
 
         return arraytext, deltatext
 
 
 def _msearch(m, s, lo=0, hi=None):
     """return a tuple (start, end) that says where to find s within m.
 
     If the string is found m[start:end] are the line containing
     that string.  If start == end the string was not found and
     they indicate the proper sorted insertion point.
 
     m should be a buffer, a memoryview or a byte string.
     s is a byte string"""
 
     def advance(i, c):
         while i < lenm and m[i : i + 1] != c:
             i += 1
         return i
 
     if not s:
         return (lo, lo)
     lenm = len(m)
     if not hi:
         hi = lenm
     while lo < hi:
         mid = (lo + hi) // 2
         start = mid
         while start > 0 and m[start - 1 : start] != b'\n':
             start -= 1
         end = advance(start, b'\0')
         if bytes(m[start:end]) < s:
             # we know that after the null there are 40 bytes of sha1
             # this translates to the bisect lo = mid + 1
             lo = advance(end + 40, b'\n') + 1
         else:
             # this translates to the bisect hi = mid
             hi = start
     end = advance(lo, b'\0')
     found = m[lo:end]
     if s == found:
         # we know that after the null there are 40 bytes of sha1
         end = advance(end + 40, b'\n')
         return (lo, end + 1)
     else:
         return (lo, lo)
 
 
 def _checkforbidden(l):
     """Check filenames for illegal characters."""
     for f in l:
         if b'\n' in f or b'\r' in f:
             raise error.StorageError(
                 _(b"'\\n' and '\\r' disallowed in filenames: %r")
                 % pycompat.bytestr(f)
             )
 
 
 # apply the changes collected during the bisect loop to our addlist
 # return a delta suitable for addrevision
 def _addlistdelta(addlist, x):
     # for large addlist arrays, building a new array is cheaper
     # than repeatedly modifying the existing one
     currentposition = 0
     newaddlist = bytearray()
 
     for start, end, content in x:
         newaddlist += addlist[currentposition:start]
         if content:
             newaddlist += bytearray(content)
 
         currentposition = end
 
     newaddlist += addlist[currentposition:]
 
     deltatext = b"".join(
         struct.pack(b">lll", start, end, len(content)) + content
         for start, end, content in x
     )
     return deltatext, newaddlist
 
 
 def _splittopdir(f):
     if b'/' in f:
         dir, subpath = f.split(b'/', 1)
         return dir + b'/', subpath
     else:
         return b'', f
 
 
 _noop = lambda s: None
 
 
 @interfaceutil.implementer(repository.imanifestdict)
 class treemanifest:
     def __init__(self, nodeconstants, dir=b'', text=b''):
         self._dir = dir
         self.nodeconstants = nodeconstants
         self._node = self.nodeconstants.nullid
         self._nodelen = self.nodeconstants.nodelen
         self._loadfunc = _noop
         self._copyfunc = _noop
         self._dirty = False
         self._dirs = {}
         self._lazydirs = {}
         # Using _lazymanifest here is a little slower than plain old dicts
         self._files = {}
         self._flags = {}
         if text:
 
             def readsubtree(subdir, subm):
                 raise AssertionError(
                     b'treemanifest constructor only accepts flat manifests'
                 )
 
             self.parse(text, readsubtree)
             self._dirty = True  # Mark flat manifest dirty after parsing
 
     def _subpath(self, path):
         return self._dir + path
 
     def _loadalllazy(self):
         selfdirs = self._dirs
         subpath = self._subpath
         for d, (node, readsubtree, docopy) in self._lazydirs.items():
             if docopy:
                 selfdirs[d] = readsubtree(subpath(d), node).copy()
             else:
                 selfdirs[d] = readsubtree(subpath(d), node)
         self._lazydirs = {}
 
     def _loadlazy(self, d):
         v = self._lazydirs.get(d)
         if v:
             node, readsubtree, docopy = v
             if docopy:
                 self._dirs[d] = readsubtree(self._subpath(d), node).copy()
             else:
                 self._dirs[d] = readsubtree(self._subpath(d), node)
             del self._lazydirs[d]
 
     def _loadchildrensetlazy(self, visit):
         if not visit:
             return None
         if visit == b'all' or visit == b'this':
             self._loadalllazy()
             return None
 
         loadlazy = self._loadlazy
         for k in visit:
             loadlazy(k + b'/')
         return visit
 
     def _loaddifflazy(self, t1, t2):
         """load items in t1 and t2 if they're needed for diffing.
 
         The criteria currently is:
         - if it's not present in _lazydirs in either t1 or t2, load it in the
           other (it may already be loaded or it may not exist, doesn't matter)
         - if it's present in _lazydirs in both, compare the nodeid; if it
           differs, load it in both
         """
         toloadlazy = []
         for d, v1 in t1._lazydirs.items():
             v2 = t2._lazydirs.get(d)
             if not v2 or v2[0] != v1[0]:
                 toloadlazy.append(d)
         for d, v1 in t2._lazydirs.items():
             if d not in t1._lazydirs:
                 toloadlazy.append(d)
 
         for d in toloadlazy:
             t1._loadlazy(d)
             t2._loadlazy(d)
 
     def __len__(self):
         self._load()
         size = len(self._files)
         self._loadalllazy()
         for m in self._dirs.values():
             size += m.__len__()
         return size
 
     def __nonzero__(self):
         # Faster than "__len() != 0" since it avoids loading sub-manifests
         return not self._isempty()
 
     __bool__ = __nonzero__
 
     def _isempty(self):
         self._load()  # for consistency; already loaded by all callers
         # See if we can skip loading everything.
         if self._files or (
             self._dirs and any(not m._isempty() for m in self._dirs.values())
         ):
             return False
         self._loadalllazy()
         return not self._dirs or all(m._isempty() for m in self._dirs.values())
 
     @encoding.strmethod
     def __repr__(self):
         return (
             b'<treemanifest dir=%s, node=%s, loaded=%r, dirty=%r at 0x%x>'
             % (
                 self._dir,
                 hex(self._node),
                 bool(self._loadfunc is _noop),
                 self._dirty,
                 id(self),
             )
         )
 
     def dir(self):
         """The directory that this tree manifest represents, including a
         trailing '/'. Empty string for the repo root directory."""
         return self._dir
 
     def node(self):
         """This node of this instance. nullid for unsaved instances. Should
         be updated when the instance is read or written from a revlog.
         """
         assert not self._dirty
         return self._node
 
     def setnode(self, node):
         self._node = node
         self._dirty = False
 
     def iterentries(self):
         self._load()
         self._loadalllazy()
         for p, n in sorted(
             itertools.chain(self._dirs.items(), self._files.items())
         ):
             if p in self._files:
                 yield self._subpath(p), n, self._flags.get(p, b'')
             else:
                 for x in n.iterentries():
                     yield x
 
     def items(self):
         self._load()
         self._loadalllazy()
         for p, n in sorted(
             itertools.chain(self._dirs.items(), self._files.items())
         ):
             if p in self._files:
                 yield self._subpath(p), n
             else:
                 for f, sn in n.items():
                     yield f, sn
 
     iteritems = items
 
     def iterkeys(self):
         self._load()
         self._loadalllazy()
         for p in sorted(itertools.chain(self._dirs, self._files)):
             if p in self._files:
                 yield self._subpath(p)
             else:
                 for f in self._dirs[p]:
                     yield f
 
     def keys(self):
         return list(self.iterkeys())
 
     def __iter__(self):
         return self.iterkeys()
 
     def __contains__(self, f):
         if f is None:
             return False
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             if dir not in self._dirs:
                 return False
 
             return self._dirs[dir].__contains__(subpath)
         else:
             return f in self._files
 
     def get(self, f, default=None):
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             if dir not in self._dirs:
                 return default
             return self._dirs[dir].get(subpath, default)
         else:
             return self._files.get(f, default)
 
     def __getitem__(self, f):
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             return self._dirs[dir].__getitem__(subpath)
         else:
             return self._files[f]
 
     def flags(self, f):
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             if dir not in self._dirs:
                 return b''
             return self._dirs[dir].flags(subpath)
         else:
             if f in self._lazydirs or f in self._dirs:
                 return b''
             return self._flags.get(f, b'')
 
     def find(self, f):
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             return self._dirs[dir].find(subpath)
         else:
             return self._files[f], self._flags.get(f, b'')
 
     def __delitem__(self, f):
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
 
             self._dirs[dir].__delitem__(subpath)
             # If the directory is now empty, remove it
             if self._dirs[dir]._isempty():
                 del self._dirs[dir]
         else:
             del self._files[f]
             if f in self._flags:
                 del self._flags[f]
         self._dirty = True
 
     def __setitem__(self, f, n):
         assert n is not None
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
             if dir not in self._dirs:
                 self._dirs[dir] = treemanifest(
                     self.nodeconstants, self._subpath(dir)
                 )
             self._dirs[dir].__setitem__(subpath, n)
         else:
             # manifest nodes are either 20 bytes or 32 bytes,
             # depending on the hash in use. Assert this as historically
             # sometimes extra bytes were added.
             assert len(n) in (20, 32)
             self._files[f] = n
         self._dirty = True
 
     def _load(self):
         if self._loadfunc is not _noop:
             lf, self._loadfunc = self._loadfunc, _noop
             lf(self)
         elif self._copyfunc is not _noop:
             cf, self._copyfunc = self._copyfunc, _noop
             cf(self)
 
     def setflag(self, f, flags):
         """Set the flags (symlink, executable) for path f."""
         if flags not in _manifestflags:
             raise TypeError(b"Invalid manifest flag set.")
         self._load()
         dir, subpath = _splittopdir(f)
         if dir:
             self._loadlazy(dir)
             if dir not in self._dirs:
                 self._dirs[dir] = treemanifest(
                     self.nodeconstants, self._subpath(dir)
                 )
             self._dirs[dir].setflag(subpath, flags)
         else:
             self._flags[f] = flags
         self._dirty = True
 
     def copy(self):
         copy = treemanifest(self.nodeconstants, self._dir)
         copy._node = self._node
         copy._dirty = self._dirty
         if self._copyfunc is _noop:
 
             def _copyfunc(s):
                 self._load()
                 s._lazydirs = {
                     d: (n, r, True) for d, (n, r, c) in self._lazydirs.items()
                 }
                 sdirs = s._dirs
                 for d, v in self._dirs.items():
                     sdirs[d] = v.copy()
                 s._files = dict.copy(self._files)
                 s._flags = dict.copy(self._flags)
 
             if self._loadfunc is _noop:
                 _copyfunc(copy)
             else:
                 copy._copyfunc = _copyfunc
         else:
             copy._copyfunc = self._copyfunc
         return copy
 
     def filesnotin(self, m2, match=None):
         '''Set of files in this manifest that are not in the other'''
         if match and not match.always():
             m1 = self._matches(match)
             m2 = m2._matches(match)
             return m1.filesnotin(m2)
 
         files = set()
 
         def _filesnotin(t1, t2):
             if t1._node == t2._node and not t1._dirty and not t2._dirty:
                 return
             t1._load()
             t2._load()
             self._loaddifflazy(t1, t2)
             for d, m1 in t1._dirs.items():
                 if d in t2._dirs:
                     m2 = t2._dirs[d]
                     _filesnotin(m1, m2)
                 else:
                     files.update(m1.iterkeys())
 
             for fn in t1._files:
                 if fn not in t2._files:
                     files.add(t1._subpath(fn))
 
         _filesnotin(self, m2)
         return files
 
     @propertycache
     def _alldirs(self):
         return pathutil.dirs(self)
 
     def dirs(self):
         return self._alldirs
 
     def hasdir(self, dir):
         self._load()
         topdir, subdir = _splittopdir(dir)
         if topdir:
             self._loadlazy(topdir)
             if topdir in self._dirs:
                 return self._dirs[topdir].hasdir(subdir)
             return False
         dirslash = dir + b'/'
         return dirslash in self._dirs or dirslash in self._lazydirs
 
     def walk(self, match):
         """Generates matching file names.
 
         It also reports nonexistent files by marking them bad with match.bad().
         """
         if match.always():
             for f in iter(self):
                 yield f
             return
 
         fset = set(match.files())
 
         for fn in self._walk(match):
             if fn in fset:
                 # specified pattern is the exact name
                 fset.remove(fn)
             yield fn
 
         # for dirstate.walk, files=[''] means "walk the whole tree".
         # follow that here, too
         fset.discard(b'')
 
         for fn in sorted(fset):
             if not self.hasdir(fn):
                 match.bad(fn, None)
 
     def _walk(self, match):
         '''Recursively generates matching file names for walk().'''
         visit = match.visitchildrenset(self._dir[:-1])
         if not visit:
             return
 
         # yield this dir's files and walk its submanifests
         self._load()
         visit = self._loadchildrensetlazy(visit)
         for p in sorted(list(self._dirs) + list(self._files)):
             if p in self._files:
                 fullp = self._subpath(p)
                 if match(fullp):
                     yield fullp
             else:
                 if not visit or p[:-1] in visit:
                     for f in self._dirs[p]._walk(match):
                         yield f
 
     def _matches(self, match):
         """recursively generate a new manifest filtered by the match argument."""
         if match.always():
             return self.copy()
         return self._matches_inner(match)
 
     def _matches_inner(self, match):
         if match.always():
             return self.copy()
 
         visit = match.visitchildrenset(self._dir[:-1])
         if visit == b'all':
             return self.copy()
         ret = treemanifest(self.nodeconstants, self._dir)
         if not visit:
             return ret
 
         self._load()
         for fn in self._files:
             # While visitchildrenset *usually* lists only subdirs, this is
             # actually up to the matcher and may have some files in the set().
             # If visit == 'this', we should obviously look at the files in this
             # directory; if visit is a set, and fn is in it, we should inspect
             # fn (but no need to inspect things not in the set).
             if visit != b'this' and fn not in visit:
                 continue
             fullp = self._subpath(fn)
             # visitchildrenset isn't perfect, we still need to call the regular
             # matcher code to further filter results.
             if not match(fullp):
                 continue
             ret._files[fn] = self._files[fn]
             if fn in self._flags:
                 ret._flags[fn] = self._flags[fn]
 
         visit = self._loadchildrensetlazy(visit)
         for dir, subm in self._dirs.items():
             if visit and dir[:-1] not in visit:
                 continue
             m = subm._matches_inner(match)
             if not m._isempty():
                 ret._dirs[dir] = m
 
         if not ret._isempty():
             ret._dirty = True
         return ret
 
     def fastdelta(self, base, changes):
         raise FastdeltaUnavailable()
 
     def diff(self, m2, match=None, clean=False):
         """Finds changes between the current manifest and m2.
 
         Args:
           m2: the manifest to which this manifest should be compared.
           clean: if true, include files unchanged between these manifests
                  with a None value in the returned dictionary.
 
         The result is returned as a dict with filename as key and
         values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the
         nodeid in the current/other manifest and fl1/fl2 is the flag
         in the current/other manifest. Where the file does not exist,
         the nodeid will be None and the flags will be the empty
         string.
         """
         if match and not match.always():
             m1 = self._matches(match)
             m2 = m2._matches(match)
             return m1.diff(m2, clean=clean)
         result = {}
         emptytree = treemanifest(self.nodeconstants)
 
         def _iterativediff(t1, t2, stack):
             """compares two tree manifests and append new tree-manifests which
             needs to be compared to stack"""
             if t1._node == t2._node and not t1._dirty and not t2._dirty:
                 return
             t1._load()
             t2._load()
             self._loaddifflazy(t1, t2)
 
             for d, m1 in t1._dirs.items():
                 m2 = t2._dirs.get(d, emptytree)
                 stack.append((m1, m2))
 
             for d, m2 in t2._dirs.items():
                 if d not in t1._dirs:
                     stack.append((emptytree, m2))
 
             for fn, n1 in t1._files.items():
                 fl1 = t1._flags.get(fn, b'')
                 n2 = t2._files.get(fn, None)
                 fl2 = t2._flags.get(fn, b'')
                 if n1 != n2 or fl1 != fl2:
                     result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2))
                 elif clean:
                     result[t1._subpath(fn)] = None
 
             for fn, n2 in t2._files.items():
                 if fn not in t1._files:
                     fl2 = t2._flags.get(fn, b'')
                     result[t2._subpath(fn)] = ((None, b''), (n2, fl2))
 
         stackls = []
         _iterativediff(self, m2, stackls)
         while stackls:
             t1, t2 = stackls.pop()
             # stackls is populated in the function call
             _iterativediff(t1, t2, stackls)
         return result
 
     def unmodifiedsince(self, m2):
         return not self._dirty and not m2._dirty and self._node == m2._node
 
     def parse(self, text, readsubtree):
         selflazy = self._lazydirs
         for f, n, fl in _parse(self._nodelen, text):
             if fl == b't':
                 f = f + b'/'
                 # False below means "doesn't need to be copied" and can use the
                 # cached value from readsubtree directly.
                 selflazy[f] = (n, readsubtree, False)
             elif b'/' in f:
                 # This is a flat manifest, so use __setitem__ and setflag rather
                 # than assigning directly to _files and _flags, so we can
                 # assign a path in a subdirectory, and to mark dirty (compared
                 # to nullid).
                 self[f] = n
                 if fl:
                     self.setflag(f, fl)
             else:
                 # Assigning to _files and _flags avoids marking as dirty,
                 # and should be a little faster.
                 self._files[f] = n
                 if fl:
                     self._flags[f] = fl
 
     def text(self):
         """Get the full data of this manifest as a bytestring."""
         self._load()
         return _text(self.iterentries())
 
     def dirtext(self):
         """Get the full data of this directory as a bytestring. Make sure that
         any submanifests have been written first, so their nodeids are correct.
         """
         self._load()
         flags = self.flags
         lazydirs = [(d[:-1], v[0], b't') for d, v in self._lazydirs.items()]
         dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs]
         files = [(f, self._files[f], flags(f)) for f in self._files]
         return _text(sorted(dirs + files + lazydirs))
 
     def read(self, gettext, readsubtree):
         def _load_for_read(s):
             s.parse(gettext(), readsubtree)
             s._dirty = False
 
         self._loadfunc = _load_for_read
 
     def writesubtrees(self, m1, m2, writesubtree, match):
         self._load()  # for consistency; should never have any effect here
         m1._load()
         m2._load()
         emptytree = treemanifest(self.nodeconstants)
 
         def getnode(m, d):
             ld = m._lazydirs.get(d)
             if ld:
                 return ld[0]
             return m._dirs.get(d, emptytree)._node
 
         # let's skip investigating things that `match` says we do not need.
         visit = match.visitchildrenset(self._dir[:-1])
         visit = self._loadchildrensetlazy(visit)
         if visit == b'this' or visit == b'all':
             visit = None
         for d, subm in self._dirs.items():
             if visit and d[:-1] not in visit:
                 continue
             subp1 = getnode(m1, d)
             subp2 = getnode(m2, d)
             if subp1 == self.nodeconstants.nullid:
                 subp1, subp2 = subp2, subp1
             writesubtree(subm, subp1, subp2, match)
 
     def walksubtrees(self, matcher=None):
         """Returns an iterator of the subtrees of this manifest, including this
         manifest itself.
 
         If `matcher` is provided, it only returns subtrees that match.
         """
         if matcher and not matcher.visitdir(self._dir[:-1]):
             return
         if not matcher or matcher(self._dir[:-1]):
             yield self
 
         self._load()
         # OPT: use visitchildrenset to avoid loading everything.
         self._loadalllazy()
         for d, subm in self._dirs.items():
             for subtree in subm.walksubtrees(matcher=matcher):
                 yield subtree
 
 
 class manifestfulltextcache(util.lrucachedict):
     """File-backed LRU cache for the manifest cache
 
     File consists of entries, up to EOF:
 
     - 20 bytes node, 4 bytes length, <length> manifest data
 
     These are written in reverse cache order (oldest to newest).
 
     """
 
     _file = b'manifestfulltextcache'
 
     def __init__(self, max):
         super(manifestfulltextcache, self).__init__(max)
         self._dirty = False
         self._read = False
         self._opener = None
 
     def read(self):
         if self._read or self._opener is None:
             return
 
         try:
             with self._opener(self._file) as fp:
                 set = super(manifestfulltextcache, self).__setitem__
                 # ignore trailing data, this is a cache, corruption is skipped
                 while True:
                     # TODO do we need to do work here for sha1 portability?
                     node = fp.read(20)
                     if len(node) < 20:
                         break
                     try:
                         size = struct.unpack(b'>L', fp.read(4))[0]
                     except struct.error:
                         break
                     value = bytearray(fp.read(size))
                     if len(value) != size:
                         break
                     set(node, value)
         except IOError:
             # the file is allowed to be missing
             pass
 
         self._read = True
         self._dirty = False
 
     def write(self):
         if not self._dirty or self._opener is None:
             return
         # rotate backwards to the first used node
         try:
             with self._opener(
                 self._file, b'w', atomictemp=True, checkambig=True
             ) as fp:
                 node = self._head.prev
                 while True:
                     if node.key in self._cache:
                         fp.write(node.key)
                         fp.write(struct.pack(b'>L', len(node.value)))
                         fp.write(node.value)
                     if node is self._head:
                         break
                     node = node.prev
         except IOError:
             # We could not write the cache (eg: permission error)
             # the content can be missing.
             #
             # We could try harder and see if we could recreate a wcache
             # directory were we coudl write too.
             #
             # XXX the error pass silently, having some way to issue an error
             # log `ui.log` would be nice.
             pass
 
     def __len__(self):
         if not self._read:
             self.read()
         return super(manifestfulltextcache, self).__len__()
 
     def __contains__(self, k):
         if not self._read:
             self.read()
         return super(manifestfulltextcache, self).__contains__(k)
 
     def __iter__(self):
         if not self._read:
             self.read()
         return super(manifestfulltextcache, self).__iter__()
 
     def __getitem__(self, k):
         if not self._read:
             self.read()
         # the cache lru order can change on read
         setdirty = self._cache.get(k) is not self._head
         value = super(manifestfulltextcache, self).__getitem__(k)
         if setdirty:
             self._dirty = True
         return value
 
     def __setitem__(self, k, v):
         if not self._read:
             self.read()
         super(manifestfulltextcache, self).__setitem__(k, v)
         self._dirty = True
 
     def __delitem__(self, k):
         if not self._read:
             self.read()
         super(manifestfulltextcache, self).__delitem__(k)
         self._dirty = True
 
     def get(self, k, default=None):
         if not self._read:
             self.read()
         return super(manifestfulltextcache, self).get(k, default=default)
 
     def clear(self, clear_persisted_data=False):
         super(manifestfulltextcache, self).clear()
         if clear_persisted_data:
             self._dirty = True
             self.write()
         self._read = False
 
 
 # and upper bound of what we expect from compression
 # (real live value seems to be "3")
 MAXCOMPRESSION = 3
 
 
 class FastdeltaUnavailable(Exception):
     """Exception raised when fastdelta isn't usable on a manifest."""
 
 
 @interfaceutil.implementer(repository.imanifeststorage)
 class manifestrevlog:
     """A revlog that stores manifest texts. This is responsible for caching the
     full-text manifest contents.
     """
 
     def __init__(
         self,
         nodeconstants,
         opener,
         tree=b'',
         dirlogcache=None,
         treemanifest=False,
     ):
         """Constructs a new manifest revlog
 
         `indexfile` - used by extensions to have two manifests at once, like
         when transitioning between flatmanifeset and treemanifests.
 
         `treemanifest` - used to indicate this is a tree manifest revlog. Opener
         options can also be used to make this a tree manifest revlog. The opener
         option takes precedence, so if it is set to True, we ignore whatever
         value is passed in to the constructor.
         """
         self.nodeconstants = nodeconstants
         # During normal operations, we expect to deal with not more than four
         # revs at a time (such as during commit --amend). When rebasing large
         # stacks of commits, the number can go up, hence the config knob below.
         cachesize = 4
         optiontreemanifest = False
         opts = getattr(opener, 'options', None)
         if opts is not None:
             cachesize = opts.get(b'manifestcachesize', cachesize)
             optiontreemanifest = opts.get(b'treemanifest', False)
 
         self._treeondisk = optiontreemanifest or treemanifest
 
         self._fulltextcache = manifestfulltextcache(cachesize)
 
         if tree:
             assert self._treeondisk, (tree, b'opts is %r' % opts)
 
         radix = b'00manifest'
         if tree:
             radix = b"meta/" + tree + radix
 
         self.tree = tree
 
         # The dirlogcache is kept on the root manifest log
         if tree:
             self._dirlogcache = dirlogcache
         else:
             self._dirlogcache = {b'': self}
 
         self._revlog = revlog.revlog(
             opener,
             target=(revlog_constants.KIND_MANIFESTLOG, self.tree),
             radix=radix,
             # only root indexfile is cached
             checkambig=not bool(tree),
             mmaplargeindex=True,
             upperboundcomp=MAXCOMPRESSION,
             persistentnodemap=opener.options.get(b'persistent-nodemap', False),
         )
 
         self.index = self._revlog.index
         self._generaldelta = self._revlog._generaldelta
 
     def _setupmanifestcachehooks(self, repo):
         """Persist the manifestfulltextcache on lock release"""
         if not util.safehasattr(repo, b'_wlockref'):
             return
 
         self._fulltextcache._opener = repo.wcachevfs
         if repo._currentlock(repo._wlockref) is None:
             return
 
         reporef = weakref.ref(repo)
         manifestrevlogref = weakref.ref(self)
 
         def persistmanifestcache(success):
             # Repo is in an unknown state, do not persist.
             if not success:
                 return
 
             repo = reporef()
             self = manifestrevlogref()
             if repo is None or self is None:
                 return
             if repo.manifestlog.getstorage(b'') is not self:
                 # there's a different manifest in play now, abort
                 return
             self._fulltextcache.write()
 
         repo._afterlock(persistmanifestcache)
 
     @property
     def fulltextcache(self):
         return self._fulltextcache
 
     def clearcaches(self, clear_persisted_data=False):
         self._revlog.clearcaches()
         self._fulltextcache.clear(clear_persisted_data=clear_persisted_data)
         self._dirlogcache = {self.tree: self}
 
     def dirlog(self, d):
         if d:
             assert self._treeondisk
         if d not in self._dirlogcache:
             mfrevlog = manifestrevlog(
                 self.nodeconstants,
                 self.opener,
                 d,
                 self._dirlogcache,
                 treemanifest=self._treeondisk,
             )
             self._dirlogcache[d] = mfrevlog
         return self._dirlogcache[d]
 
     def add(
         self,
         m,
         transaction,
         link,
         p1,
         p2,
         added,
         removed,
         readtree=None,
         match=None,
     ):
         """add some manifest entry in to the manifest log
 
         input:
 
           m:           the manifest dict we want to store
           transaction: the open transaction
           p1:          manifest-node of p1
           p2:          manifest-node of p2
           added:       file added/changed compared to parent
           removed:     file removed compared to parent
 
         tree manifest input:
 
           readtree:    a function to read a subtree
           match:       a filematcher for the subpart of the tree manifest
         """
         try:
             if p1 not in self.fulltextcache:
                 raise FastdeltaUnavailable()
             # If our first parent is in the manifest cache, we can
             # compute a delta here using properties we know about the
             # manifest up-front, which may save time later for the
             # revlog layer.
 
             _checkforbidden(added)
             # combine the changed lists into one sorted iterator
             work = heapq.merge(
                 [(x, False) for x in sorted(added)],
                 [(x, True) for x in sorted(removed)],
             )
 
             arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work)
             cachedelta = self._revlog.rev(p1), deltatext
             text = util.buffer(arraytext)
             rev = self._revlog.addrevision(
                 text, transaction, link, p1, p2, cachedelta
             )
             n = self._revlog.node(rev)
         except FastdeltaUnavailable:
             # The first parent manifest isn't already loaded or the
             # manifest implementation doesn't support fastdelta, so
             # we'll just encode a fulltext of the manifest and pass
             # that through to the revlog layer, and let it handle the
             # delta process.
             if self._treeondisk:
                 assert readtree, b"readtree must be set for treemanifest writes"
                 assert match, b"match must be specified for treemanifest writes"
                 m1 = readtree(self.tree, p1)
                 m2 = readtree(self.tree, p2)
                 n = self._addtree(
                     m, transaction, link, m1, m2, readtree, match=match
                 )
                 arraytext = None
             else:
                 text = m.text()
                 rev = self._revlog.addrevision(text, transaction, link, p1, p2)
                 n = self._revlog.node(rev)
                 arraytext = bytearray(text)
 
         if arraytext is not None:
             self.fulltextcache[n] = arraytext
 
         return n
 
     def _addtree(self, m, transaction, link, m1, m2, readtree, match):
         # If the manifest is unchanged compared to one parent,
         # don't write a new revision
         if self.tree != b'' and (
             m.unmodifiedsince(m1) or m.unmodifiedsince(m2)
         ):
             return m.node()
 
         def writesubtree(subm, subp1, subp2, match):
             sublog = self.dirlog(subm.dir())
             sublog.add(
                 subm,
                 transaction,
                 link,
                 subp1,
                 subp2,
                 None,
                 None,
                 readtree=readtree,
                 match=match,
             )
 
         m.writesubtrees(m1, m2, writesubtree, match)
         text = m.dirtext()
         n = None
         if self.tree != b'':
             # Double-check whether contents are unchanged to one parent
             if text == m1.dirtext():
                 n = m1.node()
             elif text == m2.dirtext():
                 n = m2.node()
 
         if not n:
             rev = self._revlog.addrevision(
                 text, transaction, link, m1.node(), m2.node()
             )
             n = self._revlog.node(rev)
 
         # Save nodeid so parent manifest can calculate its nodeid
         m.setnode(n)
         return n
 
     def __len__(self):
         return len(self._revlog)
 
     def __iter__(self):
         return self._revlog.__iter__()
 
     def rev(self, node):
         return self._revlog.rev(node)
 
     def node(self, rev):
         return self._revlog.node(rev)
 
     def lookup(self, value):
         return self._revlog.lookup(value)
 
     def parentrevs(self, rev):
         return self._revlog.parentrevs(rev)
 
     def parents(self, node):
         return self._revlog.parents(node)
 
     def linkrev(self, rev):
         return self._revlog.linkrev(rev)
 
     def checksize(self):
         return self._revlog.checksize()
 
     def revision(self, node, _df=None):
         return self._revlog.revision(node, _df=_df)
 
     def rawdata(self, node, _df=None):
         return self._revlog.rawdata(node, _df=_df)
 
     def revdiff(self, rev1, rev2):
         return self._revlog.revdiff(rev1, rev2)
 
     def cmp(self, node, text):
         return self._revlog.cmp(node, text)
 
     def deltaparent(self, rev):
         return self._revlog.deltaparent(rev)
 
     def emitrevisions(
         self,
         nodes,
         nodesorder=None,
         revisiondata=False,
         assumehaveparentrevisions=False,
         deltamode=repository.CG_DELTAMODE_STD,
         sidedata_helpers=None,
         debug_info=None,
     ):
         return self._revlog.emitrevisions(
             nodes,
             nodesorder=nodesorder,
             revisiondata=revisiondata,
             assumehaveparentrevisions=assumehaveparentrevisions,
             deltamode=deltamode,
             sidedata_helpers=sidedata_helpers,
             debug_info=debug_info,
         )
 
     def addgroup(
         self,
         deltas,
         linkmapper,
         transaction,
         alwayscache=False,
         addrevisioncb=None,
         duplicaterevisioncb=None,
+        debug_info=None,
     ):
         return self._revlog.addgroup(
             deltas,
             linkmapper,
             transaction,
             alwayscache=alwayscache,
             addrevisioncb=addrevisioncb,
             duplicaterevisioncb=duplicaterevisioncb,
+            debug_info=debug_info,
         )
 
     def rawsize(self, rev):
         return self._revlog.rawsize(rev)
 
     def getstrippoint(self, minlink):
         return self._revlog.getstrippoint(minlink)
 
     def strip(self, minlink, transaction):
         return self._revlog.strip(minlink, transaction)
 
     def files(self):
         return self._revlog.files()
 
     def clone(self, tr, destrevlog, **kwargs):
         if not isinstance(destrevlog, manifestrevlog):
             raise error.ProgrammingError(b'expected manifestrevlog to clone()')
 
         return self._revlog.clone(tr, destrevlog._revlog, **kwargs)
 
     def storageinfo(
         self,
         exclusivefiles=False,
         sharedfiles=False,
         revisionscount=False,
         trackedsize=False,
         storedsize=False,
     ):
         return self._revlog.storageinfo(
             exclusivefiles=exclusivefiles,
             sharedfiles=sharedfiles,
             revisionscount=revisionscount,
             trackedsize=trackedsize,
             storedsize=storedsize,
         )
 
     @property
     def opener(self):
         return self._revlog.opener
 
     @opener.setter
     def opener(self, value):
         self._revlog.opener = value
 
 
 @interfaceutil.implementer(repository.imanifestlog)
 class manifestlog:
     """A collection class representing the collection of manifest snapshots
     referenced by commits in the repository.
 
     In this situation, 'manifest' refers to the abstract concept of a snapshot
     of the list of files in the given commit. Consumers of the output of this
     class do not care about the implementation details of the actual manifests
     they receive (i.e. tree or flat or lazily loaded, etc)."""
 
     def __init__(self, opener, repo, rootstore, narrowmatch):
         self.nodeconstants = repo.nodeconstants
         usetreemanifest = False
         cachesize = 4
 
         opts = getattr(opener, 'options', None)
         if opts is not None:
             usetreemanifest = opts.get(b'treemanifest', usetreemanifest)
             cachesize = opts.get(b'manifestcachesize', cachesize)
 
         self._treemanifests = usetreemanifest
 
         self._rootstore = rootstore
         self._rootstore._setupmanifestcachehooks(repo)
         self._narrowmatch = narrowmatch
 
         # A cache of the manifestctx or treemanifestctx for each directory
         self._dirmancache = {}
         self._dirmancache[b''] = util.lrucachedict(cachesize)
 
         self._cachesize = cachesize
 
     def __getitem__(self, node):
         """Retrieves the manifest instance for the given node. Throws a
         LookupError if not found.
         """
         return self.get(b'', node)
 
     def get(self, tree, node, verify=True):
         """Retrieves the manifest instance for the given node. Throws a
         LookupError if not found.
 
         `verify` - if True an exception will be thrown if the node is not in
                    the revlog
         """
         if node in self._dirmancache.get(tree, ()):
             return self._dirmancache[tree][node]
 
         if not self._narrowmatch.always():
             if not self._narrowmatch.visitdir(tree[:-1]):
                 return excludeddirmanifestctx(self.nodeconstants, tree, node)
         if tree:
             if self._rootstore._treeondisk:
                 if verify:
                     # Side-effect is LookupError is raised if node doesn't
                     # exist.
                     self.getstorage(tree).rev(node)
 
                 m = treemanifestctx(self, tree, node)
             else:
                 raise error.Abort(
                     _(
                         b"cannot ask for manifest directory '%s' in a flat "
                         b"manifest"
                     )
                     % tree
                 )
         else:
             if verify:
                 # Side-effect is LookupError is raised if node doesn't exist.
                 self._rootstore.rev(node)
 
             if self._treemanifests:
                 m = treemanifestctx(self, b'', node)
             else:
                 m = manifestctx(self, node)
 
         if node != self.nodeconstants.nullid:
             mancache = self._dirmancache.get(tree)
             if not mancache:
                 mancache = util.lrucachedict(self._cachesize)
                 self._dirmancache[tree] = mancache
             mancache[node] = m
         return m
 
     def getstorage(self, tree):
         return self._rootstore.dirlog(tree)
 
     def clearcaches(self, clear_persisted_data=False):
         self._dirmancache.clear()
         self._rootstore.clearcaches(clear_persisted_data=clear_persisted_data)
 
     def rev(self, node):
         return self._rootstore.rev(node)
 
     def update_caches(self, transaction):
         return self._rootstore._revlog.update_caches(transaction=transaction)
 
 
 @interfaceutil.implementer(repository.imanifestrevisionwritable)
 class memmanifestctx:
     def __init__(self, manifestlog):
         self._manifestlog = manifestlog
         self._manifestdict = manifestdict(manifestlog.nodeconstants.nodelen)
 
     def _storage(self):
         return self._manifestlog.getstorage(b'')
 
     def copy(self):
         memmf = memmanifestctx(self._manifestlog)
         memmf._manifestdict = self.read().copy()
         return memmf
 
     def read(self):
         return self._manifestdict
 
     def write(self, transaction, link, p1, p2, added, removed, match=None):
         return self._storage().add(
             self._manifestdict,
             transaction,
             link,
             p1,
             p2,
             added,
             removed,
             match=match,
         )
 
 
 @interfaceutil.implementer(repository.imanifestrevisionstored)
 class manifestctx:
     """A class representing a single revision of a manifest, including its
     contents, its parent revs, and its linkrev.
     """
 
     def __init__(self, manifestlog, node):
         self._manifestlog = manifestlog
         self._data = None
 
         self._node = node
 
         # TODO: We eventually want p1, p2, and linkrev exposed on this class,
         # but let's add it later when something needs it and we can load it
         # lazily.
         # self.p1, self.p2 = store.parents(node)
         # rev = store.rev(node)
         # self.linkrev = store.linkrev(rev)
 
     def _storage(self):
         return self._manifestlog.getstorage(b'')
 
     def node(self):
         return self._node
 
     def copy(self):
         memmf = memmanifestctx(self._manifestlog)
         memmf._manifestdict = self.read().copy()
         return memmf
 
     @propertycache
     def parents(self):
         return self._storage().parents(self._node)
 
     def read(self):
         if self._data is None:
             nc = self._manifestlog.nodeconstants
             if self._node == nc.nullid:
                 self._data = manifestdict(nc.nodelen)
             else:
                 store = self._storage()
                 if self._node in store.fulltextcache:
                     text = pycompat.bytestr(store.fulltextcache[self._node])
                 else:
                     text = store.revision(self._node)
                     arraytext = bytearray(text)
                     store.fulltextcache[self._node] = arraytext
                 self._data = manifestdict(nc.nodelen, text)
         return self._data
 
     def readfast(self, shallow=False):
         """Calls either readdelta or read, based on which would be less work.
         readdelta is called if the delta is against the p1, and therefore can be
         read quickly.
 
         If `shallow` is True, nothing changes since this is a flat manifest.
         """
         store = self._storage()
         r = store.rev(self._node)
         deltaparent = store.deltaparent(r)
         if deltaparent != nullrev and deltaparent in store.parentrevs(r):
             return self.readdelta()
         return self.read()
 
     def readdelta(self, shallow=False):
         """Returns a manifest containing just the entries that are present
         in this manifest, but not in its p1 manifest. This is efficient to read
         if the revlog delta is already p1.
 
         Changing the value of `shallow` has no effect on flat manifests.
         """
         store = self._storage()
         r = store.rev(self._node)
         d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
         return manifestdict(store.nodeconstants.nodelen, d)
 
     def find(self, key):
         return self.read().find(key)
 
 
 @interfaceutil.implementer(repository.imanifestrevisionwritable)
 class memtreemanifestctx:
     def __init__(self, manifestlog, dir=b''):
         self._manifestlog = manifestlog
         self._dir = dir
         self._treemanifest = treemanifest(manifestlog.nodeconstants)
 
     def _storage(self):
         return self._manifestlog.getstorage(b'')
 
     def copy(self):
         memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
         memmf._treemanifest = self._treemanifest.copy()
         return memmf
 
     def read(self):
         return self._treemanifest
 
     def write(self, transaction, link, p1, p2, added, removed, match=None):
         def readtree(dir, node):
             return self._manifestlog.get(dir, node).read()
 
         return self._storage().add(
             self._treemanifest,
             transaction,
             link,
             p1,
             p2,
             added,
             removed,
             readtree=readtree,
             match=match,
         )
 
 
 @interfaceutil.implementer(repository.imanifestrevisionstored)
 class treemanifestctx:
     def __init__(self, manifestlog, dir, node):
         self._manifestlog = manifestlog
         self._dir = dir
         self._data = None
 
         self._node = node
 
         # TODO: Load p1/p2/linkrev lazily. They need to be lazily loaded so that
         # we can instantiate treemanifestctx objects for directories we don't
         # have on disk.
         # self.p1, self.p2 = store.parents(node)
         # rev = store.rev(node)
         # self.linkrev = store.linkrev(rev)
 
     def _storage(self):
         narrowmatch = self._manifestlog._narrowmatch
         if not narrowmatch.always():
             if not narrowmatch.visitdir(self._dir[:-1]):
                 return excludedmanifestrevlog(
                     self._manifestlog.nodeconstants, self._dir
                 )
         return self._manifestlog.getstorage(self._dir)
 
     def read(self):
         if self._data is None:
             store = self._storage()
             if self._node == self._manifestlog.nodeconstants.nullid:
                 self._data = treemanifest(self._manifestlog.nodeconstants)
             # TODO accessing non-public API
             elif store._treeondisk:
                 m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
 
                 def gettext():
                     return store.revision(self._node)
 
                 def readsubtree(dir, subm):
                     # Set verify to False since we need to be able to create
                     # subtrees for trees that don't exist on disk.
                     return self._manifestlog.get(dir, subm, verify=False).read()
 
                 m.read(gettext, readsubtree)
                 m.setnode(self._node)
                 self._data = m
             else:
                 if self._node in store.fulltextcache:
                     text = pycompat.bytestr(store.fulltextcache[self._node])
                 else:
                     text = store.revision(self._node)
                     arraytext = bytearray(text)
                     store.fulltextcache[self._node] = arraytext
                 self._data = treemanifest(
                     self._manifestlog.nodeconstants, dir=self._dir, text=text
                 )
 
         return self._data
 
     def node(self):
         return self._node
 
     def copy(self):
         memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
         memmf._treemanifest = self.read().copy()
         return memmf
 
     @propertycache
     def parents(self):
         return self._storage().parents(self._node)
 
     def readdelta(self, shallow=False):
         """Returns a manifest containing just the entries that are present
         in this manifest, but not in its p1 manifest. This is efficient to read
         if the revlog delta is already p1.
 
         If `shallow` is True, this will read the delta for this directory,
         without recursively reading subdirectory manifests. Instead, any
         subdirectory entry will be reported as it appears in the manifest, i.e.
         the subdirectory will be reported among files and distinguished only by
         its 't' flag.
         """
         store = self._storage()
         if shallow:
             r = store.rev(self._node)
             d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
             return manifestdict(store.nodeconstants.nodelen, d)
         else:
             # Need to perform a slow delta
             r0 = store.deltaparent(store.rev(self._node))
             m0 = self._manifestlog.get(self._dir, store.node(r0)).read()
             m1 = self.read()
             md = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
             for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).items():
                 if n1:
                     md[f] = n1
                     if fl1:
                         md.setflag(f, fl1)
             return md
 
     def readfast(self, shallow=False):
         """Calls either readdelta or read, based on which would be less work.
         readdelta is called if the delta is against the p1, and therefore can be
         read quickly.
 
         If `shallow` is True, it only returns the entries from this manifest,
         and not any submanifests.
         """
         store = self._storage()
         r = store.rev(self._node)
         deltaparent = store.deltaparent(r)
         if deltaparent != nullrev and deltaparent in store.parentrevs(r):
             return self.readdelta(shallow=shallow)
 
         if shallow:
             return manifestdict(
                 store.nodeconstants.nodelen, store.revision(self._node)
             )
         else:
             return self.read()
 
     def find(self, key):
         return self.read().find(key)
 
 
 class excludeddir(treemanifest):
     """Stand-in for a directory that is excluded from the repository.
 
     With narrowing active on a repository that uses treemanifests,
     some of the directory revlogs will be excluded from the resulting
     clone. This is a huge storage win for clients, but means we need
     some sort of pseudo-manifest to surface to internals so we can
     detect a merge conflict outside the narrowspec. That's what this
     class is: it stands in for a directory whose node is known, but
     whose contents are unknown.
     """
 
     def __init__(self, nodeconstants, dir, node):
         super(excludeddir, self).__init__(nodeconstants, dir)
         self._node = node
         # Add an empty file, which will be included by iterators and such,
         # appearing as the directory itself (i.e. something like "dir/")
         self._files[b''] = node
         self._flags[b''] = b't'
 
     # Manifests outside the narrowspec should never be modified, so avoid
     # copying. This makes a noticeable difference when there are very many
     # directories outside the narrowspec. Also, it makes sense for the copy to
     # be of the same type as the original, which would not happen with the
     # super type's copy().
     def copy(self):
         return self
 
 
 class excludeddirmanifestctx(treemanifestctx):
     """context wrapper for excludeddir - see that docstring for rationale"""
 
     def __init__(self, nodeconstants, dir, node):
         self.nodeconstants = nodeconstants
         self._dir = dir
         self._node = node
 
     def read(self):
         return excludeddir(self.nodeconstants, self._dir, self._node)
 
     def readfast(self, shallow=False):
         # special version of readfast since we don't have underlying storage
         return self.read()
 
     def write(self, *args):
         raise error.ProgrammingError(
             b'attempt to write manifest from excluded dir %s' % self._dir
         )
 
 
 class excludedmanifestrevlog(manifestrevlog):
     """Stand-in for excluded treemanifest revlogs.
 
     When narrowing is active on a treemanifest repository, we'll have
     references to directories we can't see due to the revlog being
     skipped. This class exists to conform to the manifestrevlog
     interface for those directories and proactively prevent writes to
     outside the narrowspec.
     """
 
     def __init__(self, nodeconstants, dir):
         self.nodeconstants = nodeconstants
         self._dir = dir
 
     def __len__(self):
         raise error.ProgrammingError(
             b'attempt to get length of excluded dir %s' % self._dir
         )
 
     def rev(self, node):
         raise error.ProgrammingError(
             b'attempt to get rev from excluded dir %s' % self._dir
         )
 
     def linkrev(self, node):
         raise error.ProgrammingError(
             b'attempt to get linkrev from excluded dir %s' % self._dir
         )
 
     def node(self, rev):
         raise error.ProgrammingError(
             b'attempt to get node from excluded dir %s' % self._dir
         )
 
     def add(self, *args, **kwargs):
         # We should never write entries in dirlogs outside the narrow clone.
         # However, the method still gets called from writesubtree() in
         # _addtree(), so we need to handle it. We should possibly make that
         # avoid calling add() with a clean manifest (_dirty is always False
         # in excludeddir instances).
         pass

mercurial/revlog.py

@@ -1,3352 +1,3354 b''
 # revlog.py - storage back-end for mercurial
 # coding: utf8
 #
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """Storage back-end for Mercurial.
 
 This provides efficient delta storage with O(1) retrieve and append
 and O(changes) merge between branches.
 """
 
 
 import binascii
 import collections
 import contextlib
 import io
 import os
 import struct
 import zlib
 
 # import stuff from node for others to import from revlog
 from .node import (
     bin,
     hex,
     nullrev,
     sha1nodeconstants,
     short,
     wdirrev,
 )
 from .i18n import _
 from .pycompat import getattr
 from .revlogutils.constants import (
     ALL_KINDS,
     CHANGELOGV2,
     COMP_MODE_DEFAULT,
     COMP_MODE_INLINE,
     COMP_MODE_PLAIN,
     ENTRY_RANK,
     FEATURES_BY_VERSION,
     FLAG_GENERALDELTA,
     FLAG_INLINE_DATA,
     INDEX_HEADER,
     KIND_CHANGELOG,
     KIND_FILELOG,
     RANK_UNKNOWN,
     REVLOGV0,
     REVLOGV1,
     REVLOGV1_FLAGS,
     REVLOGV2,
     REVLOGV2_FLAGS,
     REVLOG_DEFAULT_FLAGS,
     REVLOG_DEFAULT_FORMAT,
     REVLOG_DEFAULT_VERSION,
     SUPPORTED_FLAGS,
 )
 from .revlogutils.flagutil import (
     REVIDX_DEFAULT_FLAGS,
     REVIDX_ELLIPSIS,
     REVIDX_EXTSTORED,
     REVIDX_FLAGS_ORDER,
     REVIDX_HASCOPIESINFO,
     REVIDX_ISCENSORED,
     REVIDX_RAWTEXT_CHANGING_FLAGS,
 )
 from .thirdparty import attr
 from . import (
     ancestor,
     dagop,
     error,
     mdiff,
     policy,
     pycompat,
     revlogutils,
     templatefilters,
     util,
 )
 from .interfaces import (
     repository,
     util as interfaceutil,
 )
 from .revlogutils import (
     deltas as deltautil,
     docket as docketutil,
     flagutil,
     nodemap as nodemaputil,
     randomaccessfile,
     revlogv0,
     rewrite,
     sidedata as sidedatautil,
 )
 from .utils import (
     storageutil,
     stringutil,
 )
 
 # blanked usage of all the name to prevent pyflakes constraints
 # We need these name available in the module for extensions.
 
 REVLOGV0
 REVLOGV1
 REVLOGV2
 CHANGELOGV2
 FLAG_INLINE_DATA
 FLAG_GENERALDELTA
 REVLOG_DEFAULT_FLAGS
 REVLOG_DEFAULT_FORMAT
 REVLOG_DEFAULT_VERSION
 REVLOGV1_FLAGS
 REVLOGV2_FLAGS
 REVIDX_ISCENSORED
 REVIDX_ELLIPSIS
 REVIDX_HASCOPIESINFO
 REVIDX_EXTSTORED
 REVIDX_DEFAULT_FLAGS
 REVIDX_FLAGS_ORDER
 REVIDX_RAWTEXT_CHANGING_FLAGS
 
 parsers = policy.importmod('parsers')
 rustancestor = policy.importrust('ancestor')
 rustdagop = policy.importrust('dagop')
 rustrevlog = policy.importrust('revlog')
 
 # Aliased for performance.
 _zlibdecompress = zlib.decompress
 
 # max size of revlog with inline data
 _maxinline = 131072
 
 # Flag processors for REVIDX_ELLIPSIS.
 def ellipsisreadprocessor(rl, text):
     return text, False
 
 
 def ellipsiswriteprocessor(rl, text):
     return text, False
 
 
 def ellipsisrawprocessor(rl, text):
     return False
 
 
 ellipsisprocessor = (
     ellipsisreadprocessor,
     ellipsiswriteprocessor,
     ellipsisrawprocessor,
 )
 
 
 def _verify_revision(rl, skipflags, state, node):
     """Verify the integrity of the given revlog ``node`` while providing a hook
     point for extensions to influence the operation."""
     if skipflags:
         state[b'skipread'].add(node)
     else:
         # Side-effect: read content and verify hash.
         rl.revision(node)
 
 
 # True if a fast implementation for persistent-nodemap is available
 #
 # We also consider we have a "fast" implementation in "pure" python because
 # people using pure don't really have performance consideration (and a
 # wheelbarrow of other slowness source)
 HAS_FAST_PERSISTENT_NODEMAP = rustrevlog is not None or util.safehasattr(
     parsers, 'BaseIndexObject'
 )
 
 
 @interfaceutil.implementer(repository.irevisiondelta)
 @attr.s(slots=True)
 class revlogrevisiondelta:
     node = attr.ib()
     p1node = attr.ib()
     p2node = attr.ib()
     basenode = attr.ib()
     flags = attr.ib()
     baserevisionsize = attr.ib()
     revision = attr.ib()
     delta = attr.ib()
     sidedata = attr.ib()
     protocol_flags = attr.ib()
     linknode = attr.ib(default=None)
 
 
 @interfaceutil.implementer(repository.iverifyproblem)
 @attr.s(frozen=True)
 class revlogproblem:
     warning = attr.ib(default=None)
     error = attr.ib(default=None)
     node = attr.ib(default=None)
 
 
 def parse_index_v1(data, inline):
     # call the C implementation to parse the index data
     index, cache = parsers.parse_index2(data, inline)
     return index, cache
 
 
 def parse_index_v2(data, inline):
     # call the C implementation to parse the index data
     index, cache = parsers.parse_index2(data, inline, format=REVLOGV2)
     return index, cache
 
 
 def parse_index_cl_v2(data, inline):
     # call the C implementation to parse the index data
     index, cache = parsers.parse_index2(data, inline, format=CHANGELOGV2)
     return index, cache
 
 
 if util.safehasattr(parsers, 'parse_index_devel_nodemap'):
 
     def parse_index_v1_nodemap(data, inline):
         index, cache = parsers.parse_index_devel_nodemap(data, inline)
         return index, cache
 
 
 else:
     parse_index_v1_nodemap = None
 
 
 def parse_index_v1_mixed(data, inline):
     index, cache = parse_index_v1(data, inline)
     return rustrevlog.MixedIndex(index), cache
 
 
 # corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
 # signed integer)
 _maxentrysize = 0x7FFFFFFF
 
 FILE_TOO_SHORT_MSG = _(
     b'cannot read from revlog %s;'
     b'  expected %d bytes from offset %d, data size is %d'
 )
 
 hexdigits = b'0123456789abcdefABCDEF'
 
 
 class revlog:
     """
     the underlying revision storage object
 
     A revlog consists of two parts, an index and the revision data.
 
     The index is a file with a fixed record size containing
     information on each revision, including its nodeid (hash), the
     nodeids of its parents, the position and offset of its data within
     the data file, and the revision it's based on. Finally, each entry
     contains a linkrev entry that can serve as a pointer to external
     data.
 
     The revision data itself is a linear collection of data chunks.
     Each chunk represents a revision and is usually represented as a
     delta against the previous chunk. To bound lookup time, runs of
     deltas are limited to about 2 times the length of the original
     version data. This makes retrieval of a version proportional to
     its size, or O(1) relative to the number of revisions.
 
     Both pieces of the revlog are written to in an append-only
     fashion, which means we never need to rewrite a file to insert or
     remove data, and can use some simple techniques to avoid the need
     for locking while reading.
 
     If checkambig, indexfile is opened with checkambig=True at
     writing, to avoid file stat ambiguity.
 
     If mmaplargeindex is True, and an mmapindexthreshold is set, the
     index will be mmapped rather than read if it is larger than the
     configured threshold.
 
     If censorable is True, the revlog can have censored revisions.
 
     If `upperboundcomp` is not None, this is the expected maximal gain from
     compression for the data content.
 
     `concurrencychecker` is an optional function that receives 3 arguments: a
     file handle, a filename, and an expected position. It should check whether
     the current position in the file handle is valid, and log/warn/fail (by
     raising).
 
     See mercurial/revlogutils/contants.py for details about the content of an
     index entry.
     """
 
     _flagserrorclass = error.RevlogError
 
     def __init__(
         self,
         opener,
         target,
         radix,
         postfix=None,  # only exist for `tmpcensored` now
         checkambig=False,
         mmaplargeindex=False,
         censorable=False,
         upperboundcomp=None,
         persistentnodemap=False,
         concurrencychecker=None,
         trypending=False,
         canonical_parent_order=True,
     ):
         """
         create a revlog object
 
         opener is a function that abstracts the file opening operation
         and can be used to implement COW semantics or the like.
 
         `target`: a (KIND, ID) tuple that identify the content stored in
         this revlog. It help the rest of the code to understand what the revlog
         is about without having to resort to heuristic and index filename
         analysis. Note: that this must be reliably be set by normal code, but
         that test, debug, or performance measurement code might not set this to
         accurate value.
         """
         self.upperboundcomp = upperboundcomp
 
         self.radix = radix
 
         self._docket_file = None
         self._indexfile = None
         self._datafile = None
         self._sidedatafile = None
         self._nodemap_file = None
         self.postfix = postfix
         self._trypending = trypending
         self.opener = opener
         if persistentnodemap:
             self._nodemap_file = nodemaputil.get_nodemap_file(self)
 
         assert target[0] in ALL_KINDS
         assert len(target) == 2
         self.target = target
         #  When True, indexfile is opened with checkambig=True at writing, to
         #  avoid file stat ambiguity.
         self._checkambig = checkambig
         self._mmaplargeindex = mmaplargeindex
         self._censorable = censorable
         # 3-tuple of (node, rev, text) for a raw revision.
         self._revisioncache = None
         # Maps rev to chain base rev.
         self._chainbasecache = util.lrucachedict(100)
         # 2-tuple of (offset, data) of raw data from the revlog at an offset.
         self._chunkcache = (0, b'')
         # How much data to read and cache into the raw revlog data cache.
         self._chunkcachesize = 65536
         self._maxchainlen = None
         self._deltabothparents = True
         self._debug_delta = False
         self.index = None
         self._docket = None
         self._nodemap_docket = None
         # Mapping of partial identifiers to full nodes.
         self._pcache = {}
         # Mapping of revision integer to full node.
         self._compengine = b'zlib'
         self._compengineopts = {}
         self._maxdeltachainspan = -1
         self._withsparseread = False
         self._sparserevlog = False
         self.hassidedata = False
         self._srdensitythreshold = 0.50
         self._srmingapsize = 262144
 
         # Make copy of flag processors so each revlog instance can support
         # custom flags.
         self._flagprocessors = dict(flagutil.flagprocessors)
 
         # 3-tuple of file handles being used for active writing.
         self._writinghandles = None
         # prevent nesting of addgroup
         self._adding_group = None
 
         self._loadindex()
 
         self._concurrencychecker = concurrencychecker
 
         # parent order is supposed to be semantically irrelevant, so we
         # normally resort parents to ensure that the first parent is non-null,
         # if there is a non-null parent at all.
         # filelog abuses the parent order as flag to mark some instances of
         # meta-encoded files, so allow it to disable this behavior.
         self.canonical_parent_order = canonical_parent_order
 
     def _init_opts(self):
         """process options (from above/config) to setup associated default revlog mode
 
         These values might be affected when actually reading on disk information.
 
         The relevant values are returned for use in _loadindex().
 
         * newversionflags:
             version header to use if we need to create a new revlog
 
         * mmapindexthreshold:
             minimal index size for start to use mmap
 
         * force_nodemap:
             force the usage of a "development" version of the nodemap code
         """
         mmapindexthreshold = None
         opts = self.opener.options
 
         if b'changelogv2' in opts and self.revlog_kind == KIND_CHANGELOG:
             new_header = CHANGELOGV2
         elif b'revlogv2' in opts:
             new_header = REVLOGV2
         elif b'revlogv1' in opts:
             new_header = REVLOGV1 | FLAG_INLINE_DATA
             if b'generaldelta' in opts:
                 new_header |= FLAG_GENERALDELTA
         elif b'revlogv0' in self.opener.options:
             new_header = REVLOGV0
         else:
             new_header = REVLOG_DEFAULT_VERSION
 
         if b'chunkcachesize' in opts:
             self._chunkcachesize = opts[b'chunkcachesize']
         if b'maxchainlen' in opts:
             self._maxchainlen = opts[b'maxchainlen']
         if b'deltabothparents' in opts:
             self._deltabothparents = opts[b'deltabothparents']
         self._lazydelta = bool(opts.get(b'lazydelta', True))
         self._lazydeltabase = False
         if self._lazydelta:
             self._lazydeltabase = bool(opts.get(b'lazydeltabase', False))
         if b'debug-delta' in opts:
             self._debug_delta = opts[b'debug-delta']
         if b'compengine' in opts:
             self._compengine = opts[b'compengine']
         if b'zlib.level' in opts:
             self._compengineopts[b'zlib.level'] = opts[b'zlib.level']
         if b'zstd.level' in opts:
             self._compengineopts[b'zstd.level'] = opts[b'zstd.level']
         if b'maxdeltachainspan' in opts:
             self._maxdeltachainspan = opts[b'maxdeltachainspan']
         if self._mmaplargeindex and b'mmapindexthreshold' in opts:
             mmapindexthreshold = opts[b'mmapindexthreshold']
         self._sparserevlog = bool(opts.get(b'sparse-revlog', False))
         withsparseread = bool(opts.get(b'with-sparse-read', False))
         # sparse-revlog forces sparse-read
         self._withsparseread = self._sparserevlog or withsparseread
         if b'sparse-read-density-threshold' in opts:
             self._srdensitythreshold = opts[b'sparse-read-density-threshold']
         if b'sparse-read-min-gap-size' in opts:
             self._srmingapsize = opts[b'sparse-read-min-gap-size']
         if opts.get(b'enableellipsis'):
             self._flagprocessors[REVIDX_ELLIPSIS] = ellipsisprocessor
 
         # revlog v0 doesn't have flag processors
         for flag, processor in opts.get(b'flagprocessors', {}).items():
             flagutil.insertflagprocessor(flag, processor, self._flagprocessors)
 
         if self._chunkcachesize <= 0:
             raise error.RevlogError(
                 _(b'revlog chunk cache size %r is not greater than 0')
                 % self._chunkcachesize
             )
         elif self._chunkcachesize & (self._chunkcachesize - 1):
             raise error.RevlogError(
                 _(b'revlog chunk cache size %r is not a power of 2')
                 % self._chunkcachesize
             )
         force_nodemap = opts.get(b'devel-force-nodemap', False)
         return new_header, mmapindexthreshold, force_nodemap
 
     def _get_data(self, filepath, mmap_threshold, size=None):
         """return a file content with or without mmap
 
         If the file is missing return the empty string"""
         try:
             with self.opener(filepath) as fp:
                 if mmap_threshold is not None:
                     file_size = self.opener.fstat(fp).st_size
                     if file_size >= mmap_threshold:
                         if size is not None:
                             # avoid potentiel mmap crash
                             size = min(file_size, size)
                         # TODO: should .close() to release resources without
                         # relying on Python GC
                         if size is None:
                             return util.buffer(util.mmapread(fp))
                         else:
                             return util.buffer(util.mmapread(fp, size))
                 if size is None:
                     return fp.read()
                 else:
                     return fp.read(size)
         except FileNotFoundError:
             return b''
 
     def _loadindex(self, docket=None):
 
         new_header, mmapindexthreshold, force_nodemap = self._init_opts()
 
         if self.postfix is not None:
             entry_point = b'%s.i.%s' % (self.radix, self.postfix)
         elif self._trypending and self.opener.exists(b'%s.i.a' % self.radix):
             entry_point = b'%s.i.a' % self.radix
         else:
             entry_point = b'%s.i' % self.radix
 
         if docket is not None:
             self._docket = docket
             self._docket_file = entry_point
         else:
             self._initempty = True
             entry_data = self._get_data(entry_point, mmapindexthreshold)
             if len(entry_data) > 0:
                 header = INDEX_HEADER.unpack(entry_data[:4])[0]
                 self._initempty = False
             else:
                 header = new_header
 
             self._format_flags = header & ~0xFFFF
             self._format_version = header & 0xFFFF
 
             supported_flags = SUPPORTED_FLAGS.get(self._format_version)
             if supported_flags is None:
                 msg = _(b'unknown version (%d) in revlog %s')
                 msg %= (self._format_version, self.display_id)
                 raise error.RevlogError(msg)
             elif self._format_flags & ~supported_flags:
                 msg = _(b'unknown flags (%#04x) in version %d revlog %s')
                 display_flag = self._format_flags >> 16
                 msg %= (display_flag, self._format_version, self.display_id)
                 raise error.RevlogError(msg)
 
             features = FEATURES_BY_VERSION[self._format_version]
             self._inline = features[b'inline'](self._format_flags)
             self._generaldelta = features[b'generaldelta'](self._format_flags)
             self.hassidedata = features[b'sidedata']
 
             if not features[b'docket']:
                 self._indexfile = entry_point
                 index_data = entry_data
             else:
                 self._docket_file = entry_point
                 if self._initempty:
                     self._docket = docketutil.default_docket(self, header)
                 else:
                     self._docket = docketutil.parse_docket(
                         self, entry_data, use_pending=self._trypending
                     )
 
         if self._docket is not None:
             self._indexfile = self._docket.index_filepath()
             index_data = b''
             index_size = self._docket.index_end
             if index_size > 0:
                 index_data = self._get_data(
                     self._indexfile, mmapindexthreshold, size=index_size
                 )
                 if len(index_data) < index_size:
                     msg = _(b'too few index data for %s: got %d, expected %d')
                     msg %= (self.display_id, len(index_data), index_size)
                     raise error.RevlogError(msg)
 
             self._inline = False
             # generaldelta implied by version 2 revlogs.
             self._generaldelta = True
             # the logic for persistent nodemap will be dealt with within the
             # main docket, so disable it for now.
             self._nodemap_file = None
 
         if self._docket is not None:
             self._datafile = self._docket.data_filepath()
             self._sidedatafile = self._docket.sidedata_filepath()
         elif self.postfix is None:
             self._datafile = b'%s.d' % self.radix
         else:
             self._datafile = b'%s.d.%s' % (self.radix, self.postfix)
 
         self.nodeconstants = sha1nodeconstants
         self.nullid = self.nodeconstants.nullid
 
         # sparse-revlog can't be on without general-delta (issue6056)
         if not self._generaldelta:
             self._sparserevlog = False
 
         self._storedeltachains = True
 
         devel_nodemap = (
             self._nodemap_file
             and force_nodemap
             and parse_index_v1_nodemap is not None
         )
 
         use_rust_index = False
         if rustrevlog is not None:
             if self._nodemap_file is not None:
                 use_rust_index = True
             else:
                 use_rust_index = self.opener.options.get(b'rust.index')
 
         self._parse_index = parse_index_v1
         if self._format_version == REVLOGV0:
             self._parse_index = revlogv0.parse_index_v0
         elif self._format_version == REVLOGV2:
             self._parse_index = parse_index_v2
         elif self._format_version == CHANGELOGV2:
             self._parse_index = parse_index_cl_v2
         elif devel_nodemap:
             self._parse_index = parse_index_v1_nodemap
         elif use_rust_index:
             self._parse_index = parse_index_v1_mixed
         try:
             d = self._parse_index(index_data, self._inline)
             index, chunkcache = d
             use_nodemap = (
                 not self._inline
                 and self._nodemap_file is not None
                 and util.safehasattr(index, 'update_nodemap_data')
             )
             if use_nodemap:
                 nodemap_data = nodemaputil.persisted_data(self)
                 if nodemap_data is not None:
                     docket = nodemap_data[0]
                     if (
                         len(d[0]) > docket.tip_rev
                         and d[0][docket.tip_rev][7] == docket.tip_node
                     ):
                         # no changelog tampering
                         self._nodemap_docket = docket
                         index.update_nodemap_data(*nodemap_data)
         except (ValueError, IndexError):
             raise error.RevlogError(
                 _(b"index %s is corrupted") % self.display_id
             )
         self.index = index
         self._segmentfile = randomaccessfile.randomaccessfile(
             self.opener,
             (self._indexfile if self._inline else self._datafile),
             self._chunkcachesize,
             chunkcache,
         )
         self._segmentfile_sidedata = randomaccessfile.randomaccessfile(
             self.opener,
             self._sidedatafile,
             self._chunkcachesize,
         )
         # revnum -> (chain-length, sum-delta-length)
         self._chaininfocache = util.lrucachedict(500)
         # revlog header -> revlog compressor
         self._decompressors = {}
 
     @util.propertycache
     def revlog_kind(self):
         return self.target[0]
 
     @util.propertycache
     def display_id(self):
         """The public facing "ID" of the revlog that we use in message"""
         if self.revlog_kind == KIND_FILELOG:
             # Reference the file without the "data/" prefix, so it is familiar
             # to the user.
             return self.target[1]
         else:
             return self.radix
 
     def _get_decompressor(self, t):
         try:
             compressor = self._decompressors[t]
         except KeyError:
             try:
                 engine = util.compengines.forrevlogheader(t)
                 compressor = engine.revlogcompressor(self._compengineopts)
                 self._decompressors[t] = compressor
             except KeyError:
                 raise error.RevlogError(
                     _(b'unknown compression type %s') % binascii.hexlify(t)
                 )
         return compressor
 
     @util.propertycache
     def _compressor(self):
         engine = util.compengines[self._compengine]
         return engine.revlogcompressor(self._compengineopts)
 
     @util.propertycache
     def _decompressor(self):
         """the default decompressor"""
         if self._docket is None:
             return None
         t = self._docket.default_compression_header
         c = self._get_decompressor(t)
         return c.decompress
 
     def _indexfp(self):
         """file object for the revlog's index file"""
         return self.opener(self._indexfile, mode=b"r")
 
     def __index_write_fp(self):
         # You should not use this directly and use `_writing` instead
         try:
             f = self.opener(
                 self._indexfile, mode=b"r+", checkambig=self._checkambig
             )
             if self._docket is None:
                 f.seek(0, os.SEEK_END)
             else:
                 f.seek(self._docket.index_end, os.SEEK_SET)
             return f
         except FileNotFoundError:
             return self.opener(
                 self._indexfile, mode=b"w+", checkambig=self._checkambig
             )
 
     def __index_new_fp(self):
         # You should not use this unless you are upgrading from inline revlog
         return self.opener(
             self._indexfile,
             mode=b"w",
             checkambig=self._checkambig,
             atomictemp=True,
         )
 
     def _datafp(self, mode=b'r'):
         """file object for the revlog's data file"""
         return self.opener(self._datafile, mode=mode)
 
     @contextlib.contextmanager
     def _sidedatareadfp(self):
         """file object suitable to read sidedata"""
         if self._writinghandles:
             yield self._writinghandles[2]
         else:
             with self.opener(self._sidedatafile) as fp:
                 yield fp
 
     def tiprev(self):
         return len(self.index) - 1
 
     def tip(self):
         return self.node(self.tiprev())
 
     def __contains__(self, rev):
         return 0 <= rev < len(self)
 
     def __len__(self):
         return len(self.index)
 
     def __iter__(self):
         return iter(range(len(self)))
 
     def revs(self, start=0, stop=None):
         """iterate over all rev in this revlog (from start to stop)"""
         return storageutil.iterrevs(len(self), start=start, stop=stop)
 
     def hasnode(self, node):
         try:
             self.rev(node)
             return True
         except KeyError:
             return False
 
     def candelta(self, baserev, rev):
         """whether two revisions (baserev, rev) can be delta-ed or not"""
         # Disable delta if either rev requires a content-changing flag
         # processor (ex. LFS). This is because such flag processor can alter
         # the rawtext content that the delta will be based on, and two clients
         # could have a same revlog node with different flags (i.e. different
         # rawtext contents) and the delta could be incompatible.
         if (self.flags(baserev) & REVIDX_RAWTEXT_CHANGING_FLAGS) or (
             self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS
         ):
             return False
         return True
 
     def update_caches(self, transaction):
         if self._nodemap_file is not None:
             if transaction is None:
                 nodemaputil.update_persistent_nodemap(self)
             else:
                 nodemaputil.setup_persistent_nodemap(transaction, self)
 
     def clearcaches(self):
         self._revisioncache = None
         self._chainbasecache.clear()
         self._segmentfile.clear_cache()
         self._segmentfile_sidedata.clear_cache()
         self._pcache = {}
         self._nodemap_docket = None
         self.index.clearcaches()
         # The python code is the one responsible for validating the docket, we
         # end up having to refresh it here.
         use_nodemap = (
             not self._inline
             and self._nodemap_file is not None
             and util.safehasattr(self.index, 'update_nodemap_data')
         )
         if use_nodemap:
             nodemap_data = nodemaputil.persisted_data(self)
             if nodemap_data is not None:
                 self._nodemap_docket = nodemap_data[0]
                 self.index.update_nodemap_data(*nodemap_data)
 
     def rev(self, node):
         try:
             return self.index.rev(node)
         except TypeError:
             raise
         except error.RevlogError:
             # parsers.c radix tree lookup failed
             if (
                 node == self.nodeconstants.wdirid
                 or node in self.nodeconstants.wdirfilenodeids
             ):
                 raise error.WdirUnsupported
             raise error.LookupError(node, self.display_id, _(b'no node'))
 
     # Accessors for index entries.
 
     # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes
     # are flags.
     def start(self, rev):
         return int(self.index[rev][0] >> 16)
 
     def sidedata_cut_off(self, rev):
         sd_cut_off = self.index[rev][8]
         if sd_cut_off != 0:
             return sd_cut_off
         # This is some annoying dance, because entries without sidedata
         # currently use 0 as their ofsset. (instead of previous-offset +
         # previous-size)
         #
         # We should reconsider this sidedata → 0 sidata_offset policy.
         # In the meantime, we need this.
         while 0 <= rev:
             e = self.index[rev]
             if e[9] != 0:
                 return e[8] + e[9]
             rev -= 1
         return 0
 
     def flags(self, rev):
         return self.index[rev][0] & 0xFFFF
 
     def length(self, rev):
         return self.index[rev][1]
 
     def sidedata_length(self, rev):
         if not self.hassidedata:
             return 0
         return self.index[rev][9]
 
     def rawsize(self, rev):
         """return the length of the uncompressed text for a given revision"""
         l = self.index[rev][2]
         if l >= 0:
             return l
 
         t = self.rawdata(rev)
         return len(t)
 
     def size(self, rev):
         """length of non-raw text (processed by a "read" flag processor)"""
         # fast path: if no "read" flag processor could change the content,
         # size is rawsize. note: ELLIPSIS is known to not change the content.
         flags = self.flags(rev)
         if flags & (flagutil.REVIDX_KNOWN_FLAGS ^ REVIDX_ELLIPSIS) == 0:
             return self.rawsize(rev)
 
         return len(self.revision(rev))
 
     def fast_rank(self, rev):
         """Return the rank of a revision if already known, or None otherwise.
 
         The rank of a revision is the size of the sub-graph it defines as a
         head. Equivalently, the rank of a revision `r` is the size of the set
         `ancestors(r)`, `r` included.
 
         This method returns the rank retrieved from the revlog in constant
         time. It makes no attempt at computing unknown values for versions of
         the revlog which do not persist the rank.
         """
         rank = self.index[rev][ENTRY_RANK]
         if self._format_version != CHANGELOGV2 or rank == RANK_UNKNOWN:
             return None
         if rev == nullrev:
             return 0  # convention
         return rank
 
     def chainbase(self, rev):
         base = self._chainbasecache.get(rev)
         if base is not None:
             return base
 
         index = self.index
         iterrev = rev
         base = index[iterrev][3]
         while base != iterrev:
             iterrev = base
             base = index[iterrev][3]
 
         self._chainbasecache[rev] = base
         return base
 
     def linkrev(self, rev):
         return self.index[rev][4]
 
     def parentrevs(self, rev):
         try:
             entry = self.index[rev]
         except IndexError:
             if rev == wdirrev:
                 raise error.WdirUnsupported
             raise
 
         if self.canonical_parent_order and entry[5] == nullrev:
             return entry[6], entry[5]
         else:
             return entry[5], entry[6]
 
     # fast parentrevs(rev) where rev isn't filtered
     _uncheckedparentrevs = parentrevs
 
     def node(self, rev):
         try:
             return self.index[rev][7]
         except IndexError:
             if rev == wdirrev:
                 raise error.WdirUnsupported
             raise
 
     # Derived from index values.
 
     def end(self, rev):
         return self.start(rev) + self.length(rev)
 
     def parents(self, node):
         i = self.index
         d = i[self.rev(node)]
         # inline node() to avoid function call overhead
         if self.canonical_parent_order and d[5] == self.nullid:
             return i[d[6]][7], i[d[5]][7]
         else:
             return i[d[5]][7], i[d[6]][7]
 
     def chainlen(self, rev):
         return self._chaininfo(rev)[0]
 
     def _chaininfo(self, rev):
         chaininfocache = self._chaininfocache
         if rev in chaininfocache:
             return chaininfocache[rev]
         index = self.index
         generaldelta = self._generaldelta
         iterrev = rev
         e = index[iterrev]
         clen = 0
         compresseddeltalen = 0
         while iterrev != e[3]:
             clen += 1
             compresseddeltalen += e[1]
             if generaldelta:
                 iterrev = e[3]
             else:
                 iterrev -= 1
             if iterrev in chaininfocache:
                 t = chaininfocache[iterrev]
                 clen += t[0]
                 compresseddeltalen += t[1]
                 break
             e = index[iterrev]
         else:
             # Add text length of base since decompressing that also takes
             # work. For cache hits the length is already included.
             compresseddeltalen += e[1]
         r = (clen, compresseddeltalen)
         chaininfocache[rev] = r
         return r
 
     def _deltachain(self, rev, stoprev=None):
         """Obtain the delta chain for a revision.
 
         ``stoprev`` specifies a revision to stop at. If not specified, we
         stop at the base of the chain.
 
         Returns a 2-tuple of (chain, stopped) where ``chain`` is a list of
         revs in ascending order and ``stopped`` is a bool indicating whether
         ``stoprev`` was hit.
         """
         # Try C implementation.
         try:
             return self.index.deltachain(rev, stoprev, self._generaldelta)
         except AttributeError:
             pass
 
         chain = []
 
         # Alias to prevent attribute lookup in tight loop.
         index = self.index
         generaldelta = self._generaldelta
 
         iterrev = rev
         e = index[iterrev]
         while iterrev != e[3] and iterrev != stoprev:
             chain.append(iterrev)
             if generaldelta:
                 iterrev = e[3]
             else:
                 iterrev -= 1
             e = index[iterrev]
 
         if iterrev == stoprev:
             stopped = True
         else:
             chain.append(iterrev)
             stopped = False
 
         chain.reverse()
         return chain, stopped
 
     def ancestors(self, revs, stoprev=0, inclusive=False):
         """Generate the ancestors of 'revs' in reverse revision order.
         Does not generate revs lower than stoprev.
 
         See the documentation for ancestor.lazyancestors for more details."""
 
         # first, make sure start revisions aren't filtered
         revs = list(revs)
         checkrev = self.node
         for r in revs:
             checkrev(r)
         # and we're sure ancestors aren't filtered as well
 
         if rustancestor is not None and self.index.rust_ext_compat:
             lazyancestors = rustancestor.LazyAncestors
             arg = self.index
         else:
             lazyancestors = ancestor.lazyancestors
             arg = self._uncheckedparentrevs
         return lazyancestors(arg, revs, stoprev=stoprev, inclusive=inclusive)
 
     def descendants(self, revs):
         return dagop.descendantrevs(revs, self.revs, self.parentrevs)
 
     def findcommonmissing(self, common=None, heads=None):
         """Return a tuple of the ancestors of common and the ancestors of heads
         that are not ancestors of common. In revset terminology, we return the
         tuple:
 
           ::common, (::heads) - (::common)
 
         The list is sorted by revision number, meaning it is
         topologically sorted.
 
         'heads' and 'common' are both lists of node IDs.  If heads is
         not supplied, uses all of the revlog's heads.  If common is not
         supplied, uses nullid."""
         if common is None:
             common = [self.nullid]
         if heads is None:
             heads = self.heads()
 
         common = [self.rev(n) for n in common]
         heads = [self.rev(n) for n in heads]
 
         # we want the ancestors, but inclusive
         class lazyset:
             def __init__(self, lazyvalues):
                 self.addedvalues = set()
                 self.lazyvalues = lazyvalues
 
             def __contains__(self, value):
                 return value in self.addedvalues or value in self.lazyvalues
 
             def __iter__(self):
                 added = self.addedvalues
                 for r in added:
                     yield r
                 for r in self.lazyvalues:
                     if not r in added:
                         yield r
 
             def add(self, value):
                 self.addedvalues.add(value)
 
             def update(self, values):
                 self.addedvalues.update(values)
 
         has = lazyset(self.ancestors(common))
         has.add(nullrev)
         has.update(common)
 
         # take all ancestors from heads that aren't in has
         missing = set()
         visit = collections.deque(r for r in heads if r not in has)
         while visit:
             r = visit.popleft()
             if r in missing:
                 continue
             else:
                 missing.add(r)
                 for p in self.parentrevs(r):
                     if p not in has:
                         visit.append(p)
         missing = list(missing)
         missing.sort()
         return has, [self.node(miss) for miss in missing]
 
     def incrementalmissingrevs(self, common=None):
         """Return an object that can be used to incrementally compute the
         revision numbers of the ancestors of arbitrary sets that are not
         ancestors of common. This is an ancestor.incrementalmissingancestors
         object.
 
         'common' is a list of revision numbers. If common is not supplied, uses
         nullrev.
         """
         if common is None:
             common = [nullrev]
 
         if rustancestor is not None and self.index.rust_ext_compat:
             return rustancestor.MissingAncestors(self.index, common)
         return ancestor.incrementalmissingancestors(self.parentrevs, common)
 
     def findmissingrevs(self, common=None, heads=None):
         """Return the revision numbers of the ancestors of heads that
         are not ancestors of common.
 
         More specifically, return a list of revision numbers corresponding to
         nodes N such that every N satisfies the following constraints:
 
           1. N is an ancestor of some node in 'heads'
           2. N is not an ancestor of any node in 'common'
 
         The list is sorted by revision number, meaning it is
         topologically sorted.
 
         'heads' and 'common' are both lists of revision numbers.  If heads is
         not supplied, uses all of the revlog's heads.  If common is not
         supplied, uses nullid."""
         if common is None:
             common = [nullrev]
         if heads is None:
             heads = self.headrevs()
 
         inc = self.incrementalmissingrevs(common=common)
         return inc.missingancestors(heads)
 
     def findmissing(self, common=None, heads=None):
         """Return the ancestors of heads that are not ancestors of common.
 
         More specifically, return a list of nodes N such that every N
         satisfies the following constraints:
 
           1. N is an ancestor of some node in 'heads'
           2. N is not an ancestor of any node in 'common'
 
         The list is sorted by revision number, meaning it is
         topologically sorted.
 
         'heads' and 'common' are both lists of node IDs.  If heads is
         not supplied, uses all of the revlog's heads.  If common is not
         supplied, uses nullid."""
         if common is None:
             common = [self.nullid]
         if heads is None:
             heads = self.heads()
 
         common = [self.rev(n) for n in common]
         heads = [self.rev(n) for n in heads]
 
         inc = self.incrementalmissingrevs(common=common)
         return [self.node(r) for r in inc.missingancestors(heads)]
 
     def nodesbetween(self, roots=None, heads=None):
         """Return a topological path from 'roots' to 'heads'.
 
         Return a tuple (nodes, outroots, outheads) where 'nodes' is a
         topologically sorted list of all nodes N that satisfy both of
         these constraints:
 
           1. N is a descendant of some node in 'roots'
           2. N is an ancestor of some node in 'heads'
 
         Every node is considered to be both a descendant and an ancestor
         of itself, so every reachable node in 'roots' and 'heads' will be
         included in 'nodes'.
 
         'outroots' is the list of reachable nodes in 'roots', i.e., the
         subset of 'roots' that is returned in 'nodes'.  Likewise,
         'outheads' is the subset of 'heads' that is also in 'nodes'.
 
         'roots' and 'heads' are both lists of node IDs.  If 'roots' is
         unspecified, uses nullid as the only root.  If 'heads' is
         unspecified, uses list of all of the revlog's heads."""
         nonodes = ([], [], [])
         if roots is not None:
             roots = list(roots)
             if not roots:
                 return nonodes
             lowestrev = min([self.rev(n) for n in roots])
         else:
             roots = [self.nullid]  # Everybody's a descendant of nullid
             lowestrev = nullrev
         if (lowestrev == nullrev) and (heads is None):
             # We want _all_ the nodes!
             return (
                 [self.node(r) for r in self],
                 [self.nullid],
                 list(self.heads()),
             )
         if heads is None:
             # All nodes are ancestors, so the latest ancestor is the last
             # node.
             highestrev = len(self) - 1
             # Set ancestors to None to signal that every node is an ancestor.
             ancestors = None
             # Set heads to an empty dictionary for later discovery of heads
             heads = {}
         else:
             heads = list(heads)
             if not heads:
                 return nonodes
             ancestors = set()
             # Turn heads into a dictionary so we can remove 'fake' heads.
             # Also, later we will be using it to filter out the heads we can't
             # find from roots.
             heads = dict.fromkeys(heads, False)
             # Start at the top and keep marking parents until we're done.
             nodestotag = set(heads)
             # Remember where the top was so we can use it as a limit later.
             highestrev = max([self.rev(n) for n in nodestotag])
             while nodestotag:
                 # grab a node to tag
                 n = nodestotag.pop()
                 # Never tag nullid
                 if n == self.nullid:
                     continue
                 # A node's revision number represents its place in a
                 # topologically sorted list of nodes.
                 r = self.rev(n)
                 if r >= lowestrev:
                     if n not in ancestors:
                         # If we are possibly a descendant of one of the roots
                         # and we haven't already been marked as an ancestor
                         ancestors.add(n)  # Mark as ancestor
                         # Add non-nullid parents to list of nodes to tag.
                         nodestotag.update(
                             [p for p in self.parents(n) if p != self.nullid]
                         )
                     elif n in heads:  # We've seen it before, is it a fake head?
                         # So it is, real heads should not be the ancestors of
                         # any other heads.
                         heads.pop(n)
             if not ancestors:
                 return nonodes
             # Now that we have our set of ancestors, we want to remove any
             # roots that are not ancestors.
 
             # If one of the roots was nullid, everything is included anyway.
             if lowestrev > nullrev:
                 # But, since we weren't, let's recompute the lowest rev to not
                 # include roots that aren't ancestors.
 
                 # Filter out roots that aren't ancestors of heads
                 roots = [root for root in roots if root in ancestors]
                 # Recompute the lowest revision
                 if roots:
                     lowestrev = min([self.rev(root) for root in roots])
                 else:
                     # No more roots?  Return empty list
                     return nonodes
             else:
                 # We are descending from nullid, and don't need to care about
                 # any other roots.
                 lowestrev = nullrev
                 roots = [self.nullid]
         # Transform our roots list into a set.
         descendants = set(roots)
         # Also, keep the original roots so we can filter out roots that aren't
         # 'real' roots (i.e. are descended from other roots).
         roots = descendants.copy()
         # Our topologically sorted list of output nodes.
         orderedout = []
         # Don't start at nullid since we don't want nullid in our output list,
         # and if nullid shows up in descendants, empty parents will look like
         # they're descendants.
         for r in self.revs(start=max(lowestrev, 0), stop=highestrev + 1):
             n = self.node(r)
             isdescendant = False
             if lowestrev == nullrev:  # Everybody is a descendant of nullid
                 isdescendant = True
             elif n in descendants:
                 # n is already a descendant
                 isdescendant = True
                 # This check only needs to be done here because all the roots
                 # will start being marked is descendants before the loop.
                 if n in roots:
                     # If n was a root, check if it's a 'real' root.
                     p = tuple(self.parents(n))
                     # If any of its parents are descendants, it's not a root.
                     if (p[0] in descendants) or (p[1] in descendants):
                         roots.remove(n)
             else:
                 p = tuple(self.parents(n))
                 # A node is a descendant if either of its parents are
                 # descendants.  (We seeded the dependents list with the roots
                 # up there, remember?)
                 if (p[0] in descendants) or (p[1] in descendants):
                     descendants.add(n)
                     isdescendant = True
             if isdescendant and ((ancestors is None) or (n in ancestors)):
                 # Only include nodes that are both descendants and ancestors.
                 orderedout.append(n)
                 if (ancestors is not None) and (n in heads):
                     # We're trying to figure out which heads are reachable
                     # from roots.
                     # Mark this head as having been reached
                     heads[n] = True
                 elif ancestors is None:
                     # Otherwise, we're trying to discover the heads.
                     # Assume this is a head because if it isn't, the next step
                     # will eventually remove it.
                     heads[n] = True
                     # But, obviously its parents aren't.
                     for p in self.parents(n):
                         heads.pop(p, None)
         heads = [head for head, flag in heads.items() if flag]
         roots = list(roots)
         assert orderedout
         assert roots
         assert heads
         return (orderedout, roots, heads)
 
     def headrevs(self, revs=None):
         if revs is None:
             try:
                 return self.index.headrevs()
             except AttributeError:
                 return self._headrevs()
         if rustdagop is not None and self.index.rust_ext_compat:
             return rustdagop.headrevs(self.index, revs)
         return dagop.headrevs(revs, self._uncheckedparentrevs)
 
     def computephases(self, roots):
         return self.index.computephasesmapsets(roots)
 
     def _headrevs(self):
         count = len(self)
         if not count:
             return [nullrev]
         # we won't iter over filtered rev so nobody is a head at start
         ishead = [0] * (count + 1)
         index = self.index
         for r in self:
             ishead[r] = 1  # I may be an head
             e = index[r]
             ishead[e[5]] = ishead[e[6]] = 0  # my parent are not
         return [r for r, val in enumerate(ishead) if val]
 
     def heads(self, start=None, stop=None):
         """return the list of all nodes that have no children
 
         if start is specified, only heads that are descendants of
         start will be returned
         if stop is specified, it will consider all the revs from stop
         as if they had no children
         """
         if start is None and stop is None:
             if not len(self):
                 return [self.nullid]
             return [self.node(r) for r in self.headrevs()]
 
         if start is None:
             start = nullrev
         else:
             start = self.rev(start)
 
         stoprevs = {self.rev(n) for n in stop or []}
 
         revs = dagop.headrevssubset(
             self.revs, self.parentrevs, startrev=start, stoprevs=stoprevs
         )
 
         return [self.node(rev) for rev in revs]
 
     def children(self, node):
         """find the children of a given node"""
         c = []
         p = self.rev(node)
         for r in self.revs(start=p + 1):
             prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
             if prevs:
                 for pr in prevs:
                     if pr == p:
                         c.append(self.node(r))
             elif p == nullrev:
                 c.append(self.node(r))
         return c
 
     def commonancestorsheads(self, a, b):
         """calculate all the heads of the common ancestors of nodes a and b"""
         a, b = self.rev(a), self.rev(b)
         ancs = self._commonancestorsheads(a, b)
         return pycompat.maplist(self.node, ancs)
 
     def _commonancestorsheads(self, *revs):
         """calculate all the heads of the common ancestors of revs"""
         try:
             ancs = self.index.commonancestorsheads(*revs)
         except (AttributeError, OverflowError):  # C implementation failed
             ancs = ancestor.commonancestorsheads(self.parentrevs, *revs)
         return ancs
 
     def isancestor(self, a, b):
         """return True if node a is an ancestor of node b
 
         A revision is considered an ancestor of itself."""
         a, b = self.rev(a), self.rev(b)
         return self.isancestorrev(a, b)
 
     def isancestorrev(self, a, b):
         """return True if revision a is an ancestor of revision b
 
         A revision is considered an ancestor of itself.
 
         The implementation of this is trivial but the use of
         reachableroots is not."""
         if a == nullrev:
             return True
         elif a == b:
             return True
         elif a > b:
             return False
         return bool(self.reachableroots(a, [b], [a], includepath=False))
 
     def reachableroots(self, minroot, heads, roots, includepath=False):
         """return (heads(::(<roots> and <roots>::<heads>)))
 
         If includepath is True, return (<roots>::<heads>)."""
         try:
             return self.index.reachableroots2(
                 minroot, heads, roots, includepath
             )
         except AttributeError:
             return dagop._reachablerootspure(
                 self.parentrevs, minroot, roots, heads, includepath
             )
 
     def ancestor(self, a, b):
         """calculate the "best" common ancestor of nodes a and b"""
 
         a, b = self.rev(a), self.rev(b)
         try:
             ancs = self.index.ancestors(a, b)
         except (AttributeError, OverflowError):
             ancs = ancestor.ancestors(self.parentrevs, a, b)
         if ancs:
             # choose a consistent winner when there's a tie
             return min(map(self.node, ancs))
         return self.nullid
 
     def _match(self, id):
         if isinstance(id, int):
             # rev
             return self.node(id)
         if len(id) == self.nodeconstants.nodelen:
             # possibly a binary node
             # odds of a binary node being all hex in ASCII are 1 in 10**25
             try:
                 node = id
                 self.rev(node)  # quick search the index
                 return node
             except error.LookupError:
                 pass  # may be partial hex id
         try:
             # str(rev)
             rev = int(id)
             if b"%d" % rev != id:
                 raise ValueError
             if rev < 0:
                 rev = len(self) + rev
             if rev < 0 or rev >= len(self):
                 raise ValueError
             return self.node(rev)
         except (ValueError, OverflowError):
             pass
         if len(id) == 2 * self.nodeconstants.nodelen:
             try:
                 # a full hex nodeid?
                 node = bin(id)
                 self.rev(node)
                 return node
             except (binascii.Error, error.LookupError):
                 pass
 
     def _partialmatch(self, id):
         # we don't care wdirfilenodeids as they should be always full hash
         maybewdir = self.nodeconstants.wdirhex.startswith(id)
         ambiguous = False
         try:
             partial = self.index.partialmatch(id)
             if partial and self.hasnode(partial):
                 if maybewdir:
                     # single 'ff...' match in radix tree, ambiguous with wdir
                     ambiguous = True
                 else:
                     return partial
             elif maybewdir:
                 # no 'ff...' match in radix tree, wdir identified
                 raise error.WdirUnsupported
             else:
                 return None
         except error.RevlogError:
             # parsers.c radix tree lookup gave multiple matches
             # fast path: for unfiltered changelog, radix tree is accurate
             if not getattr(self, 'filteredrevs', None):
                 ambiguous = True
             # fall through to slow path that filters hidden revisions
         except (AttributeError, ValueError):
             # we are pure python, or key is not hex
             pass
         if ambiguous:
             raise error.AmbiguousPrefixLookupError(
                 id, self.display_id, _(b'ambiguous identifier')
             )
 
         if id in self._pcache:
             return self._pcache[id]
 
         if len(id) <= 40:
             # hex(node)[:...]
             l = len(id) // 2 * 2  # grab an even number of digits
             try:
                 # we're dropping the last digit, so let's check that it's hex,
                 # to avoid the expensive computation below if it's not
                 if len(id) % 2 > 0:
                     if not (id[-1] in hexdigits):
                         return None
                 prefix = bin(id[:l])
             except binascii.Error:
                 pass
             else:
                 nl = [e[7] for e in self.index if e[7].startswith(prefix)]
                 nl = [
                     n for n in nl if hex(n).startswith(id) and self.hasnode(n)
                 ]
                 if self.nodeconstants.nullhex.startswith(id):
                     nl.append(self.nullid)
                 if len(nl) > 0:
                     if len(nl) == 1 and not maybewdir:
                         self._pcache[id] = nl[0]
                         return nl[0]
                     raise error.AmbiguousPrefixLookupError(
                         id, self.display_id, _(b'ambiguous identifier')
                     )
                 if maybewdir:
                     raise error.WdirUnsupported
                 return None
 
     def lookup(self, id):
         """locate a node based on:
         - revision number or str(revision number)
         - nodeid or subset of hex nodeid
         """
         n = self._match(id)
         if n is not None:
             return n
         n = self._partialmatch(id)
         if n:
             return n
 
         raise error.LookupError(id, self.display_id, _(b'no match found'))
 
     def shortest(self, node, minlength=1):
         """Find the shortest unambiguous prefix that matches node."""
 
         def isvalid(prefix):
             try:
                 matchednode = self._partialmatch(prefix)
             except error.AmbiguousPrefixLookupError:
                 return False
             except error.WdirUnsupported:
                 # single 'ff...' match
                 return True
             if matchednode is None:
                 raise error.LookupError(node, self.display_id, _(b'no node'))
             return True
 
         def maybewdir(prefix):
             return all(c == b'f' for c in pycompat.iterbytestr(prefix))
 
         hexnode = hex(node)
 
         def disambiguate(hexnode, minlength):
             """Disambiguate against wdirid."""
             for length in range(minlength, len(hexnode) + 1):
                 prefix = hexnode[:length]
                 if not maybewdir(prefix):
                     return prefix
 
         if not getattr(self, 'filteredrevs', None):
             try:
                 length = max(self.index.shortest(node), minlength)
                 return disambiguate(hexnode, length)
             except error.RevlogError:
                 if node != self.nodeconstants.wdirid:
                     raise error.LookupError(
                         node, self.display_id, _(b'no node')
                     )
             except AttributeError:
                 # Fall through to pure code
                 pass
 
         if node == self.nodeconstants.wdirid:
             for length in range(minlength, len(hexnode) + 1):
                 prefix = hexnode[:length]
                 if isvalid(prefix):
                     return prefix
 
         for length in range(minlength, len(hexnode) + 1):
             prefix = hexnode[:length]
             if isvalid(prefix):
                 return disambiguate(hexnode, length)
 
     def cmp(self, node, text):
         """compare text with a given file revision
 
         returns True if text is different than what is stored.
         """
         p1, p2 = self.parents(node)
         return storageutil.hashrevisionsha1(text, p1, p2) != node
 
     def _getsegmentforrevs(self, startrev, endrev, df=None):
         """Obtain a segment of raw data corresponding to a range of revisions.
 
         Accepts the start and end revisions and an optional already-open
         file handle to be used for reading. If the file handle is read, its
         seek position will not be preserved.
 
         Requests for data may be satisfied by a cache.
 
         Returns a 2-tuple of (offset, data) for the requested range of
         revisions. Offset is the integer offset from the beginning of the
         revlog and data is a str or buffer of the raw byte data.
 
         Callers will need to call ``self.start(rev)`` and ``self.length(rev)``
         to determine where each revision's data begins and ends.
         """
         # Inlined self.start(startrev) & self.end(endrev) for perf reasons
         # (functions are expensive).
         index = self.index
         istart = index[startrev]
         start = int(istart[0] >> 16)
         if startrev == endrev:
             end = start + istart[1]
         else:
             iend = index[endrev]
             end = int(iend[0] >> 16) + iend[1]
 
         if self._inline:
             start += (startrev + 1) * self.index.entry_size
             end += (endrev + 1) * self.index.entry_size
         length = end - start
 
         return start, self._segmentfile.read_chunk(start, length, df)
 
     def _chunk(self, rev, df=None):
         """Obtain a single decompressed chunk for a revision.
 
         Accepts an integer revision and an optional already-open file handle
         to be used for reading. If used, the seek position of the file will not
         be preserved.
 
         Returns a str holding uncompressed data for the requested revision.
         """
         compression_mode = self.index[rev][10]
         data = self._getsegmentforrevs(rev, rev, df=df)[1]
         if compression_mode == COMP_MODE_PLAIN:
             return data
         elif compression_mode == COMP_MODE_DEFAULT:
             return self._decompressor(data)
         elif compression_mode == COMP_MODE_INLINE:
             return self.decompress(data)
         else:
             msg = b'unknown compression mode %d'
             msg %= compression_mode
             raise error.RevlogError(msg)
 
     def _chunks(self, revs, df=None, targetsize=None):
         """Obtain decompressed chunks for the specified revisions.
 
         Accepts an iterable of numeric revisions that are assumed to be in
         ascending order. Also accepts an optional already-open file handle
         to be used for reading. If used, the seek position of the file will
         not be preserved.
 
         This function is similar to calling ``self._chunk()`` multiple times,
         but is faster.
 
         Returns a list with decompressed data for each requested revision.
         """
         if not revs:
             return []
         start = self.start
         length = self.length
         inline = self._inline
         iosize = self.index.entry_size
         buffer = util.buffer
 
         l = []
         ladd = l.append
 
         if not self._withsparseread:
             slicedchunks = (revs,)
         else:
             slicedchunks = deltautil.slicechunk(
                 self, revs, targetsize=targetsize
             )
 
         for revschunk in slicedchunks:
             firstrev = revschunk[0]
             # Skip trailing revisions with empty diff
             for lastrev in revschunk[::-1]:
                 if length(lastrev) != 0:
                     break
 
             try:
                 offset, data = self._getsegmentforrevs(firstrev, lastrev, df=df)
             except OverflowError:
                 # issue4215 - we can't cache a run of chunks greater than
                 # 2G on Windows
                 return [self._chunk(rev, df=df) for rev in revschunk]
 
             decomp = self.decompress
             # self._decompressor might be None, but will not be used in that case
             def_decomp = self._decompressor
             for rev in revschunk:
                 chunkstart = start(rev)
                 if inline:
                     chunkstart += (rev + 1) * iosize
                 chunklength = length(rev)
                 comp_mode = self.index[rev][10]
                 c = buffer(data, chunkstart - offset, chunklength)
                 if comp_mode == COMP_MODE_PLAIN:
                     ladd(c)
                 elif comp_mode == COMP_MODE_INLINE:
                     ladd(decomp(c))
                 elif comp_mode == COMP_MODE_DEFAULT:
                     ladd(def_decomp(c))
                 else:
                     msg = b'unknown compression mode %d'
                     msg %= comp_mode
                     raise error.RevlogError(msg)
 
         return l
 
     def deltaparent(self, rev):
         """return deltaparent of the given revision"""
         base = self.index[rev][3]
         if base == rev:
             return nullrev
         elif self._generaldelta:
             return base
         else:
             return rev - 1
 
     def issnapshot(self, rev):
         """tells whether rev is a snapshot"""
         if not self._sparserevlog:
             return self.deltaparent(rev) == nullrev
         elif util.safehasattr(self.index, b'issnapshot'):
             # directly assign the method to cache the testing and access
             self.issnapshot = self.index.issnapshot
             return self.issnapshot(rev)
         if rev == nullrev:
             return True
         entry = self.index[rev]
         base = entry[3]
         if base == rev:
             return True
         if base == nullrev:
             return True
         p1 = entry[5]
         while self.length(p1) == 0:
             b = self.deltaparent(p1)
             if b == p1:
                 break
             p1 = b
         p2 = entry[6]
         while self.length(p2) == 0:
             b = self.deltaparent(p2)
             if b == p2:
                 break
             p2 = b
         if base == p1 or base == p2:
             return False
         return self.issnapshot(base)
 
     def snapshotdepth(self, rev):
         """number of snapshot in the chain before this one"""
         if not self.issnapshot(rev):
             raise error.ProgrammingError(b'revision %d not a snapshot')
         return len(self._deltachain(rev)[0]) - 1
 
     def revdiff(self, rev1, rev2):
         """return or calculate a delta between two revisions
 
         The delta calculated is in binary form and is intended to be written to
         revlog data directly. So this function needs raw revision data.
         """
         if rev1 != nullrev and self.deltaparent(rev2) == rev1:
             return bytes(self._chunk(rev2))
 
         return mdiff.textdiff(self.rawdata(rev1), self.rawdata(rev2))
 
     def revision(self, nodeorrev, _df=None):
         """return an uncompressed revision of a given node or revision
         number.
 
         _df - an existing file handle to read from. (internal-only)
         """
         return self._revisiondata(nodeorrev, _df)
 
     def sidedata(self, nodeorrev, _df=None):
         """a map of extra data related to the changeset but not part of the hash
 
         This function currently return a dictionary. However, more advanced
         mapping object will likely be used in the future for a more
         efficient/lazy code.
         """
         # deal with <nodeorrev> argument type
         if isinstance(nodeorrev, int):
             rev = nodeorrev
         else:
             rev = self.rev(nodeorrev)
         return self._sidedata(rev)
 
     def _revisiondata(self, nodeorrev, _df=None, raw=False):
         # deal with <nodeorrev> argument type
         if isinstance(nodeorrev, int):
             rev = nodeorrev
             node = self.node(rev)
         else:
             node = nodeorrev
             rev = None
 
         # fast path the special `nullid` rev
         if node == self.nullid:
             return b""
 
         # ``rawtext`` is the text as stored inside the revlog. Might be the
         # revision or might need to be processed to retrieve the revision.
         rev, rawtext, validated = self._rawtext(node, rev, _df=_df)
 
         if raw and validated:
             # if we don't want to process the raw text and that raw
             # text is cached, we can exit early.
             return rawtext
         if rev is None:
             rev = self.rev(node)
         # the revlog's flag for this revision
         # (usually alter its state or content)
         flags = self.flags(rev)
 
         if validated and flags == REVIDX_DEFAULT_FLAGS:
             # no extra flags set, no flag processor runs, text = rawtext
             return rawtext
 
         if raw:
             validatehash = flagutil.processflagsraw(self, rawtext, flags)
             text = rawtext
         else:
             r = flagutil.processflagsread(self, rawtext, flags)
             text, validatehash = r
         if validatehash:
             self.checkhash(text, node, rev=rev)
         if not validated:
             self._revisioncache = (node, rev, rawtext)
 
         return text
 
     def _rawtext(self, node, rev, _df=None):
         """return the possibly unvalidated rawtext for a revision
 
         returns (rev, rawtext, validated)
         """
 
         # revision in the cache (could be useful to apply delta)
         cachedrev = None
         # An intermediate text to apply deltas to
         basetext = None
 
         # Check if we have the entry in cache
         # The cache entry looks like (node, rev, rawtext)
         if self._revisioncache:
             if self._revisioncache[0] == node:
                 return (rev, self._revisioncache[2], True)
             cachedrev = self._revisioncache[1]
 
         if rev is None:
             rev = self.rev(node)
 
         chain, stopped = self._deltachain(rev, stoprev=cachedrev)
         if stopped:
             basetext = self._revisioncache[2]
 
         # drop cache to save memory, the caller is expected to
         # update self._revisioncache after validating the text
         self._revisioncache = None
 
         targetsize = None
         rawsize = self.index[rev][2]
         if 0 <= rawsize:
             targetsize = 4 * rawsize
 
         bins = self._chunks(chain, df=_df, targetsize=targetsize)
         if basetext is None:
             basetext = bytes(bins[0])
             bins = bins[1:]
 
         rawtext = mdiff.patches(basetext, bins)
         del basetext  # let us have a chance to free memory early
         return (rev, rawtext, False)
 
     def _sidedata(self, rev):
         """Return the sidedata for a given revision number."""
         index_entry = self.index[rev]
         sidedata_offset = index_entry[8]
         sidedata_size = index_entry[9]
 
         if self._inline:
             sidedata_offset += self.index.entry_size * (1 + rev)
         if sidedata_size == 0:
             return {}
 
         if self._docket.sidedata_end < sidedata_offset + sidedata_size:
             filename = self._sidedatafile
             end = self._docket.sidedata_end
             offset = sidedata_offset
             length = sidedata_size
             m = FILE_TOO_SHORT_MSG % (filename, length, offset, end)
             raise error.RevlogError(m)
 
         comp_segment = self._segmentfile_sidedata.read_chunk(
             sidedata_offset, sidedata_size
         )
 
         comp = self.index[rev][11]
         if comp == COMP_MODE_PLAIN:
             segment = comp_segment
         elif comp == COMP_MODE_DEFAULT:
             segment = self._decompressor(comp_segment)
         elif comp == COMP_MODE_INLINE:
             segment = self.decompress(comp_segment)
         else:
             msg = b'unknown compression mode %d'
             msg %= comp
             raise error.RevlogError(msg)
 
         sidedata = sidedatautil.deserialize_sidedata(segment)
         return sidedata
 
     def rawdata(self, nodeorrev, _df=None):
         """return an uncompressed raw data of a given node or revision number.
 
         _df - an existing file handle to read from. (internal-only)
         """
         return self._revisiondata(nodeorrev, _df, raw=True)
 
     def hash(self, text, p1, p2):
         """Compute a node hash.
 
         Available as a function so that subclasses can replace the hash
         as needed.
         """
         return storageutil.hashrevisionsha1(text, p1, p2)
 
     def checkhash(self, text, node, p1=None, p2=None, rev=None):
         """Check node hash integrity.
 
         Available as a function so that subclasses can extend hash mismatch
         behaviors as needed.
         """
         try:
             if p1 is None and p2 is None:
                 p1, p2 = self.parents(node)
             if node != self.hash(text, p1, p2):
                 # Clear the revision cache on hash failure. The revision cache
                 # only stores the raw revision and clearing the cache does have
                 # the side-effect that we won't have a cache hit when the raw
                 # revision data is accessed. But this case should be rare and
                 # it is extra work to teach the cache about the hash
                 # verification state.
                 if self._revisioncache and self._revisioncache[0] == node:
                     self._revisioncache = None
 
                 revornode = rev
                 if revornode is None:
                     revornode = templatefilters.short(hex(node))
                 raise error.RevlogError(
                     _(b"integrity check failed on %s:%s")
                     % (self.display_id, pycompat.bytestr(revornode))
                 )
         except error.RevlogError:
             if self._censorable and storageutil.iscensoredtext(text):
                 raise error.CensoredNodeError(self.display_id, node, text)
             raise
 
     def _enforceinlinesize(self, tr):
         """Check if the revlog is too big for inline and convert if so.
 
         This should be called after revisions are added to the revlog. If the
         revlog has grown too large to be an inline revlog, it will convert it
         to use multiple index and data files.
         """
         tiprev = len(self) - 1
         total_size = self.start(tiprev) + self.length(tiprev)
         if not self._inline or total_size < _maxinline:
             return
 
         troffset = tr.findoffset(self._indexfile)
         if troffset is None:
             raise error.RevlogError(
                 _(b"%s not found in the transaction") % self._indexfile
             )
         trindex = None
         tr.add(self._datafile, 0)
 
         existing_handles = False
         if self._writinghandles is not None:
             existing_handles = True
             fp = self._writinghandles[0]
             fp.flush()
             fp.close()
             # We can't use the cached file handle after close(). So prevent
             # its usage.
             self._writinghandles = None
             self._segmentfile.writing_handle = None
             # No need to deal with sidedata writing handle as it is only
             # relevant with revlog-v2 which is never inline, not reaching
             # this code
 
         new_dfh = self._datafp(b'w+')
         new_dfh.truncate(0)  # drop any potentially existing data
         try:
             with self._indexfp() as read_ifh:
                 for r in self:
                     new_dfh.write(self._getsegmentforrevs(r, r, df=read_ifh)[1])
                     if (
                         trindex is None
                         and troffset
                         <= self.start(r) + r * self.index.entry_size
                     ):
                         trindex = r
                 new_dfh.flush()
 
             if trindex is None:
                 trindex = 0
 
             with self.__index_new_fp() as fp:
                 self._format_flags &= ~FLAG_INLINE_DATA
                 self._inline = False
                 for i in self:
                     e = self.index.entry_binary(i)
                     if i == 0 and self._docket is None:
                         header = self._format_flags | self._format_version
                         header = self.index.pack_header(header)
                         e = header + e
                     fp.write(e)
                 if self._docket is not None:
                     self._docket.index_end = fp.tell()
 
                 # There is a small transactional race here. If the rename of
                 # the index fails, we should remove the datafile. It is more
                 # important to ensure that the data file is not truncated
                 # when the index is replaced as otherwise data is lost.
                 tr.replace(self._datafile, self.start(trindex))
 
                 # the temp file replace the real index when we exit the context
                 # manager
 
             tr.replace(self._indexfile, trindex * self.index.entry_size)
             nodemaputil.setup_persistent_nodemap(tr, self)
             self._segmentfile = randomaccessfile.randomaccessfile(
                 self.opener,
                 self._datafile,
                 self._chunkcachesize,
             )
 
             if existing_handles:
                 # switched from inline to conventional reopen the index
                 ifh = self.__index_write_fp()
                 self._writinghandles = (ifh, new_dfh, None)
                 self._segmentfile.writing_handle = new_dfh
                 new_dfh = None
                 # No need to deal with sidedata writing handle as it is only
                 # relevant with revlog-v2 which is never inline, not reaching
                 # this code
         finally:
             if new_dfh is not None:
                 new_dfh.close()
 
     def _nodeduplicatecallback(self, transaction, node):
         """called when trying to add a node already stored."""
 
     @contextlib.contextmanager
     def reading(self):
         """Context manager that keeps data and sidedata files open for reading"""
         with self._segmentfile.reading():
             with self._segmentfile_sidedata.reading():
                 yield
 
     @contextlib.contextmanager
     def _writing(self, transaction):
         if self._trypending:
             msg = b'try to write in a `trypending` revlog: %s'
             msg %= self.display_id
             raise error.ProgrammingError(msg)
         if self._writinghandles is not None:
             yield
         else:
             ifh = dfh = sdfh = None
             try:
                 r = len(self)
                 # opening the data file.
                 dsize = 0
                 if r:
                     dsize = self.end(r - 1)
                 dfh = None
                 if not self._inline:
                     try:
                         dfh = self._datafp(b"r+")
                         if self._docket is None:
                             dfh.seek(0, os.SEEK_END)
                         else:
                             dfh.seek(self._docket.data_end, os.SEEK_SET)
                     except FileNotFoundError:
                         dfh = self._datafp(b"w+")
                     transaction.add(self._datafile, dsize)
                 if self._sidedatafile is not None:
                     # revlog-v2 does not inline, help Pytype
                     assert dfh is not None
                     try:
                         sdfh = self.opener(self._sidedatafile, mode=b"r+")
                         dfh.seek(self._docket.sidedata_end, os.SEEK_SET)
                     except FileNotFoundError:
                         sdfh = self.opener(self._sidedatafile, mode=b"w+")
                     transaction.add(
                         self._sidedatafile, self._docket.sidedata_end
                     )
 
                 # opening the index file.
                 isize = r * self.index.entry_size
                 ifh = self.__index_write_fp()
                 if self._inline:
                     transaction.add(self._indexfile, dsize + isize)
                 else:
                     transaction.add(self._indexfile, isize)
                 # exposing all file handle for writing.
                 self._writinghandles = (ifh, dfh, sdfh)
                 self._segmentfile.writing_handle = ifh if self._inline else dfh
                 self._segmentfile_sidedata.writing_handle = sdfh
                 yield
                 if self._docket is not None:
                     self._write_docket(transaction)
             finally:
                 self._writinghandles = None
                 self._segmentfile.writing_handle = None
                 self._segmentfile_sidedata.writing_handle = None
                 if dfh is not None:
                     dfh.close()
                 if sdfh is not None:
                     sdfh.close()
                 # closing the index file last to avoid exposing referent to
                 # potential unflushed data content.
                 if ifh is not None:
                     ifh.close()
 
     def _write_docket(self, transaction):
         """write the current docket on disk
 
         Exist as a method to help changelog to implement transaction logic
 
         We could also imagine using the same transaction logic for all revlog
         since docket are cheap."""
         self._docket.write(transaction)
 
     def addrevision(
         self,
         text,
         transaction,
         link,
         p1,
         p2,
         cachedelta=None,
         node=None,
         flags=REVIDX_DEFAULT_FLAGS,
         deltacomputer=None,
         sidedata=None,
     ):
         """add a revision to the log
 
         text - the revision data to add
         transaction - the transaction object used for rollback
         link - the linkrev data to add
         p1, p2 - the parent nodeids of the revision
         cachedelta - an optional precomputed delta
         node - nodeid of revision; typically node is not specified, and it is
             computed by default as hash(text, p1, p2), however subclasses might
             use different hashing method (and override checkhash() in such case)
         flags - the known flags to set on the revision
         deltacomputer - an optional deltacomputer instance shared between
             multiple calls
         """
         if link == nullrev:
             raise error.RevlogError(
                 _(b"attempted to add linkrev -1 to %s") % self.display_id
             )
 
         if sidedata is None:
             sidedata = {}
         elif sidedata and not self.hassidedata:
             raise error.ProgrammingError(
                 _(b"trying to add sidedata to a revlog who don't support them")
             )
 
         if flags:
             node = node or self.hash(text, p1, p2)
 
         rawtext, validatehash = flagutil.processflagswrite(self, text, flags)
 
         # If the flag processor modifies the revision data, ignore any provided
         # cachedelta.
         if rawtext != text:
             cachedelta = None
 
         if len(rawtext) > _maxentrysize:
             raise error.RevlogError(
                 _(
                     b"%s: size of %d bytes exceeds maximum revlog storage of 2GiB"
                 )
                 % (self.display_id, len(rawtext))
             )
 
         node = node or self.hash(rawtext, p1, p2)
         rev = self.index.get_rev(node)
         if rev is not None:
             return rev
 
         if validatehash:
             self.checkhash(rawtext, node, p1=p1, p2=p2)
 
         return self.addrawrevision(
             rawtext,
             transaction,
             link,
             p1,
             p2,
             node,
             flags,
             cachedelta=cachedelta,
             deltacomputer=deltacomputer,
             sidedata=sidedata,
         )
 
     def addrawrevision(
         self,
         rawtext,
         transaction,
         link,
         p1,
         p2,
         node,
         flags,
         cachedelta=None,
         deltacomputer=None,
         sidedata=None,
     ):
         """add a raw revision with known flags, node and parents
         useful when reusing a revision not stored in this revlog (ex: received
         over wire, or read from an external bundle).
         """
         with self._writing(transaction):
             return self._addrevision(
                 node,
                 rawtext,
                 transaction,
                 link,
                 p1,
                 p2,
                 flags,
                 cachedelta,
                 deltacomputer=deltacomputer,
                 sidedata=sidedata,
             )
 
     def compress(self, data):
         """Generate a possibly-compressed representation of data."""
         if not data:
             return b'', data
 
         compressed = self._compressor.compress(data)
 
         if compressed:
             # The revlog compressor added the header in the returned data.
             return b'', compressed
 
         if data[0:1] == b'\0':
             return b'', data
         return b'u', data
 
     def decompress(self, data):
         """Decompress a revlog chunk.
 
         The chunk is expected to begin with a header identifying the
         format type so it can be routed to an appropriate decompressor.
         """
         if not data:
             return data
 
         # Revlogs are read much more frequently than they are written and many
         # chunks only take microseconds to decompress, so performance is
         # important here.
         #
         # We can make a few assumptions about revlogs:
         #
         # 1) the majority of chunks will be compressed (as opposed to inline
         #    raw data).
         # 2) decompressing *any* data will likely by at least 10x slower than
         #    returning raw inline data.
         # 3) we want to prioritize common and officially supported compression
         #    engines
         #
         # It follows that we want to optimize for "decompress compressed data
         # when encoded with common and officially supported compression engines"
         # case over "raw data" and "data encoded by less common or non-official
         # compression engines." That is why we have the inline lookup first
         # followed by the compengines lookup.
         #
         # According to `hg perfrevlogchunks`, this is ~0.5% faster for zlib
         # compressed chunks. And this matters for changelog and manifest reads.
         t = data[0:1]
 
         if t == b'x':
             try:
                 return _zlibdecompress(data)
             except zlib.error as e:
                 raise error.RevlogError(
                     _(b'revlog decompress error: %s')
                     % stringutil.forcebytestr(e)
                 )
         # '\0' is more common than 'u' so it goes first.
         elif t == b'\0':
             return data
         elif t == b'u':
             return util.buffer(data, 1)
 
         compressor = self._get_decompressor(t)
 
         return compressor.decompress(data)
 
     def _addrevision(
         self,
         node,
         rawtext,
         transaction,
         link,
         p1,
         p2,
         flags,
         cachedelta,
         alwayscache=False,
         deltacomputer=None,
         sidedata=None,
     ):
         """internal function to add revisions to the log
 
         see addrevision for argument descriptions.
 
         note: "addrevision" takes non-raw text, "_addrevision" takes raw text.
 
         if "deltacomputer" is not provided or None, a defaultdeltacomputer will
         be used.
 
         invariants:
         - rawtext is optional (can be None); if not set, cachedelta must be set.
           if both are set, they must correspond to each other.
         """
         if node == self.nullid:
             raise error.RevlogError(
                 _(b"%s: attempt to add null revision") % self.display_id
             )
         if (
             node == self.nodeconstants.wdirid
             or node in self.nodeconstants.wdirfilenodeids
         ):
             raise error.RevlogError(
                 _(b"%s: attempt to add wdir revision") % self.display_id
             )
         if self._writinghandles is None:
             msg = b'adding revision outside `revlog._writing` context'
             raise error.ProgrammingError(msg)
 
         if self._inline:
             fh = self._writinghandles[0]
         else:
             fh = self._writinghandles[1]
 
         btext = [rawtext]
 
         curr = len(self)
         prev = curr - 1
 
         offset = self._get_data_offset(prev)
 
         if self._concurrencychecker:
             ifh, dfh, sdfh = self._writinghandles
             # XXX no checking for the sidedata file
             if self._inline:
                 # offset is "as if" it were in the .d file, so we need to add on
                 # the size of the entry metadata.
                 self._concurrencychecker(
                     ifh, self._indexfile, offset + curr * self.index.entry_size
                 )
             else:
                 # Entries in the .i are a consistent size.
                 self._concurrencychecker(
                     ifh, self._indexfile, curr * self.index.entry_size
                 )
                 self._concurrencychecker(dfh, self._datafile, offset)
 
         p1r, p2r = self.rev(p1), self.rev(p2)
 
         # full versions are inserted when the needed deltas
         # become comparable to the uncompressed text
         if rawtext is None:
             # need rawtext size, before changed by flag processors, which is
             # the non-raw size. use revlog explicitly to avoid filelog's extra
             # logic that might remove metadata size.
             textlen = mdiff.patchedsize(
                 revlog.size(self, cachedelta[0]), cachedelta[1]
             )
         else:
             textlen = len(rawtext)
 
         if deltacomputer is None:
             write_debug = None
             if self._debug_delta:
                 write_debug = transaction._report
             deltacomputer = deltautil.deltacomputer(
                 self, write_debug=write_debug
             )
 
         revinfo = revlogutils.revisioninfo(
             node,
             p1,
             p2,
             btext,
             textlen,
             cachedelta,
             flags,
         )
 
         deltainfo = deltacomputer.finddeltainfo(revinfo, fh)
 
         compression_mode = COMP_MODE_INLINE
         if self._docket is not None:
             default_comp = self._docket.default_compression_header
             r = deltautil.delta_compression(default_comp, deltainfo)
             compression_mode, deltainfo = r
 
         sidedata_compression_mode = COMP_MODE_INLINE
         if sidedata and self.hassidedata:
             sidedata_compression_mode = COMP_MODE_PLAIN
             serialized_sidedata = sidedatautil.serialize_sidedata(sidedata)
             sidedata_offset = self._docket.sidedata_end
             h, comp_sidedata = self.compress(serialized_sidedata)
             if (
                 h != b'u'
                 and comp_sidedata[0:1] != b'\0'
                 and len(comp_sidedata) < len(serialized_sidedata)
             ):
                 assert not h
                 if (
                     comp_sidedata[0:1]
                     == self._docket.default_compression_header
                 ):
                     sidedata_compression_mode = COMP_MODE_DEFAULT
                     serialized_sidedata = comp_sidedata
                 else:
                     sidedata_compression_mode = COMP_MODE_INLINE
                     serialized_sidedata = comp_sidedata
         else:
             serialized_sidedata = b""
             # Don't store the offset if the sidedata is empty, that way
             # we can easily detect empty sidedata and they will be no different
             # than ones we manually add.
             sidedata_offset = 0
 
         rank = RANK_UNKNOWN
         if self._format_version == CHANGELOGV2:
             if (p1r, p2r) == (nullrev, nullrev):
                 rank = 1
             elif p1r != nullrev and p2r == nullrev:
                 rank = 1 + self.fast_rank(p1r)
             elif p1r == nullrev and p2r != nullrev:
                 rank = 1 + self.fast_rank(p2r)
             else:  # merge node
                 if rustdagop is not None and self.index.rust_ext_compat:
                     rank = rustdagop.rank(self.index, p1r, p2r)
                 else:
                     pmin, pmax = sorted((p1r, p2r))
                     rank = 1 + self.fast_rank(pmax)
                     rank += sum(1 for _ in self.findmissingrevs([pmax], [pmin]))
 
         e = revlogutils.entry(
             flags=flags,
             data_offset=offset,
             data_compressed_length=deltainfo.deltalen,
             data_uncompressed_length=textlen,
             data_compression_mode=compression_mode,
             data_delta_base=deltainfo.base,
             link_rev=link,
             parent_rev_1=p1r,
             parent_rev_2=p2r,
             node_id=node,
             sidedata_offset=sidedata_offset,
             sidedata_compressed_length=len(serialized_sidedata),
             sidedata_compression_mode=sidedata_compression_mode,
             rank=rank,
         )
 
         self.index.append(e)
         entry = self.index.entry_binary(curr)
         if curr == 0 and self._docket is None:
             header = self._format_flags | self._format_version
             header = self.index.pack_header(header)
             entry = header + entry
         self._writeentry(
             transaction,
             entry,
             deltainfo.data,
             link,
             offset,
             serialized_sidedata,
             sidedata_offset,
         )
 
         rawtext = btext[0]
 
         if alwayscache and rawtext is None:
             rawtext = deltacomputer.buildtext(revinfo, fh)
 
         if type(rawtext) == bytes:  # only accept immutable objects
             self._revisioncache = (node, curr, rawtext)
         self._chainbasecache[curr] = deltainfo.chainbase
         return curr
 
     def _get_data_offset(self, prev):
         """Returns the current offset in the (in-transaction) data file.
         Versions < 2 of the revlog can get this 0(1), revlog v2 needs a docket
         file to store that information: since sidedata can be rewritten to the
         end of the data file within a transaction, you can have cases where, for
         example, rev `n` does not have sidedata while rev `n - 1` does, leading
         to `n - 1`'s sidedata being written after `n`'s data.
 
         TODO cache this in a docket file before getting out of experimental."""
         if self._docket is None:
             return self.end(prev)
         else:
             return self._docket.data_end
 
     def _writeentry(
         self, transaction, entry, data, link, offset, sidedata, sidedata_offset
     ):
         # Files opened in a+ mode have inconsistent behavior on various
         # platforms. Windows requires that a file positioning call be made
         # when the file handle transitions between reads and writes. See
         # 3686fa2b8eee and the mixedfilemodewrapper in windows.py. On other
         # platforms, Python or the platform itself can be buggy. Some versions
         # of Solaris have been observed to not append at the end of the file
         # if the file was seeked to before the end. See issue4943 for more.
         #
         # We work around this issue by inserting a seek() before writing.
         # Note: This is likely not necessary on Python 3. However, because
         # the file handle is reused for reads and may be seeked there, we need
         # to be careful before changing this.
         if self._writinghandles is None:
             msg = b'adding revision outside `revlog._writing` context'
             raise error.ProgrammingError(msg)
         ifh, dfh, sdfh = self._writinghandles
         if self._docket is None:
             ifh.seek(0, os.SEEK_END)
         else:
             ifh.seek(self._docket.index_end, os.SEEK_SET)
         if dfh:
             if self._docket is None:
                 dfh.seek(0, os.SEEK_END)
             else:
                 dfh.seek(self._docket.data_end, os.SEEK_SET)
         if sdfh:
             sdfh.seek(self._docket.sidedata_end, os.SEEK_SET)
 
         curr = len(self) - 1
         if not self._inline:
             transaction.add(self._datafile, offset)
             if self._sidedatafile:
                 transaction.add(self._sidedatafile, sidedata_offset)
             transaction.add(self._indexfile, curr * len(entry))
             if data[0]:
                 dfh.write(data[0])
             dfh.write(data[1])
             if sidedata:
                 sdfh.write(sidedata)
             ifh.write(entry)
         else:
             offset += curr * self.index.entry_size
             transaction.add(self._indexfile, offset)
             ifh.write(entry)
             ifh.write(data[0])
             ifh.write(data[1])
             assert not sidedata
             self._enforceinlinesize(transaction)
         if self._docket is not None:
             # revlog-v2 always has 3 writing handles, help Pytype
             wh1 = self._writinghandles[0]
             wh2 = self._writinghandles[1]
             wh3 = self._writinghandles[2]
             assert wh1 is not None
             assert wh2 is not None
             assert wh3 is not None
             self._docket.index_end = wh1.tell()
             self._docket.data_end = wh2.tell()
             self._docket.sidedata_end = wh3.tell()
 
         nodemaputil.setup_persistent_nodemap(transaction, self)
 
     def addgroup(
         self,
         deltas,
         linkmapper,
         transaction,
         alwayscache=False,
         addrevisioncb=None,
         duplicaterevisioncb=None,
+        debug_info=None,
     ):
         """
         add a delta group
 
         given a set of deltas, add them to the revision log. the
         first delta is against its parent, which should be in our
         log, the rest are against the previous delta.
 
         If ``addrevisioncb`` is defined, it will be called with arguments of
         this revlog and the node that was added.
         """
 
         if self._adding_group:
             raise error.ProgrammingError(b'cannot nest addgroup() calls')
 
         self._adding_group = True
         empty = True
         try:
             with self._writing(transaction):
                 write_debug = None
                 if self._debug_delta:
                     write_debug = transaction._report
                 deltacomputer = deltautil.deltacomputer(
                     self,
                     write_debug=write_debug,
+                    debug_info=debug_info,
                 )
                 # loop through our set of deltas
                 for data in deltas:
                     (
                         node,
                         p1,
                         p2,
                         linknode,
                         deltabase,
                         delta,
                         flags,
                         sidedata,
                     ) = data
                     link = linkmapper(linknode)
                     flags = flags or REVIDX_DEFAULT_FLAGS
 
                     rev = self.index.get_rev(node)
                     if rev is not None:
                         # this can happen if two branches make the same change
                         self._nodeduplicatecallback(transaction, rev)
                         if duplicaterevisioncb:
                             duplicaterevisioncb(self, rev)
                         empty = False
                         continue
 
                     for p in (p1, p2):
                         if not self.index.has_node(p):
                             raise error.LookupError(
                                 p, self.radix, _(b'unknown parent')
                             )
 
                     if not self.index.has_node(deltabase):
                         raise error.LookupError(
                             deltabase, self.display_id, _(b'unknown delta base')
                         )
 
                     baserev = self.rev(deltabase)
 
                     if baserev != nullrev and self.iscensored(baserev):
                         # if base is censored, delta must be full replacement in a
                         # single patch operation
                         hlen = struct.calcsize(b">lll")
                         oldlen = self.rawsize(baserev)
                         newlen = len(delta) - hlen
                         if delta[:hlen] != mdiff.replacediffheader(
                             oldlen, newlen
                         ):
                             raise error.CensoredBaseError(
                                 self.display_id, self.node(baserev)
                             )
 
                     if not flags and self._peek_iscensored(baserev, delta):
                         flags |= REVIDX_ISCENSORED
 
                     # We assume consumers of addrevisioncb will want to retrieve
                     # the added revision, which will require a call to
                     # revision(). revision() will fast path if there is a cache
                     # hit. So, we tell _addrevision() to always cache in this case.
                     # We're only using addgroup() in the context of changegroup
                     # generation so the revision data can always be handled as raw
                     # by the flagprocessor.
                     rev = self._addrevision(
                         node,
                         None,
                         transaction,
                         link,
                         p1,
                         p2,
                         flags,
                         (baserev, delta),
                         alwayscache=alwayscache,
                         deltacomputer=deltacomputer,
                         sidedata=sidedata,
                     )
 
                     if addrevisioncb:
                         addrevisioncb(self, rev)
                     empty = False
         finally:
             self._adding_group = False
         return not empty
 
     def iscensored(self, rev):
         """Check if a file revision is censored."""
         if not self._censorable:
             return False
 
         return self.flags(rev) & REVIDX_ISCENSORED
 
     def _peek_iscensored(self, baserev, delta):
         """Quickly check if a delta produces a censored revision."""
         if not self._censorable:
             return False
 
         return storageutil.deltaiscensored(delta, baserev, self.rawsize)
 
     def getstrippoint(self, minlink):
         """find the minimum rev that must be stripped to strip the linkrev
 
         Returns a tuple containing the minimum rev and a set of all revs that
         have linkrevs that will be broken by this strip.
         """
         return storageutil.resolvestripinfo(
             minlink,
             len(self) - 1,
             self.headrevs(),
             self.linkrev,
             self.parentrevs,
         )
 
     def strip(self, minlink, transaction):
         """truncate the revlog on the first revision with a linkrev >= minlink
 
         This function is called when we're stripping revision minlink and
         its descendants from the repository.
 
         We have to remove all revisions with linkrev >= minlink, because
         the equivalent changelog revisions will be renumbered after the
         strip.
 
         So we truncate the revlog on the first of these revisions, and
         trust that the caller has saved the revisions that shouldn't be
         removed and that it'll re-add them after this truncation.
         """
         if len(self) == 0:
             return
 
         rev, _ = self.getstrippoint(minlink)
         if rev == len(self):
             return
 
         # first truncate the files on disk
         data_end = self.start(rev)
         if not self._inline:
             transaction.add(self._datafile, data_end)
             end = rev * self.index.entry_size
         else:
             end = data_end + (rev * self.index.entry_size)
 
         if self._sidedatafile:
             sidedata_end = self.sidedata_cut_off(rev)
             transaction.add(self._sidedatafile, sidedata_end)
 
         transaction.add(self._indexfile, end)
         if self._docket is not None:
             # XXX we could, leverage the docket while stripping. However it is
             # not powerfull enough at the time of this comment
             self._docket.index_end = end
             self._docket.data_end = data_end
             self._docket.sidedata_end = sidedata_end
             self._docket.write(transaction, stripping=True)
 
         # then reset internal state in memory to forget those revisions
         self._revisioncache = None
         self._chaininfocache = util.lrucachedict(500)
         self._segmentfile.clear_cache()
         self._segmentfile_sidedata.clear_cache()
 
         del self.index[rev:-1]
 
     def checksize(self):
         """Check size of index and data files
 
         return a (dd, di) tuple.
         - dd: extra bytes for the "data" file
         - di: extra bytes for the "index" file
 
         A healthy revlog will return (0, 0).
         """
         expected = 0
         if len(self):
             expected = max(0, self.end(len(self) - 1))
 
         try:
             with self._datafp() as f:
                 f.seek(0, io.SEEK_END)
                 actual = f.tell()
             dd = actual - expected
         except FileNotFoundError:
             dd = 0
 
         try:
             f = self.opener(self._indexfile)
             f.seek(0, io.SEEK_END)
             actual = f.tell()
             f.close()
             s = self.index.entry_size
             i = max(0, actual // s)
             di = actual - (i * s)
             if self._inline:
                 databytes = 0
                 for r in self:
                     databytes += max(0, self.length(r))
                 dd = 0
                 di = actual - len(self) * s - databytes
         except FileNotFoundError:
             di = 0
 
         return (dd, di)
 
     def files(self):
         res = [self._indexfile]
         if self._docket_file is None:
             if not self._inline:
                 res.append(self._datafile)
         else:
             res.append(self._docket_file)
             res.extend(self._docket.old_index_filepaths(include_empty=False))
             if self._docket.data_end:
                 res.append(self._datafile)
             res.extend(self._docket.old_data_filepaths(include_empty=False))
             if self._docket.sidedata_end:
                 res.append(self._sidedatafile)
             res.extend(self._docket.old_sidedata_filepaths(include_empty=False))
         return res
 
     def emitrevisions(
         self,
         nodes,
         nodesorder=None,
         revisiondata=False,
         assumehaveparentrevisions=False,
         deltamode=repository.CG_DELTAMODE_STD,
         sidedata_helpers=None,
         debug_info=None,
     ):
         if nodesorder not in (b'nodes', b'storage', b'linear', None):
             raise error.ProgrammingError(
                 b'unhandled value for nodesorder: %s' % nodesorder
             )
 
         if nodesorder is None and not self._generaldelta:
             nodesorder = b'storage'
 
         if (
             not self._storedeltachains
             and deltamode != repository.CG_DELTAMODE_PREV
         ):
             deltamode = repository.CG_DELTAMODE_FULL
 
         return storageutil.emitrevisions(
             self,
             nodes,
             nodesorder,
             revlogrevisiondelta,
             deltaparentfn=self.deltaparent,
             candeltafn=self.candelta,
             rawsizefn=self.rawsize,
             revdifffn=self.revdiff,
             flagsfn=self.flags,
             deltamode=deltamode,
             revisiondata=revisiondata,
             assumehaveparentrevisions=assumehaveparentrevisions,
             sidedata_helpers=sidedata_helpers,
             debug_info=debug_info,
         )
 
     DELTAREUSEALWAYS = b'always'
     DELTAREUSESAMEREVS = b'samerevs'
     DELTAREUSENEVER = b'never'
 
     DELTAREUSEFULLADD = b'fulladd'
 
     DELTAREUSEALL = {b'always', b'samerevs', b'never', b'fulladd'}
 
     def clone(
         self,
         tr,
         destrevlog,
         addrevisioncb=None,
         deltareuse=DELTAREUSESAMEREVS,
         forcedeltabothparents=None,
         sidedata_helpers=None,
     ):
         """Copy this revlog to another, possibly with format changes.
 
         The destination revlog will contain the same revisions and nodes.
         However, it may not be bit-for-bit identical due to e.g. delta encoding
         differences.
 
         The ``deltareuse`` argument control how deltas from the existing revlog
         are preserved in the destination revlog. The argument can have the
         following values:
 
         DELTAREUSEALWAYS
            Deltas will always be reused (if possible), even if the destination
            revlog would not select the same revisions for the delta. This is the
            fastest mode of operation.
         DELTAREUSESAMEREVS
            Deltas will be reused if the destination revlog would pick the same
            revisions for the delta. This mode strikes a balance between speed
            and optimization.
         DELTAREUSENEVER
            Deltas will never be reused. This is the slowest mode of execution.
            This mode can be used to recompute deltas (e.g. if the diff/delta
            algorithm changes).
         DELTAREUSEFULLADD
            Revision will be re-added as if their were new content. This is
            slower than DELTAREUSEALWAYS but allow more mechanism to kicks in.
            eg: large file detection and handling.
 
         Delta computation can be slow, so the choice of delta reuse policy can
         significantly affect run time.
 
         The default policy (``DELTAREUSESAMEREVS``) strikes a balance between
         two extremes. Deltas will be reused if they are appropriate. But if the
         delta could choose a better revision, it will do so. This means if you
         are converting a non-generaldelta revlog to a generaldelta revlog,
         deltas will be recomputed if the delta's parent isn't a parent of the
         revision.
 
         In addition to the delta policy, the ``forcedeltabothparents``
         argument controls whether to force compute deltas against both parents
         for merges. By default, the current default is used.
 
         See `revlogutil.sidedata.get_sidedata_helpers` for the doc on
         `sidedata_helpers`.
         """
         if deltareuse not in self.DELTAREUSEALL:
             raise ValueError(
                 _(b'value for deltareuse invalid: %s') % deltareuse
             )
 
         if len(destrevlog):
             raise ValueError(_(b'destination revlog is not empty'))
 
         if getattr(self, 'filteredrevs', None):
             raise ValueError(_(b'source revlog has filtered revisions'))
         if getattr(destrevlog, 'filteredrevs', None):
             raise ValueError(_(b'destination revlog has filtered revisions'))
 
         # lazydelta and lazydeltabase controls whether to reuse a cached delta,
         # if possible.
         oldlazydelta = destrevlog._lazydelta
         oldlazydeltabase = destrevlog._lazydeltabase
         oldamd = destrevlog._deltabothparents
 
         try:
             if deltareuse == self.DELTAREUSEALWAYS:
                 destrevlog._lazydeltabase = True
                 destrevlog._lazydelta = True
             elif deltareuse == self.DELTAREUSESAMEREVS:
                 destrevlog._lazydeltabase = False
                 destrevlog._lazydelta = True
             elif deltareuse == self.DELTAREUSENEVER:
                 destrevlog._lazydeltabase = False
                 destrevlog._lazydelta = False
 
             destrevlog._deltabothparents = forcedeltabothparents or oldamd
 
             self._clone(
                 tr,
                 destrevlog,
                 addrevisioncb,
                 deltareuse,
                 forcedeltabothparents,
                 sidedata_helpers,
             )
 
         finally:
             destrevlog._lazydelta = oldlazydelta
             destrevlog._lazydeltabase = oldlazydeltabase
             destrevlog._deltabothparents = oldamd
 
     def _clone(
         self,
         tr,
         destrevlog,
         addrevisioncb,
         deltareuse,
         forcedeltabothparents,
         sidedata_helpers,
     ):
         """perform the core duty of `revlog.clone` after parameter processing"""
         write_debug = None
         if self._debug_delta:
             write_debug = tr._report
         deltacomputer = deltautil.deltacomputer(
             destrevlog,
             write_debug=write_debug,
         )
         index = self.index
         for rev in self:
             entry = index[rev]
 
             # Some classes override linkrev to take filtered revs into
             # account. Use raw entry from index.
             flags = entry[0] & 0xFFFF
             linkrev = entry[4]
             p1 = index[entry[5]][7]
             p2 = index[entry[6]][7]
             node = entry[7]
 
             # (Possibly) reuse the delta from the revlog if allowed and
             # the revlog chunk is a delta.
             cachedelta = None
             rawtext = None
             if deltareuse == self.DELTAREUSEFULLADD:
                 text = self._revisiondata(rev)
                 sidedata = self.sidedata(rev)
 
                 if sidedata_helpers is not None:
                     (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
                         self, sidedata_helpers, sidedata, rev
                     )
                     flags = flags | new_flags[0] & ~new_flags[1]
 
                 destrevlog.addrevision(
                     text,
                     tr,
                     linkrev,
                     p1,
                     p2,
                     cachedelta=cachedelta,
                     node=node,
                     flags=flags,
                     deltacomputer=deltacomputer,
                     sidedata=sidedata,
                 )
             else:
                 if destrevlog._lazydelta:
                     dp = self.deltaparent(rev)
                     if dp != nullrev:
                         cachedelta = (dp, bytes(self._chunk(rev)))
 
                 sidedata = None
                 if not cachedelta:
                     rawtext = self._revisiondata(rev)
                     sidedata = self.sidedata(rev)
                 if sidedata is None:
                     sidedata = self.sidedata(rev)
 
                 if sidedata_helpers is not None:
                     (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
                         self, sidedata_helpers, sidedata, rev
                     )
                     flags = flags | new_flags[0] & ~new_flags[1]
 
                 with destrevlog._writing(tr):
                     destrevlog._addrevision(
                         node,
                         rawtext,
                         tr,
                         linkrev,
                         p1,
                         p2,
                         flags,
                         cachedelta,
                         deltacomputer=deltacomputer,
                         sidedata=sidedata,
                     )
 
             if addrevisioncb:
                 addrevisioncb(self, rev, node)
 
     def censorrevision(self, tr, censornode, tombstone=b''):
         if self._format_version == REVLOGV0:
             raise error.RevlogError(
                 _(b'cannot censor with version %d revlogs')
                 % self._format_version
             )
         elif self._format_version == REVLOGV1:
             rewrite.v1_censor(self, tr, censornode, tombstone)
         else:
             rewrite.v2_censor(self, tr, censornode, tombstone)
 
     def verifyintegrity(self, state):
         """Verifies the integrity of the revlog.
 
         Yields ``revlogproblem`` instances describing problems that are
         found.
         """
         dd, di = self.checksize()
         if dd:
             yield revlogproblem(error=_(b'data length off by %d bytes') % dd)
         if di:
             yield revlogproblem(error=_(b'index contains %d extra bytes') % di)
 
         version = self._format_version
 
         # The verifier tells us what version revlog we should be.
         if version != state[b'expectedversion']:
             yield revlogproblem(
                 warning=_(b"warning: '%s' uses revlog format %d; expected %d")
                 % (self.display_id, version, state[b'expectedversion'])
             )
 
         state[b'skipread'] = set()
         state[b'safe_renamed'] = set()
 
         for rev in self:
             node = self.node(rev)
 
             # Verify contents. 4 cases to care about:
             #
             #   common: the most common case
             #   rename: with a rename
             #   meta: file content starts with b'\1\n', the metadata
             #         header defined in filelog.py, but without a rename
             #   ext: content stored externally
             #
             # More formally, their differences are shown below:
             #
             #                       | common | rename | meta  | ext
             #  -------------------------------------------------------
             #   flags()             | 0      | 0      | 0     | not 0
             #   renamed()           | False  | True   | False | ?
             #   rawtext[0:2]=='\1\n'| False  | True   | True  | ?
             #
             # "rawtext" means the raw text stored in revlog data, which
             # could be retrieved by "rawdata(rev)". "text"
             # mentioned below is "revision(rev)".
             #
             # There are 3 different lengths stored physically:
             #  1. L1: rawsize, stored in revlog index
             #  2. L2: len(rawtext), stored in revlog data
             #  3. L3: len(text), stored in revlog data if flags==0, or
             #     possibly somewhere else if flags!=0
             #
             # L1 should be equal to L2. L3 could be different from them.
             # "text" may or may not affect commit hash depending on flag
             # processors (see flagutil.addflagprocessor).
             #
             #              | common  | rename | meta  | ext
             # -------------------------------------------------
             #    rawsize() | L1      | L1     | L1    | L1
             #       size() | L1      | L2-LM  | L1(*) | L1 (?)
             # len(rawtext) | L2      | L2     | L2    | L2
             #    len(text) | L2      | L2     | L2    | L3
             #  len(read()) | L2      | L2-LM  | L2-LM | L3 (?)
             #
             # LM:  length of metadata, depending on rawtext
             # (*): not ideal, see comment in filelog.size
             # (?): could be "- len(meta)" if the resolved content has
             #      rename metadata
             #
             # Checks needed to be done:
             #  1. length check: L1 == L2, in all cases.
             #  2. hash check: depending on flag processor, we may need to
             #     use either "text" (external), or "rawtext" (in revlog).
 
             try:
                 skipflags = state.get(b'skipflags', 0)
                 if skipflags:
                     skipflags &= self.flags(rev)
 
                 _verify_revision(self, skipflags, state, node)
 
                 l1 = self.rawsize(rev)
                 l2 = len(self.rawdata(node))
 
                 if l1 != l2:
                     yield revlogproblem(
                         error=_(b'unpacked size is %d, %d expected') % (l2, l1),
                         node=node,
                     )
 
             except error.CensoredNodeError:
                 if state[b'erroroncensored']:
                     yield revlogproblem(
                         error=_(b'censored file data'), node=node
                     )
                     state[b'skipread'].add(node)
             except Exception as e:
                 yield revlogproblem(
                     error=_(b'unpacking %s: %s')
                     % (short(node), stringutil.forcebytestr(e)),
                     node=node,
                 )
                 state[b'skipread'].add(node)
 
     def storageinfo(
         self,
         exclusivefiles=False,
         sharedfiles=False,
         revisionscount=False,
         trackedsize=False,
         storedsize=False,
     ):
         d = {}
 
         if exclusivefiles:
             d[b'exclusivefiles'] = [(self.opener, self._indexfile)]
             if not self._inline:
                 d[b'exclusivefiles'].append((self.opener, self._datafile))
 
         if sharedfiles:
             d[b'sharedfiles'] = []
 
         if revisionscount:
             d[b'revisionscount'] = len(self)
 
         if trackedsize:
             d[b'trackedsize'] = sum(map(self.rawsize, iter(self)))
 
         if storedsize:
             d[b'storedsize'] = sum(
                 self.opener.stat(path).st_size for path in self.files()
             )
 
         return d
 
     def rewrite_sidedata(self, transaction, helpers, startrev, endrev):
         if not self.hassidedata:
             return
         # revlog formats with sidedata support does not support inline
         assert not self._inline
         if not helpers[1] and not helpers[2]:
             # Nothing to generate or remove
             return
 
         new_entries = []
         # append the new sidedata
         with self._writing(transaction):
             ifh, dfh, sdfh = self._writinghandles
             dfh.seek(self._docket.sidedata_end, os.SEEK_SET)
 
             current_offset = sdfh.tell()
             for rev in range(startrev, endrev + 1):
                 entry = self.index[rev]
                 new_sidedata, flags = sidedatautil.run_sidedata_helpers(
                     store=self,
                     sidedata_helpers=helpers,
                     sidedata={},
                     rev=rev,
                 )
 
                 serialized_sidedata = sidedatautil.serialize_sidedata(
                     new_sidedata
                 )
 
                 sidedata_compression_mode = COMP_MODE_INLINE
                 if serialized_sidedata and self.hassidedata:
                     sidedata_compression_mode = COMP_MODE_PLAIN
                     h, comp_sidedata = self.compress(serialized_sidedata)
                     if (
                         h != b'u'
                         and comp_sidedata[0] != b'\0'
                         and len(comp_sidedata) < len(serialized_sidedata)
                     ):
                         assert not h
                         if (
                             comp_sidedata[0]
                             == self._docket.default_compression_header
                         ):
                             sidedata_compression_mode = COMP_MODE_DEFAULT
                             serialized_sidedata = comp_sidedata
                         else:
                             sidedata_compression_mode = COMP_MODE_INLINE
                             serialized_sidedata = comp_sidedata
                 if entry[8] != 0 or entry[9] != 0:
                     # rewriting entries that already have sidedata is not
                     # supported yet, because it introduces garbage data in the
                     # revlog.
                     msg = b"rewriting existing sidedata is not supported yet"
                     raise error.Abort(msg)
 
                 # Apply (potential) flags to add and to remove after running
                 # the sidedata helpers
                 new_offset_flags = entry[0] | flags[0] & ~flags[1]
                 entry_update = (
                     current_offset,
                     len(serialized_sidedata),
                     new_offset_flags,
                     sidedata_compression_mode,
                 )
 
                 # the sidedata computation might have move the file cursors around
                 sdfh.seek(current_offset, os.SEEK_SET)
                 sdfh.write(serialized_sidedata)
                 new_entries.append(entry_update)
                 current_offset += len(serialized_sidedata)
                 self._docket.sidedata_end = sdfh.tell()
 
             # rewrite the new index entries
             ifh.seek(startrev * self.index.entry_size)
             for i, e in enumerate(new_entries):
                 rev = startrev + i
                 self.index.replace_sidedata_info(rev, *e)
                 packed = self.index.entry_binary(rev)
                 if rev == 0 and self._docket is None:
                     header = self._format_flags | self._format_version
                     header = self.index.pack_header(header)
                     packed = header + packed
                 ifh.write(packed)

mercurial/revlogutils/deltas.py

@@ -1,1351 +1,1386 b''
 # revlogdeltas.py - Logic around delta computation for revlog
 #
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 # Copyright 2018 Octobus <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """Helper class to compute deltas stored inside revlogs"""
 
 
 import collections
 import struct
 
 # import stuff from node for others to import from revlog
 from ..node import nullrev
 from ..i18n import _
 from ..pycompat import getattr
 
 from .constants import (
     COMP_MODE_DEFAULT,
     COMP_MODE_INLINE,
     COMP_MODE_PLAIN,
     KIND_CHANGELOG,
     KIND_FILELOG,
     KIND_MANIFESTLOG,
     REVIDX_ISCENSORED,
     REVIDX_RAWTEXT_CHANGING_FLAGS,
 )
 
 from ..thirdparty import attr
 
 from .. import (
     error,
     mdiff,
     util,
 )
 
 from . import flagutil
 
 # maximum <delta-chain-data>/<revision-text-length> ratio
 LIMIT_DELTA2TEXT = 2
 
 
 class _testrevlog:
     """minimalist fake revlog to use in doctests"""
 
     def __init__(self, data, density=0.5, mingap=0, snapshot=()):
         """data is an list of revision payload boundaries"""
         self._data = data
         self._srdensitythreshold = density
         self._srmingapsize = mingap
         self._snapshot = set(snapshot)
         self.index = None
 
     def start(self, rev):
         if rev == nullrev:
             return 0
         if rev == 0:
             return 0
         return self._data[rev - 1]
 
     def end(self, rev):
         if rev == nullrev:
             return 0
         return self._data[rev]
 
     def length(self, rev):
         return self.end(rev) - self.start(rev)
 
     def __len__(self):
         return len(self._data)
 
     def issnapshot(self, rev):
         if rev == nullrev:
             return True
         return rev in self._snapshot
 
 
 def slicechunk(revlog, revs, targetsize=None):
     """slice revs to reduce the amount of unrelated data to be read from disk.
 
     ``revs`` is sliced into groups that should be read in one time.
     Assume that revs are sorted.
 
     The initial chunk is sliced until the overall density (payload/chunks-span
     ratio) is above `revlog._srdensitythreshold`. No gap smaller than
     `revlog._srmingapsize` is skipped.
 
     If `targetsize` is set, no chunk larger than `targetsize` will be yield.
     For consistency with other slicing choice, this limit won't go lower than
     `revlog._srmingapsize`.
 
     If individual revisions chunk are larger than this limit, they will still
     be raised individually.
 
     >>> data = [
     ...  5,  #00 (5)
     ...  10, #01 (5)
     ...  12, #02 (2)
     ...  12, #03 (empty)
     ...  27, #04 (15)
     ...  31, #05 (4)
     ...  31, #06 (empty)
     ...  42, #07 (11)
     ...  47, #08 (5)
     ...  47, #09 (empty)
     ...  48, #10 (1)
     ...  51, #11 (3)
     ...  74, #12 (23)
     ...  85, #13 (11)
     ...  86, #14 (1)
     ...  91, #15 (5)
     ... ]
     >>> revlog = _testrevlog(data, snapshot=range(16))
 
     >>> list(slicechunk(revlog, list(range(16))))
     [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]
     >>> list(slicechunk(revlog, [0, 15]))
     [[0], [15]]
     >>> list(slicechunk(revlog, [0, 11, 15]))
     [[0], [11], [15]]
     >>> list(slicechunk(revlog, [0, 11, 13, 15]))
     [[0], [11, 13, 15]]
     >>> list(slicechunk(revlog, [1, 2, 3, 5, 8, 10, 11, 14]))
     [[1, 2], [5, 8, 10, 11], [14]]
 
     Slicing with a maximum chunk size
     >>> list(slicechunk(revlog, [0, 11, 13, 15], targetsize=15))
     [[0], [11], [13], [15]]
     >>> list(slicechunk(revlog, [0, 11, 13, 15], targetsize=20))
     [[0], [11], [13, 15]]
 
     Slicing involving nullrev
     >>> list(slicechunk(revlog, [-1, 0, 11, 13, 15], targetsize=20))
     [[-1, 0], [11], [13, 15]]
     >>> list(slicechunk(revlog, [-1, 13, 15], targetsize=5))
     [[-1], [13], [15]]
     """
     if targetsize is not None:
         targetsize = max(targetsize, revlog._srmingapsize)
     # targetsize should not be specified when evaluating delta candidates:
     # * targetsize is used to ensure we stay within specification when reading,
     densityslicing = getattr(revlog.index, 'slicechunktodensity', None)
     if densityslicing is None:
         densityslicing = lambda x, y, z: _slicechunktodensity(revlog, x, y, z)
     for chunk in densityslicing(
         revs, revlog._srdensitythreshold, revlog._srmingapsize
     ):
         for subchunk in _slicechunktosize(revlog, chunk, targetsize):
             yield subchunk
 
 
 def _slicechunktosize(revlog, revs, targetsize=None):
     """slice revs to match the target size
 
     This is intended to be used on chunk that density slicing selected by that
     are still too large compared to the read garantee of revlog. This might
     happens when "minimal gap size" interrupted the slicing or when chain are
     built in a way that create large blocks next to each other.
 
     >>> data = [
     ...  3,  #0 (3)
     ...  5,  #1 (2)
     ...  6,  #2 (1)
     ...  8,  #3 (2)
     ...  8,  #4 (empty)
     ...  11, #5 (3)
     ...  12, #6 (1)
     ...  13, #7 (1)
     ...  14, #8 (1)
     ... ]
 
     == All snapshots cases ==
     >>> revlog = _testrevlog(data, snapshot=range(9))
 
     Cases where chunk is already small enough
     >>> list(_slicechunktosize(revlog, [0], 3))
     [[0]]
     >>> list(_slicechunktosize(revlog, [6, 7], 3))
     [[6, 7]]
     >>> list(_slicechunktosize(revlog, [0], None))
     [[0]]
     >>> list(_slicechunktosize(revlog, [6, 7], None))
     [[6, 7]]
 
     cases where we need actual slicing
     >>> list(_slicechunktosize(revlog, [0, 1], 3))
     [[0], [1]]
     >>> list(_slicechunktosize(revlog, [1, 3], 3))
     [[1], [3]]
     >>> list(_slicechunktosize(revlog, [1, 2, 3], 3))
     [[1, 2], [3]]
     >>> list(_slicechunktosize(revlog, [3, 5], 3))
     [[3], [5]]
     >>> list(_slicechunktosize(revlog, [3, 4, 5], 3))
     [[3], [5]]
     >>> list(_slicechunktosize(revlog, [5, 6, 7, 8], 3))
     [[5], [6, 7, 8]]
     >>> list(_slicechunktosize(revlog, [0, 1, 2, 3, 4, 5, 6, 7, 8], 3))
     [[0], [1, 2], [3], [5], [6, 7, 8]]
 
     Case with too large individual chunk (must return valid chunk)
     >>> list(_slicechunktosize(revlog, [0, 1], 2))
     [[0], [1]]
     >>> list(_slicechunktosize(revlog, [1, 3], 1))
     [[1], [3]]
     >>> list(_slicechunktosize(revlog, [3, 4, 5], 2))
     [[3], [5]]
 
     == No Snapshot cases ==
     >>> revlog = _testrevlog(data)
 
     Cases where chunk is already small enough
     >>> list(_slicechunktosize(revlog, [0], 3))
     [[0]]
     >>> list(_slicechunktosize(revlog, [6, 7], 3))
     [[6, 7]]
     >>> list(_slicechunktosize(revlog, [0], None))
     [[0]]
     >>> list(_slicechunktosize(revlog, [6, 7], None))
     [[6, 7]]
 
     cases where we need actual slicing
     >>> list(_slicechunktosize(revlog, [0, 1], 3))
     [[0], [1]]
     >>> list(_slicechunktosize(revlog, [1, 3], 3))
     [[1], [3]]
     >>> list(_slicechunktosize(revlog, [1, 2, 3], 3))
     [[1], [2, 3]]
     >>> list(_slicechunktosize(revlog, [3, 5], 3))
     [[3], [5]]
     >>> list(_slicechunktosize(revlog, [3, 4, 5], 3))
     [[3], [4, 5]]
     >>> list(_slicechunktosize(revlog, [5, 6, 7, 8], 3))
     [[5], [6, 7, 8]]
     >>> list(_slicechunktosize(revlog, [0, 1, 2, 3, 4, 5, 6, 7, 8], 3))
     [[0], [1, 2], [3], [5], [6, 7, 8]]
 
     Case with too large individual chunk (must return valid chunk)
     >>> list(_slicechunktosize(revlog, [0, 1], 2))
     [[0], [1]]
     >>> list(_slicechunktosize(revlog, [1, 3], 1))
     [[1], [3]]
     >>> list(_slicechunktosize(revlog, [3, 4, 5], 2))
     [[3], [5]]
 
     == mixed case ==
     >>> revlog = _testrevlog(data, snapshot=[0, 1, 2])
     >>> list(_slicechunktosize(revlog, list(range(9)), 5))
     [[0, 1], [2], [3, 4, 5], [6, 7, 8]]
     """
     assert targetsize is None or 0 <= targetsize
     startdata = revlog.start(revs[0])
     enddata = revlog.end(revs[-1])
     fullspan = enddata - startdata
     if targetsize is None or fullspan <= targetsize:
         yield revs
         return
 
     startrevidx = 0
     endrevidx = 1
     iterrevs = enumerate(revs)
     next(iterrevs)  # skip first rev.
     # first step: get snapshots out of the way
     for idx, r in iterrevs:
         span = revlog.end(r) - startdata
         snapshot = revlog.issnapshot(r)
         if span <= targetsize and snapshot:
             endrevidx = idx + 1
         else:
             chunk = _trimchunk(revlog, revs, startrevidx, endrevidx)
             if chunk:
                 yield chunk
             startrevidx = idx
             startdata = revlog.start(r)
             endrevidx = idx + 1
         if not snapshot:
             break
 
     # for the others, we use binary slicing to quickly converge toward valid
     # chunks (otherwise, we might end up looking for start/end of many
     # revisions). This logic is not looking for the perfect slicing point, it
     # focuses on quickly converging toward valid chunks.
     nbitem = len(revs)
     while (enddata - startdata) > targetsize:
         endrevidx = nbitem
         if nbitem - startrevidx <= 1:
             break  # protect against individual chunk larger than limit
         localenddata = revlog.end(revs[endrevidx - 1])
         span = localenddata - startdata
         while span > targetsize:
             if endrevidx - startrevidx <= 1:
                 break  # protect against individual chunk larger than limit
             endrevidx -= (endrevidx - startrevidx) // 2
             localenddata = revlog.end(revs[endrevidx - 1])
             span = localenddata - startdata
         chunk = _trimchunk(revlog, revs, startrevidx, endrevidx)
         if chunk:
             yield chunk
         startrevidx = endrevidx
         startdata = revlog.start(revs[startrevidx])
 
     chunk = _trimchunk(revlog, revs, startrevidx)
     if chunk:
         yield chunk
 
 
 def _slicechunktodensity(revlog, revs, targetdensity=0.5, mingapsize=0):
     """slice revs to reduce the amount of unrelated data to be read from disk.
 
     ``revs`` is sliced into groups that should be read in one time.
     Assume that revs are sorted.
 
     The initial chunk is sliced until the overall density (payload/chunks-span
     ratio) is above `targetdensity`. No gap smaller than `mingapsize` is
     skipped.
 
     >>> revlog = _testrevlog([
     ...  5,  #00 (5)
     ...  10, #01 (5)
     ...  12, #02 (2)
     ...  12, #03 (empty)
     ...  27, #04 (15)
     ...  31, #05 (4)
     ...  31, #06 (empty)
     ...  42, #07 (11)
     ...  47, #08 (5)
     ...  47, #09 (empty)
     ...  48, #10 (1)
     ...  51, #11 (3)
     ...  74, #12 (23)
     ...  85, #13 (11)
     ...  86, #14 (1)
     ...  91, #15 (5)
     ... ])
 
     >>> list(_slicechunktodensity(revlog, list(range(16))))
     [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]
     >>> list(_slicechunktodensity(revlog, [0, 15]))
     [[0], [15]]
     >>> list(_slicechunktodensity(revlog, [0, 11, 15]))
     [[0], [11], [15]]
     >>> list(_slicechunktodensity(revlog, [0, 11, 13, 15]))
     [[0], [11, 13, 15]]
     >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14]))
     [[1, 2], [5, 8, 10, 11], [14]]
     >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
     ...                           mingapsize=20))
     [[1, 2, 3, 5, 8, 10, 11], [14]]
     >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
     ...                           targetdensity=0.95))
     [[1, 2], [5], [8, 10, 11], [14]]
     >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
     ...                           targetdensity=0.95, mingapsize=12))
     [[1, 2], [5, 8, 10, 11], [14]]
     """
     start = revlog.start
     length = revlog.length
 
     if len(revs) <= 1:
         yield revs
         return
 
     deltachainspan = segmentspan(revlog, revs)
 
     if deltachainspan < mingapsize:
         yield revs
         return
 
     readdata = deltachainspan
     chainpayload = sum(length(r) for r in revs)
 
     if deltachainspan:
         density = chainpayload / float(deltachainspan)
     else:
         density = 1.0
 
     if density >= targetdensity:
         yield revs
         return
 
     # Store the gaps in a heap to have them sorted by decreasing size
     gaps = []
     prevend = None
     for i, rev in enumerate(revs):
         revstart = start(rev)
         revlen = length(rev)
 
         # Skip empty revisions to form larger holes
         if revlen == 0:
             continue
 
         if prevend is not None:
             gapsize = revstart - prevend
             # only consider holes that are large enough
             if gapsize > mingapsize:
                 gaps.append((gapsize, i))
 
         prevend = revstart + revlen
     # sort the gaps to pop them from largest to small
     gaps.sort()
 
     # Collect the indices of the largest holes until the density is acceptable
     selected = []
     while gaps and density < targetdensity:
         gapsize, gapidx = gaps.pop()
 
         selected.append(gapidx)
 
         # the gap sizes are stored as negatives to be sorted decreasingly
         # by the heap
         readdata -= gapsize
         if readdata > 0:
             density = chainpayload / float(readdata)
         else:
             density = 1.0
     selected.sort()
 
     # Cut the revs at collected indices
     previdx = 0
     for idx in selected:
 
         chunk = _trimchunk(revlog, revs, previdx, idx)
         if chunk:
             yield chunk
 
         previdx = idx
 
     chunk = _trimchunk(revlog, revs, previdx)
     if chunk:
         yield chunk
 
 
 def _trimchunk(revlog, revs, startidx, endidx=None):
     """returns revs[startidx:endidx] without empty trailing revs
 
     Doctest Setup
     >>> revlog = _testrevlog([
     ...  5,  #0
     ...  10, #1
     ...  12, #2
     ...  12, #3 (empty)
     ...  17, #4
     ...  21, #5
     ...  21, #6 (empty)
     ... ])
 
     Contiguous cases:
     >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0)
     [0, 1, 2, 3, 4, 5]
     >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0, 5)
     [0, 1, 2, 3, 4]
     >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0, 4)
     [0, 1, 2]
     >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 2, 4)
     [2]
     >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 3)
     [3, 4, 5]
     >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 3, 5)
     [3, 4]
 
     Discontiguous cases:
     >>> _trimchunk(revlog, [1, 3, 5, 6], 0)
     [1, 3, 5]
     >>> _trimchunk(revlog, [1, 3, 5, 6], 0, 2)
     [1]
     >>> _trimchunk(revlog, [1, 3, 5, 6], 1, 3)
     [3, 5]
     >>> _trimchunk(revlog, [1, 3, 5, 6], 1)
     [3, 5]
     """
     length = revlog.length
 
     if endidx is None:
         endidx = len(revs)
 
     # If we have a non-emtpy delta candidate, there are nothing to trim
     if revs[endidx - 1] < len(revlog):
         # Trim empty revs at the end, except the very first revision of a chain
         while (
             endidx > 1 and endidx > startidx and length(revs[endidx - 1]) == 0
         ):
             endidx -= 1
 
     return revs[startidx:endidx]
 
 
 def segmentspan(revlog, revs):
     """Get the byte span of a segment of revisions
 
     revs is a sorted array of revision numbers
 
     >>> revlog = _testrevlog([
     ...  5,  #0
     ...  10, #1
     ...  12, #2
     ...  12, #3 (empty)
     ...  17, #4
     ... ])
 
     >>> segmentspan(revlog, [0, 1, 2, 3, 4])
     17
     >>> segmentspan(revlog, [0, 4])
     17
     >>> segmentspan(revlog, [3, 4])
     5
     >>> segmentspan(revlog, [1, 2, 3,])
     7
     >>> segmentspan(revlog, [1, 3])
     7
     """
     if not revs:
         return 0
     end = revlog.end(revs[-1])
     return end - revlog.start(revs[0])
 
 
 def _textfromdelta(fh, revlog, baserev, delta, p1, p2, flags, expectednode):
     """build full text from a (base, delta) pair and other metadata"""
     # special case deltas which replace entire base; no need to decode
     # base revision. this neatly avoids censored bases, which throw when
     # they're decoded.
     hlen = struct.calcsize(b">lll")
     if delta[:hlen] == mdiff.replacediffheader(
         revlog.rawsize(baserev), len(delta) - hlen
     ):
         fulltext = delta[hlen:]
     else:
         # deltabase is rawtext before changed by flag processors, which is
         # equivalent to non-raw text
         basetext = revlog.revision(baserev, _df=fh)
         fulltext = mdiff.patch(basetext, delta)
 
     try:
         validatehash = flagutil.processflagsraw(revlog, fulltext, flags)
         if validatehash:
             revlog.checkhash(fulltext, expectednode, p1=p1, p2=p2)
         if flags & REVIDX_ISCENSORED:
             raise error.StorageError(
                 _(b'node %s is not censored') % expectednode
             )
     except error.CensoredNodeError:
         # must pass the censored index flag to add censored revisions
         if not flags & REVIDX_ISCENSORED:
             raise
     return fulltext
 
 
 @attr.s(slots=True, frozen=True)
 class _deltainfo:
     distance = attr.ib()
     deltalen = attr.ib()
     data = attr.ib()
     base = attr.ib()
     chainbase = attr.ib()
     chainlen = attr.ib()
     compresseddeltalen = attr.ib()
     snapshotdepth = attr.ib()
 
 
 def drop_u_compression(delta):
     """turn into a "u" (no-compression) into no-compression without header
 
     This is useful for revlog format that has better compression method.
     """
     assert delta.data[0] == b'u', delta.data[0]
     return _deltainfo(
         delta.distance,
         delta.deltalen - 1,
         (b'', delta.data[1]),
         delta.base,
         delta.chainbase,
         delta.chainlen,
         delta.compresseddeltalen,
         delta.snapshotdepth,
     )
 
 
 def isgooddeltainfo(revlog, deltainfo, revinfo):
     """Returns True if the given delta is good. Good means that it is within
     the disk span, disk size, and chain length bounds that we know to be
     performant."""
     if deltainfo is None:
         return False
 
     # - 'deltainfo.distance' is the distance from the base revision --
     #   bounding it limits the amount of I/O we need to do.
     # - 'deltainfo.compresseddeltalen' is the sum of the total size of
     #   deltas we need to apply -- bounding it limits the amount of CPU
     #   we consume.
 
     textlen = revinfo.textlen
     defaultmax = textlen * 4
     maxdist = revlog._maxdeltachainspan
     if not maxdist:
         maxdist = deltainfo.distance  # ensure the conditional pass
     maxdist = max(maxdist, defaultmax)
 
     # Bad delta from read span:
     #
     #   If the span of data read is larger than the maximum allowed.
     #
     #   In the sparse-revlog case, we rely on the associated "sparse reading"
     #   to avoid issue related to the span of data. In theory, it would be
     #   possible to build pathological revlog where delta pattern would lead
     #   to too many reads. However, they do not happen in practice at all. So
     #   we skip the span check entirely.
     if not revlog._sparserevlog and maxdist < deltainfo.distance:
         return False
 
     # Bad delta from new delta size:
     #
     #   If the delta size is larger than the target text, storing the
     #   delta will be inefficient.
     if textlen < deltainfo.deltalen:
         return False
 
     # Bad delta from cumulated payload size:
     #
     #   If the sum of delta get larger than K * target text length.
     if textlen * LIMIT_DELTA2TEXT < deltainfo.compresseddeltalen:
         return False
 
     # Bad delta from chain length:
     #
     #   If the number of delta in the chain gets too high.
     if revlog._maxchainlen and revlog._maxchainlen < deltainfo.chainlen:
         return False
 
     # bad delta from intermediate snapshot size limit
     #
     #   If an intermediate snapshot size is higher than the limit.  The
     #   limit exist to prevent endless chain of intermediate delta to be
     #   created.
     if (
         deltainfo.snapshotdepth is not None
         and (textlen >> deltainfo.snapshotdepth) < deltainfo.deltalen
     ):
         return False
 
     # bad delta if new intermediate snapshot is larger than the previous
     # snapshot
     if (
         deltainfo.snapshotdepth
         and revlog.length(deltainfo.base) < deltainfo.deltalen
     ):
         return False
 
     return True
 
 
 # If a revision's full text is that much bigger than a base candidate full
 # text's, it is very unlikely that it will produce a valid delta. We no longer
 # consider these candidates.
 LIMIT_BASE2TEXT = 500
 
 
 def _candidategroups(revlog, textlen, p1, p2, cachedelta):
     """Provides group of revision to be tested as delta base
 
     This top level function focus on emitting groups with unique and worthwhile
     content. See _raw_candidate_groups for details about the group order.
     """
     # should we try to build a delta?
     if not (len(revlog) and revlog._storedeltachains):
         yield None
         return
 
     deltalength = revlog.length
     deltaparent = revlog.deltaparent
     sparse = revlog._sparserevlog
     good = None
 
     deltas_limit = textlen * LIMIT_DELTA2TEXT
 
     tested = {nullrev}
-    candidates = _refinedgroups(revlog, p1, p2, cachedelta)
+    candidates = _refinedgroups(
+        revlog,
+        p1,
+        p2,
+        cachedelta,
+    )
     while True:
         temptative = candidates.send(good)
         if temptative is None:
             break
         group = []
         for rev in temptative:
             # skip over empty delta (no need to include them in a chain)
             while revlog._generaldelta and not (
                 rev == nullrev or rev in tested or deltalength(rev)
             ):
                 tested.add(rev)
                 rev = deltaparent(rev)
             # no need to try a delta against nullrev, this will be done as a
             # last resort.
             if rev == nullrev:
                 continue
             # filter out revision we tested already
             if rev in tested:
                 continue
             tested.add(rev)
             # filter out delta base that will never produce good delta
             if deltas_limit < revlog.length(rev):
                 continue
             if sparse and revlog.rawsize(rev) < (textlen // LIMIT_BASE2TEXT):
                 continue
             # no delta for rawtext-changing revs (see "candelta" for why)
             if revlog.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS:
                 continue
+
             # If we reach here, we are about to build and test a delta.
             # The delta building process will compute the chaininfo in all
             # case, since that computation is cached, it is fine to access it
             # here too.
             chainlen, chainsize = revlog._chaininfo(rev)
             # if chain will be too long, skip base
             if revlog._maxchainlen and chainlen >= revlog._maxchainlen:
                 continue
             # if chain already have too much data, skip base
             if deltas_limit < chainsize:
                 continue
             if sparse and revlog.upperboundcomp is not None:
                 maxcomp = revlog.upperboundcomp
                 basenotsnap = (p1, p2, nullrev)
                 if rev not in basenotsnap and revlog.issnapshot(rev):
                     snapshotdepth = revlog.snapshotdepth(rev)
                     # If text is significantly larger than the base, we can
                     # expect the resulting delta to be proportional to the size
                     # difference
                     revsize = revlog.rawsize(rev)
                     rawsizedistance = max(textlen - revsize, 0)
                     # use an estimate of the compression upper bound.
                     lowestrealisticdeltalen = rawsizedistance // maxcomp
 
                     # check the absolute constraint on the delta size
                     snapshotlimit = textlen >> snapshotdepth
                     if snapshotlimit < lowestrealisticdeltalen:
                         # delta lower bound is larger than accepted upper bound
                         continue
 
                     # check the relative constraint on the delta size
                     revlength = revlog.length(rev)
                     if revlength < lowestrealisticdeltalen:
                         # delta probable lower bound is larger than target base
                         continue
 
             group.append(rev)
         if group:
             # XXX: in the sparse revlog case, group can become large,
             #      impacting performances. Some bounding or slicing mecanism
             #      would help to reduce this impact.
             good = yield tuple(group)
     yield None
 
 
 def _findsnapshots(revlog, cache, start_rev):
     """find snapshot from start_rev to tip"""
     if util.safehasattr(revlog.index, b'findsnapshots'):
         revlog.index.findsnapshots(cache, start_rev)
     else:
         deltaparent = revlog.deltaparent
         issnapshot = revlog.issnapshot
         for rev in revlog.revs(start_rev):
             if issnapshot(rev):
                 cache[deltaparent(rev)].append(rev)
 
 
 def _refinedgroups(revlog, p1, p2, cachedelta):
     good = None
     # First we try to reuse a the delta contained in the bundle.
     # (or from the source revlog)
     #
     # This logic only applies to general delta repositories and can be disabled
     # through configuration. Disabling reuse source delta is useful when
     # we want to make sure we recomputed "optimal" deltas.
+    debug_info = None
     if cachedelta and revlog._generaldelta and revlog._lazydeltabase:
         # Assume what we received from the server is a good choice
         # build delta will reuse the cache
+        if debug_info is not None:
+            debug_info['cached-delta.tested'] += 1
         good = yield (cachedelta[0],)
         if good is not None:
+            if debug_info is not None:
+                debug_info['cached-delta.accepted'] += 1
             yield None
             return
+    # XXX cache me higher
     snapshots = collections.defaultdict(list)
-    for candidates in _rawgroups(revlog, p1, p2, cachedelta, snapshots):
+    groups = _rawgroups(
+        revlog,
+        p1,
+        p2,
+        cachedelta,
+        snapshots,
+    )
+    for candidates in groups:
         good = yield candidates
         if good is not None:
             break
 
     # If sparse revlog is enabled, we can try to refine the available deltas
     if not revlog._sparserevlog:
         yield None
         return
 
     # if we have a refinable value, try to refine it
     if good is not None and good not in (p1, p2) and revlog.issnapshot(good):
         # refine snapshot down
         previous = None
         while previous != good:
             previous = good
             base = revlog.deltaparent(good)
             if base == nullrev:
                 break
             good = yield (base,)
         # refine snapshot up
         if not snapshots:
             _findsnapshots(revlog, snapshots, good + 1)
         previous = None
         while good != previous:
             previous = good
             children = tuple(sorted(c for c in snapshots[good]))
             good = yield children
 
-    # we have found nothing
+    if debug_info is not None:
+        if good is None:
+            debug_info['no-solution'] += 1
+
     yield None
 
 
 def _rawgroups(revlog, p1, p2, cachedelta, snapshots=None):
     """Provides group of revision to be tested as delta base
 
     This lower level function focus on emitting delta theorically interresting
     without looking it any practical details.
 
     The group order aims at providing fast or small candidates first.
     """
     gdelta = revlog._generaldelta
     # gate sparse behind general-delta because of issue6056
     sparse = gdelta and revlog._sparserevlog
     curr = len(revlog)
     prev = curr - 1
     deltachain = lambda rev: revlog._deltachain(rev)[0]
 
     if gdelta:
         # exclude already lazy tested base if any
         parents = [p for p in (p1, p2) if p != nullrev]
 
         if not revlog._deltabothparents and len(parents) == 2:
             parents.sort()
             # To minimize the chance of having to build a fulltext,
             # pick first whichever parent is closest to us (max rev)
             yield (parents[1],)
             # then the other one (min rev) if the first did not fit
             yield (parents[0],)
         elif len(parents) > 0:
             # Test all parents (1 or 2), and keep the best candidate
             yield parents
 
     if sparse and parents:
         if snapshots is None:
             # map: base-rev: snapshot-rev
             snapshots = collections.defaultdict(list)
         # See if we can use an existing snapshot in the parent chains to use as
         # a base for a new intermediate-snapshot
         #
         # search for snapshot in parents delta chain
         # map: snapshot-level: snapshot-rev
         parents_snaps = collections.defaultdict(set)
         candidate_chains = [deltachain(p) for p in parents]
         for chain in candidate_chains:
             for idx, s in enumerate(chain):
                 if not revlog.issnapshot(s):
                     break
                 parents_snaps[idx].add(s)
         snapfloor = min(parents_snaps[0]) + 1
         _findsnapshots(revlog, snapshots, snapfloor)
         # search for the highest "unrelated" revision
         #
         # Adding snapshots used by "unrelated" revision increase the odd we
         # reuse an independant, yet better snapshot chain.
         #
         # XXX instead of building a set of revisions, we could lazily enumerate
         # over the chains. That would be more efficient, however we stick to
         # simple code for now.
         all_revs = set()
         for chain in candidate_chains:
             all_revs.update(chain)
         other = None
         for r in revlog.revs(prev, snapfloor):
             if r not in all_revs:
                 other = r
                 break
         if other is not None:
             # To avoid unfair competition, we won't use unrelated intermediate
             # snapshot that are deeper than the ones from the parent delta
             # chain.
             max_depth = max(parents_snaps.keys())
             chain = deltachain(other)
             for idx, s in enumerate(chain):
                 if s < snapfloor:
                     continue
                 if max_depth < idx:
                     break
                 if not revlog.issnapshot(s):
                     break
                 parents_snaps[idx].add(s)
         # Test them as possible intermediate snapshot base
         # We test them from highest to lowest level. High level one are more
         # likely to result in small delta
         floor = None
         for idx, snaps in sorted(parents_snaps.items(), reverse=True):
             siblings = set()
             for s in snaps:
                 siblings.update(snapshots[s])
             # Before considering making a new intermediate snapshot, we check
             # if an existing snapshot, children of base we consider, would be
             # suitable.
             #
             # It give a change to reuse a delta chain "unrelated" to the
             # current revision instead of starting our own. Without such
             # re-use, topological branches would keep reopening new chains.
             # Creating more and more snapshot as the repository grow.
 
             if floor is not None:
                 # We only do this for siblings created after the one in our
                 # parent's delta chain. Those created before has less chances
                 # to be valid base since our ancestors had to create a new
                 # snapshot.
                 siblings = [r for r in siblings if floor < r]
             yield tuple(sorted(siblings))
             # then test the base from our parent's delta chain.
             yield tuple(sorted(snaps))
             floor = min(snaps)
         # No suitable base found in the parent chain, search if any full
         # snapshots emitted since parent's base would be a suitable base for an
         # intermediate snapshot.
         #
         # It give a chance to reuse a delta chain unrelated to the current
         # revisions instead of starting our own. Without such re-use,
         # topological branches would keep reopening new full chains. Creating
         # more and more snapshot as the repository grow.
         yield tuple(snapshots[nullrev])
 
     if not sparse:
         # other approach failed try against prev to hopefully save us a
         # fulltext.
         yield (prev,)
 
 
 class deltacomputer:
-    def __init__(self, revlog, write_debug=None, debug_search=False):
+    def __init__(
+        self,
+        revlog,
+        write_debug=None,
+        debug_search=False,
+        debug_info=None,
+    ):
         self.revlog = revlog
         self._write_debug = write_debug
         self._debug_search = debug_search
+        self._debug_info = debug_info
 
     def buildtext(self, revinfo, fh):
         """Builds a fulltext version of a revision
 
         revinfo: revisioninfo instance that contains all needed info
         fh:      file handle to either the .i or the .d revlog file,
                  depending on whether it is inlined or not
         """
         btext = revinfo.btext
         if btext[0] is not None:
             return btext[0]
 
         revlog = self.revlog
         cachedelta = revinfo.cachedelta
         baserev = cachedelta[0]
         delta = cachedelta[1]
 
         fulltext = btext[0] = _textfromdelta(
             fh,
             revlog,
             baserev,
             delta,
             revinfo.p1,
             revinfo.p2,
             revinfo.flags,
             revinfo.node,
         )
         return fulltext
 
     def _builddeltadiff(self, base, revinfo, fh):
         revlog = self.revlog
         t = self.buildtext(revinfo, fh)
         if revlog.iscensored(base):
             # deltas based on a censored revision must replace the
             # full content in one patch, so delta works everywhere
             header = mdiff.replacediffheader(revlog.rawsize(base), len(t))
             delta = header + t
         else:
             ptext = revlog.rawdata(base, _df=fh)
             delta = mdiff.textdiff(ptext, t)
 
         return delta
 
     def _builddeltainfo(self, revinfo, base, fh):
         # can we use the cached delta?
         revlog = self.revlog
         debug_search = self._write_debug is not None and self._debug_search
         chainbase = revlog.chainbase(base)
         if revlog._generaldelta:
             deltabase = base
         else:
             deltabase = chainbase
         snapshotdepth = None
         if revlog._sparserevlog and deltabase == nullrev:
             snapshotdepth = 0
         elif revlog._sparserevlog and revlog.issnapshot(deltabase):
             # A delta chain should always be one full snapshot,
             # zero or more semi-snapshots, and zero or more deltas
             p1, p2 = revlog.rev(revinfo.p1), revlog.rev(revinfo.p2)
             if deltabase not in (p1, p2) and revlog.issnapshot(deltabase):
                 snapshotdepth = len(revlog._deltachain(deltabase)[0])
         delta = None
         if revinfo.cachedelta:
             cachebase, cachediff = revinfo.cachedelta
             # check if the diff still apply
             currentbase = cachebase
             while (
                 currentbase != nullrev
                 and currentbase != base
                 and self.revlog.length(currentbase) == 0
             ):
                 currentbase = self.revlog.deltaparent(currentbase)
             if self.revlog._lazydelta and currentbase == base:
                 delta = revinfo.cachedelta[1]
         if delta is None:
             delta = self._builddeltadiff(base, revinfo, fh)
         if debug_search:
             msg = b"DBG-DELTAS-SEARCH:     uncompressed-delta-size=%d\n"
             msg %= len(delta)
             self._write_debug(msg)
         # snapshotdept need to be neither None nor 0 level snapshot
         if revlog.upperboundcomp is not None and snapshotdepth:
             lowestrealisticdeltalen = len(delta) // revlog.upperboundcomp
             snapshotlimit = revinfo.textlen >> snapshotdepth
             if debug_search:
                 msg = b"DBG-DELTAS-SEARCH:     projected-lower-size=%d\n"
                 msg %= lowestrealisticdeltalen
                 self._write_debug(msg)
             if snapshotlimit < lowestrealisticdeltalen:
                 if debug_search:
                     msg = b"DBG-DELTAS-SEARCH:     DISCARDED (snapshot limit)\n"
                     self._write_debug(msg)
                 return None
             if revlog.length(base) < lowestrealisticdeltalen:
                 if debug_search:
                     msg = b"DBG-DELTAS-SEARCH:     DISCARDED (prev size)\n"
                     self._write_debug(msg)
                 return None
         header, data = revlog.compress(delta)
         deltalen = len(header) + len(data)
         offset = revlog.end(len(revlog) - 1)
         dist = deltalen + offset - revlog.start(chainbase)
         chainlen, compresseddeltalen = revlog._chaininfo(base)
         chainlen += 1
         compresseddeltalen += deltalen
 
         return _deltainfo(
             dist,
             deltalen,
             (header, data),
             deltabase,
             chainbase,
             chainlen,
             compresseddeltalen,
             snapshotdepth,
         )
 
     def _fullsnapshotinfo(self, fh, revinfo, curr):
         rawtext = self.buildtext(revinfo, fh)
         data = self.revlog.compress(rawtext)
         compresseddeltalen = deltalen = dist = len(data[1]) + len(data[0])
         deltabase = chainbase = curr
         snapshotdepth = 0
         chainlen = 1
 
         return _deltainfo(
             dist,
             deltalen,
             data,
             deltabase,
             chainbase,
             chainlen,
             compresseddeltalen,
             snapshotdepth,
         )
 
     def finddeltainfo(self, revinfo, fh, excluded_bases=None, target_rev=None):
         """Find an acceptable delta against a candidate revision
 
         revinfo: information about the revision (instance of _revisioninfo)
         fh:      file handle to either the .i or the .d revlog file,
                  depending on whether it is inlined or not
 
         Returns the first acceptable candidate revision, as ordered by
         _candidategroups
 
         If no suitable deltabase is found, we return delta info for a full
         snapshot.
 
         `excluded_bases` is an optional set of revision that cannot be used as
         a delta base. Use this to recompute delta suitable in censor or strip
         context.
         """
         if target_rev is None:
             target_rev = len(self.revlog)
 
         if not revinfo.textlen:
             return self._fullsnapshotinfo(fh, revinfo, target_rev)
 
         if excluded_bases is None:
             excluded_bases = set()
 
         # no delta for flag processor revision (see "candelta" for why)
         # not calling candelta since only one revision needs test, also to
         # avoid overhead fetching flags again.
         if revinfo.flags & REVIDX_RAWTEXT_CHANGING_FLAGS:
             return self._fullsnapshotinfo(fh, revinfo, target_rev)
 
-        if self._write_debug is not None:
+        gather_debug = (
+            self._write_debug is not None or self._debug_info is not None
+        )
+        debug_search = self._write_debug is not None and self._debug_search
+
+        if gather_debug:
             start = util.timer()
 
-        debug_search = self._write_debug is not None and self._debug_search
-
         # count the number of different delta we tried (for debug purpose)
         dbg_try_count = 0
         # count the number of "search round" we did. (for debug purpose)
         dbg_try_rounds = 0
         dbg_type = b'unknown'
 
         cachedelta = revinfo.cachedelta
         p1 = revinfo.p1
         p2 = revinfo.p2
         revlog = self.revlog
 
         deltainfo = None
         p1r, p2r = revlog.rev(p1), revlog.rev(p2)
 
-        if self._write_debug is not None:
+        if gather_debug:
             if p1r != nullrev:
                 p1_chain_len = revlog._chaininfo(p1r)[0]
             else:
                 p1_chain_len = -1
             if p2r != nullrev:
                 p2_chain_len = revlog._chaininfo(p2r)[0]
             else:
                 p2_chain_len = -1
         if debug_search:
             msg = b"DBG-DELTAS-SEARCH: SEARCH rev=%d\n"
             msg %= target_rev
             self._write_debug(msg)
 
         groups = _candidategroups(
             self.revlog, revinfo.textlen, p1r, p2r, cachedelta
         )
         candidaterevs = next(groups)
         while candidaterevs is not None:
             dbg_try_rounds += 1
             if debug_search:
                 prev = None
                 if deltainfo is not None:
                     prev = deltainfo.base
 
                 if (
                     cachedelta is not None
                     and len(candidaterevs) == 1
                     and cachedelta[0] in candidaterevs
                 ):
                     round_type = b"cached-delta"
                 elif p1 in candidaterevs or p2 in candidaterevs:
                     round_type = b"parents"
                 elif prev is not None and all(c < prev for c in candidaterevs):
                     round_type = b"refine-down"
                 elif prev is not None and all(c > prev for c in candidaterevs):
                     round_type = b"refine-up"
                 else:
                     round_type = b"search-down"
                 msg = b"DBG-DELTAS-SEARCH: ROUND #%d - %d candidates - %s\n"
                 msg %= (dbg_try_rounds, len(candidaterevs), round_type)
                 self._write_debug(msg)
             nominateddeltas = []
             if deltainfo is not None:
                 if debug_search:
                     msg = (
                         b"DBG-DELTAS-SEARCH:   CONTENDER: rev=%d - length=%d\n"
                     )
                     msg %= (deltainfo.base, deltainfo.deltalen)
                     self._write_debug(msg)
                 # if we already found a good delta,
                 # challenge it against refined candidates
                 nominateddeltas.append(deltainfo)
             for candidaterev in candidaterevs:
                 if debug_search:
                     msg = b"DBG-DELTAS-SEARCH:   CANDIDATE: rev=%d\n"
                     msg %= candidaterev
                     self._write_debug(msg)
                     candidate_type = None
                     if candidaterev == p1:
                         candidate_type = b"p1"
                     elif candidaterev == p2:
                         candidate_type = b"p2"
                     elif self.revlog.issnapshot(candidaterev):
                         candidate_type = b"snapshot-%d"
                         candidate_type %= self.revlog.snapshotdepth(
                             candidaterev
                         )
 
                     if candidate_type is not None:
                         msg = b"DBG-DELTAS-SEARCH:     type=%s\n"
                         msg %= candidate_type
                         self._write_debug(msg)
                     msg = b"DBG-DELTAS-SEARCH:     size=%d\n"
                     msg %= self.revlog.length(candidaterev)
                     self._write_debug(msg)
                     msg = b"DBG-DELTAS-SEARCH:     base=%d\n"
                     msg %= self.revlog.deltaparent(candidaterev)
                     self._write_debug(msg)
                 if candidaterev in excluded_bases:
                     if debug_search:
                         msg = b"DBG-DELTAS-SEARCH:     EXCLUDED\n"
                         self._write_debug(msg)
                     continue
                 if candidaterev >= target_rev:
                     if debug_search:
                         msg = b"DBG-DELTAS-SEARCH:     TOO-HIGH\n"
                         self._write_debug(msg)
                     continue
                 dbg_try_count += 1
 
                 if debug_search:
                     delta_start = util.timer()
                 candidatedelta = self._builddeltainfo(revinfo, candidaterev, fh)
                 if debug_search:
                     delta_end = util.timer()
                     msg = b"DBG-DELTAS-SEARCH:     delta-search-time=%f\n"
                     msg %= delta_end - delta_start
                     self._write_debug(msg)
                 if candidatedelta is not None:
                     if isgooddeltainfo(self.revlog, candidatedelta, revinfo):
                         if debug_search:
                             msg = b"DBG-DELTAS-SEARCH:     DELTA: length=%d (GOOD)\n"
                             msg %= candidatedelta.deltalen
                             self._write_debug(msg)
                         nominateddeltas.append(candidatedelta)
                     elif debug_search:
                         msg = b"DBG-DELTAS-SEARCH:     DELTA: length=%d (BAD)\n"
                         msg %= candidatedelta.deltalen
                         self._write_debug(msg)
                 elif debug_search:
                     msg = b"DBG-DELTAS-SEARCH:     NO-DELTA\n"
                     self._write_debug(msg)
             if nominateddeltas:
                 deltainfo = min(nominateddeltas, key=lambda x: x.deltalen)
             if deltainfo is not None:
                 candidaterevs = groups.send(deltainfo.base)
             else:
                 candidaterevs = next(groups)
 
         if deltainfo is None:
             dbg_type = b"full"
             deltainfo = self._fullsnapshotinfo(fh, revinfo, target_rev)
         elif deltainfo.snapshotdepth:  # pytype: disable=attribute-error
             dbg_type = b"snapshot"
         else:
             dbg_type = b"delta"
 
-        if self._write_debug is not None:
+        if gather_debug:
             end = util.timer()
-            assert deltainfo is not None  # please pytype
             used_cached = (
                 cachedelta is not None
                 and dbg_try_rounds == 1
                 and dbg_try_count == 1
                 and deltainfo.base == cachedelta[0]
             )
             dbg = {
                 'duration': end - start,
                 'revision': target_rev,
-                'delta-base': deltainfo.base,
+                'delta-base': deltainfo.base,  # pytype: disable=attribute-error
                 'search_round_count': dbg_try_rounds,
                 'using-cached-base': used_cached,
                 'delta_try_count': dbg_try_count,
                 'type': dbg_type,
                 'p1-chain-len': p1_chain_len,
                 'p2-chain-len': p2_chain_len,
             }
             if (
                 deltainfo.snapshotdepth  # pytype: disable=attribute-error
                 is not None
             ):
                 dbg[
                     'snapshot-depth'
                 ] = deltainfo.snapshotdepth  # pytype: disable=attribute-error
             else:
                 dbg['snapshot-depth'] = 0
             target_revlog = b"UNKNOWN"
             target_type = self.revlog.target[0]
             target_key = self.revlog.target[1]
             if target_type == KIND_CHANGELOG:
                 target_revlog = b'CHANGELOG:'
             elif target_type == KIND_MANIFESTLOG:
                 target_revlog = b'MANIFESTLOG:'
                 if target_key:
                     target_revlog += b'%s:' % target_key
             elif target_type == KIND_FILELOG:
                 target_revlog = b'FILELOG:'
                 if target_key:
                     target_revlog += b'%s:' % target_key
             dbg['target-revlog'] = target_revlog
 
+            if self._debug_info is not None:
+                self._debug_info.append(dbg)
+
+            if self._write_debug is not None:
             msg = (
                 b"DBG-DELTAS:"
                 b" %-12s"
                 b" rev=%d:"
                 b" delta-base=%d"
                 b" is-cached=%d"
                 b" - search-rounds=%d"
                 b" try-count=%d"
                 b" - delta-type=%-6s"
                 b" snap-depth=%d"
                 b" - p1-chain-length=%d"
                 b" p2-chain-length=%d"
                 b" - duration=%f"
                 b"\n"
             )
             msg %= (
                 dbg["target-revlog"],
                 dbg["revision"],
                 dbg["delta-base"],
                 dbg["using-cached-base"],
                 dbg["search_round_count"],
                 dbg["delta_try_count"],
                 dbg["type"],
                 dbg["snapshot-depth"],
                 dbg["p1-chain-len"],
                 dbg["p2-chain-len"],
                 dbg["duration"],
             )
             self._write_debug(msg)
         return deltainfo
 
 
 def delta_compression(default_compression_header, deltainfo):
     """return (COMPRESSION_MODE, deltainfo)
 
     used by revlog v2+ format to dispatch between PLAIN and DEFAULT
     compression.
     """
     h, d = deltainfo.data
     compression_mode = COMP_MODE_INLINE
     if not h and not d:
         # not data to store at all... declare them uncompressed
         compression_mode = COMP_MODE_PLAIN
     elif not h:
         t = d[0:1]
         if t == b'\0':
             compression_mode = COMP_MODE_PLAIN
         elif t == default_compression_header:
             compression_mode = COMP_MODE_DEFAULT
     elif h == b'u':
         # we have a more efficient way to declare uncompressed
         h = b''
         compression_mode = COMP_MODE_PLAIN
         deltainfo = drop_u_compression(deltainfo)
     return compression_mode, deltainfo

tests/test-bundle.t

@@ -1,1083 +1,1127 b''
 Setting up test
 
   $ hg init test
   $ cd test
   $ echo 0 > afile
   $ hg add afile
   $ hg commit -m "0.0"
   $ echo 1 >> afile
   $ hg commit -m "0.1"
   $ echo 2 >> afile
   $ hg commit -m "0.2"
   $ echo 3 >> afile
   $ hg commit -m "0.3"
   $ hg update -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 1 >> afile
   $ hg commit -m "1.1"
   created new head
   $ echo 2 >> afile
   $ hg commit -m "1.2"
   $ echo "a line" > fred
   $ echo 3 >> afile
   $ hg add fred
   $ hg commit -m "1.3"
   $ hg mv afile adifferentfile
   $ hg commit -m "1.3m"
   $ hg update -C 3
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg mv afile anotherfile
   $ hg commit -m "0.3m"
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 9 changesets with 7 changes to 4 files
   $ cd ..
   $ hg init empty
 
 Bundle and phase
 
   $ hg -R test phase --force --secret 0
   $ hg -R test bundle phase.hg empty
   searching for changes
   no changes found (ignored 9 secret changesets)
   [1]
   $ hg -R test phase --draft -r 'head()'
 
 Bundle --all
 
   $ hg -R test bundle --all all.hg
   9 changesets found
 
 Bundle test to full.hg
 
   $ hg -R test bundle full.hg empty
   searching for changes
   9 changesets found
 
 Unbundle full.hg in test
 
   $ hg -R test unbundle full.hg
   adding changesets
   adding manifests
   adding file changes
   added 0 changesets with 0 changes to 4 files
   (run 'hg update' to get a working copy)
 
 Verify empty
 
   $ hg -R empty heads
   [1]
   $ hg -R empty verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 0 changesets with 0 changes to 0 files
 
 #if repobundlerepo
 
 Pull full.hg into test (using --cwd)
 
   $ hg --cwd test pull ../full.hg
   pulling from ../full.hg
   searching for changes
   no changes found
 
 Verify that there are no leaked temporary files after pull (issue2797)
 
   $ ls test/.hg | grep .hg10un
   [1]
 
 Pull full.hg into empty (using --cwd)
 
   $ hg --cwd empty pull ../full.hg
   pulling from ../full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   new changesets f9ee2f85a263:aa35859c02ea (9 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Rollback empty
 
   $ hg -R empty rollback
   repository tip rolled back to revision -1 (undo pull)
 
 Pull full.hg into empty again (using --cwd)
 
   $ hg --cwd empty pull ../full.hg
   pulling from ../full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   new changesets f9ee2f85a263:aa35859c02ea (9 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Pull full.hg into test (using -R)
 
   $ hg -R test pull full.hg
   pulling from full.hg
   searching for changes
   no changes found
 
 Pull full.hg into empty (using -R)
 
   $ hg -R empty pull full.hg
   pulling from full.hg
   searching for changes
   no changes found
 
 Rollback empty
 
   $ hg -R empty rollback
   repository tip rolled back to revision -1 (undo pull)
 
 Pull full.hg into empty again (using -R)
 
   $ hg -R empty pull full.hg
   pulling from full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   new changesets f9ee2f85a263:aa35859c02ea (9 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Log -R full.hg in fresh empty
 
   $ rm -r empty
   $ hg init empty
   $ cd empty
   $ hg -R bundle://../full.hg log
   changeset:   8:aa35859c02ea
   tag:         tip
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
   changeset:   7:a6a34bfa0076
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   changeset:   6:7373c1169842
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3
   
   changeset:   5:1bb50a9436a7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.2
   
   changeset:   4:095197eb4973
   parent:      0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.1
   
   changeset:   3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3
   
   changeset:   2:e38ba6f5b7e0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.2
   
   changeset:   1:34c2bf6b0626
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.1
   
   changeset:   0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.0
   
 Make sure bundlerepo doesn't leak tempfiles (issue2491)
 
   $ ls .hg
   00changelog.i
   cache
   requires
   store
   wcache
 
 Pull ../full.hg into empty (with hook)
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > changegroup = sh -c "printenv.py --line changegroup"
   > EOF
 
 doesn't work (yet ?)
 NOTE: msys is mangling the URL below
 
 hg -R bundle://../full.hg verify
 
   $ hg pull bundle://../full.hg
   pulling from bundle:../full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   new changesets f9ee2f85a263:aa35859c02ea (9 drafts)
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=f9ee2f85a263049e9ae6d37a0e67e96194ffb735
   HG_NODE_LAST=aa35859c02ea8bd48da5da68cd2740ac71afcbaf
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   bundle:../full.hg (no-msys !)
   bundle;../full.hg (msys !)
   HG_URL=bundle:../full.hg (no-msys !)
   HG_URL=bundle;../full.hg (msys !)
   
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Rollback empty
 
   $ hg rollback
   repository tip rolled back to revision -1 (undo pull)
   $ cd ..
 
 Log -R bundle:empty+full.hg
 
   $ hg -R bundle:empty+full.hg log --template="{rev} "; echo ""
   8 7 6 5 4 3 2 1 0 
 
 Pull full.hg into empty again (using -R; with hook)
 
   $ hg -R empty pull full.hg
   pulling from full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   new changesets f9ee2f85a263:aa35859c02ea (9 drafts)
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=f9ee2f85a263049e9ae6d37a0e67e96194ffb735
   HG_NODE_LAST=aa35859c02ea8bd48da5da68cd2740ac71afcbaf
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   bundle:empty+full.hg
   HG_URL=bundle:empty+full.hg
   
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 #endif
 
 Cannot produce streaming clone bundles with "hg bundle"
 
   $ hg -R test bundle -t packed1 packed.hg
   abort: packed bundles cannot be produced by "hg bundle"
   (use 'hg debugcreatestreamclonebundle')
   [10]
 
 packed1 is produced properly
 
 
 #if reporevlogstore rust
 
   $ hg -R test debugcreatestreamclonebundle packed.hg
   writing 2665 bytes for 6 files
   bundle requirements: generaldelta, revlog-compression-zstd, revlogv1, sparserevlog
 
   $ f -B 64 --size --sha1 --hexdump packed.hg
   packed.hg: size=2865, sha1=353d10311f4befa195d9a1ca4b8e26518115c702
   0000: 48 47 53 31 55 4e 00 00 00 00 00 00 00 06 00 00 |HGS1UN..........|
   0010: 00 00 00 00 0a 69 00 3b 67 65 6e 65 72 61 6c 64 |.....i.;generald|
   0020: 65 6c 74 61 2c 72 65 76 6c 6f 67 2d 63 6f 6d 70 |elta,revlog-comp|
   0030: 72 65 73 73 69 6f 6e 2d 7a 73 74 64 2c 72 65 76 |ression-zstd,rev|
   $ hg debugbundle --spec packed.hg
   none-packed1;requirements%3Dgeneraldelta%2Crevlog-compression-zstd%2Crevlogv1%2Csparserevlog
 #endif
 
 #if reporevlogstore no-rust zstd
 
   $ hg -R test debugcreatestreamclonebundle packed.hg
   writing 2665 bytes for 6 files
   bundle requirements: generaldelta, revlog-compression-zstd, revlogv1, sparserevlog
 
   $ f -B 64 --size --sha1 --hexdump packed.hg
   packed.hg: size=2865, sha1=353d10311f4befa195d9a1ca4b8e26518115c702
   0000: 48 47 53 31 55 4e 00 00 00 00 00 00 00 06 00 00 |HGS1UN..........|
   0010: 00 00 00 00 0a 69 00 3b 67 65 6e 65 72 61 6c 64 |.....i.;generald|
   0020: 65 6c 74 61 2c 72 65 76 6c 6f 67 2d 63 6f 6d 70 |elta,revlog-comp|
   0030: 72 65 73 73 69 6f 6e 2d 7a 73 74 64 2c 72 65 76 |ression-zstd,rev|
   $ hg debugbundle --spec packed.hg
   none-packed1;requirements%3Dgeneraldelta%2Crevlog-compression-zstd%2Crevlogv1%2Csparserevlog
 #endif
 
 #if reporevlogstore no-rust no-zstd
 
   $ hg -R test debugcreatestreamclonebundle packed.hg
   writing 2664 bytes for 6 files
   bundle requirements: generaldelta, revlogv1, sparserevlog
 
   $ f -B 64 --size --sha1 --hexdump packed.hg
   packed.hg: size=2840, sha1=12bf3eee3eb8a04c503ce2d29b48f0135c7edff5
   0000: 48 47 53 31 55 4e 00 00 00 00 00 00 00 06 00 00 |HGS1UN..........|
   0010: 00 00 00 00 0a 68 00 23 67 65 6e 65 72 61 6c 64 |.....h.#generald|
   0020: 65 6c 74 61 2c 72 65 76 6c 6f 67 76 31 2c 73 70 |elta,revlogv1,sp|
   0030: 61 72 73 65 72 65 76 6c 6f 67 00 64 61 74 61 2f |arserevlog.data/|
   $ hg debugbundle --spec packed.hg
   none-packed1;requirements%3Dgeneraldelta%2Crevlogv1%2Csparserevlog
 #endif
 
 #if reporevlogstore
 
 generaldelta requirement is not listed in stream clone bundles unless used
 
   $ hg --config format.usegeneraldelta=false init testnongd
   $ cd testnongd
   $ touch foo
   $ hg -q commit -A -m initial
   $ cd ..
 
 #endif
 
 #if reporevlogstore rust
 
   $ hg -R testnongd debugcreatestreamclonebundle packednongd.hg
   writing 301 bytes for 3 files
   bundle requirements: revlog-compression-zstd, revlogv1
 
   $ f -B 64 --size --sha1 --hexdump packednongd.hg
   packednongd.hg: size=407, sha1=0b8714422b785ba8eb98c916b41ffd5fb994c9b5
   0000: 48 47 53 31 55 4e 00 00 00 00 00 00 00 03 00 00 |HGS1UN..........|
   0010: 00 00 00 00 01 2d 00 21 72 65 76 6c 6f 67 2d 63 |.....-.!revlog-c|
   0020: 6f 6d 70 72 65 73 73 69 6f 6e 2d 7a 73 74 64 2c |ompression-zstd,|
   0030: 72 65 76 6c 6f 67 76 31 00 64 61 74 61 2f 66 6f |revlogv1.data/fo|
 
   $ hg debugbundle --spec packednongd.hg
   none-packed1;requirements%3Drevlog-compression-zstd%2Crevlogv1
 
 #endif
 
 #if reporevlogstore no-rust zstd
 
   $ hg -R testnongd debugcreatestreamclonebundle packednongd.hg
   writing 301 bytes for 3 files
   bundle requirements: revlog-compression-zstd, revlogv1
 
   $ f -B 64 --size --sha1 --hexdump packednongd.hg
   packednongd.hg: size=407, sha1=0b8714422b785ba8eb98c916b41ffd5fb994c9b5
   0000: 48 47 53 31 55 4e 00 00 00 00 00 00 00 03 00 00 |HGS1UN..........|
   0010: 00 00 00 00 01 2d 00 21 72 65 76 6c 6f 67 2d 63 |.....-.!revlog-c|
   0020: 6f 6d 70 72 65 73 73 69 6f 6e 2d 7a 73 74 64 2c |ompression-zstd,|
   0030: 72 65 76 6c 6f 67 76 31 00 64 61 74 61 2f 66 6f |revlogv1.data/fo|
 
   $ hg debugbundle --spec packednongd.hg
   none-packed1;requirements%3Drevlog-compression-zstd%2Crevlogv1
 
 
 #endif
 
 #if reporevlogstore no-rust no-zstd
 
   $ hg -R testnongd debugcreatestreamclonebundle packednongd.hg
   writing 301 bytes for 3 files
   bundle requirements: revlogv1
 
   $ f -B 64 --size --sha1 --hexdump packednongd.hg
   packednongd.hg: size=383, sha1=1d9c230238edd5d38907100b729ba72b1831fe6f
   0000: 48 47 53 31 55 4e 00 00 00 00 00 00 00 03 00 00 |HGS1UN..........|
   0010: 00 00 00 00 01 2d 00 09 72 65 76 6c 6f 67 76 31 |.....-..revlogv1|
   0020: 00 64 61 74 61 2f 66 6f 6f 2e 69 00 36 34 0a 00 |.data/foo.i.64..|
   0030: 01 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
 
   $ hg debugbundle --spec packednongd.hg
   none-packed1;requirements%3Drevlogv1
 
 
 #endif
 
 #if reporevlogstore
 
 Warning emitted when packed bundles contain secret changesets
 
   $ hg init testsecret
   $ cd testsecret
   $ touch foo
   $ hg -q commit -A -m initial
   $ hg phase --force --secret -r .
   $ cd ..
 
 #endif
 
 #if reporevlogstore rust
 
   $ hg -R testsecret debugcreatestreamclonebundle packedsecret.hg
   (warning: stream clone bundle will contain secret revisions)
   writing 301 bytes for 3 files
   bundle requirements: generaldelta, revlog-compression-zstd, revlogv1, sparserevlog
 
 #endif
 
 #if reporevlogstore no-rust zstd
 
   $ hg -R testsecret debugcreatestreamclonebundle packedsecret.hg
   (warning: stream clone bundle will contain secret revisions)
   writing 301 bytes for 3 files
   bundle requirements: generaldelta, revlog-compression-zstd, revlogv1, sparserevlog
 
 #endif
 
 #if reporevlogstore no-rust no-zstd
 
   $ hg -R testsecret debugcreatestreamclonebundle packedsecret.hg
   (warning: stream clone bundle will contain secret revisions)
   writing 301 bytes for 3 files
   bundle requirements: generaldelta, revlogv1, sparserevlog
 
 #endif
 
 #if reporevlogstore
 
 Unpacking packed1 bundles with "hg unbundle" isn't allowed
 
   $ hg init packed
   $ hg -R packed unbundle packed.hg
   abort: packed bundles cannot be applied with "hg unbundle"
   (use "hg debugapplystreamclonebundle")
   [10]
 
 packed1 can be consumed from debug command
 
 (this also confirms that streamclone-ed changes are visible via
 @filecache properties to in-process procedures before closing
 transaction)
 
   $ cat > $TESTTMP/showtip.py <<EOF
   > 
   > def showtip(ui, repo, hooktype, **kwargs):
   >     ui.warn(b'%s: %s\n' % (hooktype, repo[b'tip'].hex()[:12]))
   > 
   > def reposetup(ui, repo):
   >     # this confirms (and ensures) that (empty) 00changelog.i
   >     # before streamclone is already cached as repo.changelog
   >     ui.setconfig(b'hooks', b'pretxnopen.showtip', showtip)
   > 
   >     # this confirms that streamclone-ed changes are visible to
   >     # in-process procedures before closing transaction
   >     ui.setconfig(b'hooks', b'pretxnclose.showtip', showtip)
   > 
   >     # this confirms that streamclone-ed changes are still visible
   >     # after closing transaction
   >     ui.setconfig(b'hooks', b'txnclose.showtip', showtip)
   > EOF
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > showtip = $TESTTMP/showtip.py
   > EOF
 
   $ hg -R packed debugapplystreamclonebundle packed.hg
   6 files to transfer, 2.60 KB of data
   pretxnopen: 000000000000
   pretxnclose: aa35859c02ea
   transferred 2.60 KB in * seconds (* */sec) (glob)
   txnclose: aa35859c02ea
 
 (for safety, confirm visibility of streamclone-ed changes by another
 process, too)
 
   $ hg -R packed tip -T "{node|short}\n"
   aa35859c02ea
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > showtip = !
   > EOF
 
 Does not work on non-empty repo
 
   $ hg -R packed debugapplystreamclonebundle packed.hg
   abort: cannot apply stream clone bundle on non-empty repo
   [255]
 
 #endif
 
 Create partial clones
 
   $ rm -r empty
   $ hg init empty
   $ hg clone -r 3 test partial
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 1 files
   new changesets f9ee2f85a263:eebf5a27f8ca
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg clone partial partial2
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd partial
 
 #if repobundlerepo
 
 Log -R full.hg in partial
 
   $ hg -R bundle://../full.hg log -T phases
   changeset:   8:aa35859c02ea
   tag:         tip
   phase:       draft
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
   changeset:   7:a6a34bfa0076
   phase:       draft
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   changeset:   6:7373c1169842
   phase:       draft
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3
   
   changeset:   5:1bb50a9436a7
   phase:       draft
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.2
   
   changeset:   4:095197eb4973
   phase:       draft
   parent:      0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.1
   
   changeset:   3:eebf5a27f8ca
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3
   
   changeset:   2:e38ba6f5b7e0
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.2
   
   changeset:   1:34c2bf6b0626
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.1
   
   changeset:   0:f9ee2f85a263
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.0
   
 
 Incoming full.hg in partial
 
   $ hg incoming bundle://../full.hg
   comparing with bundle:../full.hg
   searching for changes
   changeset:   4:095197eb4973
   parent:      0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.1
   
   changeset:   5:1bb50a9436a7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.2
   
   changeset:   6:7373c1169842
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3
   
   changeset:   7:a6a34bfa0076
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   changeset:   8:aa35859c02ea
   tag:         tip
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
 
 Outgoing -R full.hg vs partial2 in partial
 
   $ hg -R bundle://../full.hg outgoing ../partial2
   comparing with ../partial2
   searching for changes
   changeset:   4:095197eb4973
   parent:      0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.1
   
   changeset:   5:1bb50a9436a7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.2
   
   changeset:   6:7373c1169842
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3
   
   changeset:   7:a6a34bfa0076
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   changeset:   8:aa35859c02ea
   tag:         tip
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
 
 Outgoing -R does-not-exist.hg vs partial2 in partial
 
   $ hg -R bundle://../does-not-exist.hg outgoing ../partial2
   abort: *../does-not-exist.hg* (glob)
   [255]
 
 #endif
 
   $ cd ..
 
 hide outer repo
   $ hg init
 
 Direct clone from bundle (all-history)
 
 #if repobundlerepo
 
   $ hg clone full.hg full-clone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   new changesets f9ee2f85a263:aa35859c02ea (9 drafts)
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R full-clone heads
   changeset:   8:aa35859c02ea
   tag:         tip
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
   changeset:   7:a6a34bfa0076
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   $ rm -r full-clone
 
 When cloning from a non-copiable repository into '', do not
 recurse infinitely (issue2528)
 
   $ hg clone full.hg ''
   abort: empty destination path is not valid
   [10]
 
 test for https://bz.mercurial-scm.org/216
 
 Unbundle incremental bundles into fresh empty in one go
 
   $ rm -r empty
   $ hg init empty
   $ hg -R test bundle --base null -r 0 ../0.hg
   1 changesets found
   $ hg -R test bundle --exact -r 1 ../1.hg
   1 changesets found
   $ hg -R empty unbundle -u ../0.hg ../1.hg
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets f9ee2f85a263 (1 drafts)
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 34c2bf6b0626 (1 drafts)
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 View full contents of the bundle
   $ hg -R test bundle --base null -r 3  ../partial.hg
   4 changesets found
   $ cd test
   $ hg -R ../../partial.hg log -r "bundle()"
   changeset:   0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.0
   
   changeset:   1:34c2bf6b0626
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.1
   
   changeset:   2:e38ba6f5b7e0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.2
   
   changeset:   3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3
   
   $ cd ..
 
 #endif
 
 test for 540d1059c802
 
   $ hg init orig
   $ cd orig
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m 'add foo'
 
   $ hg clone . ../copy
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg tag foo
 
   $ cd ../copy
   $ echo >> foo
   $ hg ci -m 'change foo'
   $ hg bundle ../bundle.hg ../orig
   searching for changes
   1 changesets found
 
   $ cd ..
 
 #if repobundlerepo
   $ cd orig
   $ hg incoming ../bundle.hg
   comparing with ../bundle.hg
   searching for changes
   changeset:   2:ed1b79f46b9a
   tag:         tip
   parent:      0:bbd179dfa0a7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo
   
   $ cd ..
 
 test bundle with # in the filename (issue2154):
 
   $ cp bundle.hg 'test#bundle.hg'
   $ cd orig
   $ hg incoming '../test#bundle.hg'
   comparing with ../test
   abort: unknown revision 'bundle.hg'
   [10]
 
 note that percent encoding is not handled:
 
   $ hg incoming ../test%23bundle.hg
   abort: repository ../test%23bundle.hg not found
   [255]
   $ cd ..
 
 #endif
 
 test to bundle revisions on the newly created branch (issue3828):
 
   $ hg -q clone -U test test-clone
   $ cd test
 
   $ hg -q branch foo
   $ hg commit -m "create foo branch"
   $ hg -q outgoing ../test-clone
   9:b4f5acb1ee27
   $ hg -q bundle --branch foo foo.hg ../test-clone
 #if repobundlerepo
   $ hg -R foo.hg -q log -r "bundle()"
   9:b4f5acb1ee27
 #endif
 
   $ cd ..
 
 test for https://bz.mercurial-scm.org/1144
 
 test that verify bundle does not traceback
 
 partial history bundle, fails w/ unknown parent
 
   $ hg -R bundle.hg verify
   abort: 00changelog@bbd179dfa0a71671c253b3ae0aa1513b60d199fa: unknown parent
   [50]
 
 full history bundle, refuses to verify non-local repo
 
 #if repobundlerepo
   $ hg -R all.hg verify
   abort: cannot verify bundle or remote repos
   [255]
 #endif
 
 but, regular verify must continue to work
 
   $ hg -R orig verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 2 changesets with 2 changes to 2 files
 
 #if repobundlerepo
 diff against bundle
 
   $ hg init b
   $ cd b
   $ hg -R ../all.hg diff -r tip
   diff -r aa35859c02ea anotherfile
   --- a/anotherfile	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,4 +0,0 @@
   -0
   -1
   -2
   -3
   $ cd ..
 #endif
 
 bundle single branch
 
   $ hg init branchy
   $ cd branchy
   $ echo a >a
   $ echo x >x
   $ hg ci -Ama
   adding a
   adding x
   $ echo c >c
   $ echo xx >x
   $ hg ci -Amc
   adding c
   $ echo c1 >c1
   $ hg ci -Amc1
   adding c1
   $ hg up 0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo b >b
   $ hg ci -Amb
   adding b
   created new head
   $ echo b1 >b1
   $ echo xx >x
   $ hg ci -Amb1
   adding b1
   $ hg clone -q -r2 . part
 
 == bundling via incoming
 
   $ hg in -R part --bundle incoming.hg --template "{node}\n" .
   comparing with .
   searching for changes
   1a38c1b849e8b70c756d2d80b0b9a3ac0b7ea11a
   057f4db07f61970e1c11e83be79e9d08adc4dc31
 
 == bundling
 
   $ hg bundle bundle.hg part --debug --config progress.debug=true
   query 1; heads
   searching for changes
   all remote heads known locally
   2 changesets found
   list of changesets:
   1a38c1b849e8b70c756d2d80b0b9a3ac0b7ea11a
   057f4db07f61970e1c11e83be79e9d08adc4dc31
   bundle2-output-bundle: "HG20", (1 params) 2 parts total
   bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   changesets: 1/2 chunks (50.00%)
   changesets: 2/2 chunks (100.00%)
   manifests: 1/2 chunks (50.00%)
   manifests: 2/2 chunks (100.00%)
   files: b 1/3 files (33.33%)
   files: b1 2/3 files (66.67%)
   files: x 3/3 files (100.00%)
   bundle2-output-part: "cache:rev-branch-cache" (advisory) streamed payload
 
 #if repobundlerepo
 == Test for issue3441
 
   $ hg clone -q -r0 . part2
   $ hg -q -R part2 pull bundle.hg
   $ hg -R part2 verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 3 changesets with 5 changes to 4 files
 #endif
 
 == Test bundling no commits
 
   $ hg bundle -r 'public()' no-output.hg
   abort: no commits to bundle
   [10]
 
   $ cd ..
 
 When user merges to the revision existing only in the bundle,
 it should show warning that second parent of the working
 directory does not exist
 
   $ hg init update2bundled
   $ cd update2bundled
   $ cat <<EOF >> .hg/hgrc
   > [extensions]
   > strip =
   > EOF
   $ echo "aaa" >> a
   $ hg commit -A -m 0
   adding a
   $ echo "bbb" >> b
   $ hg commit -A -m 1
   adding b
   $ echo "ccc" >> c
   $ hg commit -A -m 2
   adding c
   $ hg update -r 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "ddd" >> d
   $ hg commit -A -m 3
   adding d
   created new head
   $ hg update -r 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -G
   o  changeset:   3:8bd3e1f196af
   |  tag:         tip
   |  parent:      1:a01eca7af26d
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     3
   |
   | @  changeset:   2:4652c276ac4f
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     2
   |
   o  changeset:   1:a01eca7af26d
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     1
   |
   o  changeset:   0:4fe08cd4693e
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
 
 #if repobundlerepo
   $ hg bundle --base 1 -r 3 ../update2bundled.hg
   1 changesets found
   $ hg strip -r 3
   saved backup bundle to $TESTTMP/update2bundled/.hg/strip-backup/8bd3e1f196af-017e56d8-backup.hg
   $ hg merge -R ../update2bundled.hg -r 3
   setting parent to node 8bd3e1f196af289b2b121be08031e76d7ae92098 that only exists in the bundle
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 When user updates to the revision existing only in the bundle,
 it should show warning
 
   $ hg update -R ../update2bundled.hg --clean -r 3
   setting parent to node 8bd3e1f196af289b2b121be08031e76d7ae92098 that only exists in the bundle
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 When user updates to the revision existing in the local repository
 the warning shouldn't be emitted
 
   $ hg update -R ../update2bundled.hg -r 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 #endif
 
 Test the option that create slim bundle
 
   $ hg bundle -a --config devel.bundle.delta=p1 ./slim.hg
   3 changesets found
 
 Test the option that create and no-delta's bundle
   $ hg bundle -a --config devel.bundle.delta=full ./full.hg
   3 changesets found
 
 
 Test the debug statistic when building a bundle
 -----------------------------------------------
 
   $ hg bundle -a ./default.hg --config debug.bundling-stats=yes
   3 changesets found
   DEBUG-BUNDLING: revisions:                9
   DEBUG-BUNDLING:   changelog:              3
   DEBUG-BUNDLING:   manifest:               3
   DEBUG-BUNDLING:   files:                  3 (for 3 revlogs)
   DEBUG-BUNDLING: deltas:
   DEBUG-BUNDLING:   from-storage:           2 (100% of available 2)
   DEBUG-BUNDLING:   computed:               7
   DEBUG-BUNDLING:     full:                 7 (100% of native 7)
   DEBUG-BUNDLING:       changelog:          3 (100% of native 3)
   DEBUG-BUNDLING:       manifests:          1 (100% of native 1)
   DEBUG-BUNDLING:       files:              3 (100% of native 3)
 
 Test the debug output when applying delta
 -----------------------------------------
 
   $ hg init foo
   $ hg -R foo unbundle ./slim.hg \
   > --config debug.revlog.debug-delta=yes \
   > --config storage.revlog.reuse-external-delta=no \
   > --config storage.revlog.reuse-external-delta-parent=no
   adding changesets
   DBG-DELTAS: CHANGELOG:   rev=0: delta-base=0 is-cached=0 - search-rounds=0 try-count=0 - delta-type=full   snap-depth=0 - p1-chain-length=-1 p2-chain-length=-1 - duration=* (glob)
   DBG-DELTAS: CHANGELOG:   rev=1: delta-base=1 is-cached=0 - search-rounds=0 try-count=0 - delta-type=full   snap-depth=0 - p1-chain-length=0 p2-chain-length=-1 - duration=* (glob)
   DBG-DELTAS: CHANGELOG:   rev=2: delta-base=2 is-cached=0 - search-rounds=0 try-count=0 - delta-type=full   snap-depth=0 - p1-chain-length=0 p2-chain-length=-1 - duration=* (glob)
   adding manifests
   DBG-DELTAS: MANIFESTLOG: rev=0: delta-base=0 is-cached=0 - search-rounds=0 try-count=0 - delta-type=full   snap-depth=0 - p1-chain-length=-1 p2-chain-length=-1 - duration=* (glob)
   DBG-DELTAS: MANIFESTLOG: rev=1: delta-base=0 is-cached=1 - search-rounds=1 try-count=1 - delta-type=delta  snap-depth=0 - p1-chain-length=0 p2-chain-length=-1 - duration=* (glob)
   DBG-DELTAS: MANIFESTLOG: rev=2: delta-base=1 is-cached=1 - search-rounds=1 try-count=1 - delta-type=delta  snap-depth=0 - p1-chain-length=1 p2-chain-length=-1 - duration=* (glob)
   adding file changes
   DBG-DELTAS: FILELOG:a:   rev=0: delta-base=0 is-cached=0 - search-rounds=0 try-count=0 - delta-type=full   snap-depth=0 - p1-chain-length=-1 p2-chain-length=-1 - duration=* (glob)
   DBG-DELTAS: FILELOG:b:   rev=0: delta-base=0 is-cached=0 - search-rounds=0 try-count=0 - delta-type=full   snap-depth=0 - p1-chain-length=-1 p2-chain-length=-1 - duration=* (glob)
   DBG-DELTAS: FILELOG:c:   rev=0: delta-base=0 is-cached=0 - search-rounds=0 try-count=0 - delta-type=full   snap-depth=0 - p1-chain-length=-1 p2-chain-length=-1 - duration=* (glob)
   added 3 changesets with 3 changes to 3 files
   new changesets 4fe08cd4693e:4652c276ac4f (3 drafts)
   (run 'hg update' to get a working copy)
 
+
+Test the debug statistic when applying a bundle
+-----------------------------------------------
+
+  $ hg init bar
+  $ hg -R bar unbundle ./default.hg  --config debug.unbundling-stats=yes
+  adding changesets
+  adding manifests
+  adding file changes
+  DEBUG-UNBUNDLING: revisions:                9
+  DEBUG-UNBUNDLING:   changelog:              3             ( 33%)
+  DEBUG-UNBUNDLING:   manifests:              3             ( 33%)
+  DEBUG-UNBUNDLING:   files:                  3             ( 33%)
+  DEBUG-UNBUNDLING: total-time:      ?????????????? seconds (glob)
+  DEBUG-UNBUNDLING:   changelog:     ?????????????? seconds (???%) (glob)
+  DEBUG-UNBUNDLING:   manifests:     ?????????????? seconds (???%) (glob)
+  DEBUG-UNBUNDLING:   files:         ?????????????? seconds (???%) (glob)
+  DEBUG-UNBUNDLING: type-count:
+  DEBUG-UNBUNDLING:   changelog:
+  DEBUG-UNBUNDLING:     full:                 3
+  DEBUG-UNBUNDLING:       cached:             0             (  0%)
+  DEBUG-UNBUNDLING:   manifests:
+  DEBUG-UNBUNDLING:     full:                 1
+  DEBUG-UNBUNDLING:       cached:             0             (  0%)
+  DEBUG-UNBUNDLING:     delta:                2
+  DEBUG-UNBUNDLING:       cached:             2             (100%)
+  DEBUG-UNBUNDLING:   files:
+  DEBUG-UNBUNDLING:     full:                 3
+  DEBUG-UNBUNDLING:       cached:             0             (  0%)
+  DEBUG-UNBUNDLING: type-time:
+  DEBUG-UNBUNDLING:   changelog:
+  DEBUG-UNBUNDLING:     full:        ?????????????? seconds (???% of total) (glob)
+  DEBUG-UNBUNDLING:       cached:    ?????????????? seconds (???% of total) (glob)
+  DEBUG-UNBUNDLING:   manifests:
+  DEBUG-UNBUNDLING:     full:        ?????????????? seconds (???% of total) (glob)
+  DEBUG-UNBUNDLING:       cached:    ?????????????? seconds (???% of total) (glob)
+  DEBUG-UNBUNDLING:     delta:       ?????????????? seconds (???% of total) (glob)
+  DEBUG-UNBUNDLING:       cached:    ?????????????? seconds (???% of total) (glob)
+  DEBUG-UNBUNDLING:   files:
+  DEBUG-UNBUNDLING:     full:        ?????????????? seconds (???% of total) (glob)
+  DEBUG-UNBUNDLING:       cached:    ?????????????? seconds (???% of total) (glob)
+  added 3 changesets with 3 changes to 3 files
+  new changesets 4fe08cd4693e:4652c276ac4f (3 drafts)
+  (run 'hg update' to get a working copy)