dirstate-v2: Introduce a docket file

.hg/dirstate now only contains some metadata to point to a separate data file
named .hg/dirstate.{}.d with a random hexadecimal identifier. For now every
update creates a new data file and removes the old one, but later we’ll
(usually) append to an existing file.

Separating into two files allows doing the "write to a temporary file then
atomically rename into destination" dance with only a small docket file,
without always rewriting a lot of data.

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

mercurial/dirstateutils/docket.py

@@ -0,0 +1,62 b''
+# dirstatedocket.py - docket file for dirstate-v2
+#
+# Copyright Mercurial Contributors
+#
+# This software may be used and distributed according to the terms of the
+# GNU General Public License version 2 or any later version.
+
+from __future__ import absolute_import
+
+import struct
+
+from ..revlogutils import docket as docket_mod
+
+
+V2_FORMAT_MARKER = b"dirstate-v2\n"
+
+# * 12 bytes: format marker
+# * 32 bytes: node ID of the working directory's first parent
+# * 32 bytes: node ID of the working directory's second parent
+# * 4 bytes: big-endian used size of the data file
+# * 1 byte: length of the data file's UUID
+# * variable: data file's UUID
+#
+# Node IDs are null-padded if shorter than 32 bytes.
+# A data file shorter than the specified used size is corrupted (truncated)
+HEADER = struct.Struct(">{}s32s32sLB".format(len(V2_FORMAT_MARKER)))
+
+
+class DirstateDocket(object):
+    data_filename_pattern = b'dirstate.%s.d'
+
+    def __init__(self, parents, data_size, uuid):
+        self.parents = parents
+        self.data_size = data_size
+        self.uuid = uuid
+
+    @classmethod
+    def with_new_uuid(cls, parents, data):
+        return cls(parents, data, docket_mod.make_uid())
+
+    @classmethod
+    def parse(cls, data, nodeconstants):
+        if not data:
+            parents = (nodeconstants.nullid, nodeconstants.nullid)
+            return cls(parents, 0, None)
+        marker, p1, p2, data_size, uuid_size = HEADER.unpack_from(data)
+        if marker != V2_FORMAT_MARKER:
+            raise ValueError("expected dirstate-v2 marker")
+        uuid = data[HEADER.size : HEADER.size + uuid_size]
+        p1 = p1[: nodeconstants.nodelen]
+        p2 = p2[: nodeconstants.nodelen]
+        return cls((p1, p2), data_size, uuid)
+
+    def serialize(self):
+        p1, p2 = self.parents
+        header = HEADER.pack(
+            V2_FORMAT_MARKER, p1, p2, self.data_size, len(self.uuid)
+        )
+        return header + self.uuid
+
+    def data_filename(self):
+        return self.data_filename_pattern % self.uuid

contrib/dirstatenonnormalcheck.py

@@ -1,69 +1,69 b''
 # dirstatenonnormalcheck.py - extension to check the consistency of the
 # dirstate's non-normal map
 #
 # For most operations on dirstate, this extensions checks that the nonnormalset
 # contains the right entries.
 # It compares the nonnormal file to a nonnormalset built from the map of all
 # the files in the dirstate to check that they contain the same files.
 
 from __future__ import absolute_import
 
 from mercurial import (
     dirstate,
     extensions,
     pycompat,
 )
 
 
 def nonnormalentries(dmap):
     """Compute nonnormal entries from dirstate's dmap"""
     res = set()
     for f, e in dmap.iteritems():
         if e.state != b'n' or e.mtime == -1:
             res.add(f)
     return res
 
 
 def checkconsistency(ui, orig, dmap, _nonnormalset, label):
     """Compute nonnormalset from dmap, check that it matches _nonnormalset"""
     nonnormalcomputedmap = nonnormalentries(dmap)
     if _nonnormalset != nonnormalcomputedmap:
         b_orig = pycompat.sysbytes(repr(orig))
         ui.develwarn(b"%s call to %s\n" % (label, b_orig), config=b'dirstate')
         ui.develwarn(b"inconsistency in nonnormalset\n", config=b'dirstate')
         b_nonnormal = pycompat.sysbytes(repr(_nonnormalset))
         ui.develwarn(b"[nonnormalset] %s\n" % b_nonnormal, config=b'dirstate')
         b_nonnormalcomputed = pycompat.sysbytes(repr(nonnormalcomputedmap))
         ui.develwarn(b"[map] %s\n" % b_nonnormalcomputed, config=b'dirstate')
 
 
-def _checkdirstate(orig, self, arg):
+def _checkdirstate(orig, self, *args, **kwargs):
     """Check nonnormal set consistency before and after the call to orig"""
     checkconsistency(
         self._ui, orig, self._map, self._map.nonnormalset, b"before"
     )
-    r = orig(self, arg)
+    r = orig(self, *args, **kwargs)
     checkconsistency(
         self._ui, orig, self._map, self._map.nonnormalset, b"after"
     )
     return r
 
 
 def extsetup(ui):
     """Wrap functions modifying dirstate to check nonnormalset consistency"""
     dirstatecl = dirstate.dirstate
     devel = ui.configbool(b'devel', b'all-warnings')
     paranoid = ui.configbool(b'experimental', b'nonnormalparanoidcheck')
     if devel:
         extensions.wrapfunction(dirstatecl, '_writedirstate', _checkdirstate)
         if paranoid:
             # We don't do all these checks when paranoid is disable as it would
             # make the extension run very slowly on large repos
             extensions.wrapfunction(dirstatecl, 'normallookup', _checkdirstate)
             extensions.wrapfunction(dirstatecl, 'otherparent', _checkdirstate)
             extensions.wrapfunction(dirstatecl, 'normal', _checkdirstate)
             extensions.wrapfunction(dirstatecl, 'write', _checkdirstate)
             extensions.wrapfunction(dirstatecl, 'add', _checkdirstate)
             extensions.wrapfunction(dirstatecl, 'remove', _checkdirstate)
             extensions.wrapfunction(dirstatecl, 'merge', _checkdirstate)
             extensions.wrapfunction(dirstatecl, 'drop', _checkdirstate)

mercurial/debugcommands.py

@@ -1,4833 +1,4852 b''
 # debugcommands.py - command processing for debug* commands
 #
 # Copyright 2005-2016 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 __future__ import absolute_import
 
+import binascii
 import codecs
 import collections
 import contextlib
 import difflib
 import errno
 import glob
 import operator
 import os
 import platform
 import random
 import re
 import socket
 import ssl
 import stat
 import string
 import subprocess
 import sys
 import time
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullrev,
     short,
 )
 from .pycompat import (
     getattr,
     open,
 )
 from . import (
     bundle2,
     bundlerepo,
     changegroup,
     cmdutil,
     color,
     context,
     copies,
     dagparser,
     encoding,
     error,
     exchange,
     extensions,
     filemerge,
     filesetlang,
     formatter,
     hg,
     httppeer,
     localrepo,
     lock as lockmod,
     logcmdutil,
     mergestate as mergestatemod,
     metadata,
     obsolete,
     obsutil,
     pathutil,
     phases,
     policy,
     pvec,
     pycompat,
     registrar,
     repair,
     repoview,
     revlog,
     revset,
     revsetlang,
     scmutil,
     setdiscovery,
     simplemerge,
     sshpeer,
     sslutil,
     streamclone,
     strip,
     tags as tagsmod,
     templater,
     treediscovery,
     upgrade,
     url as urlmod,
     util,
     vfs as vfsmod,
     wireprotoframing,
     wireprotoserver,
     wireprotov2peer,
 )
 from .interfaces import repository
 from .utils import (
     cborutil,
     compression,
     dateutil,
     procutil,
     stringutil,
     urlutil,
 )
 
 from .revlogutils import (
     deltas as deltautil,
     nodemap,
     sidedata,
 )
 
 release = lockmod.release
 
 table = {}
 table.update(strip.command._table)
 command = registrar.command(table)
 
 
 @command(b'debugancestor', [], _(b'[INDEX] REV1 REV2'), optionalrepo=True)
 def debugancestor(ui, repo, *args):
     """find the ancestor revision of two revisions in a given index"""
     if len(args) == 3:
         index, rev1, rev2 = args
         r = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), index)
         lookup = r.lookup
     elif len(args) == 2:
         if not repo:
             raise error.Abort(
                 _(b'there is no Mercurial repository here (.hg not found)')
             )
         rev1, rev2 = args
         r = repo.changelog
         lookup = repo.lookup
     else:
         raise error.Abort(_(b'either two or three arguments required'))
     a = r.ancestor(lookup(rev1), lookup(rev2))
     ui.write(b'%d:%s\n' % (r.rev(a), hex(a)))
 
 
 @command(b'debugantivirusrunning', [])
 def debugantivirusrunning(ui, repo):
     """attempt to trigger an antivirus scanner to see if one is active"""
     with repo.cachevfs.open('eicar-test-file.com', b'wb') as f:
         f.write(
             util.b85decode(
                 # This is a base85-armored version of the EICAR test file. See
                 # https://en.wikipedia.org/wiki/EICAR_test_file for details.
                 b'ST#=}P$fV?P+K%yP+C|uG$>GBDK|qyDK~v2MM*<JQY}+dK~6+LQba95P'
                 b'E<)&Nm5l)EmTEQR4qnHOhq9iNGnJx'
             )
         )
     # Give an AV engine time to scan the file.
     time.sleep(2)
     util.unlink(repo.cachevfs.join('eicar-test-file.com'))
 
 
 @command(b'debugapplystreamclonebundle', [], b'FILE')
 def debugapplystreamclonebundle(ui, repo, fname):
     """apply a stream clone bundle file"""
     f = hg.openpath(ui, fname)
     gen = exchange.readbundle(ui, f, fname)
     gen.apply(repo)
 
 
 @command(
     b'debugbuilddag',
     [
         (
             b'm',
             b'mergeable-file',
             None,
             _(b'add single file mergeable changes'),
         ),
         (
             b'o',
             b'overwritten-file',
             None,
             _(b'add single file all revs overwrite'),
         ),
         (b'n', b'new-file', None, _(b'add new file at each rev')),
     ],
     _(b'[OPTION]... [TEXT]'),
 )
 def debugbuilddag(
     ui,
     repo,
     text=None,
     mergeable_file=False,
     overwritten_file=False,
     new_file=False,
 ):
     """builds a repo with a given DAG from scratch in the current empty repo
 
     The description of the DAG is read from stdin if not given on the
     command line.
 
     Elements:
 
      - "+n" is a linear run of n nodes based on the current default parent
      - "." is a single node based on the current default parent
      - "$" resets the default parent to null (implied at the start);
            otherwise the default parent is always the last node created
      - "<p" sets the default parent to the backref p
      - "*p" is a fork at parent p, which is a backref
      - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
      - "/p2" is a merge of the preceding node and p2
      - ":tag" defines a local tag for the preceding node
      - "@branch" sets the named branch for subsequent nodes
      - "#...\\n" is a comment up to the end of the line
 
     Whitespace between the above elements is ignored.
 
     A backref is either
 
      - a number n, which references the node curr-n, where curr is the current
        node, or
      - the name of a local tag you placed earlier using ":tag", or
      - empty to denote the default parent.
 
     All string valued-elements are either strictly alphanumeric, or must
     be enclosed in double quotes ("..."), with "\\" as escape character.
     """
 
     if text is None:
         ui.status(_(b"reading DAG from stdin\n"))
         text = ui.fin.read()
 
     cl = repo.changelog
     if len(cl) > 0:
         raise error.Abort(_(b'repository is not empty'))
 
     # determine number of revs in DAG
     total = 0
     for type, data in dagparser.parsedag(text):
         if type == b'n':
             total += 1
 
     if mergeable_file:
         linesperrev = 2
         # make a file with k lines per rev
         initialmergedlines = [
             b'%d' % i for i in pycompat.xrange(0, total * linesperrev)
         ]
         initialmergedlines.append(b"")
 
     tags = []
     progress = ui.makeprogress(
         _(b'building'), unit=_(b'revisions'), total=total
     )
     with progress, repo.wlock(), repo.lock(), repo.transaction(b"builddag"):
         at = -1
         atbranch = b'default'
         nodeids = []
         id = 0
         progress.update(id)
         for type, data in dagparser.parsedag(text):
             if type == b'n':
                 ui.note((b'node %s\n' % pycompat.bytestr(data)))
                 id, ps = data
 
                 files = []
                 filecontent = {}
 
                 p2 = None
                 if mergeable_file:
                     fn = b"mf"
                     p1 = repo[ps[0]]
                     if len(ps) > 1:
                         p2 = repo[ps[1]]
                         pa = p1.ancestor(p2)
                         base, local, other = [
                             x[fn].data() for x in (pa, p1, p2)
                         ]
                         m3 = simplemerge.Merge3Text(base, local, other)
                         ml = [l.strip() for l in m3.merge_lines()]
                         ml.append(b"")
                     elif at > 0:
                         ml = p1[fn].data().split(b"\n")
                     else:
                         ml = initialmergedlines
                     ml[id * linesperrev] += b" r%i" % id
                     mergedtext = b"\n".join(ml)
                     files.append(fn)
                     filecontent[fn] = mergedtext
 
                 if overwritten_file:
                     fn = b"of"
                     files.append(fn)
                     filecontent[fn] = b"r%i\n" % id
 
                 if new_file:
                     fn = b"nf%i" % id
                     files.append(fn)
                     filecontent[fn] = b"r%i\n" % id
                     if len(ps) > 1:
                         if not p2:
                             p2 = repo[ps[1]]
                         for fn in p2:
                             if fn.startswith(b"nf"):
                                 files.append(fn)
                                 filecontent[fn] = p2[fn].data()
 
                 def fctxfn(repo, cx, path):
                     if path in filecontent:
                         return context.memfilectx(
                             repo, cx, path, filecontent[path]
                         )
                     return None
 
                 if len(ps) == 0 or ps[0] < 0:
                     pars = [None, None]
                 elif len(ps) == 1:
                     pars = [nodeids[ps[0]], None]
                 else:
                     pars = [nodeids[p] for p in ps]
                 cx = context.memctx(
                     repo,
                     pars,
                     b"r%i" % id,
                     files,
                     fctxfn,
                     date=(id, 0),
                     user=b"debugbuilddag",
                     extra={b'branch': atbranch},
                 )
                 nodeid = repo.commitctx(cx)
                 nodeids.append(nodeid)
                 at = id
             elif type == b'l':
                 id, name = data
                 ui.note((b'tag %s\n' % name))
                 tags.append(b"%s %s\n" % (hex(repo.changelog.node(id)), name))
             elif type == b'a':
                 ui.note((b'branch %s\n' % data))
                 atbranch = data
             progress.update(id)
 
         if tags:
             repo.vfs.write(b"localtags", b"".join(tags))
 
 
 def _debugchangegroup(ui, gen, all=None, indent=0, **opts):
     indent_string = b' ' * indent
     if all:
         ui.writenoi18n(
             b"%sformat: id, p1, p2, cset, delta base, len(delta)\n"
             % indent_string
         )
 
         def showchunks(named):
             ui.write(b"\n%s%s\n" % (indent_string, named))
             for deltadata in gen.deltaiter():
                 node, p1, p2, cs, deltabase, delta, flags, sidedata = deltadata
                 ui.write(
                     b"%s%s %s %s %s %s %d\n"
                     % (
                         indent_string,
                         hex(node),
                         hex(p1),
                         hex(p2),
                         hex(cs),
                         hex(deltabase),
                         len(delta),
                     )
                 )
 
         gen.changelogheader()
         showchunks(b"changelog")
         gen.manifestheader()
         showchunks(b"manifest")
         for chunkdata in iter(gen.filelogheader, {}):
             fname = chunkdata[b'filename']
             showchunks(fname)
     else:
         if isinstance(gen, bundle2.unbundle20):
             raise error.Abort(_(b'use debugbundle2 for this file'))
         gen.changelogheader()
         for deltadata in gen.deltaiter():
             node, p1, p2, cs, deltabase, delta, flags, sidedata = deltadata
             ui.write(b"%s%s\n" % (indent_string, hex(node)))
 
 
 def _debugobsmarkers(ui, part, indent=0, **opts):
     """display version and markers contained in 'data'"""
     opts = pycompat.byteskwargs(opts)
     data = part.read()
     indent_string = b' ' * indent
     try:
         version, markers = obsolete._readmarkers(data)
     except error.UnknownVersion as exc:
         msg = b"%sunsupported version: %s (%d bytes)\n"
         msg %= indent_string, exc.version, len(data)
         ui.write(msg)
     else:
         msg = b"%sversion: %d (%d bytes)\n"
         msg %= indent_string, version, len(data)
         ui.write(msg)
         fm = ui.formatter(b'debugobsolete', opts)
         for rawmarker in sorted(markers):
             m = obsutil.marker(None, rawmarker)
             fm.startitem()
             fm.plain(indent_string)
             cmdutil.showmarker(fm, m)
         fm.end()
 
 
 def _debugphaseheads(ui, data, indent=0):
     """display version and markers contained in 'data'"""
     indent_string = b' ' * indent
     headsbyphase = phases.binarydecode(data)
     for phase in phases.allphases:
         for head in headsbyphase[phase]:
             ui.write(indent_string)
             ui.write(b'%s %s\n' % (hex(head), phases.phasenames[phase]))
 
 
 def _quasirepr(thing):
     if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)):
         return b'{%s}' % (
             b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing))
         )
     return pycompat.bytestr(repr(thing))
 
 
 def _debugbundle2(ui, gen, all=None, **opts):
     """lists the contents of a bundle2"""
     if not isinstance(gen, bundle2.unbundle20):
         raise error.Abort(_(b'not a bundle2 file'))
     ui.write((b'Stream params: %s\n' % _quasirepr(gen.params)))
     parttypes = opts.get('part_type', [])
     for part in gen.iterparts():
         if parttypes and part.type not in parttypes:
             continue
         msg = b'%s -- %s (mandatory: %r)\n'
         ui.write((msg % (part.type, _quasirepr(part.params), part.mandatory)))
         if part.type == b'changegroup':
             version = part.params.get(b'version', b'01')
             cg = changegroup.getunbundler(version, part, b'UN')
             if not ui.quiet:
                 _debugchangegroup(ui, cg, all=all, indent=4, **opts)
         if part.type == b'obsmarkers':
             if not ui.quiet:
                 _debugobsmarkers(ui, part, indent=4, **opts)
         if part.type == b'phase-heads':
             if not ui.quiet:
                 _debugphaseheads(ui, part, indent=4)
 
 
 @command(
     b'debugbundle',
     [
         (b'a', b'all', None, _(b'show all details')),
         (b'', b'part-type', [], _(b'show only the named part type')),
         (b'', b'spec', None, _(b'print the bundlespec of the bundle')),
     ],
     _(b'FILE'),
     norepo=True,
 )
 def debugbundle(ui, bundlepath, all=None, spec=None, **opts):
     """lists the contents of a bundle"""
     with hg.openpath(ui, bundlepath) as f:
         if spec:
             spec = exchange.getbundlespec(ui, f)
             ui.write(b'%s\n' % spec)
             return
 
         gen = exchange.readbundle(ui, f, bundlepath)
         if isinstance(gen, bundle2.unbundle20):
             return _debugbundle2(ui, gen, all=all, **opts)
         _debugchangegroup(ui, gen, all=all, **opts)
 
 
 @command(b'debugcapabilities', [], _(b'PATH'), norepo=True)
 def debugcapabilities(ui, path, **opts):
     """lists the capabilities of a remote peer"""
     opts = pycompat.byteskwargs(opts)
     peer = hg.peer(ui, opts, path)
     try:
         caps = peer.capabilities()
         ui.writenoi18n(b'Main capabilities:\n')
         for c in sorted(caps):
             ui.write(b'  %s\n' % c)
         b2caps = bundle2.bundle2caps(peer)
         if b2caps:
             ui.writenoi18n(b'Bundle2 capabilities:\n')
             for key, values in sorted(pycompat.iteritems(b2caps)):
                 ui.write(b'  %s\n' % key)
                 for v in values:
                     ui.write(b'    %s\n' % v)
     finally:
         peer.close()
 
 
 @command(
     b'debugchangedfiles',
     [
         (
             b'',
             b'compute',
             False,
             b"compute information instead of reading it from storage",
         ),
     ],
     b'REV',
 )
 def debugchangedfiles(ui, repo, rev, **opts):
     """list the stored files changes for a revision"""
     ctx = scmutil.revsingle(repo, rev, None)
     files = None
 
     if opts['compute']:
         files = metadata.compute_all_files_changes(ctx)
     else:
         sd = repo.changelog.sidedata(ctx.rev())
         files_block = sd.get(sidedata.SD_FILES)
         if files_block is not None:
             files = metadata.decode_files_sidedata(sd)
     if files is not None:
         for f in sorted(files.touched):
             if f in files.added:
                 action = b"added"
             elif f in files.removed:
                 action = b"removed"
             elif f in files.merged:
                 action = b"merged"
             elif f in files.salvaged:
                 action = b"salvaged"
             else:
                 action = b"touched"
 
             copy_parent = b""
             copy_source = b""
             if f in files.copied_from_p1:
                 copy_parent = b"p1"
                 copy_source = files.copied_from_p1[f]
             elif f in files.copied_from_p2:
                 copy_parent = b"p2"
                 copy_source = files.copied_from_p2[f]
 
             data = (action, copy_parent, f, copy_source)
             template = b"%-8s %2s: %s, %s;\n"
             ui.write(template % data)
 
 
 @command(b'debugcheckstate', [], b'')
 def debugcheckstate(ui, repo):
     """validate the correctness of the current dirstate"""
     parent1, parent2 = repo.dirstate.parents()
     m1 = repo[parent1].manifest()
     m2 = repo[parent2].manifest()
     errors = 0
     for f in repo.dirstate:
         state = repo.dirstate[f]
         if state in b"nr" and f not in m1:
             ui.warn(_(b"%s in state %s, but not in manifest1\n") % (f, state))
             errors += 1
         if state in b"a" and f in m1:
             ui.warn(_(b"%s in state %s, but also in manifest1\n") % (f, state))
             errors += 1
         if state in b"m" and f not in m1 and f not in m2:
             ui.warn(
                 _(b"%s in state %s, but not in either manifest\n") % (f, state)
             )
             errors += 1
     for f in m1:
         state = repo.dirstate[f]
         if state not in b"nrm":
             ui.warn(_(b"%s in manifest1, but listed as state %s") % (f, state))
             errors += 1
     if errors:
         errstr = _(b".hg/dirstate inconsistent with current parent's manifest")
         raise error.Abort(errstr)
 
 
 @command(
     b'debugcolor',
     [(b'', b'style', None, _(b'show all configured styles'))],
     b'hg debugcolor',
 )
 def debugcolor(ui, repo, **opts):
     """show available color, effects or style"""
     ui.writenoi18n(b'color mode: %s\n' % stringutil.pprint(ui._colormode))
     if opts.get('style'):
         return _debugdisplaystyle(ui)
     else:
         return _debugdisplaycolor(ui)
 
 
 def _debugdisplaycolor(ui):
     ui = ui.copy()
     ui._styles.clear()
     for effect in color._activeeffects(ui).keys():
         ui._styles[effect] = effect
     if ui._terminfoparams:
         for k, v in ui.configitems(b'color'):
             if k.startswith(b'color.'):
                 ui._styles[k] = k[6:]
             elif k.startswith(b'terminfo.'):
                 ui._styles[k] = k[9:]
     ui.write(_(b'available colors:\n'))
     # sort label with a '_' after the other to group '_background' entry.
     items = sorted(ui._styles.items(), key=lambda i: (b'_' in i[0], i[0], i[1]))
     for colorname, label in items:
         ui.write(b'%s\n' % colorname, label=label)
 
 
 def _debugdisplaystyle(ui):
     ui.write(_(b'available style:\n'))
     if not ui._styles:
         return
     width = max(len(s) for s in ui._styles)
     for label, effects in sorted(ui._styles.items()):
         ui.write(b'%s' % label, label=label)
         if effects:
             # 50
             ui.write(b': ')
             ui.write(b' ' * (max(0, width - len(label))))
             ui.write(b', '.join(ui.label(e, e) for e in effects.split()))
         ui.write(b'\n')
 
 
 @command(b'debugcreatestreamclonebundle', [], b'FILE')
 def debugcreatestreamclonebundle(ui, repo, fname):
     """create a stream clone bundle file
 
     Stream bundles are special bundles that are essentially archives of
     revlog files. They are commonly used for cloning very quickly.
     """
     # TODO we may want to turn this into an abort when this functionality
     # is moved into `hg bundle`.
     if phases.hassecret(repo):
         ui.warn(
             _(
                 b'(warning: stream clone bundle will contain secret '
                 b'revisions)\n'
             )
         )
 
     requirements, gen = streamclone.generatebundlev1(repo)
     changegroup.writechunks(ui, gen, fname)
 
     ui.write(_(b'bundle requirements: %s\n') % b', '.join(sorted(requirements)))
 
 
 @command(
     b'debugdag',
     [
         (b't', b'tags', None, _(b'use tags as labels')),
         (b'b', b'branches', None, _(b'annotate with branch names')),
         (b'', b'dots', None, _(b'use dots for runs')),
         (b's', b'spaces', None, _(b'separate elements by spaces')),
     ],
     _(b'[OPTION]... [FILE [REV]...]'),
     optionalrepo=True,
 )
 def debugdag(ui, repo, file_=None, *revs, **opts):
     """format the changelog or an index DAG as a concise textual description
 
     If you pass a revlog index, the revlog's DAG is emitted. If you list
     revision numbers, they get labeled in the output as rN.
 
     Otherwise, the changelog DAG of the current repo is emitted.
     """
     spaces = opts.get('spaces')
     dots = opts.get('dots')
     if file_:
         rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), file_)
         revs = {int(r) for r in revs}
 
         def events():
             for r in rlog:
                 yield b'n', (r, list(p for p in rlog.parentrevs(r) if p != -1))
                 if r in revs:
                     yield b'l', (r, b"r%i" % r)
 
     elif repo:
         cl = repo.changelog
         tags = opts.get('tags')
         branches = opts.get('branches')
         if tags:
             labels = {}
             for l, n in repo.tags().items():
                 labels.setdefault(cl.rev(n), []).append(l)
 
         def events():
             b = b"default"
             for r in cl:
                 if branches:
                     newb = cl.read(cl.node(r))[5][b'branch']
                     if newb != b:
                         yield b'a', newb
                         b = newb
                 yield b'n', (r, list(p for p in cl.parentrevs(r) if p != -1))
                 if tags:
                     ls = labels.get(r)
                     if ls:
                         for l in ls:
                             yield b'l', (r, l)
 
     else:
         raise error.Abort(_(b'need repo for changelog dag'))
 
     for line in dagparser.dagtextlines(
         events(),
         addspaces=spaces,
         wraplabels=True,
         wrapannotations=True,
         wrapnonlinear=dots,
         usedots=dots,
         maxlinewidth=70,
     ):
         ui.write(line)
         ui.write(b"\n")
 
 
 @command(b'debugdata', cmdutil.debugrevlogopts, _(b'-c|-m|FILE REV'))
 def debugdata(ui, repo, file_, rev=None, **opts):
     """dump the contents of a data file revision"""
     opts = pycompat.byteskwargs(opts)
     if opts.get(b'changelog') or opts.get(b'manifest') or opts.get(b'dir'):
         if rev is not None:
             raise error.CommandError(b'debugdata', _(b'invalid arguments'))
         file_, rev = None, file_
     elif rev is None:
         raise error.CommandError(b'debugdata', _(b'invalid arguments'))
     r = cmdutil.openstorage(repo, b'debugdata', file_, opts)
     try:
         ui.write(r.rawdata(r.lookup(rev)))
     except KeyError:
         raise error.Abort(_(b'invalid revision identifier %s') % rev)
 
 
 @command(
     b'debugdate',
     [(b'e', b'extended', None, _(b'try extended date formats'))],
     _(b'[-e] DATE [RANGE]'),
     norepo=True,
     optionalrepo=True,
 )
 def debugdate(ui, date, range=None, **opts):
     """parse and display a date"""
     if opts["extended"]:
         d = dateutil.parsedate(date, dateutil.extendeddateformats)
     else:
         d = dateutil.parsedate(date)
     ui.writenoi18n(b"internal: %d %d\n" % d)
     ui.writenoi18n(b"standard: %s\n" % dateutil.datestr(d))
     if range:
         m = dateutil.matchdate(range)
         ui.writenoi18n(b"match: %s\n" % m(d[0]))
 
 
 @command(
     b'debugdeltachain',
     cmdutil.debugrevlogopts + cmdutil.formatteropts,
     _(b'-c|-m|FILE'),
     optionalrepo=True,
 )
 def debugdeltachain(ui, repo, file_=None, **opts):
     """dump information about delta chains in a revlog
 
     Output can be templatized. Available template keywords are:
 
     :``rev``:       revision number
     :``chainid``:   delta chain identifier (numbered by unique base)
     :``chainlen``:  delta chain length to this revision
     :``prevrev``:   previous revision in delta chain
     :``deltatype``: role of delta / how it was computed
     :``compsize``:  compressed size of revision
     :``uncompsize``: uncompressed size of revision
     :``chainsize``: total size of compressed revisions in chain
     :``chainratio``: total chain size divided by uncompressed revision size
                     (new delta chains typically start at ratio 2.00)
     :``lindist``:   linear distance from base revision in delta chain to end
                     of this revision
     :``extradist``: total size of revisions not part of this delta chain from
                     base of delta chain to end of this revision; a measurement
                     of how much extra data we need to read/seek across to read
                     the delta chain for this revision
     :``extraratio``: extradist divided by chainsize; another representation of
                     how much unrelated data is needed to load this delta chain
 
     If the repository is configured to use the sparse read, additional keywords
     are available:
 
     :``readsize``:     total size of data read from the disk for a revision
                        (sum of the sizes of all the blocks)
     :``largestblock``: size of the largest block of data read from the disk
     :``readdensity``:  density of useful bytes in the data read from the disk
     :``srchunks``:  in how many data hunks the whole revision would be read
 
     The sparse read can be enabled with experimental.sparse-read = True
     """
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, b'debugdeltachain', file_, opts)
     index = r.index
     start = r.start
     length = r.length
     generaldelta = r._generaldelta
     withsparseread = getattr(r, '_withsparseread', False)
 
     def revinfo(rev):
         e = index[rev]
         compsize = e[1]
         uncompsize = e[2]
         chainsize = 0
 
         if generaldelta:
             if e[3] == e[5]:
                 deltatype = b'p1'
             elif e[3] == e[6]:
                 deltatype = b'p2'
             elif e[3] == rev - 1:
                 deltatype = b'prev'
             elif e[3] == rev:
                 deltatype = b'base'
             else:
                 deltatype = b'other'
         else:
             if e[3] == rev:
                 deltatype = b'base'
             else:
                 deltatype = b'prev'
 
         chain = r._deltachain(rev)[0]
         for iterrev in chain:
             e = index[iterrev]
             chainsize += e[1]
 
         return compsize, uncompsize, deltatype, chain, chainsize
 
     fm = ui.formatter(b'debugdeltachain', opts)
 
     fm.plain(
         b'    rev  chain# chainlen     prev   delta       '
         b'size    rawsize  chainsize     ratio   lindist extradist '
         b'extraratio'
     )
     if withsparseread:
         fm.plain(b'   readsize largestblk rddensity srchunks')
     fm.plain(b'\n')
 
     chainbases = {}
     for rev in r:
         comp, uncomp, deltatype, chain, chainsize = revinfo(rev)
         chainbase = chain[0]
         chainid = chainbases.setdefault(chainbase, len(chainbases) + 1)
         basestart = start(chainbase)
         revstart = start(rev)
         lineardist = revstart + comp - basestart
         extradist = lineardist - chainsize
         try:
             prevrev = chain[-2]
         except IndexError:
             prevrev = -1
 
         if uncomp != 0:
             chainratio = float(chainsize) / float(uncomp)
         else:
             chainratio = chainsize
 
         if chainsize != 0:
             extraratio = float(extradist) / float(chainsize)
         else:
             extraratio = extradist
 
         fm.startitem()
         fm.write(
             b'rev chainid chainlen prevrev deltatype compsize '
             b'uncompsize chainsize chainratio lindist extradist '
             b'extraratio',
             b'%7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f',
             rev,
             chainid,
             len(chain),
             prevrev,
             deltatype,
             comp,
             uncomp,
             chainsize,
             chainratio,
             lineardist,
             extradist,
             extraratio,
             rev=rev,
             chainid=chainid,
             chainlen=len(chain),
             prevrev=prevrev,
             deltatype=deltatype,
             compsize=comp,
             uncompsize=uncomp,
             chainsize=chainsize,
             chainratio=chainratio,
             lindist=lineardist,
             extradist=extradist,
             extraratio=extraratio,
         )
         if withsparseread:
             readsize = 0
             largestblock = 0
             srchunks = 0
 
             for revschunk in deltautil.slicechunk(r, chain):
                 srchunks += 1
                 blkend = start(revschunk[-1]) + length(revschunk[-1])
                 blksize = blkend - start(revschunk[0])
 
                 readsize += blksize
                 if largestblock < blksize:
                     largestblock = blksize
 
             if readsize:
                 readdensity = float(chainsize) / float(readsize)
             else:
                 readdensity = 1
 
             fm.write(
                 b'readsize largestblock readdensity srchunks',
                 b' %10d %10d %9.5f %8d',
                 readsize,
                 largestblock,
                 readdensity,
                 srchunks,
                 readsize=readsize,
                 largestblock=largestblock,
                 readdensity=readdensity,
                 srchunks=srchunks,
             )
 
         fm.plain(b'\n')
 
     fm.end()
 
 
 @command(
     b'debugdirstate|debugstate',
     [
         (
             b'',
             b'nodates',
             None,
             _(b'do not display the saved mtime (DEPRECATED)'),
         ),
         (b'', b'dates', True, _(b'display the saved mtime')),
         (b'', b'datesort', None, _(b'sort by saved mtime')),
         (b'', b'dirs', False, _(b'display directories')),
     ],
     _(b'[OPTION]...'),
 )
 def debugstate(ui, repo, **opts):
     """show the contents of the current dirstate"""
 
     nodates = not opts['dates']
     if opts.get('nodates') is not None:
         nodates = True
     datesort = opts.get('datesort')
 
     if datesort:
         keyfunc = lambda x: (
             x[1].v1_mtime(),
             x[0],
         )  # sort by mtime, then by filename
     else:
         keyfunc = None  # sort by filename
     entries = list(pycompat.iteritems(repo.dirstate))
     if opts['dirs']:
         entries.extend(repo.dirstate.directories())
     entries.sort(key=keyfunc)
     for file_, ent in entries:
         if ent.v1_mtime() == -1:
             timestr = b'unset               '
         elif nodates:
             timestr = b'set                 '
         else:
             timestr = time.strftime(
                 "%Y-%m-%d %H:%M:%S ", time.localtime(ent.v1_mtime())
             )
             timestr = encoding.strtolocal(timestr)
         if ent.mode & 0o20000:
             mode = b'lnk'
         else:
             mode = b'%3o' % (ent.v1_mode() & 0o777 & ~util.umask)
         ui.write(
             b"%c %s %10d %s%s\n"
             % (ent.v1_state(), mode, ent.v1_size(), timestr, file_)
         )
     for f in repo.dirstate.copies():
         ui.write(_(b"copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
 
 
 @command(
+    b'debugdirstateignorepatternshash',
+    [],
+    _(b''),
+)
+def debugdirstateignorepatternshash(ui, repo, **opts):
+    """show the hash of ignore patterns stored in dirstate if v2,
+    or nothing for dirstate-v2
+    """
+    if repo.dirstate._use_dirstate_v2:
+        hash_offset = 16  # Four 32-bit integers before this field
+        hash_len = 20  # 160 bits for SHA-1
+        data_filename = repo.dirstate._map.docket.data_filename()
+        with repo.vfs(data_filename) as f:
+            hash_bytes = f.read(hash_offset + hash_len)[-hash_len:]
+        ui.write(binascii.hexlify(hash_bytes) + b'\n')
+
+
+@command(
     b'debugdiscovery',
     [
         (b'', b'old', None, _(b'use old-style discovery')),
         (
             b'',
             b'nonheads',
             None,
             _(b'use old-style discovery with non-heads included'),
         ),
         (b'', b'rev', [], b'restrict discovery to this set of revs'),
         (b'', b'seed', b'12323', b'specify the random seed use for discovery'),
         (
             b'',
             b'local-as-revs',
             b"",
             b'treat local has having these revisions only',
         ),
         (
             b'',
             b'remote-as-revs',
             b"",
             b'use local as remote, with only these these revisions',
         ),
     ]
     + cmdutil.remoteopts
     + cmdutil.formatteropts,
     _(b'[--rev REV] [OTHER]'),
 )
 def debugdiscovery(ui, repo, remoteurl=b"default", **opts):
     """runs the changeset discovery protocol in isolation
 
     The local peer can be "replaced" by a subset of the local repository by
     using the `--local-as-revs` flag. Int he same way, usual `remote` peer can
     be "replaced" by a subset of the local repository using the
     `--local-as-revs` flag. This is useful to efficiently debug pathological
     discovery situation.
 
     The following developer oriented config are relevant for people playing with this command:
 
     * devel.discovery.exchange-heads=True
 
       If False, the discovery will not start with
       remote head fetching and local head querying.
 
     * devel.discovery.grow-sample=True
 
       If False, the sample size used in set discovery will not be increased
       through the process
 
     * devel.discovery.grow-sample.dynamic=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)
 
     * devel.discovery.grow-sample.rate=1.05
 
       the rate at which the sample grow
 
     * devel.discovery.randomize=True
 
       If andom sampling during discovery are deterministic. It is meant for
       integration tests.
 
     * devel.discovery.sample-size=200
 
       Control the initial size of the discovery sample
 
     * devel.discovery.sample-size.initial=100
 
       Control the initial size of the discovery for initial change
     """
     opts = pycompat.byteskwargs(opts)
     unfi = repo.unfiltered()
 
     # setup potential extra filtering
     local_revs = opts[b"local_as_revs"]
     remote_revs = opts[b"remote_as_revs"]
 
     # make sure tests are repeatable
     random.seed(int(opts[b'seed']))
 
     if not remote_revs:
 
         remoteurl, branches = urlutil.get_unique_pull_path(
             b'debugdiscovery', repo, ui, remoteurl
         )
         remote = hg.peer(repo, opts, remoteurl)
         ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(remoteurl))
     else:
         branches = (None, [])
         remote_filtered_revs = scmutil.revrange(
             unfi, [b"not (::(%s))" % remote_revs]
         )
         remote_filtered_revs = frozenset(remote_filtered_revs)
 
         def remote_func(x):
             return remote_filtered_revs
 
         repoview.filtertable[b'debug-discovery-remote-filter'] = remote_func
 
         remote = repo.peer()
         remote._repo = remote._repo.filtered(b'debug-discovery-remote-filter')
 
     if local_revs:
         local_filtered_revs = scmutil.revrange(
             unfi, [b"not (::(%s))" % local_revs]
         )
         local_filtered_revs = frozenset(local_filtered_revs)
 
         def local_func(x):
             return local_filtered_revs
 
         repoview.filtertable[b'debug-discovery-local-filter'] = local_func
         repo = repo.filtered(b'debug-discovery-local-filter')
 
     data = {}
     if opts.get(b'old'):
 
         def doit(pushedrevs, remoteheads, remote=remote):
             if not util.safehasattr(remote, b'branches'):
                 # enable in-client legacy support
                 remote = localrepo.locallegacypeer(remote.local())
             common, _in, hds = treediscovery.findcommonincoming(
                 repo, remote, force=True, audit=data
             )
             common = set(common)
             if not opts.get(b'nonheads'):
                 ui.writenoi18n(
                     b"unpruned common: %s\n"
                     % b" ".join(sorted(short(n) for n in common))
                 )
 
                 clnode = repo.changelog.node
                 common = repo.revs(b'heads(::%ln)', common)
                 common = {clnode(r) for r in common}
             return common, hds
 
     else:
 
         def doit(pushedrevs, remoteheads, remote=remote):
             nodes = None
             if pushedrevs:
                 revs = scmutil.revrange(repo, pushedrevs)
                 nodes = [repo[r].node() for r in revs]
             common, any, hds = setdiscovery.findcommonheads(
                 ui, repo, remote, ancestorsof=nodes, audit=data
             )
             return common, hds
 
     remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None)
     localrevs = opts[b'rev']
 
     fm = ui.formatter(b'debugdiscovery', opts)
     if fm.strict_format:
 
         @contextlib.contextmanager
         def may_capture_output():
             ui.pushbuffer()
             yield
             data[b'output'] = ui.popbuffer()
 
     else:
         may_capture_output = util.nullcontextmanager
     with may_capture_output():
         with util.timedcm('debug-discovery') as t:
             common, hds = doit(localrevs, remoterevs)
 
     # compute all statistics
     heads_common = set(common)
     heads_remote = set(hds)
     heads_local = set(repo.heads())
     # note: they cannot be a local or remote head that is in common and not
     # itself a head of common.
     heads_common_local = heads_common & heads_local
     heads_common_remote = heads_common & heads_remote
     heads_common_both = heads_common & heads_remote & heads_local
 
     all = repo.revs(b'all()')
     common = repo.revs(b'::%ln', common)
     roots_common = repo.revs(b'roots(::%ld)', common)
     missing = repo.revs(b'not ::%ld', common)
     heads_missing = repo.revs(b'heads(%ld)', missing)
     roots_missing = repo.revs(b'roots(%ld)', missing)
     assert len(common) + len(missing) == len(all)
 
     initial_undecided = repo.revs(
         b'not (::%ln or %ln::)', heads_common_remote, heads_common_local
     )
     heads_initial_undecided = repo.revs(b'heads(%ld)', initial_undecided)
     roots_initial_undecided = repo.revs(b'roots(%ld)', initial_undecided)
     common_initial_undecided = initial_undecided & common
     missing_initial_undecided = initial_undecided & missing
 
     data[b'elapsed'] = t.elapsed
     data[b'nb-common-heads'] = len(heads_common)
     data[b'nb-common-heads-local'] = len(heads_common_local)
     data[b'nb-common-heads-remote'] = len(heads_common_remote)
     data[b'nb-common-heads-both'] = len(heads_common_both)
     data[b'nb-common-roots'] = len(roots_common)
     data[b'nb-head-local'] = len(heads_local)
     data[b'nb-head-local-missing'] = len(heads_local) - len(heads_common_local)
     data[b'nb-head-remote'] = len(heads_remote)
     data[b'nb-head-remote-unknown'] = len(heads_remote) - len(
         heads_common_remote
     )
     data[b'nb-revs'] = len(all)
     data[b'nb-revs-common'] = len(common)
     data[b'nb-revs-missing'] = len(missing)
     data[b'nb-missing-heads'] = len(heads_missing)
     data[b'nb-missing-roots'] = len(roots_missing)
     data[b'nb-ini_und'] = len(initial_undecided)
     data[b'nb-ini_und-heads'] = len(heads_initial_undecided)
     data[b'nb-ini_und-roots'] = len(roots_initial_undecided)
     data[b'nb-ini_und-common'] = len(common_initial_undecided)
     data[b'nb-ini_und-missing'] = len(missing_initial_undecided)
 
     fm.startitem()
     fm.data(**pycompat.strkwargs(data))
     # display discovery summary
     fm.plain(b"elapsed time:  %(elapsed)f seconds\n" % data)
     fm.plain(b"round-trips:           %(total-roundtrips)9d\n" % data)
     fm.plain(b"heads summary:\n")
     fm.plain(b"  total common heads:  %(nb-common-heads)9d\n" % data)
     fm.plain(b"    also local heads:  %(nb-common-heads-local)9d\n" % data)
     fm.plain(b"    also remote heads: %(nb-common-heads-remote)9d\n" % data)
     fm.plain(b"    both:              %(nb-common-heads-both)9d\n" % data)
     fm.plain(b"  local heads:         %(nb-head-local)9d\n" % data)
     fm.plain(b"    common:            %(nb-common-heads-local)9d\n" % data)
     fm.plain(b"    missing:           %(nb-head-local-missing)9d\n" % data)
     fm.plain(b"  remote heads:        %(nb-head-remote)9d\n" % data)
     fm.plain(b"    common:            %(nb-common-heads-remote)9d\n" % data)
     fm.plain(b"    unknown:           %(nb-head-remote-unknown)9d\n" % data)
     fm.plain(b"local changesets:      %(nb-revs)9d\n" % data)
     fm.plain(b"  common:              %(nb-revs-common)9d\n" % data)
     fm.plain(b"    heads:             %(nb-common-heads)9d\n" % data)
     fm.plain(b"    roots:             %(nb-common-roots)9d\n" % data)
     fm.plain(b"  missing:             %(nb-revs-missing)9d\n" % data)
     fm.plain(b"    heads:             %(nb-missing-heads)9d\n" % data)
     fm.plain(b"    roots:             %(nb-missing-roots)9d\n" % data)
     fm.plain(b"  first undecided set: %(nb-ini_und)9d\n" % data)
     fm.plain(b"    heads:             %(nb-ini_und-heads)9d\n" % data)
     fm.plain(b"    roots:             %(nb-ini_und-roots)9d\n" % data)
     fm.plain(b"    common:            %(nb-ini_und-common)9d\n" % data)
     fm.plain(b"    missing:           %(nb-ini_und-missing)9d\n" % data)
 
     if ui.verbose:
         fm.plain(
             b"common heads: %s\n"
             % b" ".join(sorted(short(n) for n in heads_common))
         )
     fm.end()
 
 
 _chunksize = 4 << 10
 
 
 @command(
     b'debugdownload',
     [
         (b'o', b'output', b'', _(b'path')),
     ],
     optionalrepo=True,
 )
 def debugdownload(ui, repo, url, output=None, **opts):
     """download a resource using Mercurial logic and config"""
     fh = urlmod.open(ui, url, output)
 
     dest = ui
     if output:
         dest = open(output, b"wb", _chunksize)
     try:
         data = fh.read(_chunksize)
         while data:
             dest.write(data)
             data = fh.read(_chunksize)
     finally:
         if output:
             dest.close()
 
 
 @command(b'debugextensions', cmdutil.formatteropts, [], optionalrepo=True)
 def debugextensions(ui, repo, **opts):
     '''show information about active extensions'''
     opts = pycompat.byteskwargs(opts)
     exts = extensions.extensions(ui)
     hgver = util.version()
     fm = ui.formatter(b'debugextensions', opts)
     for extname, extmod in sorted(exts, key=operator.itemgetter(0)):
         isinternal = extensions.ismoduleinternal(extmod)
         extsource = None
 
         if util.safehasattr(extmod, '__file__'):
             extsource = pycompat.fsencode(extmod.__file__)
         elif getattr(sys, 'oxidized', False):
             extsource = pycompat.sysexecutable
         if isinternal:
             exttestedwith = []  # never expose magic string to users
         else:
             exttestedwith = getattr(extmod, 'testedwith', b'').split()
         extbuglink = getattr(extmod, 'buglink', None)
 
         fm.startitem()
 
         if ui.quiet or ui.verbose:
             fm.write(b'name', b'%s\n', extname)
         else:
             fm.write(b'name', b'%s', extname)
             if isinternal or hgver in exttestedwith:
                 fm.plain(b'\n')
             elif not exttestedwith:
                 fm.plain(_(b' (untested!)\n'))
             else:
                 lasttestedversion = exttestedwith[-1]
                 fm.plain(b' (%s!)\n' % lasttestedversion)
 
         fm.condwrite(
             ui.verbose and extsource,
             b'source',
             _(b'  location: %s\n'),
             extsource or b"",
         )
 
         if ui.verbose:
             fm.plain(_(b'  bundled: %s\n') % [b'no', b'yes'][isinternal])
         fm.data(bundled=isinternal)
 
         fm.condwrite(
             ui.verbose and exttestedwith,
             b'testedwith',
             _(b'  tested with: %s\n'),
             fm.formatlist(exttestedwith, name=b'ver'),
         )
 
         fm.condwrite(
             ui.verbose and extbuglink,
             b'buglink',
             _(b'  bug reporting: %s\n'),
             extbuglink or b"",
         )
 
     fm.end()
 
 
 @command(
     b'debugfileset',
     [
         (
             b'r',
             b'rev',
             b'',
             _(b'apply the filespec on this revision'),
             _(b'REV'),
         ),
         (
             b'',
             b'all-files',
             False,
             _(b'test files from all revisions and working directory'),
         ),
         (
             b's',
             b'show-matcher',
             None,
             _(b'print internal representation of matcher'),
         ),
         (
             b'p',
             b'show-stage',
             [],
             _(b'print parsed tree at the given stage'),
             _(b'NAME'),
         ),
     ],
     _(b'[-r REV] [--all-files] [OPTION]... FILESPEC'),
 )
 def debugfileset(ui, repo, expr, **opts):
     '''parse and apply a fileset specification'''
     from . import fileset
 
     fileset.symbols  # force import of fileset so we have predicates to optimize
     opts = pycompat.byteskwargs(opts)
     ctx = scmutil.revsingle(repo, opts.get(b'rev'), None)
 
     stages = [
         (b'parsed', pycompat.identity),
         (b'analyzed', filesetlang.analyze),
         (b'optimized', filesetlang.optimize),
     ]
     stagenames = {n for n, f in stages}
 
     showalways = set()
     if ui.verbose and not opts[b'show_stage']:
         # show parsed tree by --verbose (deprecated)
         showalways.add(b'parsed')
     if opts[b'show_stage'] == [b'all']:
         showalways.update(stagenames)
     else:
         for n in opts[b'show_stage']:
             if n not in stagenames:
                 raise error.Abort(_(b'invalid stage name: %s') % n)
         showalways.update(opts[b'show_stage'])
 
     tree = filesetlang.parse(expr)
     for n, f in stages:
         tree = f(tree)
         if n in showalways:
             if opts[b'show_stage'] or n != b'parsed':
                 ui.write(b"* %s:\n" % n)
             ui.write(filesetlang.prettyformat(tree), b"\n")
 
     files = set()
     if opts[b'all_files']:
         for r in repo:
             c = repo[r]
             files.update(c.files())
             files.update(c.substate)
     if opts[b'all_files'] or ctx.rev() is None:
         wctx = repo[None]
         files.update(
             repo.dirstate.walk(
                 scmutil.matchall(repo),
                 subrepos=list(wctx.substate),
                 unknown=True,
                 ignored=True,
             )
         )
         files.update(wctx.substate)
     else:
         files.update(ctx.files())
         files.update(ctx.substate)
 
     m = ctx.matchfileset(repo.getcwd(), expr)
     if opts[b'show_matcher'] or (opts[b'show_matcher'] is None and ui.verbose):
         ui.writenoi18n(b'* matcher:\n', stringutil.prettyrepr(m), b'\n')
     for f in sorted(files):
         if not m(f):
             continue
         ui.write(b"%s\n" % f)
 
 
 @command(b'debugformat', [] + cmdutil.formatteropts)
 def debugformat(ui, repo, **opts):
     """display format information about the current repository
 
     Use --verbose to get extra information about current config value and
     Mercurial default."""
     opts = pycompat.byteskwargs(opts)
     maxvariantlength = max(len(fv.name) for fv in upgrade.allformatvariant)
     maxvariantlength = max(len(b'format-variant'), maxvariantlength)
 
     def makeformatname(name):
         return b'%s:' + (b' ' * (maxvariantlength - len(name)))
 
     fm = ui.formatter(b'debugformat', opts)
     if fm.isplain():
 
         def formatvalue(value):
             if util.safehasattr(value, b'startswith'):
                 return value
             if value:
                 return b'yes'
             else:
                 return b'no'
 
     else:
         formatvalue = pycompat.identity
 
     fm.plain(b'format-variant')
     fm.plain(b' ' * (maxvariantlength - len(b'format-variant')))
     fm.plain(b' repo')
     if ui.verbose:
         fm.plain(b' config default')
     fm.plain(b'\n')
     for fv in upgrade.allformatvariant:
         fm.startitem()
         repovalue = fv.fromrepo(repo)
         configvalue = fv.fromconfig(repo)
 
         if repovalue != configvalue:
             namelabel = b'formatvariant.name.mismatchconfig'
             repolabel = b'formatvariant.repo.mismatchconfig'
         elif repovalue != fv.default:
             namelabel = b'formatvariant.name.mismatchdefault'
             repolabel = b'formatvariant.repo.mismatchdefault'
         else:
             namelabel = b'formatvariant.name.uptodate'
             repolabel = b'formatvariant.repo.uptodate'
 
         fm.write(b'name', makeformatname(fv.name), fv.name, label=namelabel)
         fm.write(b'repo', b' %3s', formatvalue(repovalue), label=repolabel)
         if fv.default != configvalue:
             configlabel = b'formatvariant.config.special'
         else:
             configlabel = b'formatvariant.config.default'
         fm.condwrite(
             ui.verbose,
             b'config',
             b' %6s',
             formatvalue(configvalue),
             label=configlabel,
         )
         fm.condwrite(
             ui.verbose,
             b'default',
             b' %7s',
             formatvalue(fv.default),
             label=b'formatvariant.default',
         )
         fm.plain(b'\n')
     fm.end()
 
 
 @command(b'debugfsinfo', [], _(b'[PATH]'), norepo=True)
 def debugfsinfo(ui, path=b"."):
     """show information detected about current filesystem"""
     ui.writenoi18n(b'path: %s\n' % path)
     ui.writenoi18n(
         b'mounted on: %s\n' % (util.getfsmountpoint(path) or b'(unknown)')
     )
     ui.writenoi18n(b'exec: %s\n' % (util.checkexec(path) and b'yes' or b'no'))
     ui.writenoi18n(b'fstype: %s\n' % (util.getfstype(path) or b'(unknown)'))
     ui.writenoi18n(
         b'symlink: %s\n' % (util.checklink(path) and b'yes' or b'no')
     )
     ui.writenoi18n(
         b'hardlink: %s\n' % (util.checknlink(path) and b'yes' or b'no')
     )
     casesensitive = b'(unknown)'
     try:
         with pycompat.namedtempfile(prefix=b'.debugfsinfo', dir=path) as f:
             casesensitive = util.fscasesensitive(f.name) and b'yes' or b'no'
     except OSError:
         pass
     ui.writenoi18n(b'case-sensitive: %s\n' % casesensitive)
 
 
 @command(
     b'debuggetbundle',
     [
         (b'H', b'head', [], _(b'id of head node'), _(b'ID')),
         (b'C', b'common', [], _(b'id of common node'), _(b'ID')),
         (
             b't',
             b'type',
             b'bzip2',
             _(b'bundle compression type to use'),
             _(b'TYPE'),
         ),
     ],
     _(b'REPO FILE [-H|-C ID]...'),
     norepo=True,
 )
 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
     """retrieves a bundle from a repo
 
     Every ID must be a full-length hex node id string. Saves the bundle to the
     given file.
     """
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     if not repo.capable(b'getbundle'):
         raise error.Abort(b"getbundle() not supported by target repository")
     args = {}
     if common:
         args['common'] = [bin(s) for s in common]
     if head:
         args['heads'] = [bin(s) for s in head]
     # TODO: get desired bundlecaps from command line.
     args['bundlecaps'] = None
     bundle = repo.getbundle(b'debug', **args)
 
     bundletype = opts.get(b'type', b'bzip2').lower()
     btypes = {
         b'none': b'HG10UN',
         b'bzip2': b'HG10BZ',
         b'gzip': b'HG10GZ',
         b'bundle2': b'HG20',
     }
     bundletype = btypes.get(bundletype)
     if bundletype not in bundle2.bundletypes:
         raise error.Abort(_(b'unknown bundle type specified with --type'))
     bundle2.writebundle(ui, bundle, bundlepath, bundletype)
 
 
 @command(b'debugignore', [], b'[FILE]')
 def debugignore(ui, repo, *files, **opts):
     """display the combined ignore pattern and information about ignored files
 
     With no argument display the combined ignore pattern.
 
     Given space separated file names, shows if the given file is ignored and
     if so, show the ignore rule (file and line number) that matched it.
     """
     ignore = repo.dirstate._ignore
     if not files:
         # Show all the patterns
         ui.write(b"%s\n" % pycompat.byterepr(ignore))
     else:
         m = scmutil.match(repo[None], pats=files)
         uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
         for f in m.files():
             nf = util.normpath(f)
             ignored = None
             ignoredata = None
             if nf != b'.':
                 if ignore(nf):
                     ignored = nf
                     ignoredata = repo.dirstate._ignorefileandline(nf)
                 else:
                     for p in pathutil.finddirs(nf):
                         if ignore(p):
                             ignored = p
                             ignoredata = repo.dirstate._ignorefileandline(p)
                             break
             if ignored:
                 if ignored == nf:
                     ui.write(_(b"%s is ignored\n") % uipathfn(f))
                 else:
                     ui.write(
                         _(
                             b"%s is ignored because of "
                             b"containing directory %s\n"
                         )
                         % (uipathfn(f), ignored)
                     )
                 ignorefile, lineno, line = ignoredata
                 ui.write(
                     _(b"(ignore rule in %s, line %d: '%s')\n")
                     % (ignorefile, lineno, line)
                 )
             else:
                 ui.write(_(b"%s is not ignored\n") % uipathfn(f))
 
 
 @command(
     b'debugindex',
     cmdutil.debugrevlogopts + cmdutil.formatteropts,
     _(b'-c|-m|FILE'),
 )
 def debugindex(ui, repo, file_=None, **opts):
     """dump index data for a storage primitive"""
     opts = pycompat.byteskwargs(opts)
     store = cmdutil.openstorage(repo, b'debugindex', file_, opts)
 
     if ui.debugflag:
         shortfn = hex
     else:
         shortfn = short
 
     idlen = 12
     for i in store:
         idlen = len(shortfn(store.node(i)))
         break
 
     fm = ui.formatter(b'debugindex', opts)
     fm.plain(
         b'   rev linkrev %s %s p2\n'
         % (b'nodeid'.ljust(idlen), b'p1'.ljust(idlen))
     )
 
     for rev in store:
         node = store.node(rev)
         parents = store.parents(node)
 
         fm.startitem()
         fm.write(b'rev', b'%6d ', rev)
         fm.write(b'linkrev', b'%7d ', store.linkrev(rev))
         fm.write(b'node', b'%s ', shortfn(node))
         fm.write(b'p1', b'%s ', shortfn(parents[0]))
         fm.write(b'p2', b'%s', shortfn(parents[1]))
         fm.plain(b'\n')
 
     fm.end()
 
 
 @command(
     b'debugindexdot',
     cmdutil.debugrevlogopts,
     _(b'-c|-m|FILE'),
     optionalrepo=True,
 )
 def debugindexdot(ui, repo, file_=None, **opts):
     """dump an index DAG as a graphviz dot file"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openstorage(repo, b'debugindexdot', file_, opts)
     ui.writenoi18n(b"digraph G {\n")
     for i in r:
         node = r.node(i)
         pp = r.parents(node)
         ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i))
         if pp[1] != repo.nullid:
             ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i))
     ui.write(b"}\n")
 
 
 @command(b'debugindexstats', [])
 def debugindexstats(ui, repo):
     """show stats related to the changelog index"""
     repo.changelog.shortest(repo.nullid, 1)
     index = repo.changelog.index
     if not util.safehasattr(index, b'stats'):
         raise error.Abort(_(b'debugindexstats only works with native code'))
     for k, v in sorted(index.stats().items()):
         ui.write(b'%s: %d\n' % (k, v))
 
 
 @command(b'debuginstall', [] + cmdutil.formatteropts, b'', norepo=True)
 def debuginstall(ui, **opts):
     """test Mercurial installation
 
     Returns 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
 
     problems = 0
 
     fm = ui.formatter(b'debuginstall', opts)
     fm.startitem()
 
     # encoding might be unknown or wrong. don't translate these messages.
     fm.write(b'encoding', b"checking encoding (%s)...\n", encoding.encoding)
     err = None
     try:
         codecs.lookup(pycompat.sysstr(encoding.encoding))
     except LookupError as inst:
         err = stringutil.forcebytestr(inst)
         problems += 1
     fm.condwrite(
         err,
         b'encodingerror',
         b" %s\n (check that your locale is properly set)\n",
         err,
     )
 
     # Python
     pythonlib = None
     if util.safehasattr(os, '__file__'):
         pythonlib = os.path.dirname(pycompat.fsencode(os.__file__))
     elif getattr(sys, 'oxidized', False):
         pythonlib = pycompat.sysexecutable
 
     fm.write(
         b'pythonexe',
         _(b"checking Python executable (%s)\n"),
         pycompat.sysexecutable or _(b"unknown"),
     )
     fm.write(
         b'pythonimplementation',
         _(b"checking Python implementation (%s)\n"),
         pycompat.sysbytes(platform.python_implementation()),
     )
     fm.write(
         b'pythonver',
         _(b"checking Python version (%s)\n"),
         (b"%d.%d.%d" % sys.version_info[:3]),
     )
     fm.write(
         b'pythonlib',
         _(b"checking Python lib (%s)...\n"),
         pythonlib or _(b"unknown"),
     )
 
     try:
         from . import rustext  # pytype: disable=import-error
 
         rustext.__doc__  # trigger lazy import
     except ImportError:
         rustext = None
 
     security = set(sslutil.supportedprotocols)
     if sslutil.hassni:
         security.add(b'sni')
 
     fm.write(
         b'pythonsecurity',
         _(b"checking Python security support (%s)\n"),
         fm.formatlist(sorted(security), name=b'protocol', fmt=b'%s', sep=b','),
     )
 
     # These are warnings, not errors. So don't increment problem count. This
     # may change in the future.
     if b'tls1.2' not in security:
         fm.plain(
             _(
                 b'  TLS 1.2 not supported by Python install; '
                 b'network connections lack modern security\n'
             )
         )
     if b'sni' not in security:
         fm.plain(
             _(
                 b'  SNI not supported by Python install; may have '
                 b'connectivity issues with some servers\n'
             )
         )
 
     fm.plain(
         _(
             b"checking Rust extensions (%s)\n"
             % (b'missing' if rustext is None else b'installed')
         ),
     )
 
     # TODO print CA cert info
 
     # hg version
     hgver = util.version()
     fm.write(
         b'hgver', _(b"checking Mercurial version (%s)\n"), hgver.split(b'+')[0]
     )
     fm.write(
         b'hgverextra',
         _(b"checking Mercurial custom build (%s)\n"),
         b'+'.join(hgver.split(b'+')[1:]),
     )
 
     # compiled modules
     hgmodules = None
     if util.safehasattr(sys.modules[__name__], '__file__'):
         hgmodules = os.path.dirname(pycompat.fsencode(__file__))
     elif getattr(sys, 'oxidized', False):
         hgmodules = pycompat.sysexecutable
 
     fm.write(
         b'hgmodulepolicy', _(b"checking module policy (%s)\n"), policy.policy
     )
     fm.write(
         b'hgmodules',
         _(b"checking installed modules (%s)...\n"),
         hgmodules or _(b"unknown"),
     )
 
     rustandc = policy.policy in (b'rust+c', b'rust+c-allow')
     rustext = rustandc  # for now, that's the only case
     cext = policy.policy in (b'c', b'allow') or rustandc
     nopure = cext or rustext
     if nopure:
         err = None
         try:
             if cext:
                 from .cext import (  # pytype: disable=import-error
                     base85,
                     bdiff,
                     mpatch,
                     osutil,
                 )
 
                 # quiet pyflakes
                 dir(bdiff), dir(mpatch), dir(base85), dir(osutil)
             if rustext:
                 from .rustext import (  # pytype: disable=import-error
                     ancestor,
                     dirstate,
                 )
 
                 dir(ancestor), dir(dirstate)  # quiet pyflakes
         except Exception as inst:
             err = stringutil.forcebytestr(inst)
             problems += 1
         fm.condwrite(err, b'extensionserror', b" %s\n", err)
 
     compengines = util.compengines._engines.values()
     fm.write(
         b'compengines',
         _(b'checking registered compression engines (%s)\n'),
         fm.formatlist(
             sorted(e.name() for e in compengines),
             name=b'compengine',
             fmt=b'%s',
             sep=b', ',
         ),
     )
     fm.write(
         b'compenginesavail',
         _(b'checking available compression engines (%s)\n'),
         fm.formatlist(
             sorted(e.name() for e in compengines if e.available()),
             name=b'compengine',
             fmt=b'%s',
             sep=b', ',
         ),
     )
     wirecompengines = compression.compengines.supportedwireengines(
         compression.SERVERROLE
     )
     fm.write(
         b'compenginesserver',
         _(
             b'checking available compression engines '
             b'for wire protocol (%s)\n'
         ),
         fm.formatlist(
             [e.name() for e in wirecompengines if e.wireprotosupport()],
             name=b'compengine',
             fmt=b'%s',
             sep=b', ',
         ),
     )
     re2 = b'missing'
     if util._re2:
         re2 = b'available'
     fm.plain(_(b'checking "re2" regexp engine (%s)\n') % re2)
     fm.data(re2=bool(util._re2))
 
     # templates
     p = templater.templatedir()
     fm.write(b'templatedirs', b'checking templates (%s)...\n', p or b'')
     fm.condwrite(not p, b'', _(b" no template directories found\n"))
     if p:
         (m, fp) = templater.try_open_template(b"map-cmdline.default")
         if m:
             # template found, check if it is working
             err = None
             try:
                 templater.templater.frommapfile(m)
             except Exception as inst:
                 err = stringutil.forcebytestr(inst)
                 p = None
             fm.condwrite(err, b'defaulttemplateerror', b" %s\n", err)
         else:
             p = None
         fm.condwrite(
             p, b'defaulttemplate', _(b"checking default template (%s)\n"), m
         )
         fm.condwrite(
             not m,
             b'defaulttemplatenotfound',
             _(b" template '%s' not found\n"),
             b"default",
         )
     if not p:
         problems += 1
     fm.condwrite(
         not p, b'', _(b" (templates seem to have been installed incorrectly)\n")
     )
 
     # editor
     editor = ui.geteditor()
     editor = util.expandpath(editor)
     editorbin = procutil.shellsplit(editor)[0]
     fm.write(b'editor', _(b"checking commit editor... (%s)\n"), editorbin)
     cmdpath = procutil.findexe(editorbin)
     fm.condwrite(
         not cmdpath and editor == b'vi',
         b'vinotfound',
         _(
             b" No commit editor set and can't find %s in PATH\n"
             b" (specify a commit editor in your configuration"
             b" file)\n"
         ),
         not cmdpath and editor == b'vi' and editorbin,
     )
     fm.condwrite(
         not cmdpath and editor != b'vi',
         b'editornotfound',
         _(
             b" Can't find editor '%s' in PATH\n"
             b" (specify a commit editor in your configuration"
             b" file)\n"
         ),
         not cmdpath and editorbin,
     )
     if not cmdpath and editor != b'vi':
         problems += 1
 
     # check username
     username = None
     err = None
     try:
         username = ui.username()
     except error.Abort as e:
         err = e.message
         problems += 1
 
     fm.condwrite(
         username, b'username', _(b"checking username (%s)\n"), username
     )
     fm.condwrite(
         err,
         b'usernameerror',
         _(
             b"checking username...\n %s\n"
             b" (specify a username in your configuration file)\n"
         ),
         err,
     )
 
     for name, mod in extensions.extensions():
         handler = getattr(mod, 'debuginstall', None)
         if handler is not None:
             problems += handler(ui, fm)
 
     fm.condwrite(not problems, b'', _(b"no problems detected\n"))
     if not problems:
         fm.data(problems=problems)
     fm.condwrite(
         problems,
         b'problems',
         _(b"%d problems detected, please check your install!\n"),
         problems,
     )
     fm.end()
 
     return problems
 
 
 @command(b'debugknown', [], _(b'REPO ID...'), norepo=True)
 def debugknown(ui, repopath, *ids, **opts):
     """test whether node ids are known to a repo
 
     Every ID must be a full-length hex node id string. Returns a list of 0s
     and 1s indicating unknown/known.
     """
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     if not repo.capable(b'known'):
         raise error.Abort(b"known() not supported by target repository")
     flags = repo.known([bin(s) for s in ids])
     ui.write(b"%s\n" % (b"".join([f and b"1" or b"0" for f in flags])))
 
 
 @command(b'debuglabelcomplete', [], _(b'LABEL...'))
 def debuglabelcomplete(ui, repo, *args):
     '''backwards compatibility with old bash completion scripts (DEPRECATED)'''
     debugnamecomplete(ui, repo, *args)
 
 
 @command(
     b'debuglocks',
     [
         (b'L', b'force-free-lock', None, _(b'free the store lock (DANGEROUS)')),
         (
             b'W',
             b'force-free-wlock',
             None,
             _(b'free the working state lock (DANGEROUS)'),
         ),
         (b's', b'set-lock', None, _(b'set the store lock until stopped')),
         (
             b'S',
             b'set-wlock',
             None,
             _(b'set the working state lock until stopped'),
         ),
     ],
     _(b'[OPTION]...'),
 )
 def debuglocks(ui, repo, **opts):
     """show or modify state of locks
 
     By default, this command will show which locks are held. This
     includes the user and process holding the lock, the amount of time
     the lock has been held, and the machine name where the process is
     running if it's not local.
 
     Locks protect the integrity of Mercurial's data, so should be
     treated with care. System crashes or other interruptions may cause
     locks to not be properly released, though Mercurial will usually
     detect and remove such stale locks automatically.
 
     However, detecting stale locks may not always be possible (for
     instance, on a shared filesystem). Removing locks may also be
     blocked by filesystem permissions.
 
     Setting a lock will prevent other commands from changing the data.
     The command will wait until an interruption (SIGINT, SIGTERM, ...) occurs.
     The set locks are removed when the command exits.
 
     Returns 0 if no locks are held.
 
     """
 
     if opts.get('force_free_lock'):
         repo.svfs.unlink(b'lock')
     if opts.get('force_free_wlock'):
         repo.vfs.unlink(b'wlock')
     if opts.get('force_free_lock') or opts.get('force_free_wlock'):
         return 0
 
     locks = []
     try:
         if opts.get('set_wlock'):
             try:
                 locks.append(repo.wlock(False))
             except error.LockHeld:
                 raise error.Abort(_(b'wlock is already held'))
         if opts.get('set_lock'):
             try:
                 locks.append(repo.lock(False))
             except error.LockHeld:
                 raise error.Abort(_(b'lock is already held'))
         if len(locks):
             ui.promptchoice(_(b"ready to release the lock (y)? $$ &Yes"))
             return 0
     finally:
         release(*locks)
 
     now = time.time()
     held = 0
 
     def report(vfs, name, method):
         # this causes stale locks to get reaped for more accurate reporting
         try:
             l = method(False)
         except error.LockHeld:
             l = None
 
         if l:
             l.release()
         else:
             try:
                 st = vfs.lstat(name)
                 age = now - st[stat.ST_MTIME]
                 user = util.username(st.st_uid)
                 locker = vfs.readlock(name)
                 if b":" in locker:
                     host, pid = locker.split(b':')
                     if host == socket.gethostname():
                         locker = b'user %s, process %s' % (user or b'None', pid)
                     else:
                         locker = b'user %s, process %s, host %s' % (
                             user or b'None',
                             pid,
                             host,
                         )
                 ui.writenoi18n(b"%-6s %s (%ds)\n" % (name + b":", locker, age))
                 return 1
             except OSError as e:
                 if e.errno != errno.ENOENT:
                     raise
 
         ui.writenoi18n(b"%-6s free\n" % (name + b":"))
         return 0
 
     held += report(repo.svfs, b"lock", repo.lock)
     held += report(repo.vfs, b"wlock", repo.wlock)
 
     return held
 
 
 @command(
     b'debugmanifestfulltextcache',
     [
         (b'', b'clear', False, _(b'clear the cache')),
         (
             b'a',
             b'add',
             [],
             _(b'add the given manifest nodes to the cache'),
             _(b'NODE'),
         ),
     ],
     b'',
 )
 def debugmanifestfulltextcache(ui, repo, add=(), **opts):
     """show, clear or amend the contents of the manifest fulltext cache"""
 
     def getcache():
         r = repo.manifestlog.getstorage(b'')
         try:
             return r._fulltextcache
         except AttributeError:
             msg = _(
                 b"Current revlog implementation doesn't appear to have a "
                 b"manifest fulltext cache\n"
             )
             raise error.Abort(msg)
 
     if opts.get('clear'):
         with repo.wlock():
             cache = getcache()
             cache.clear(clear_persisted_data=True)
             return
 
     if add:
         with repo.wlock():
             m = repo.manifestlog
             store = m.getstorage(b'')
             for n in add:
                 try:
                     manifest = m[store.lookup(n)]
                 except error.LookupError as e:
                     raise error.Abort(
                         bytes(e), hint=b"Check your manifest node id"
                     )
                 manifest.read()  # stores revisision in cache too
             return
 
     cache = getcache()
     if not len(cache):
         ui.write(_(b'cache empty\n'))
     else:
         ui.write(
             _(
                 b'cache contains %d manifest entries, in order of most to '
                 b'least recent:\n'
             )
             % (len(cache),)
         )
         totalsize = 0
         for nodeid in cache:
             # Use cache.get to not update the LRU order
             data = cache.peek(nodeid)
             size = len(data)
             totalsize += size + 24  # 20 bytes nodeid, 4 bytes size
             ui.write(
                 _(b'id: %s, size %s\n') % (hex(nodeid), util.bytecount(size))
             )
         ondisk = cache._opener.stat(b'manifestfulltextcache').st_size
         ui.write(
             _(b'total cache data size %s, on-disk %s\n')
             % (util.bytecount(totalsize), util.bytecount(ondisk))
         )
 
 
 @command(b'debugmergestate', [] + cmdutil.templateopts, b'')
 def debugmergestate(ui, repo, *args, **opts):
     """print merge state
 
     Use --verbose to print out information about whether v1 or v2 merge state
     was chosen."""
 
     if ui.verbose:
         ms = mergestatemod.mergestate(repo)
 
         # sort so that reasonable information is on top
         v1records = ms._readrecordsv1()
         v2records = ms._readrecordsv2()
 
         if not v1records and not v2records:
             pass
         elif not v2records:
             ui.writenoi18n(b'no version 2 merge state\n')
         elif ms._v1v2match(v1records, v2records):
             ui.writenoi18n(b'v1 and v2 states match: using v2\n')
         else:
             ui.writenoi18n(b'v1 and v2 states mismatch: using v1\n')
 
     opts = pycompat.byteskwargs(opts)
     if not opts[b'template']:
         opts[b'template'] = (
             b'{if(commits, "", "no merge state found\n")}'
             b'{commits % "{name}{if(label, " ({label})")}: {node}\n"}'
             b'{files % "file: {path} (state \\"{state}\\")\n'
             b'{if(local_path, "'
             b'  local path: {local_path} (hash {local_key}, flags \\"{local_flags}\\")\n'
             b'  ancestor path: {ancestor_path} (node {ancestor_node})\n'
             b'  other path: {other_path} (node {other_node})\n'
             b'")}'
             b'{if(rename_side, "'
             b'  rename side: {rename_side}\n'
             b'  renamed path: {renamed_path}\n'
             b'")}'
             b'{extras % "  extra: {key} = {value}\n"}'
             b'"}'
             b'{extras % "extra: {file} ({key} = {value})\n"}'
         )
 
     ms = mergestatemod.mergestate.read(repo)
 
     fm = ui.formatter(b'debugmergestate', opts)
     fm.startitem()
 
     fm_commits = fm.nested(b'commits')
     if ms.active():
         for name, node, label_index in (
             (b'local', ms.local, 0),
             (b'other', ms.other, 1),
         ):
             fm_commits.startitem()
             fm_commits.data(name=name)
             fm_commits.data(node=hex(node))
             if ms._labels and len(ms._labels) > label_index:
                 fm_commits.data(label=ms._labels[label_index])
     fm_commits.end()
 
     fm_files = fm.nested(b'files')
     if ms.active():
         for f in ms:
             fm_files.startitem()
             fm_files.data(path=f)
             state = ms._state[f]
             fm_files.data(state=state[0])
             if state[0] in (
                 mergestatemod.MERGE_RECORD_UNRESOLVED,
                 mergestatemod.MERGE_RECORD_RESOLVED,
             ):
                 fm_files.data(local_key=state[1])
                 fm_files.data(local_path=state[2])
                 fm_files.data(ancestor_path=state[3])
                 fm_files.data(ancestor_node=state[4])
                 fm_files.data(other_path=state[5])
                 fm_files.data(other_node=state[6])
                 fm_files.data(local_flags=state[7])
             elif state[0] in (
                 mergestatemod.MERGE_RECORD_UNRESOLVED_PATH,
                 mergestatemod.MERGE_RECORD_RESOLVED_PATH,
             ):
                 fm_files.data(renamed_path=state[1])
                 fm_files.data(rename_side=state[2])
             fm_extras = fm_files.nested(b'extras')
             for k, v in sorted(ms.extras(f).items()):
                 fm_extras.startitem()
                 fm_extras.data(key=k)
                 fm_extras.data(value=v)
             fm_extras.end()
 
     fm_files.end()
 
     fm_extras = fm.nested(b'extras')
     for f, d in sorted(pycompat.iteritems(ms.allextras())):
         if f in ms:
             # If file is in mergestate, we have already processed it's extras
             continue
         for k, v in pycompat.iteritems(d):
             fm_extras.startitem()
             fm_extras.data(file=f)
             fm_extras.data(key=k)
             fm_extras.data(value=v)
     fm_extras.end()
 
     fm.end()
 
 
 @command(b'debugnamecomplete', [], _(b'NAME...'))
 def debugnamecomplete(ui, repo, *args):
     '''complete "names" - tags, open branch names, bookmark names'''
 
     names = set()
     # since we previously only listed open branches, we will handle that
     # specially (after this for loop)
     for name, ns in pycompat.iteritems(repo.names):
         if name != b'branches':
             names.update(ns.listnames(repo))
     names.update(
         tag
         for (tag, heads, tip, closed) in repo.branchmap().iterbranches()
         if not closed
     )
     completions = set()
     if not args:
         args = [b'']
     for a in args:
         completions.update(n for n in names if n.startswith(a))
     ui.write(b'\n'.join(sorted(completions)))
     ui.write(b'\n')
 
 
 @command(
     b'debugnodemap',
     [
         (
             b'',
             b'dump-new',
             False,
             _(b'write a (new) persistent binary nodemap on stdout'),
         ),
         (b'', b'dump-disk', False, _(b'dump on-disk data on stdout')),
         (
             b'',
             b'check',
             False,
             _(b'check that the data on disk data are correct.'),
         ),
         (
             b'',
             b'metadata',
             False,
             _(b'display the on disk meta data for the nodemap'),
         ),
     ],
 )
 def debugnodemap(ui, repo, **opts):
     """write and inspect on disk nodemap"""
     if opts['dump_new']:
         unfi = repo.unfiltered()
         cl = unfi.changelog
         if util.safehasattr(cl.index, "nodemap_data_all"):
             data = cl.index.nodemap_data_all()
         else:
             data = nodemap.persistent_data(cl.index)
         ui.write(data)
     elif opts['dump_disk']:
         unfi = repo.unfiltered()
         cl = unfi.changelog
         nm_data = nodemap.persisted_data(cl)
         if nm_data is not None:
             docket, data = nm_data
             ui.write(data[:])
     elif opts['check']:
         unfi = repo.unfiltered()
         cl = unfi.changelog
         nm_data = nodemap.persisted_data(cl)
         if nm_data is not None:
             docket, data = nm_data
             return nodemap.check_data(ui, cl.index, data)
     elif opts['metadata']:
         unfi = repo.unfiltered()
         cl = unfi.changelog
         nm_data = nodemap.persisted_data(cl)
         if nm_data is not None:
             docket, data = nm_data
             ui.write((b"uid: %s\n") % docket.uid)
             ui.write((b"tip-rev: %d\n") % docket.tip_rev)
             ui.write((b"tip-node: %s\n") % hex(docket.tip_node))
             ui.write((b"data-length: %d\n") % docket.data_length)
             ui.write((b"data-unused: %d\n") % docket.data_unused)
             unused_perc = docket.data_unused * 100.0 / docket.data_length
             ui.write((b"data-unused: %2.3f%%\n") % unused_perc)
 
 
 @command(
     b'debugobsolete',
     [
         (b'', b'flags', 0, _(b'markers flag')),
         (
             b'',
             b'record-parents',
             False,
             _(b'record parent information for the precursor'),
         ),
         (b'r', b'rev', [], _(b'display markers relevant to REV')),
         (
             b'',
             b'exclusive',
             False,
             _(b'restrict display to markers only relevant to REV'),
         ),
         (b'', b'index', False, _(b'display index of the marker')),
         (b'', b'delete', [], _(b'delete markers specified by indices')),
     ]
     + cmdutil.commitopts2
     + cmdutil.formatteropts,
     _(b'[OBSOLETED [REPLACEMENT ...]]'),
 )
 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
     """create arbitrary obsolete marker
 
     With no arguments, displays the list of obsolescence markers."""
 
     opts = pycompat.byteskwargs(opts)
 
     def parsenodeid(s):
         try:
             # We do not use revsingle/revrange functions here to accept
             # arbitrary node identifiers, possibly not present in the
             # local repository.
             n = bin(s)
             if len(n) != repo.nodeconstants.nodelen:
                 raise TypeError()
             return n
         except TypeError:
             raise error.InputError(
                 b'changeset references must be full hexadecimal '
                 b'node identifiers'
             )
 
     if opts.get(b'delete'):
         indices = []
         for v in opts.get(b'delete'):
             try:
                 indices.append(int(v))
             except ValueError:
                 raise error.InputError(
                     _(b'invalid index value: %r') % v,
                     hint=_(b'use integers for indices'),
                 )
 
         if repo.currenttransaction():
             raise error.Abort(
                 _(b'cannot delete obsmarkers in the middle of transaction.')
             )
 
         with repo.lock():
             n = repair.deleteobsmarkers(repo.obsstore, indices)
             ui.write(_(b'deleted %i obsolescence markers\n') % n)
 
         return
 
     if precursor is not None:
         if opts[b'rev']:
             raise error.InputError(
                 b'cannot select revision when creating marker'
             )
         metadata = {}
         metadata[b'user'] = encoding.fromlocal(opts[b'user'] or ui.username())
         succs = tuple(parsenodeid(succ) for succ in successors)
         l = repo.lock()
         try:
             tr = repo.transaction(b'debugobsolete')
             try:
                 date = opts.get(b'date')
                 if date:
                     date = dateutil.parsedate(date)
                 else:
                     date = None
                 prec = parsenodeid(precursor)
                 parents = None
                 if opts[b'record_parents']:
                     if prec not in repo.unfiltered():
                         raise error.Abort(
                             b'cannot used --record-parents on '
                             b'unknown changesets'
                         )
                     parents = repo.unfiltered()[prec].parents()
                     parents = tuple(p.node() for p in parents)
                 repo.obsstore.create(
                     tr,
                     prec,
                     succs,
                     opts[b'flags'],
                     parents=parents,
                     date=date,
                     metadata=metadata,
                     ui=ui,
                 )
                 tr.close()
             except ValueError as exc:
                 raise error.Abort(
                     _(b'bad obsmarker input: %s') % stringutil.forcebytestr(exc)
                 )
             finally:
                 tr.release()
         finally:
             l.release()
     else:
         if opts[b'rev']:
             revs = scmutil.revrange(repo, opts[b'rev'])
             nodes = [repo[r].node() for r in revs]
             markers = list(
                 obsutil.getmarkers(
                     repo, nodes=nodes, exclusive=opts[b'exclusive']
                 )
             )
             markers.sort(key=lambda x: x._data)
         else:
             markers = obsutil.getmarkers(repo)
 
         markerstoiter = markers
         isrelevant = lambda m: True
         if opts.get(b'rev') and opts.get(b'index'):
             markerstoiter = obsutil.getmarkers(repo)
             markerset = set(markers)
             isrelevant = lambda m: m in markerset
 
         fm = ui.formatter(b'debugobsolete', opts)
         for i, m in enumerate(markerstoiter):
             if not isrelevant(m):
                 # marker can be irrelevant when we're iterating over a set
                 # of markers (markerstoiter) which is bigger than the set
                 # of markers we want to display (markers)
                 # this can happen if both --index and --rev options are
                 # provided and thus we need to iterate over all of the markers
                 # to get the correct indices, but only display the ones that
                 # are relevant to --rev value
                 continue
             fm.startitem()
             ind = i if opts.get(b'index') else None
             cmdutil.showmarker(fm, m, index=ind)
         fm.end()
 
 
 @command(
     b'debugp1copies',
     [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
     _(b'[-r REV]'),
 )
 def debugp1copies(ui, repo, **opts):
     """dump copy information compared to p1"""
 
     opts = pycompat.byteskwargs(opts)
     ctx = scmutil.revsingle(repo, opts.get(b'rev'), default=None)
     for dst, src in ctx.p1copies().items():
         ui.write(b'%s -> %s\n' % (src, dst))
 
 
 @command(
     b'debugp2copies',
     [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
     _(b'[-r REV]'),
 )
 def debugp1copies(ui, repo, **opts):
     """dump copy information compared to p2"""
 
     opts = pycompat.byteskwargs(opts)
     ctx = scmutil.revsingle(repo, opts.get(b'rev'), default=None)
     for dst, src in ctx.p2copies().items():
         ui.write(b'%s -> %s\n' % (src, dst))
 
 
 @command(
     b'debugpathcomplete',
     [
         (b'f', b'full', None, _(b'complete an entire path')),
         (b'n', b'normal', None, _(b'show only normal files')),
         (b'a', b'added', None, _(b'show only added files')),
         (b'r', b'removed', None, _(b'show only removed files')),
     ],
     _(b'FILESPEC...'),
 )
 def debugpathcomplete(ui, repo, *specs, **opts):
     """complete part or all of a tracked path
 
     This command supports shells that offer path name completion. It
     currently completes only files already known to the dirstate.
 
     Completion extends only to the next path segment unless
     --full is specified, in which case entire paths are used."""
 
     def complete(path, acceptable):
         dirstate = repo.dirstate
         spec = os.path.normpath(os.path.join(encoding.getcwd(), path))
         rootdir = repo.root + pycompat.ossep
         if spec != repo.root and not spec.startswith(rootdir):
             return [], []
         if os.path.isdir(spec):
             spec += b'/'
         spec = spec[len(rootdir) :]
         fixpaths = pycompat.ossep != b'/'
         if fixpaths:
             spec = spec.replace(pycompat.ossep, b'/')
         speclen = len(spec)
         fullpaths = opts['full']
         files, dirs = set(), set()
         adddir, addfile = dirs.add, files.add
         for f, st in pycompat.iteritems(dirstate):
             if f.startswith(spec) and st.state in acceptable:
                 if fixpaths:
                     f = f.replace(b'/', pycompat.ossep)
                 if fullpaths:
                     addfile(f)
                     continue
                 s = f.find(pycompat.ossep, speclen)
                 if s >= 0:
                     adddir(f[:s])
                 else:
                     addfile(f)
         return files, dirs
 
     acceptable = b''
     if opts['normal']:
         acceptable += b'nm'
     if opts['added']:
         acceptable += b'a'
     if opts['removed']:
         acceptable += b'r'
     cwd = repo.getcwd()
     if not specs:
         specs = [b'.']
 
     files, dirs = set(), set()
     for spec in specs:
         f, d = complete(spec, acceptable or b'nmar')
         files.update(f)
         dirs.update(d)
     files.update(dirs)
     ui.write(b'\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
     ui.write(b'\n')
 
 
 @command(
     b'debugpathcopies',
     cmdutil.walkopts,
     b'hg debugpathcopies REV1 REV2 [FILE]',
     inferrepo=True,
 )
 def debugpathcopies(ui, repo, rev1, rev2, *pats, **opts):
     """show copies between two revisions"""
     ctx1 = scmutil.revsingle(repo, rev1)
     ctx2 = scmutil.revsingle(repo, rev2)
     m = scmutil.match(ctx1, pats, opts)
     for dst, src in sorted(copies.pathcopies(ctx1, ctx2, m).items()):
         ui.write(b'%s -> %s\n' % (src, dst))
 
 
 @command(b'debugpeer', [], _(b'PATH'), norepo=True)
 def debugpeer(ui, path):
     """establish a connection to a peer repository"""
     # Always enable peer request logging. Requires --debug to display
     # though.
     overrides = {
         (b'devel', b'debug.peer-request'): True,
     }
 
     with ui.configoverride(overrides):
         peer = hg.peer(ui, {}, path)
 
         try:
             local = peer.local() is not None
             canpush = peer.canpush()
 
             ui.write(_(b'url: %s\n') % peer.url())
             ui.write(_(b'local: %s\n') % (_(b'yes') if local else _(b'no')))
             ui.write(
                 _(b'pushable: %s\n') % (_(b'yes') if canpush else _(b'no'))
             )
         finally:
             peer.close()
 
 
 @command(
     b'debugpickmergetool',
     [
         (b'r', b'rev', b'', _(b'check for files in this revision'), _(b'REV')),
         (b'', b'changedelete', None, _(b'emulate merging change and delete')),
     ]
     + cmdutil.walkopts
     + cmdutil.mergetoolopts,
     _(b'[PATTERN]...'),
     inferrepo=True,
 )
 def debugpickmergetool(ui, repo, *pats, **opts):
     """examine which merge tool is chosen for specified file
 
     As described in :hg:`help merge-tools`, Mercurial examines
     configurations below in this order to decide which merge tool is
     chosen for specified file.
 
     1. ``--tool`` option
     2. ``HGMERGE`` environment variable
     3. configurations in ``merge-patterns`` section
     4. configuration of ``ui.merge``
     5. configurations in ``merge-tools`` section
     6. ``hgmerge`` tool (for historical reason only)
     7. default tool for fallback (``:merge`` or ``:prompt``)
 
     This command writes out examination result in the style below::
 
         FILE = MERGETOOL
 
     By default, all files known in the first parent context of the
     working directory are examined. Use file patterns and/or -I/-X
     options to limit target files. -r/--rev is also useful to examine
     files in another context without actual updating to it.
 
     With --debug, this command shows warning messages while matching
     against ``merge-patterns`` and so on, too. It is recommended to
     use this option with explicit file patterns and/or -I/-X options,
     because this option increases amount of output per file according
     to configurations in hgrc.
 
     With -v/--verbose, this command shows configurations below at
     first (only if specified).
 
     - ``--tool`` option
     - ``HGMERGE`` environment variable
     - configuration of ``ui.merge``
 
     If merge tool is chosen before matching against
     ``merge-patterns``, this command can't show any helpful
     information, even with --debug. In such case, information above is
     useful to know why a merge tool is chosen.
     """
     opts = pycompat.byteskwargs(opts)
     overrides = {}
     if opts[b'tool']:
         overrides[(b'ui', b'forcemerge')] = opts[b'tool']
         ui.notenoi18n(b'with --tool %r\n' % (pycompat.bytestr(opts[b'tool'])))
 
     with ui.configoverride(overrides, b'debugmergepatterns'):
         hgmerge = encoding.environ.get(b"HGMERGE")
         if hgmerge is not None:
             ui.notenoi18n(b'with HGMERGE=%r\n' % (pycompat.bytestr(hgmerge)))
         uimerge = ui.config(b"ui", b"merge")
         if uimerge:
             ui.notenoi18n(b'with ui.merge=%r\n' % (pycompat.bytestr(uimerge)))
 
         ctx = scmutil.revsingle(repo, opts.get(b'rev'))
         m = scmutil.match(ctx, pats, opts)
         changedelete = opts[b'changedelete']
         for path in ctx.walk(m):
             fctx = ctx[path]
             with ui.silent(
                 error=True
             ) if not ui.debugflag else util.nullcontextmanager():
                 tool, toolpath = filemerge._picktool(
                     repo,
                     ui,
                     path,
                     fctx.isbinary(),
                     b'l' in fctx.flags(),
                     changedelete,
                 )
             ui.write(b'%s = %s\n' % (path, tool))
 
 
 @command(b'debugpushkey', [], _(b'REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
     """access the pushkey key/value protocol
 
     With two args, list the keys in the given namespace.
 
     With five args, set a key to new if it currently is set to old.
     Reports success or failure.
     """
 
     target = hg.peer(ui, {}, repopath)
     try:
         if keyinfo:
             key, old, new = keyinfo
             with target.commandexecutor() as e:
                 r = e.callcommand(
                     b'pushkey',
                     {
                         b'namespace': namespace,
                         b'key': key,
                         b'old': old,
                         b'new': new,
                     },
                 ).result()
 
             ui.status(pycompat.bytestr(r) + b'\n')
             return not r
         else:
             for k, v in sorted(pycompat.iteritems(target.listkeys(namespace))):
                 ui.write(
                     b"%s\t%s\n"
                     % (stringutil.escapestr(k), stringutil.escapestr(v))
                 )
     finally:
         target.close()
 
 
 @command(b'debugpvec', [], _(b'A B'))
 def debugpvec(ui, repo, a, b=None):
     ca = scmutil.revsingle(repo, a)
     cb = scmutil.revsingle(repo, b)
     pa = pvec.ctxpvec(ca)
     pb = pvec.ctxpvec(cb)
     if pa == pb:
         rel = b"="
     elif pa > pb:
         rel = b">"
     elif pa < pb:
         rel = b"<"
     elif pa | pb:
         rel = b"|"
     ui.write(_(b"a: %s\n") % pa)
     ui.write(_(b"b: %s\n") % pb)
     ui.write(_(b"depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
     ui.write(
         _(b"delta: %d hdist: %d distance: %d relation: %s\n")
         % (
             abs(pa._depth - pb._depth),
             pvec._hamming(pa._vec, pb._vec),
             pa.distance(pb),
             rel,
         )
     )
 
 
 @command(
     b'debugrebuilddirstate|debugrebuildstate',
     [
         (b'r', b'rev', b'', _(b'revision to rebuild to'), _(b'REV')),
         (
             b'',
             b'minimal',
             None,
             _(
                 b'only rebuild files that are inconsistent with '
                 b'the working copy parent'
             ),
         ),
     ],
     _(b'[-r REV]'),
 )
 def debugrebuilddirstate(ui, repo, rev, **opts):
     """rebuild the dirstate as it would look like for the given revision
 
     If no revision is specified the first current parent will be used.
 
     The dirstate will be set to the files of the given revision.
     The actual working directory content or existing dirstate
     information such as adds or removes is not considered.
 
     ``minimal`` will only rebuild the dirstate status for files that claim to be
     tracked but are not in the parent manifest, or that exist in the parent
     manifest but are not in the dirstate. It will not change adds, removes, or
     modified files that are in the working copy parent.
 
     One use of this command is to make the next :hg:`status` invocation
     check the actual file content.
     """
     ctx = scmutil.revsingle(repo, rev)
     with repo.wlock():
         dirstate = repo.dirstate
         changedfiles = None
         # See command doc for what minimal does.
         if opts.get('minimal'):
             manifestfiles = set(ctx.manifest().keys())
             dirstatefiles = set(dirstate)
             manifestonly = manifestfiles - dirstatefiles
             dsonly = dirstatefiles - manifestfiles
             dsnotadded = {f for f in dsonly if dirstate[f] != b'a'}
             changedfiles = manifestonly | dsnotadded
 
         dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
 
 
 @command(b'debugrebuildfncache', [], b'')
 def debugrebuildfncache(ui, repo):
     """rebuild the fncache file"""
     repair.rebuildfncache(ui, repo)
 
 
 @command(
     b'debugrename',
     [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
     _(b'[-r REV] [FILE]...'),
 )
 def debugrename(ui, repo, *pats, **opts):
     """dump rename information"""
 
     opts = pycompat.byteskwargs(opts)
     ctx = scmutil.revsingle(repo, opts.get(b'rev'))
     m = scmutil.match(ctx, pats, opts)
     for abs in ctx.walk(m):
         fctx = ctx[abs]
         o = fctx.filelog().renamed(fctx.filenode())
         rel = repo.pathto(abs)
         if o:
             ui.write(_(b"%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
         else:
             ui.write(_(b"%s not renamed\n") % rel)
 
 
 @command(b'debugrequires|debugrequirements', [], b'')
 def debugrequirements(ui, repo):
     """print the current repo requirements"""
     for r in sorted(repo.requirements):
         ui.write(b"%s\n" % r)
 
 
 @command(
     b'debugrevlog',
     cmdutil.debugrevlogopts + [(b'd', b'dump', False, _(b'dump index data'))],
     _(b'-c|-m|FILE'),
     optionalrepo=True,
 )
 def debugrevlog(ui, repo, file_=None, **opts):
     """show data and statistics about a revlog"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, b'debugrevlog', file_, opts)
 
     if opts.get(b"dump"):
         numrevs = len(r)
         ui.write(
             (
                 b"# rev p1rev p2rev start   end deltastart base   p1   p2"
                 b" rawsize totalsize compression heads chainlen\n"
             )
         )
         ts = 0
         heads = set()
 
         for rev in pycompat.xrange(numrevs):
             dbase = r.deltaparent(rev)
             if dbase == -1:
                 dbase = rev
             cbase = r.chainbase(rev)
             clen = r.chainlen(rev)
             p1, p2 = r.parentrevs(rev)
             rs = r.rawsize(rev)
             ts = ts + rs
             heads -= set(r.parentrevs(rev))
             heads.add(rev)
             try:
                 compression = ts / r.end(rev)
             except ZeroDivisionError:
                 compression = 0
             ui.write(
                 b"%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
                 b"%11d %5d %8d\n"
                 % (
                     rev,
                     p1,
                     p2,
                     r.start(rev),
                     r.end(rev),
                     r.start(dbase),
                     r.start(cbase),
                     r.start(p1),
                     r.start(p2),
                     rs,
                     ts,
                     compression,
                     len(heads),
                     clen,
                 )
             )
         return 0
 
     format = r._format_version
     v = r._format_flags
     flags = []
     gdelta = False
     if v & revlog.FLAG_INLINE_DATA:
         flags.append(b'inline')
     if v & revlog.FLAG_GENERALDELTA:
         gdelta = True
         flags.append(b'generaldelta')
     if not flags:
         flags = [b'(none)']
 
     ### tracks merge vs single parent
     nummerges = 0
 
     ### tracks ways the "delta" are build
     # nodelta
     numempty = 0
     numemptytext = 0
     numemptydelta = 0
     # full file content
     numfull = 0
     # intermediate snapshot against a prior snapshot
     numsemi = 0
     # snapshot count per depth
     numsnapdepth = collections.defaultdict(lambda: 0)
     # delta against previous revision
     numprev = 0
     # delta against first or second parent (not prev)
     nump1 = 0
     nump2 = 0
     # delta against neither prev nor parents
     numother = 0
     # delta against prev that are also first or second parent
     # (details of `numprev`)
     nump1prev = 0
     nump2prev = 0
 
     # data about delta chain of each revs
     chainlengths = []
     chainbases = []
     chainspans = []
 
     # data about each revision
     datasize = [None, 0, 0]
     fullsize = [None, 0, 0]
     semisize = [None, 0, 0]
     # snapshot count per depth
     snapsizedepth = collections.defaultdict(lambda: [None, 0, 0])
     deltasize = [None, 0, 0]
     chunktypecounts = {}
     chunktypesizes = {}
 
     def addsize(size, l):
         if l[0] is None or size < l[0]:
             l[0] = size
         if size > l[1]:
             l[1] = size
         l[2] += size
 
     numrevs = len(r)
     for rev in pycompat.xrange(numrevs):
         p1, p2 = r.parentrevs(rev)
         delta = r.deltaparent(rev)
         if format > 0:
             addsize(r.rawsize(rev), datasize)
         if p2 != nullrev:
             nummerges += 1
         size = r.length(rev)
         if delta == nullrev:
             chainlengths.append(0)
             chainbases.append(r.start(rev))
             chainspans.append(size)
             if size == 0:
                 numempty += 1
                 numemptytext += 1
             else:
                 numfull += 1
                 numsnapdepth[0] += 1
                 addsize(size, fullsize)
                 addsize(size, snapsizedepth[0])
         else:
             chainlengths.append(chainlengths[delta] + 1)
             baseaddr = chainbases[delta]
             revaddr = r.start(rev)
             chainbases.append(baseaddr)
             chainspans.append((revaddr - baseaddr) + size)
             if size == 0:
                 numempty += 1
                 numemptydelta += 1
             elif r.issnapshot(rev):
                 addsize(size, semisize)
                 numsemi += 1
                 depth = r.snapshotdepth(rev)
                 numsnapdepth[depth] += 1
                 addsize(size, snapsizedepth[depth])
             else:
                 addsize(size, deltasize)
                 if delta == rev - 1:
                     numprev += 1
                     if delta == p1:
                         nump1prev += 1
                     elif delta == p2:
                         nump2prev += 1
                 elif delta == p1:
                     nump1 += 1
                 elif delta == p2:
                     nump2 += 1
                 elif delta != nullrev:
                     numother += 1
 
         # Obtain data on the raw chunks in the revlog.
         if util.safehasattr(r, b'_getsegmentforrevs'):
             segment = r._getsegmentforrevs(rev, rev)[1]
         else:
             segment = r._revlog._getsegmentforrevs(rev, rev)[1]
         if segment:
             chunktype = bytes(segment[0:1])
         else:
             chunktype = b'empty'
 
         if chunktype not in chunktypecounts:
             chunktypecounts[chunktype] = 0
             chunktypesizes[chunktype] = 0
 
         chunktypecounts[chunktype] += 1
         chunktypesizes[chunktype] += size
 
     # Adjust size min value for empty cases
     for size in (datasize, fullsize, semisize, deltasize):
         if size[0] is None:
             size[0] = 0
 
     numdeltas = numrevs - numfull - numempty - numsemi
     numoprev = numprev - nump1prev - nump2prev
     totalrawsize = datasize[2]
     datasize[2] /= numrevs
     fulltotal = fullsize[2]
     if numfull == 0:
         fullsize[2] = 0
     else:
         fullsize[2] /= numfull
     semitotal = semisize[2]
     snaptotal = {}
     if numsemi > 0:
         semisize[2] /= numsemi
     for depth in snapsizedepth:
         snaptotal[depth] = snapsizedepth[depth][2]
         snapsizedepth[depth][2] /= numsnapdepth[depth]
 
     deltatotal = deltasize[2]
     if numdeltas > 0:
         deltasize[2] /= numdeltas
     totalsize = fulltotal + semitotal + deltatotal
     avgchainlen = sum(chainlengths) / numrevs
     maxchainlen = max(chainlengths)
     maxchainspan = max(chainspans)
     compratio = 1
     if totalsize:
         compratio = totalrawsize / totalsize
 
     basedfmtstr = b'%%%dd\n'
     basepcfmtstr = b'%%%dd %s(%%5.2f%%%%)\n'
 
     def dfmtstr(max):
         return basedfmtstr % len(str(max))
 
     def pcfmtstr(max, padding=0):
         return basepcfmtstr % (len(str(max)), b' ' * padding)
 
     def pcfmt(value, total):
         if total:
             return (value, 100 * float(value) / total)
         else:
             return value, 100.0
 
     ui.writenoi18n(b'format : %d\n' % format)
     ui.writenoi18n(b'flags  : %s\n' % b', '.join(flags))
 
     ui.write(b'\n')
     fmt = pcfmtstr(totalsize)
     fmt2 = dfmtstr(totalsize)
     ui.writenoi18n(b'revisions     : ' + fmt2 % numrevs)
     ui.writenoi18n(b'    merges    : ' + fmt % pcfmt(nummerges, numrevs))
     ui.writenoi18n(
         b'    normal    : ' + fmt % pcfmt(numrevs - nummerges, numrevs)
     )
     ui.writenoi18n(b'revisions     : ' + fmt2 % numrevs)
     ui.writenoi18n(b'    empty     : ' + fmt % pcfmt(numempty, numrevs))
     ui.writenoi18n(
         b'                   text  : '
         + fmt % pcfmt(numemptytext, numemptytext + numemptydelta)
     )
     ui.writenoi18n(
         b'                   delta : '
         + fmt % pcfmt(numemptydelta, numemptytext + numemptydelta)
     )
     ui.writenoi18n(
         b'    snapshot  : ' + fmt % pcfmt(numfull + numsemi, numrevs)
     )
     for depth in sorted(numsnapdepth):
         ui.write(
             (b'      lvl-%-3d :       ' % depth)
             + fmt % pcfmt(numsnapdepth[depth], numrevs)
         )
     ui.writenoi18n(b'    deltas    : ' + fmt % pcfmt(numdeltas, numrevs))
     ui.writenoi18n(b'revision size : ' + fmt2 % totalsize)
     ui.writenoi18n(
         b'    snapshot  : ' + fmt % pcfmt(fulltotal + semitotal, totalsize)
     )
     for depth in sorted(numsnapdepth):
         ui.write(
             (b'      lvl-%-3d :       ' % depth)
             + fmt % pcfmt(snaptotal[depth], totalsize)
         )
     ui.writenoi18n(b'    deltas    : ' + fmt % pcfmt(deltatotal, totalsize))
 
     def fmtchunktype(chunktype):
         if chunktype == b'empty':
             return b'    %s     : ' % chunktype
         elif chunktype in pycompat.bytestr(string.ascii_letters):
             return b'    0x%s (%s)  : ' % (hex(chunktype), chunktype)
         else:
             return b'    0x%s      : ' % hex(chunktype)
 
     ui.write(b'\n')
     ui.writenoi18n(b'chunks        : ' + fmt2 % numrevs)
     for chunktype in sorted(chunktypecounts):
         ui.write(fmtchunktype(chunktype))
         ui.write(fmt % pcfmt(chunktypecounts[chunktype], numrevs))
     ui.writenoi18n(b'chunks size   : ' + fmt2 % totalsize)
     for chunktype in sorted(chunktypecounts):
         ui.write(fmtchunktype(chunktype))
         ui.write(fmt % pcfmt(chunktypesizes[chunktype], totalsize))
 
     ui.write(b'\n')
     fmt = dfmtstr(max(avgchainlen, maxchainlen, maxchainspan, compratio))
     ui.writenoi18n(b'avg chain length  : ' + fmt % avgchainlen)
     ui.writenoi18n(b'max chain length  : ' + fmt % maxchainlen)
     ui.writenoi18n(b'max chain reach   : ' + fmt % maxchainspan)
     ui.writenoi18n(b'compression ratio : ' + fmt % compratio)
 
     if format > 0:
         ui.write(b'\n')
         ui.writenoi18n(
             b'uncompressed data size (min/max/avg) : %d / %d / %d\n'
             % tuple(datasize)
         )
     ui.writenoi18n(
         b'full revision size (min/max/avg)     : %d / %d / %d\n'
         % tuple(fullsize)
     )
     ui.writenoi18n(
         b'inter-snapshot size (min/max/avg)    : %d / %d / %d\n'
         % tuple(semisize)
     )
     for depth in sorted(snapsizedepth):
         if depth == 0:
             continue
         ui.writenoi18n(
             b'    level-%-3d (min/max/avg)          : %d / %d / %d\n'
             % ((depth,) + tuple(snapsizedepth[depth]))
         )
     ui.writenoi18n(
         b'delta size (min/max/avg)             : %d / %d / %d\n'
         % tuple(deltasize)
     )
 
     if numdeltas > 0:
         ui.write(b'\n')
         fmt = pcfmtstr(numdeltas)
         fmt2 = pcfmtstr(numdeltas, 4)
         ui.writenoi18n(
             b'deltas against prev  : ' + fmt % pcfmt(numprev, numdeltas)
         )
         if numprev > 0:
             ui.writenoi18n(
                 b'    where prev = p1  : ' + fmt2 % pcfmt(nump1prev, numprev)
             )
             ui.writenoi18n(
                 b'    where prev = p2  : ' + fmt2 % pcfmt(nump2prev, numprev)
             )
             ui.writenoi18n(
                 b'    other            : ' + fmt2 % pcfmt(numoprev, numprev)
             )
         if gdelta:
             ui.writenoi18n(
                 b'deltas against p1    : ' + fmt % pcfmt(nump1, numdeltas)
             )
             ui.writenoi18n(
                 b'deltas against p2    : ' + fmt % pcfmt(nump2, numdeltas)
             )
             ui.writenoi18n(
                 b'deltas against other : ' + fmt % pcfmt(numother, numdeltas)
             )
 
 
 @command(
     b'debugrevlogindex',
     cmdutil.debugrevlogopts
     + [(b'f', b'format', 0, _(b'revlog format'), _(b'FORMAT'))],
     _(b'[-f FORMAT] -c|-m|FILE'),
     optionalrepo=True,
 )
 def debugrevlogindex(ui, repo, file_=None, **opts):
     """dump the contents of a revlog index"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, b'debugrevlogindex', file_, opts)
     format = opts.get(b'format', 0)
     if format not in (0, 1):
         raise error.Abort(_(b"unknown format %d") % format)
 
     if ui.debugflag:
         shortfn = hex
     else:
         shortfn = short
 
     # There might not be anything in r, so have a sane default
     idlen = 12
     for i in r:
         idlen = len(shortfn(r.node(i)))
         break
 
     if format == 0:
         if ui.verbose:
             ui.writenoi18n(
                 b"   rev    offset  length linkrev %s %s p2\n"
                 % (b"nodeid".ljust(idlen), b"p1".ljust(idlen))
             )
         else:
             ui.writenoi18n(
                 b"   rev linkrev %s %s p2\n"
                 % (b"nodeid".ljust(idlen), b"p1".ljust(idlen))
             )
     elif format == 1:
         if ui.verbose:
             ui.writenoi18n(
                 (
                     b"   rev flag   offset   length     size   link     p1"
                     b"     p2 %s\n"
                 )
                 % b"nodeid".rjust(idlen)
             )
         else:
             ui.writenoi18n(
                 b"   rev flag     size   link     p1     p2 %s\n"
                 % b"nodeid".rjust(idlen)
             )
 
     for i in r:
         node = r.node(i)
         if format == 0:
             try:
                 pp = r.parents(node)
             except Exception:
                 pp = [repo.nullid, repo.nullid]
             if ui.verbose:
                 ui.write(
                     b"% 6d % 9d % 7d % 7d %s %s %s\n"
                     % (
                         i,
                         r.start(i),
                         r.length(i),
                         r.linkrev(i),
                         shortfn(node),
                         shortfn(pp[0]),
                         shortfn(pp[1]),
                     )
                 )
             else:
                 ui.write(
                     b"% 6d % 7d %s %s %s\n"
                     % (
                         i,
                         r.linkrev(i),
                         shortfn(node),
                         shortfn(pp[0]),
                         shortfn(pp[1]),
                     )
                 )
         elif format == 1:
             pr = r.parentrevs(i)
             if ui.verbose:
                 ui.write(
                     b"% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d %s\n"
                     % (
                         i,
                         r.flags(i),
                         r.start(i),
                         r.length(i),
                         r.rawsize(i),
                         r.linkrev(i),
                         pr[0],
                         pr[1],
                         shortfn(node),
                     )
                 )
             else:
                 ui.write(
                     b"% 6d %04x % 8d % 6d % 6d % 6d %s\n"
                     % (
                         i,
                         r.flags(i),
                         r.rawsize(i),
                         r.linkrev(i),
                         pr[0],
                         pr[1],
                         shortfn(node),
                     )
                 )
 
 
 @command(
     b'debugrevspec',
     [
         (
             b'',
             b'optimize',
             None,
             _(b'print parsed tree after optimizing (DEPRECATED)'),
         ),
         (
             b'',
             b'show-revs',
             True,
             _(b'print list of result revisions (default)'),
         ),
         (
             b's',
             b'show-set',
             None,
             _(b'print internal representation of result set'),
         ),
         (
             b'p',
             b'show-stage',
             [],
             _(b'print parsed tree at the given stage'),
             _(b'NAME'),
         ),
         (b'', b'no-optimized', False, _(b'evaluate tree without optimization')),
         (b'', b'verify-optimized', False, _(b'verify optimized result')),
     ],
     b'REVSPEC',
 )
 def debugrevspec(ui, repo, expr, **opts):
     """parse and apply a revision specification
 
     Use -p/--show-stage option to print the parsed tree at the given stages.
     Use -p all to print tree at every stage.
 
     Use --no-show-revs option with -s or -p to print only the set
     representation or the parsed tree respectively.
 
     Use --verify-optimized to compare the optimized result with the unoptimized
     one. Returns 1 if the optimized result differs.
     """
     opts = pycompat.byteskwargs(opts)
     aliases = ui.configitems(b'revsetalias')
     stages = [
         (b'parsed', lambda tree: tree),
         (
             b'expanded',
             lambda tree: revsetlang.expandaliases(tree, aliases, ui.warn),
         ),
         (b'concatenated', revsetlang.foldconcat),
         (b'analyzed', revsetlang.analyze),
         (b'optimized', revsetlang.optimize),
     ]
     if opts[b'no_optimized']:
         stages = stages[:-1]
     if opts[b'verify_optimized'] and opts[b'no_optimized']:
         raise error.Abort(
             _(b'cannot use --verify-optimized with --no-optimized')
         )
     stagenames = {n for n, f in stages}
 
     showalways = set()
     showchanged = set()
     if ui.verbose and not opts[b'show_stage']:
         # show parsed tree by --verbose (deprecated)
         showalways.add(b'parsed')
         showchanged.update([b'expanded', b'concatenated'])
         if opts[b'optimize']:
             showalways.add(b'optimized')
     if opts[b'show_stage'] and opts[b'optimize']:
         raise error.Abort(_(b'cannot use --optimize with --show-stage'))
     if opts[b'show_stage'] == [b'all']:
         showalways.update(stagenames)
     else:
         for n in opts[b'show_stage']:
             if n not in stagenames:
                 raise error.Abort(_(b'invalid stage name: %s') % n)
         showalways.update(opts[b'show_stage'])
 
     treebystage = {}
     printedtree = None
     tree = revsetlang.parse(expr, lookup=revset.lookupfn(repo))
     for n, f in stages:
         treebystage[n] = tree = f(tree)
         if n in showalways or (n in showchanged and tree != printedtree):
             if opts[b'show_stage'] or n != b'parsed':
                 ui.write(b"* %s:\n" % n)
             ui.write(revsetlang.prettyformat(tree), b"\n")
             printedtree = tree
 
     if opts[b'verify_optimized']:
         arevs = revset.makematcher(treebystage[b'analyzed'])(repo)
         brevs = revset.makematcher(treebystage[b'optimized'])(repo)
         if opts[b'show_set'] or (opts[b'show_set'] is None and ui.verbose):
             ui.writenoi18n(
                 b"* analyzed set:\n", stringutil.prettyrepr(arevs), b"\n"
             )
             ui.writenoi18n(
                 b"* optimized set:\n", stringutil.prettyrepr(brevs), b"\n"
             )
         arevs = list(arevs)
         brevs = list(brevs)
         if arevs == brevs:
             return 0
         ui.writenoi18n(b'--- analyzed\n', label=b'diff.file_a')
         ui.writenoi18n(b'+++ optimized\n', label=b'diff.file_b')
         sm = difflib.SequenceMatcher(None, arevs, brevs)
         for tag, alo, ahi, blo, bhi in sm.get_opcodes():
             if tag in ('delete', 'replace'):
                 for c in arevs[alo:ahi]:
                     ui.write(b'-%d\n' % c, label=b'diff.deleted')
             if tag in ('insert', 'replace'):
                 for c in brevs[blo:bhi]:
                     ui.write(b'+%d\n' % c, label=b'diff.inserted')
             if tag == 'equal':
                 for c in arevs[alo:ahi]:
                     ui.write(b' %d\n' % c)
         return 1
 
     func = revset.makematcher(tree)
     revs = func(repo)
     if opts[b'show_set'] or (opts[b'show_set'] is None and ui.verbose):
         ui.writenoi18n(b"* set:\n", stringutil.prettyrepr(revs), b"\n")
     if not opts[b'show_revs']:
         return
     for c in revs:
         ui.write(b"%d\n" % c)
 
 
 @command(
     b'debugserve',
     [
         (
             b'',
             b'sshstdio',
             False,
             _(b'run an SSH server bound to process handles'),
         ),
         (b'', b'logiofd', b'', _(b'file descriptor to log server I/O to')),
         (b'', b'logiofile', b'', _(b'file to log server I/O to')),
     ],
     b'',
 )
 def debugserve(ui, repo, **opts):
     """run a server with advanced settings
 
     This command is similar to :hg:`serve`. It exists partially as a
     workaround to the fact that ``hg serve --stdio`` must have specific
     arguments for security reasons.
     """
     opts = pycompat.byteskwargs(opts)
 
     if not opts[b'sshstdio']:
         raise error.Abort(_(b'only --sshstdio is currently supported'))
 
     logfh = None
 
     if opts[b'logiofd'] and opts[b'logiofile']:
         raise error.Abort(_(b'cannot use both --logiofd and --logiofile'))
 
     if opts[b'logiofd']:
         # Ideally we would be line buffered. But line buffering in binary
         # mode isn't supported and emits a warning in Python 3.8+. Disabling
         # buffering could have performance impacts. But since this isn't
         # performance critical code, it should be fine.
         try:
             logfh = os.fdopen(int(opts[b'logiofd']), 'ab', 0)
         except OSError as e:
             if e.errno != errno.ESPIPE:
                 raise
             # can't seek a pipe, so `ab` mode fails on py3
             logfh = os.fdopen(int(opts[b'logiofd']), 'wb', 0)
     elif opts[b'logiofile']:
         logfh = open(opts[b'logiofile'], b'ab', 0)
 
     s = wireprotoserver.sshserver(ui, repo, logfh=logfh)
     s.serve_forever()
 
 
 @command(b'debugsetparents', [], _(b'REV1 [REV2]'))
 def debugsetparents(ui, repo, rev1, rev2=None):
     """manually set the parents of the current working directory (DANGEROUS)
 
     This command is not what you are looking for and should not be used. Using
     this command will most certainly results in slight corruption of the file
     level histories withing your repository. DO NOT USE THIS COMMAND.
 
     The command update the p1 and p2 field in the dirstate, and not touching
     anything else. This useful for writing repository conversion tools, but
     should be used with extreme care. For example, neither the working
     directory nor the dirstate is updated, so file status may be incorrect
     after running this command. Only used if you are one of the few people that
     deeply unstand both conversion tools and file level histories. If you are
     reading this help, you are not one of this people (most of them sailed west
     from Mithlond anyway.
 
     So one last time DO NOT USE THIS COMMAND.
 
     Returns 0 on success.
     """
 
     node1 = scmutil.revsingle(repo, rev1).node()
     node2 = scmutil.revsingle(repo, rev2, b'null').node()
 
     with repo.wlock():
         repo.setparents(node1, node2)
 
 
 @command(b'debugsidedata', cmdutil.debugrevlogopts, _(b'-c|-m|FILE REV'))
 def debugsidedata(ui, repo, file_, rev=None, **opts):
     """dump the side data for a cl/manifest/file revision
 
     Use --verbose to dump the sidedata content."""
     opts = pycompat.byteskwargs(opts)
     if opts.get(b'changelog') or opts.get(b'manifest') or opts.get(b'dir'):
         if rev is not None:
             raise error.CommandError(b'debugdata', _(b'invalid arguments'))
         file_, rev = None, file_
     elif rev is None:
         raise error.CommandError(b'debugdata', _(b'invalid arguments'))
     r = cmdutil.openstorage(repo, b'debugdata', file_, opts)
     r = getattr(r, '_revlog', r)
     try:
         sidedata = r.sidedata(r.lookup(rev))
     except KeyError:
         raise error.Abort(_(b'invalid revision identifier %s') % rev)
     if sidedata:
         sidedata = list(sidedata.items())
         sidedata.sort()
         ui.writenoi18n(b'%d sidedata entries\n' % len(sidedata))
         for key, value in sidedata:
             ui.writenoi18n(b' entry-%04o size %d\n' % (key, len(value)))
             if ui.verbose:
                 ui.writenoi18n(b'  %s\n' % stringutil.pprint(value))
 
 
 @command(b'debugssl', [], b'[SOURCE]', optionalrepo=True)
 def debugssl(ui, repo, source=None, **opts):
     """test a secure connection to a server
 
     This builds the certificate chain for the server on Windows, installing the
     missing intermediates and trusted root via Windows Update if necessary.  It
     does nothing on other platforms.
 
     If SOURCE is omitted, the 'default' path will be used.  If a URL is given,
     that server is used. See :hg:`help urls` for more information.
 
     If the update succeeds, retry the original operation.  Otherwise, the cause
     of the SSL error is likely another issue.
     """
     if not pycompat.iswindows:
         raise error.Abort(
             _(b'certificate chain building is only possible on Windows')
         )
 
     if not source:
         if not repo:
             raise error.Abort(
                 _(
                     b"there is no Mercurial repository here, and no "
                     b"server specified"
                 )
             )
         source = b"default"
 
     source, branches = urlutil.get_unique_pull_path(
         b'debugssl', repo, ui, source
     )
     url = urlutil.url(source)
 
     defaultport = {b'https': 443, b'ssh': 22}
     if url.scheme in defaultport:
         try:
             addr = (url.host, int(url.port or defaultport[url.scheme]))
         except ValueError:
             raise error.Abort(_(b"malformed port number in URL"))
     else:
         raise error.Abort(_(b"only https and ssh connections are supported"))
 
     from . import win32
 
     s = ssl.wrap_socket(
         socket.socket(),
         ssl_version=ssl.PROTOCOL_TLS,
         cert_reqs=ssl.CERT_NONE,
         ca_certs=None,
     )
 
     try:
         s.connect(addr)
         cert = s.getpeercert(True)
 
         ui.status(_(b'checking the certificate chain for %s\n') % url.host)
 
         complete = win32.checkcertificatechain(cert, build=False)
 
         if not complete:
             ui.status(_(b'certificate chain is incomplete, updating... '))
 
             if not win32.checkcertificatechain(cert):
                 ui.status(_(b'failed.\n'))
             else:
                 ui.status(_(b'done.\n'))
         else:
             ui.status(_(b'full certificate chain is available\n'))
     finally:
         s.close()
 
 
 @command(
     b"debugbackupbundle",
     [
         (
             b"",
             b"recover",
             b"",
             b"brings the specified changeset back into the repository",
         )
     ]
     + cmdutil.logopts,
     _(b"hg debugbackupbundle [--recover HASH]"),
 )
 def debugbackupbundle(ui, repo, *pats, **opts):
     """lists the changesets available in backup bundles
 
     Without any arguments, this command prints a list of the changesets in each
     backup bundle.
 
     --recover takes a changeset hash and unbundles the first bundle that
     contains that hash, which puts that changeset back in your repository.
 
     --verbose will print the entire commit message and the bundle path for that
     backup.
     """
     backups = list(
         filter(
             os.path.isfile, glob.glob(repo.vfs.join(b"strip-backup") + b"/*.hg")
         )
     )
     backups.sort(key=lambda x: os.path.getmtime(x), reverse=True)
 
     opts = pycompat.byteskwargs(opts)
     opts[b"bundle"] = b""
     opts[b"force"] = None
     limit = logcmdutil.getlimit(opts)
 
     def display(other, chlist, displayer):
         if opts.get(b"newest_first"):
             chlist.reverse()
         count = 0
         for n in chlist:
             if limit is not None and count >= limit:
                 break
             parents = [
                 True for p in other.changelog.parents(n) if p != repo.nullid
             ]
             if opts.get(b"no_merges") and len(parents) == 2:
                 continue
             count += 1
             displayer.show(other[n])
 
     recovernode = opts.get(b"recover")
     if recovernode:
         if scmutil.isrevsymbol(repo, recovernode):
             ui.warn(_(b"%s already exists in the repo\n") % recovernode)
             return
     elif backups:
         msg = _(
             b"Recover changesets using: hg debugbackupbundle --recover "
             b"<changeset hash>\n\nAvailable backup changesets:"
         )
         ui.status(msg, label=b"status.removed")
     else:
         ui.status(_(b"no backup changesets found\n"))
         return
 
     for backup in backups:
         # Much of this is copied from the hg incoming logic
         source = os.path.relpath(backup, encoding.getcwd())
         source, branches = urlutil.get_unique_pull_path(
             b'debugbackupbundle',
             repo,
             ui,
             source,
             default_branches=opts.get(b'branch'),
         )
         try:
             other = hg.peer(repo, opts, source)
         except error.LookupError as ex:
             msg = _(b"\nwarning: unable to open bundle %s") % source
             hint = _(b"\n(missing parent rev %s)\n") % short(ex.name)
             ui.warn(msg, hint=hint)
             continue
         revs, checkout = hg.addbranchrevs(
             repo, other, branches, opts.get(b"rev")
         )
 
         if revs:
             revs = [other.lookup(rev) for rev in revs]
 
         with ui.silent():
             try:
                 other, chlist, cleanupfn = bundlerepo.getremotechanges(
                     ui, repo, other, revs, opts[b"bundle"], opts[b"force"]
                 )
             except error.LookupError:
                 continue
 
         try:
             if not chlist:
                 continue
             if recovernode:
                 with repo.lock(), repo.transaction(b"unbundle") as tr:
                     if scmutil.isrevsymbol(other, recovernode):
                         ui.status(_(b"Unbundling %s\n") % (recovernode))
                         f = hg.openpath(ui, source)
                         gen = exchange.readbundle(ui, f, source)
                         if isinstance(gen, bundle2.unbundle20):
                             bundle2.applybundle(
                                 repo,
                                 gen,
                                 tr,
                                 source=b"unbundle",
                                 url=b"bundle:" + source,
                             )
                         else:
                             gen.apply(repo, b"unbundle", b"bundle:" + source)
                         break
             else:
                 backupdate = encoding.strtolocal(
                     time.strftime(
                         "%a %H:%M, %Y-%m-%d",
                         time.localtime(os.path.getmtime(source)),
                     )
                 )
                 ui.status(b"\n%s\n" % (backupdate.ljust(50)))
                 if ui.verbose:
                     ui.status(b"%s%s\n" % (b"bundle:".ljust(13), source))
                 else:
                     opts[
                         b"template"
                     ] = b"{label('status.modified', node|short)} {desc|firstline}\n"
                 displayer = logcmdutil.changesetdisplayer(
                     ui, other, opts, False
                 )
                 display(other, chlist, displayer)
                 displayer.close()
         finally:
             cleanupfn()
 
 
 @command(
     b'debugsub',
     [(b'r', b'rev', b'', _(b'revision to check'), _(b'REV'))],
     _(b'[-r REV] [REV]'),
 )
 def debugsub(ui, repo, rev=None):
     ctx = scmutil.revsingle(repo, rev, None)
     for k, v in sorted(ctx.substate.items()):
         ui.writenoi18n(b'path %s\n' % k)
         ui.writenoi18n(b' source   %s\n' % v[0])
         ui.writenoi18n(b' revision %s\n' % v[1])
 
 
 @command(b'debugshell', optionalrepo=True)
 def debugshell(ui, repo):
     """run an interactive Python interpreter
 
     The local namespace is provided with a reference to the ui and
     the repo instance (if available).
     """
     import code
 
     imported_objects = {
         'ui': ui,
         'repo': repo,
     }
 
     code.interact(local=imported_objects)
 
 
 @command(
     b'debugsuccessorssets',
     [(b'', b'closest', False, _(b'return closest successors sets only'))],
     _(b'[REV]'),
 )
 def debugsuccessorssets(ui, repo, *revs, **opts):
     """show set of successors for revision
 
     A successors set of changeset A is a consistent group of revisions that
     succeed A. It contains non-obsolete changesets only unless closests
     successors set is set.
 
     In most cases a changeset A has a single successors set containing a single
     successor (changeset A replaced by A').
 
     A changeset that is made obsolete with no successors are called "pruned".
     Such changesets have no successors sets at all.
 
     A changeset that has been "split" will have a successors set containing
     more than one successor.
 
     A changeset that has been rewritten in multiple different ways is called
     "divergent". Such changesets have multiple successor sets (each of which
     may also be split, i.e. have multiple successors).
 
     Results are displayed as follows::
 
         <rev1>
             <successors-1A>
         <rev2>
             <successors-2A>
             <successors-2B1> <successors-2B2> <successors-2B3>
 
     Here rev2 has two possible (i.e. divergent) successors sets. The first
     holds one element, whereas the second holds three (i.e. the changeset has
     been split).
     """
     # passed to successorssets caching computation from one call to another
     cache = {}
     ctx2str = bytes
     node2str = short
     for rev in scmutil.revrange(repo, revs):
         ctx = repo[rev]
         ui.write(b'%s\n' % ctx2str(ctx))
         for succsset in obsutil.successorssets(
             repo, ctx.node(), closest=opts['closest'], cache=cache
         ):
             if succsset:
                 ui.write(b'    ')
                 ui.write(node2str(succsset[0]))
                 for node in succsset[1:]:
                     ui.write(b' ')
                     ui.write(node2str(node))
             ui.write(b'\n')
 
 
 @command(b'debugtagscache', [])
 def debugtagscache(ui, repo):
     """display the contents of .hg/cache/hgtagsfnodes1"""
     cache = tagsmod.hgtagsfnodescache(repo.unfiltered())
     flog = repo.file(b'.hgtags')
     for r in repo:
         node = repo[r].node()
         tagsnode = cache.getfnode(node, computemissing=False)
         if tagsnode:
             tagsnodedisplay = hex(tagsnode)
             if not flog.hasnode(tagsnode):
                 tagsnodedisplay += b' (unknown node)'
         elif tagsnode is None:
             tagsnodedisplay = b'missing'
         else:
             tagsnodedisplay = b'invalid'
 
         ui.write(b'%d %s %s\n' % (r, hex(node), tagsnodedisplay))
 
 
 @command(
     b'debugtemplate',
     [
         (b'r', b'rev', [], _(b'apply template on changesets'), _(b'REV')),
         (b'D', b'define', [], _(b'define template keyword'), _(b'KEY=VALUE')),
     ],
     _(b'[-r REV]... [-D KEY=VALUE]... TEMPLATE'),
     optionalrepo=True,
 )
 def debugtemplate(ui, repo, tmpl, **opts):
     """parse and apply a template
 
     If -r/--rev is given, the template is processed as a log template and
     applied to the given changesets. Otherwise, it is processed as a generic
     template.
 
     Use --verbose to print the parsed tree.
     """
     revs = None
     if opts['rev']:
         if repo is None:
             raise error.RepoError(
                 _(b'there is no Mercurial repository here (.hg not found)')
             )
         revs = scmutil.revrange(repo, opts['rev'])
 
     props = {}
     for d in opts['define']:
         try:
             k, v = (e.strip() for e in d.split(b'=', 1))
             if not k or k == b'ui':
                 raise ValueError
             props[k] = v
         except ValueError:
             raise error.Abort(_(b'malformed keyword definition: %s') % d)
 
     if ui.verbose:
         aliases = ui.configitems(b'templatealias')
         tree = templater.parse(tmpl)
         ui.note(templater.prettyformat(tree), b'\n')
         newtree = templater.expandaliases(tree, aliases)
         if newtree != tree:
             ui.notenoi18n(
                 b"* expanded:\n", templater.prettyformat(newtree), b'\n'
             )
 
     if revs is None:
         tres = formatter.templateresources(ui, repo)
         t = formatter.maketemplater(ui, tmpl, resources=tres)
         if ui.verbose:
             kwds, funcs = t.symbolsuseddefault()
             ui.writenoi18n(b"* keywords: %s\n" % b', '.join(sorted(kwds)))
             ui.writenoi18n(b"* functions: %s\n" % b', '.join(sorted(funcs)))
         ui.write(t.renderdefault(props))
     else:
         displayer = logcmdutil.maketemplater(ui, repo, tmpl)
         if ui.verbose:
             kwds, funcs = displayer.t.symbolsuseddefault()
             ui.writenoi18n(b"* keywords: %s\n" % b', '.join(sorted(kwds)))
             ui.writenoi18n(b"* functions: %s\n" % b', '.join(sorted(funcs)))
         for r in revs:
             displayer.show(repo[r], **pycompat.strkwargs(props))
         displayer.close()
 
 
 @command(
     b'debuguigetpass',
     [
         (b'p', b'prompt', b'', _(b'prompt text'), _(b'TEXT')),
     ],
     _(b'[-p TEXT]'),
     norepo=True,
 )
 def debuguigetpass(ui, prompt=b''):
     """show prompt to type password"""
     r = ui.getpass(prompt)
     if r is None:
         r = b"<default response>"
     ui.writenoi18n(b'response: %s\n' % r)
 
 
 @command(
     b'debuguiprompt',
     [
         (b'p', b'prompt', b'', _(b'prompt text'), _(b'TEXT')),
     ],
     _(b'[-p TEXT]'),
     norepo=True,
 )
 def debuguiprompt(ui, prompt=b''):
     """show plain prompt"""
     r = ui.prompt(prompt)
     ui.writenoi18n(b'response: %s\n' % r)
 
 
 @command(b'debugupdatecaches', [])
 def debugupdatecaches(ui, repo, *pats, **opts):
     """warm all known caches in the repository"""
     with repo.wlock(), repo.lock():
         repo.updatecaches(caches=repository.CACHES_ALL)
 
 
 @command(
     b'debugupgraderepo',
     [
         (
             b'o',
             b'optimize',
             [],
             _(b'extra optimization to perform'),
             _(b'NAME'),
         ),
         (b'', b'run', False, _(b'performs an upgrade')),
         (b'', b'backup', True, _(b'keep the old repository content around')),
         (b'', b'changelog', None, _(b'select the changelog for upgrade')),
         (b'', b'manifest', None, _(b'select the manifest for upgrade')),
         (b'', b'filelogs', None, _(b'select all filelogs for upgrade')),
     ],
 )
 def debugupgraderepo(ui, repo, run=False, optimize=None, backup=True, **opts):
     """upgrade a repository to use different features
 
     If no arguments are specified, the repository is evaluated for upgrade
     and a list of problems and potential optimizations is printed.
 
     With ``--run``, a repository upgrade is performed. Behavior of the upgrade
     can be influenced via additional arguments. More details will be provided
     by the command output when run without ``--run``.
 
     During the upgrade, the repository will be locked and no writes will be
     allowed.
 
     At the end of the upgrade, the repository may not be readable while new
     repository data is swapped in. This window will be as long as it takes to
     rename some directories inside the ``.hg`` directory. On most machines, this
     should complete almost instantaneously and the chances of a consumer being
     unable to access the repository should be low.
 
     By default, all revlogs will be upgraded. You can restrict this using flags
     such as `--manifest`:
 
       * `--manifest`: only optimize the manifest
       * `--no-manifest`: optimize all revlog but the manifest
       * `--changelog`: optimize the changelog only
       * `--no-changelog --no-manifest`: optimize filelogs only
       * `--filelogs`: optimize the filelogs only
       * `--no-changelog --no-manifest --no-filelogs`: skip all revlog optimizations
     """
     return upgrade.upgraderepo(
         ui, repo, run=run, optimize=set(optimize), backup=backup, **opts
     )
 
 
 @command(
     b'debugwalk', cmdutil.walkopts, _(b'[OPTION]... [FILE]...'), inferrepo=True
 )
 def debugwalk(ui, repo, *pats, **opts):
     """show how files match on given patterns"""
     opts = pycompat.byteskwargs(opts)
     m = scmutil.match(repo[None], pats, opts)
     if ui.verbose:
         ui.writenoi18n(b'* matcher:\n', stringutil.prettyrepr(m), b'\n')
     items = list(repo[None].walk(m))
     if not items:
         return
     f = lambda fn: fn
     if ui.configbool(b'ui', b'slash') and pycompat.ossep != b'/':
         f = lambda fn: util.normpath(fn)
     fmt = b'f  %%-%ds  %%-%ds  %%s' % (
         max([len(abs) for abs in items]),
         max([len(repo.pathto(abs)) for abs in items]),
     )
     for abs in items:
         line = fmt % (
             abs,
             f(repo.pathto(abs)),
             m.exact(abs) and b'exact' or b'',
         )
         ui.write(b"%s\n" % line.rstrip())
 
 
 @command(b'debugwhyunstable', [], _(b'REV'))
 def debugwhyunstable(ui, repo, rev):
     """explain instabilities of a changeset"""
     for entry in obsutil.whyunstable(repo, scmutil.revsingle(repo, rev)):
         dnodes = b''
         if entry.get(b'divergentnodes'):
             dnodes = (
                 b' '.join(
                     b'%s (%s)' % (ctx.hex(), ctx.phasestr())
                     for ctx in entry[b'divergentnodes']
                 )
                 + b' '
             )
         ui.write(
             b'%s: %s%s %s\n'
             % (entry[b'instability'], dnodes, entry[b'reason'], entry[b'node'])
         )
 
 
 @command(
     b'debugwireargs',
     [
         (b'', b'three', b'', b'three'),
         (b'', b'four', b'', b'four'),
         (b'', b'five', b'', b'five'),
     ]
     + cmdutil.remoteopts,
     _(b'REPO [OPTIONS]... [ONE [TWO]]'),
     norepo=True,
 )
 def debugwireargs(ui, repopath, *vals, **opts):
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     try:
         for opt in cmdutil.remoteopts:
             del opts[opt[1]]
         args = {}
         for k, v in pycompat.iteritems(opts):
             if v:
                 args[k] = v
         args = pycompat.strkwargs(args)
         # run twice to check that we don't mess up the stream for the next command
         res1 = repo.debugwireargs(*vals, **args)
         res2 = repo.debugwireargs(*vals, **args)
         ui.write(b"%s\n" % res1)
         if res1 != res2:
             ui.warn(b"%s\n" % res2)
     finally:
         repo.close()
 
 
 def _parsewirelangblocks(fh):
     activeaction = None
     blocklines = []
     lastindent = 0
 
     for line in fh:
         line = line.rstrip()
         if not line:
             continue
 
         if line.startswith(b'#'):
             continue
 
         if not line.startswith(b' '):
             # New block. Flush previous one.
             if activeaction:
                 yield activeaction, blocklines
 
             activeaction = line
             blocklines = []
             lastindent = 0
             continue
 
         # Else we start with an indent.
 
         if not activeaction:
             raise error.Abort(_(b'indented line outside of block'))
 
         indent = len(line) - len(line.lstrip())
 
         # If this line is indented more than the last line, concatenate it.
         if indent > lastindent and blocklines:
             blocklines[-1] += line.lstrip()
         else:
             blocklines.append(line)
             lastindent = indent
 
     # Flush last block.
     if activeaction:
         yield activeaction, blocklines
 
 
 @command(
     b'debugwireproto',
     [
         (b'', b'localssh', False, _(b'start an SSH server for this repo')),
         (b'', b'peer', b'', _(b'construct a specific version of the peer')),
         (
             b'',
             b'noreadstderr',
             False,
             _(b'do not read from stderr of the remote'),
         ),
         (
             b'',
             b'nologhandshake',
             False,
             _(b'do not log I/O related to the peer handshake'),
         ),
     ]
     + cmdutil.remoteopts,
     _(b'[PATH]'),
     optionalrepo=True,
 )
 def debugwireproto(ui, repo, path=None, **opts):
     """send wire protocol commands to a server
 
     This command can be used to issue wire protocol commands to remote
     peers and to debug the raw data being exchanged.
 
     ``--localssh`` will start an SSH server against the current repository
     and connect to that. By default, the connection will perform a handshake
     and establish an appropriate peer instance.
 
     ``--peer`` can be used to bypass the handshake protocol and construct a
     peer instance using the specified class type. Valid values are ``raw``,
     ``http2``, ``ssh1``, and ``ssh2``. ``raw`` instances only allow sending
     raw data payloads and don't support higher-level command actions.
 
     ``--noreadstderr`` can be used to disable automatic reading from stderr
     of the peer (for SSH connections only). Disabling automatic reading of
     stderr is useful for making output more deterministic.
 
     Commands are issued via a mini language which is specified via stdin.
     The language consists of individual actions to perform. An action is
     defined by a block. A block is defined as a line with no leading
     space followed by 0 or more lines with leading space. Blocks are
     effectively a high-level command with additional metadata.
 
     Lines beginning with ``#`` are ignored.
 
     The following sections denote available actions.
 
     raw
     ---
 
     Send raw data to the server.
 
     The block payload contains the raw data to send as one atomic send
     operation. The data may not actually be delivered in a single system
     call: it depends on the abilities of the transport being used.
 
     Each line in the block is de-indented and concatenated. Then, that
     value is evaluated as a Python b'' literal. This allows the use of
     backslash escaping, etc.
 
     raw+
     ----
 
     Behaves like ``raw`` except flushes output afterwards.
 
     command <X>
     -----------
 
     Send a request to run a named command, whose name follows the ``command``
     string.
 
     Arguments to the command are defined as lines in this block. The format of
     each line is ``<key> <value>``. e.g.::
 
        command listkeys
            namespace bookmarks
 
     If the value begins with ``eval:``, it will be interpreted as a Python
     literal expression. Otherwise values are interpreted as Python b'' literals.
     This allows sending complex types and encoding special byte sequences via
     backslash escaping.
 
     The following arguments have special meaning:
 
     ``PUSHFILE``
         When defined, the *push* mechanism of the peer will be used instead
         of the static request-response mechanism and the content of the
         file specified in the value of this argument will be sent as the
         command payload.
 
         This can be used to submit a local bundle file to the remote.
 
     batchbegin
     ----------
 
     Instruct the peer to begin a batched send.
 
     All ``command`` blocks are queued for execution until the next
     ``batchsubmit`` block.
 
     batchsubmit
     -----------
 
     Submit previously queued ``command`` blocks as a batch request.
 
     This action MUST be paired with a ``batchbegin`` action.
 
     httprequest <method> <path>
     ---------------------------
 
     (HTTP peer only)
 
     Send an HTTP request to the peer.
 
     The HTTP request line follows the ``httprequest`` action. e.g. ``GET /foo``.
 
     Arguments of the form ``<key>: <value>`` are interpreted as HTTP request
     headers to add to the request. e.g. ``Accept: foo``.
 
     The following arguments are special:
 
     ``BODYFILE``
         The content of the file defined as the value to this argument will be
         transferred verbatim as the HTTP request body.
 
     ``frame <type> <flags> <payload>``
         Send a unified protocol frame as part of the request body.
 
         All frames will be collected and sent as the body to the HTTP
         request.
 
     close
     -----
 
     Close the connection to the server.
 
     flush
     -----
 
     Flush data written to the server.
 
     readavailable
     -------------
 
     Close the write end of the connection and read all available data from
     the server.
 
     If the connection to the server encompasses multiple pipes, we poll both
     pipes and read available data.
 
     readline
     --------
 
     Read a line of output from the server. If there are multiple output
     pipes, reads only the main pipe.
 
     ereadline
     ---------
 
     Like ``readline``, but read from the stderr pipe, if available.
 
     read <X>
     --------
 
     ``read()`` N bytes from the server's main output pipe.
 
     eread <X>
     ---------
 
     ``read()`` N bytes from the server's stderr pipe, if available.
 
     Specifying Unified Frame-Based Protocol Frames
     ----------------------------------------------
 
     It is possible to emit a *Unified Frame-Based Protocol* by using special
     syntax.
 
     A frame is composed as a type, flags, and payload. These can be parsed
     from a string of the form:
 
        <request-id> <stream-id> <stream-flags> <type> <flags> <payload>
 
     ``request-id`` and ``stream-id`` are integers defining the request and
     stream identifiers.
 
     ``type`` can be an integer value for the frame type or the string name
     of the type. The strings are defined in ``wireprotoframing.py``. e.g.
     ``command-name``.
 
     ``stream-flags`` and ``flags`` are a ``|`` delimited list of flag
     components. Each component (and there can be just one) can be an integer
     or a flag name for stream flags or frame flags, respectively. Values are
     resolved to integers and then bitwise OR'd together.
 
     ``payload`` represents the raw frame payload. If it begins with
     ``cbor:``, the following string is evaluated as Python code and the
     resulting object is fed into a CBOR encoder. Otherwise it is interpreted
     as a Python byte string literal.
     """
     opts = pycompat.byteskwargs(opts)
 
     if opts[b'localssh'] and not repo:
         raise error.Abort(_(b'--localssh requires a repository'))
 
     if opts[b'peer'] and opts[b'peer'] not in (
         b'raw',
         b'http2',
         b'ssh1',
         b'ssh2',
     ):
         raise error.Abort(
             _(b'invalid value for --peer'),
             hint=_(b'valid values are "raw", "ssh1", and "ssh2"'),
         )
 
     if path and opts[b'localssh']:
         raise error.Abort(_(b'cannot specify --localssh with an explicit path'))
 
     if ui.interactive():
         ui.write(_(b'(waiting for commands on stdin)\n'))
 
     blocks = list(_parsewirelangblocks(ui.fin))
 
     proc = None
     stdin = None
     stdout = None
     stderr = None
     opener = None
 
     if opts[b'localssh']:
         # We start the SSH server in its own process so there is process
         # separation. This prevents a whole class of potential bugs around
         # shared state from interfering with server operation.
         args = procutil.hgcmd() + [
             b'-R',
             repo.root,
             b'debugserve',
             b'--sshstdio',
         ]
         proc = subprocess.Popen(
             pycompat.rapply(procutil.tonativestr, args),
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             bufsize=0,
         )
 
         stdin = proc.stdin
         stdout = proc.stdout
         stderr = proc.stderr
 
         # We turn the pipes into observers so we can log I/O.
         if ui.verbose or opts[b'peer'] == b'raw':
             stdin = util.makeloggingfileobject(
                 ui, proc.stdin, b'i', logdata=True
             )
             stdout = util.makeloggingfileobject(
                 ui, proc.stdout, b'o', logdata=True
             )
             stderr = util.makeloggingfileobject(
                 ui, proc.stderr, b'e', logdata=True
             )
 
         # --localssh also implies the peer connection settings.
 
         url = b'ssh://localserver'
         autoreadstderr = not opts[b'noreadstderr']
 
         if opts[b'peer'] == b'ssh1':
             ui.write(_(b'creating ssh peer for wire protocol version 1\n'))
             peer = sshpeer.sshv1peer(
                 ui,
                 url,
                 proc,
                 stdin,
                 stdout,
                 stderr,
                 None,
                 autoreadstderr=autoreadstderr,
             )
         elif opts[b'peer'] == b'ssh2':
             ui.write(_(b'creating ssh peer for wire protocol version 2\n'))
             peer = sshpeer.sshv2peer(
                 ui,
                 url,
                 proc,
                 stdin,
                 stdout,
                 stderr,
                 None,
                 autoreadstderr=autoreadstderr,
             )
         elif opts[b'peer'] == b'raw':
             ui.write(_(b'using raw connection to peer\n'))
             peer = None
         else:
             ui.write(_(b'creating ssh peer from handshake results\n'))
             peer = sshpeer.makepeer(
                 ui,
                 url,
                 proc,
                 stdin,
                 stdout,
                 stderr,
                 autoreadstderr=autoreadstderr,
             )
 
     elif path:
         # We bypass hg.peer() so we can proxy the sockets.
         # TODO consider not doing this because we skip
         # ``hg.wirepeersetupfuncs`` and potentially other useful functionality.
         u = urlutil.url(path)
         if u.scheme != b'http':
             raise error.Abort(_(b'only http:// paths are currently supported'))
 
         url, authinfo = u.authinfo()
         openerargs = {
             'useragent': b'Mercurial debugwireproto',
         }
 
         # Turn pipes/sockets into observers so we can log I/O.
         if ui.verbose:
             openerargs.update(
                 {
                     'loggingfh': ui,
                     'loggingname': b's',
                     'loggingopts': {
                         'logdata': True,
                         'logdataapis': False,
                     },
                 }
             )
 
         if ui.debugflag:
             openerargs['loggingopts']['logdataapis'] = True
 
         # Don't send default headers when in raw mode. This allows us to
         # bypass most of the behavior of our URL handling code so we can
         # have near complete control over what's sent on the wire.
         if opts[b'peer'] == b'raw':
             openerargs['sendaccept'] = False
 
         opener = urlmod.opener(ui, authinfo, **openerargs)
 
         if opts[b'peer'] == b'http2':
             ui.write(_(b'creating http peer for wire protocol version 2\n'))
             # We go through makepeer() because we need an API descriptor for
             # the peer instance to be useful.
             maybe_silent = (
                 ui.silent()
                 if opts[b'nologhandshake']
                 else util.nullcontextmanager()
             )
             with maybe_silent, ui.configoverride(
                 {(b'experimental', b'httppeer.advertise-v2'): True}
             ):
                 peer = httppeer.makepeer(ui, path, opener=opener)
 
             if not isinstance(peer, httppeer.httpv2peer):
                 raise error.Abort(
                     _(
                         b'could not instantiate HTTP peer for '
                         b'wire protocol version 2'
                     ),
                     hint=_(
                         b'the server may not have the feature '
                         b'enabled or is not allowing this '
                         b'client version'
                     ),
                 )
 
         elif opts[b'peer'] == b'raw':
             ui.write(_(b'using raw connection to peer\n'))
             peer = None
         elif opts[b'peer']:
             raise error.Abort(
                 _(b'--peer %s not supported with HTTP peers') % opts[b'peer']
             )
         else:
             peer = httppeer.makepeer(ui, path, opener=opener)
 
         # We /could/ populate stdin/stdout with sock.makefile()...
     else:
         raise error.Abort(_(b'unsupported connection configuration'))
 
     batchedcommands = None
 
     # Now perform actions based on the parsed wire language instructions.
     for action, lines in blocks:
         if action in (b'raw', b'raw+'):
             if not stdin:
                 raise error.Abort(_(b'cannot call raw/raw+ on this peer'))
 
             # Concatenate the data together.
             data = b''.join(l.lstrip() for l in lines)
             data = stringutil.unescapestr(data)
             stdin.write(data)
 
             if action == b'raw+':
                 stdin.flush()
         elif action == b'flush':
             if not stdin:
                 raise error.Abort(_(b'cannot call flush on this peer'))
             stdin.flush()
         elif action.startswith(b'command'):
             if not peer:
                 raise error.Abort(
                     _(
                         b'cannot send commands unless peer instance '
                         b'is available'
                     )
                 )
 
             command = action.split(b' ', 1)[1]
 
             args = {}
             for line in lines:
                 # We need to allow empty values.
                 fields = line.lstrip().split(b' ', 1)
                 if len(fields) == 1:
                     key = fields[0]
                     value = b''
                 else:
                     key, value = fields
 
                 if value.startswith(b'eval:'):
                     value = stringutil.evalpythonliteral(value[5:])
                 else:
                     value = stringutil.unescapestr(value)
 
                 args[key] = value
 
             if batchedcommands is not None:
                 batchedcommands.append((command, args))
                 continue
 
             ui.status(_(b'sending %s command\n') % command)
 
             if b'PUSHFILE' in args:
                 with open(args[b'PUSHFILE'], 'rb') as fh:
                     del args[b'PUSHFILE']
                     res, output = peer._callpush(
                         command, fh, **pycompat.strkwargs(args)
                     )
                     ui.status(_(b'result: %s\n') % stringutil.escapestr(res))
                     ui.status(
                         _(b'remote output: %s\n') % stringutil.escapestr(output)
                     )
             else:
                 with peer.commandexecutor() as e:
                     res = e.callcommand(command, args).result()
 
                 if isinstance(res, wireprotov2peer.commandresponse):
                     val = res.objects()
                     ui.status(
                         _(b'response: %s\n')
                         % stringutil.pprint(val, bprefix=True, indent=2)
                     )
                 else:
                     ui.status(
                         _(b'response: %s\n')
                         % stringutil.pprint(res, bprefix=True, indent=2)
                     )
 
         elif action == b'batchbegin':
             if batchedcommands is not None:
                 raise error.Abort(_(b'nested batchbegin not allowed'))
 
             batchedcommands = []
         elif action == b'batchsubmit':
             # There is a batching API we could go through. But it would be
             # difficult to normalize requests into function calls. It is easier
             # to bypass this layer and normalize to commands + args.
             ui.status(
                 _(b'sending batch with %d sub-commands\n')
                 % len(batchedcommands)
             )
             assert peer is not None
             for i, chunk in enumerate(peer._submitbatch(batchedcommands)):
                 ui.status(
                     _(b'response #%d: %s\n') % (i, stringutil.escapestr(chunk))
                 )
 
             batchedcommands = None
 
         elif action.startswith(b'httprequest '):
             if not opener:
                 raise error.Abort(
                     _(b'cannot use httprequest without an HTTP peer')
                 )
 
             request = action.split(b' ', 2)
             if len(request) != 3:
                 raise error.Abort(
                     _(
                         b'invalid httprequest: expected format is '
                         b'"httprequest <method> <path>'
                     )
                 )
 
             method, httppath = request[1:]
             headers = {}
             body = None
             frames = []
             for line in lines:
                 line = line.lstrip()
                 m = re.match(b'^([a-zA-Z0-9_-]+): (.*)$', line)
                 if m:
                     # Headers need to use native strings.
                     key = pycompat.strurl(m.group(1))
                     value = pycompat.strurl(m.group(2))
                     headers[key] = value
                     continue
 
                 if line.startswith(b'BODYFILE '):
                     with open(line.split(b' ', 1), b'rb') as fh:
                         body = fh.read()
                 elif line.startswith(b'frame '):
                     frame = wireprotoframing.makeframefromhumanstring(
                         line[len(b'frame ') :]
                     )
 
                     frames.append(frame)
                 else:
                     raise error.Abort(
                         _(b'unknown argument to httprequest: %s') % line
                     )
 
             url = path + httppath
 
             if frames:
                 body = b''.join(bytes(f) for f in frames)
 
             req = urlmod.urlreq.request(pycompat.strurl(url), body, headers)
 
             # urllib.Request insists on using has_data() as a proxy for
             # determining the request method. Override that to use our
             # explicitly requested method.
             req.get_method = lambda: pycompat.sysstr(method)
 
             try:
                 res = opener.open(req)
                 body = res.read()
             except util.urlerr.urlerror as e:
                 # read() method must be called, but only exists in Python 2
                 getattr(e, 'read', lambda: None)()
                 continue
 
             ct = res.headers.get('Content-Type')
             if ct == 'application/mercurial-cbor':
                 ui.write(
                     _(b'cbor> %s\n')
                     % stringutil.pprint(
                         cborutil.decodeall(body), bprefix=True, indent=2
                     )
                 )
 
         elif action == b'close':
             assert peer is not None
             peer.close()
         elif action == b'readavailable':
             if not stdout or not stderr:
                 raise error.Abort(
                     _(b'readavailable not available on this peer')
                 )
 
             stdin.close()
             stdout.read()
             stderr.read()
 
         elif action == b'readline':
             if not stdout:
                 raise error.Abort(_(b'readline not available on this peer'))
             stdout.readline()
         elif action == b'ereadline':
             if not stderr:
                 raise error.Abort(_(b'ereadline not available on this peer'))
             stderr.readline()
         elif action.startswith(b'read '):
             count = int(action.split(b' ', 1)[1])
             if not stdout:
                 raise error.Abort(_(b'read not available on this peer'))
             stdout.read(count)
         elif action.startswith(b'eread '):
             count = int(action.split(b' ', 1)[1])
             if not stderr:
                 raise error.Abort(_(b'eread not available on this peer'))
             stderr.read(count)
         else:
             raise error.Abort(_(b'unknown action: %s') % action)
 
     if batchedcommands is not None:
         raise error.Abort(_(b'unclosed "batchbegin" request'))
 
     if peer:
         peer.close()
 
     if proc:
         proc.kill()

mercurial/dirstate.py

@@ -1,1625 +1,1626 b''
 # dirstate.py - working directory tracking 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 __future__ import absolute_import
 
 import collections
 import contextlib
 import errno
 import os
 import stat
 
 from .i18n import _
 from .pycompat import delattr
 
 from hgdemandimport import tracing
 
 from . import (
     dirstatemap,
     encoding,
     error,
     match as matchmod,
     pathutil,
     policy,
     pycompat,
     scmutil,
     sparse,
     util,
 )
 
 from .interfaces import (
     dirstate as intdirstate,
     util as interfaceutil,
 )
 
 parsers = policy.importmod('parsers')
 rustmod = policy.importrust('dirstate')
 
 SUPPORTS_DIRSTATE_V2 = rustmod is not None
 
 propertycache = util.propertycache
 filecache = scmutil.filecache
 _rangemask = dirstatemap.rangemask
 
 DirstateItem = parsers.DirstateItem
 
 
 class repocache(filecache):
     """filecache for files in .hg/"""
 
     def join(self, obj, fname):
         return obj._opener.join(fname)
 
 
 class rootcache(filecache):
     """filecache for files in the repository root"""
 
     def join(self, obj, fname):
         return obj._join(fname)
 
 
 def _getfsnow(vfs):
     '''Get "now" timestamp on filesystem'''
     tmpfd, tmpname = vfs.mkstemp()
     try:
         return os.fstat(tmpfd)[stat.ST_MTIME]
     finally:
         os.close(tmpfd)
         vfs.unlink(tmpname)
 
 
 def requires_parents_change(func):
     def wrap(self, *args, **kwargs):
         if not self.pendingparentchange():
             msg = 'calling `%s` outside of a parentchange context'
             msg %= func.__name__
             raise error.ProgrammingError(msg)
         return func(self, *args, **kwargs)
 
     return wrap
 
 
 def requires_no_parents_change(func):
     def wrap(self, *args, **kwargs):
         if self.pendingparentchange():
             msg = 'calling `%s` inside of a parentchange context'
             msg %= func.__name__
             raise error.ProgrammingError(msg)
         return func(self, *args, **kwargs)
 
     return wrap
 
 
 @interfaceutil.implementer(intdirstate.idirstate)
 class dirstate(object):
     def __init__(
         self,
         opener,
         ui,
         root,
         validate,
         sparsematchfn,
         nodeconstants,
         use_dirstate_v2,
     ):
         """Create a new dirstate object.
 
         opener is an open()-like callable that can be used to open the
         dirstate file; root is the root of the directory tracked by
         the dirstate.
         """
         self._use_dirstate_v2 = use_dirstate_v2
         self._nodeconstants = nodeconstants
         self._opener = opener
         self._validate = validate
         self._root = root
         self._sparsematchfn = sparsematchfn
         # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is
         # UNC path pointing to root share (issue4557)
         self._rootdir = pathutil.normasprefix(root)
         self._dirty = False
         self._lastnormaltime = 0
         self._ui = ui
         self._filecache = {}
         self._parentwriters = 0
         self._filename = b'dirstate'
         self._pendingfilename = b'%s.pending' % self._filename
         self._plchangecallbacks = {}
         self._origpl = None
         self._updatedfiles = set()
         self._mapcls = dirstatemap.dirstatemap
         # Access and cache cwd early, so we don't access it for the first time
         # after a working-copy update caused it to not exist (accessing it then
         # raises an exception).
         self._cwd
 
     def prefetch_parents(self):
         """make sure the parents are loaded
 
         Used to avoid a race condition.
         """
         self._pl
 
     @contextlib.contextmanager
     def parentchange(self):
         """Context manager for handling dirstate parents.
 
         If an exception occurs in the scope of the context manager,
         the incoherent dirstate won't be written when wlock is
         released.
         """
         self._parentwriters += 1
         yield
         # Typically we want the "undo" step of a context manager in a
         # finally block so it happens even when an exception
         # occurs. In this case, however, we only want to decrement
         # parentwriters if the code in the with statement exits
         # normally, so we don't have a try/finally here on purpose.
         self._parentwriters -= 1
 
     def pendingparentchange(self):
         """Returns true if the dirstate is in the middle of a set of changes
         that modify the dirstate parent.
         """
         return self._parentwriters > 0
 
     @propertycache
     def _map(self):
         """Return the dirstate contents (see documentation for dirstatemap)."""
         self._map = self._mapcls(
             self._ui,
             self._opener,
             self._root,
             self._nodeconstants,
             self._use_dirstate_v2,
         )
         return self._map
 
     @property
     def _sparsematcher(self):
         """The matcher for the sparse checkout.
 
         The working directory may not include every file from a manifest. The
         matcher obtained by this property will match a path if it is to be
         included in the working directory.
         """
         # TODO there is potential to cache this property. For now, the matcher
         # is resolved on every access. (But the called function does use a
         # cache to keep the lookup fast.)
         return self._sparsematchfn()
 
     @repocache(b'branch')
     def _branch(self):
         try:
             return self._opener.read(b"branch").strip() or b"default"
         except IOError as inst:
             if inst.errno != errno.ENOENT:
                 raise
             return b"default"
 
     @property
     def _pl(self):
         return self._map.parents()
 
     def hasdir(self, d):
         return self._map.hastrackeddir(d)
 
     @rootcache(b'.hgignore')
     def _ignore(self):
         files = self._ignorefiles()
         if not files:
             return matchmod.never()
 
         pats = [b'include:%s' % f for f in files]
         return matchmod.match(self._root, b'', [], pats, warn=self._ui.warn)
 
     @propertycache
     def _slash(self):
         return self._ui.configbool(b'ui', b'slash') and pycompat.ossep != b'/'
 
     @propertycache
     def _checklink(self):
         return util.checklink(self._root)
 
     @propertycache
     def _checkexec(self):
         return bool(util.checkexec(self._root))
 
     @propertycache
     def _checkcase(self):
         return not util.fscasesensitive(self._join(b'.hg'))
 
     def _join(self, f):
         # much faster than os.path.join()
         # it's safe because f is always a relative path
         return self._rootdir + f
 
     def flagfunc(self, buildfallback):
         if self._checklink and self._checkexec:
 
             def f(x):
                 try:
                     st = os.lstat(self._join(x))
                     if util.statislink(st):
                         return b'l'
                     if util.statisexec(st):
                         return b'x'
                 except OSError:
                     pass
                 return b''
 
             return f
 
         fallback = buildfallback()
         if self._checklink:
 
             def f(x):
                 if os.path.islink(self._join(x)):
                     return b'l'
                 if b'x' in fallback(x):
                     return b'x'
                 return b''
 
             return f
         if self._checkexec:
 
             def f(x):
                 if b'l' in fallback(x):
                     return b'l'
                 if util.isexec(self._join(x)):
                     return b'x'
                 return b''
 
             return f
         else:
             return fallback
 
     @propertycache
     def _cwd(self):
         # internal config: ui.forcecwd
         forcecwd = self._ui.config(b'ui', b'forcecwd')
         if forcecwd:
             return forcecwd
         return encoding.getcwd()
 
     def getcwd(self):
         """Return the path from which a canonical path is calculated.
 
         This path should be used to resolve file patterns or to convert
         canonical paths back to file paths for display. It shouldn't be
         used to get real file paths. Use vfs functions instead.
         """
         cwd = self._cwd
         if cwd == self._root:
             return b''
         # self._root ends with a path separator if self._root is '/' or 'C:\'
         rootsep = self._root
         if not util.endswithsep(rootsep):
             rootsep += pycompat.ossep
         if cwd.startswith(rootsep):
             return cwd[len(rootsep) :]
         else:
             # we're outside the repo. return an absolute path.
             return cwd
 
     def pathto(self, f, cwd=None):
         if cwd is None:
             cwd = self.getcwd()
         path = util.pathto(self._root, cwd, f)
         if self._slash:
             return util.pconvert(path)
         return path
 
     def __getitem__(self, key):
         """Return the current state of key (a filename) in the dirstate.
 
         States are:
           n  normal
           m  needs merging
           r  marked for removal
           a  marked for addition
           ?  not tracked
 
         XXX The "state" is a bit obscure to be in the "public" API. we should
         consider migrating all user of this to going through the dirstate entry
         instead.
         """
         entry = self._map.get(key)
         if entry is not None:
             return entry.state
         return b'?'
 
     def __contains__(self, key):
         return key in self._map
 
     def __iter__(self):
         return iter(sorted(self._map))
 
     def items(self):
         return pycompat.iteritems(self._map)
 
     iteritems = items
 
     def directories(self):
         return self._map.directories()
 
     def parents(self):
         return [self._validate(p) for p in self._pl]
 
     def p1(self):
         return self._validate(self._pl[0])
 
     def p2(self):
         return self._validate(self._pl[1])
 
     @property
     def in_merge(self):
         """True if a merge is in progress"""
         return self._pl[1] != self._nodeconstants.nullid
 
     def branch(self):
         return encoding.tolocal(self._branch)
 
     def setparents(self, p1, p2=None):
         """Set dirstate parents to p1 and p2.
 
         When moving from two parents to one, "merged" entries a
         adjusted to normal and previous copy records discarded and
         returned by the call.
 
         See localrepo.setparents()
         """
         if p2 is None:
             p2 = self._nodeconstants.nullid
         if self._parentwriters == 0:
             raise ValueError(
                 b"cannot set dirstate parent outside of "
                 b"dirstate.parentchange context manager"
             )
 
         self._dirty = True
         oldp2 = self._pl[1]
         if self._origpl is None:
             self._origpl = self._pl
         self._map.setparents(p1, p2)
         copies = {}
         if (
             oldp2 != self._nodeconstants.nullid
             and p2 == self._nodeconstants.nullid
         ):
             candidatefiles = self._map.non_normal_or_other_parent_paths()
 
             for f in candidatefiles:
                 s = self._map.get(f)
                 if s is None:
                     continue
 
                 # Discard "merged" markers when moving away from a merge state
                 if s.merged:
                     source = self._map.copymap.get(f)
                     if source:
                         copies[f] = source
                     self.normallookup(f)
                 # Also fix up otherparent markers
                 elif s.from_p2:
                     source = self._map.copymap.get(f)
                     if source:
                         copies[f] = source
                     self._add(f)
         return copies
 
     def setbranch(self, branch):
         self.__class__._branch.set(self, encoding.fromlocal(branch))
         f = self._opener(b'branch', b'w', atomictemp=True, checkambig=True)
         try:
             f.write(self._branch + b'\n')
             f.close()
 
             # make sure filecache has the correct stat info for _branch after
             # replacing the underlying file
             ce = self._filecache[b'_branch']
             if ce:
                 ce.refresh()
         except:  # re-raises
             f.discard()
             raise
 
     def invalidate(self):
         """Causes the next access to reread the dirstate.
 
         This is different from localrepo.invalidatedirstate() because it always
         rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
         check whether the dirstate has changed before rereading it."""
 
         for a in ("_map", "_branch", "_ignore"):
             if a in self.__dict__:
                 delattr(self, a)
         self._lastnormaltime = 0
         self._dirty = False
         self._updatedfiles.clear()
         self._parentwriters = 0
         self._origpl = None
 
     def copy(self, source, dest):
         """Mark dest as a copy of source. Unmark dest if source is None."""
         if source == dest:
             return
         self._dirty = True
         if source is not None:
             self._map.copymap[dest] = source
             self._updatedfiles.add(source)
             self._updatedfiles.add(dest)
         elif self._map.copymap.pop(dest, None):
             self._updatedfiles.add(dest)
 
     def copied(self, file):
         return self._map.copymap.get(file, None)
 
     def copies(self):
         return self._map.copymap
 
     @requires_no_parents_change
     def set_tracked(self, filename):
         """a "public" method for generic code to mark a file as tracked
 
         This function is to be called outside of "update/merge" case. For
         example by a command like `hg add X`.
 
         return True the file was previously untracked, False otherwise.
         """
         entry = self._map.get(filename)
         if entry is None:
             self._add(filename)
             return True
         elif not entry.tracked:
             self.normallookup(filename)
             return True
         return False
 
     @requires_no_parents_change
     def set_untracked(self, filename):
         """a "public" method for generic code to mark a file as untracked
 
         This function is to be called outside of "update/merge" case. For
         example by a command like `hg remove X`.
 
         return True the file was previously tracked, False otherwise.
         """
         entry = self._map.get(filename)
         if entry is None:
             return False
         elif entry.added:
             self._drop(filename)
             return True
         else:
             self._remove(filename)
             return True
 
     @requires_parents_change
     def update_file_reference(
         self,
         filename,
         p1_tracked,
     ):
         """Set a file as tracked in the parent (or not)
 
         This is to be called when adjust the dirstate to a new parent after an history
         rewriting operation.
 
         It should not be called during a merge (p2 != nullid) and only within
         a `with dirstate.parentchange():` context.
         """
         if self.in_merge:
             msg = b'update_file_reference should not be called when merging'
             raise error.ProgrammingError(msg)
         entry = self._map.get(filename)
         if entry is None:
             wc_tracked = False
         else:
             wc_tracked = entry.tracked
         if p1_tracked and wc_tracked:
             # the underlying reference might have changed, we will have to
             # check it.
             self.normallookup(filename)
         elif not (p1_tracked or wc_tracked):
             # the file is no longer relevant to anyone
             self._drop(filename)
         elif (not p1_tracked) and wc_tracked:
             if not entry.added:
                 self._add(filename)
         elif p1_tracked and not wc_tracked:
             if entry is None or not entry.removed:
                 self._remove(filename)
         else:
             assert False, 'unreachable'
 
     @requires_parents_change
     def update_file(
         self,
         filename,
         wc_tracked,
         p1_tracked,
         p2_tracked=False,
         merged=False,
         clean_p1=False,
         clean_p2=False,
         possibly_dirty=False,
     ):
         """update the information about a file in the dirstate
 
         This is to be called when the direstates parent changes to keep track
         of what is the file situation in regards to the working copy and its parent.
 
         This function must be called within a `dirstate.parentchange` context.
 
         note: the API is at an early stage and we might need to ajust it
         depending of what information ends up being relevant and useful to
         other processing.
         """
         if merged and (clean_p1 or clean_p2):
             msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
             raise error.ProgrammingError(msg)
         if not (p1_tracked or p2_tracked or wc_tracked):
             self._drop(filename)
         elif merged:
             assert wc_tracked
             assert self.in_merge  # we are never in the "normallookup" case
             self.otherparent(filename)
         elif not (p1_tracked or p2_tracked) and wc_tracked:
             self._addpath(filename, added=True, possibly_dirty=possibly_dirty)
             self._map.copymap.pop(filename, None)
         elif (p1_tracked or p2_tracked) and not wc_tracked:
             self._remove(filename)
         elif clean_p2 and wc_tracked:
             assert p2_tracked
             self.otherparent(filename)
         elif not p1_tracked and p2_tracked and wc_tracked:
             self._addpath(filename, from_p2=True, possibly_dirty=possibly_dirty)
             self._map.copymap.pop(filename, None)
         elif possibly_dirty:
             self._addpath(filename, possibly_dirty=possibly_dirty)
         elif wc_tracked:
             self.normal(filename)
         # XXX We need something for file that are dirty after an update
         else:
             assert False, 'unreachable'
 
     @requires_parents_change
     def update_parent_file_data(self, f, filedata):
         """update the information about the content of a file
 
         This function should be called within a `dirstate.parentchange` context.
         """
         self.normal(f, parentfiledata=filedata)
 
     def _addpath(
         self,
         f,
         mode=0,
         size=None,
         mtime=None,
         added=False,
         merged=False,
         from_p2=False,
         possibly_dirty=False,
     ):
         entry = self._map.get(f)
         if added or entry is not None and entry.removed:
             scmutil.checkfilename(f)
             if self._map.hastrackeddir(f):
                 msg = _(b'directory %r already in dirstate')
                 msg %= pycompat.bytestr(f)
                 raise error.Abort(msg)
             # shadows
             for d in pathutil.finddirs(f):
                 if self._map.hastrackeddir(d):
                     break
                 entry = self._map.get(d)
                 if entry is not None and not entry.removed:
                     msg = _(b'file %r in dirstate clashes with %r')
                     msg %= (pycompat.bytestr(d), pycompat.bytestr(f))
                     raise error.Abort(msg)
         self._dirty = True
         self._updatedfiles.add(f)
         self._map.addfile(
             f,
             mode=mode,
             size=size,
             mtime=mtime,
             added=added,
             merged=merged,
             from_p2=from_p2,
             possibly_dirty=possibly_dirty,
         )
 
     def normal(self, f, parentfiledata=None):
         """Mark a file normal and clean.
 
         parentfiledata: (mode, size, mtime) of the clean file
 
         parentfiledata should be computed from memory (for mode,
         size), as or close as possible from the point where we
         determined the file was clean, to limit the risk of the
         file having been changed by an external process between the
         moment where the file was determined to be clean and now."""
         if parentfiledata:
             (mode, size, mtime) = parentfiledata
         else:
             s = os.lstat(self._join(f))
             mode = s.st_mode
             size = s.st_size
             mtime = s[stat.ST_MTIME]
         self._addpath(f, mode=mode, size=size, mtime=mtime)
         self._map.copymap.pop(f, None)
         if f in self._map.nonnormalset:
             self._map.nonnormalset.remove(f)
         if mtime > self._lastnormaltime:
             # Remember the most recent modification timeslot for status(),
             # to make sure we won't miss future size-preserving file content
             # modifications that happen within the same timeslot.
             self._lastnormaltime = mtime
 
     def normallookup(self, f):
         '''Mark a file normal, but possibly dirty.'''
         if self.in_merge:
             # if there is a merge going on and the file was either
             # "merged" or coming from other parent (-2) before
             # being removed, restore that state.
             entry = self._map.get(f)
             if entry is not None:
                 # XXX this should probably be dealt with a a lower level
                 # (see `merged_removed` and `from_p2_removed`)
                 if entry.merged_removed or entry.from_p2_removed:
                     source = self._map.copymap.get(f)
                     if entry.merged_removed:
                         self.merge(f)
                     elif entry.from_p2_removed:
                         self.otherparent(f)
                     if source is not None:
                         self.copy(source, f)
                     return
                 elif entry.merged or entry.from_p2:
                     return
         self._addpath(f, possibly_dirty=True)
         self._map.copymap.pop(f, None)
 
     def otherparent(self, f):
         '''Mark as coming from the other parent, always dirty.'''
         if not self.in_merge:
             msg = _(b"setting %r to other parent only allowed in merges") % f
             raise error.Abort(msg)
         entry = self._map.get(f)
         if entry is not None and entry.tracked:
             # merge-like
             self._addpath(f, merged=True)
         else:
             # add-like
             self._addpath(f, from_p2=True)
         self._map.copymap.pop(f, None)
 
     def add(self, f):
         '''Mark a file added.'''
         if not self.pendingparentchange():
             util.nouideprecwarn(
                 b"do not use `add` outside of update/merge context."
                 b" Use `set_tracked`",
                 b'6.0',
                 stacklevel=2,
             )
         self._add(f)
 
     def _add(self, filename):
         """internal function to mark a file as added"""
         self._addpath(filename, added=True)
         self._map.copymap.pop(filename, None)
 
     def remove(self, f):
         '''Mark a file removed'''
         if not self.pendingparentchange():
             util.nouideprecwarn(
                 b"do not use `remove` outside of update/merge context."
                 b" Use `set_untracked`",
                 b'6.0',
                 stacklevel=2,
             )
         self._remove(f)
 
     def _remove(self, filename):
         """internal function to mark a file removed"""
         self._dirty = True
         self._updatedfiles.add(filename)
         self._map.removefile(filename, in_merge=self.in_merge)
 
     def merge(self, f):
         '''Mark a file merged.'''
         if not self.in_merge:
             return self.normallookup(f)
         return self.otherparent(f)
 
     def drop(self, f):
         '''Drop a file from the dirstate'''
         if not self.pendingparentchange():
             util.nouideprecwarn(
                 b"do not use `drop` outside of update/merge context."
                 b" Use `set_untracked`",
                 b'6.0',
                 stacklevel=2,
             )
         self._drop(f)
 
     def _drop(self, filename):
         """internal function to drop a file from the dirstate"""
         if self._map.dropfile(filename):
             self._dirty = True
             self._updatedfiles.add(filename)
             self._map.copymap.pop(filename, None)
 
     def _discoverpath(self, path, normed, ignoremissing, exists, storemap):
         if exists is None:
             exists = os.path.lexists(os.path.join(self._root, path))
         if not exists:
             # Maybe a path component exists
             if not ignoremissing and b'/' in path:
                 d, f = path.rsplit(b'/', 1)
                 d = self._normalize(d, False, ignoremissing, None)
                 folded = d + b"/" + f
             else:
                 # No path components, preserve original case
                 folded = path
         else:
             # recursively normalize leading directory components
             # against dirstate
             if b'/' in normed:
                 d, f = normed.rsplit(b'/', 1)
                 d = self._normalize(d, False, ignoremissing, True)
                 r = self._root + b"/" + d
                 folded = d + b"/" + util.fspath(f, r)
             else:
                 folded = util.fspath(normed, self._root)
             storemap[normed] = folded
 
         return folded
 
     def _normalizefile(self, path, isknown, ignoremissing=False, exists=None):
         normed = util.normcase(path)
         folded = self._map.filefoldmap.get(normed, None)
         if folded is None:
             if isknown:
                 folded = path
             else:
                 folded = self._discoverpath(
                     path, normed, ignoremissing, exists, self._map.filefoldmap
                 )
         return folded
 
     def _normalize(self, path, isknown, ignoremissing=False, exists=None):
         normed = util.normcase(path)
         folded = self._map.filefoldmap.get(normed, None)
         if folded is None:
             folded = self._map.dirfoldmap.get(normed, None)
         if folded is None:
             if isknown:
                 folded = path
             else:
                 # store discovered result in dirfoldmap so that future
                 # normalizefile calls don't start matching directories
                 folded = self._discoverpath(
                     path, normed, ignoremissing, exists, self._map.dirfoldmap
                 )
         return folded
 
     def normalize(self, path, isknown=False, ignoremissing=False):
         """
         normalize the case of a pathname when on a casefolding filesystem
 
         isknown specifies whether the filename came from walking the
         disk, to avoid extra filesystem access.
 
         If ignoremissing is True, missing path are returned
         unchanged. Otherwise, we try harder to normalize possibly
         existing path components.
 
         The normalized case is determined based on the following precedence:
 
         - version of name already stored in the dirstate
         - version of name stored on disk
         - version provided via command arguments
         """
 
         if self._checkcase:
             return self._normalize(path, isknown, ignoremissing)
         return path
 
     def clear(self):
         self._map.clear()
         self._lastnormaltime = 0
         self._updatedfiles.clear()
         self._dirty = True
 
     def rebuild(self, parent, allfiles, changedfiles=None):
         if changedfiles is None:
             # Rebuild entire dirstate
             to_lookup = allfiles
             to_drop = []
             lastnormaltime = self._lastnormaltime
             self.clear()
             self._lastnormaltime = lastnormaltime
         elif len(changedfiles) < 10:
             # Avoid turning allfiles into a set, which can be expensive if it's
             # large.
             to_lookup = []
             to_drop = []
             for f in changedfiles:
                 if f in allfiles:
                     to_lookup.append(f)
                 else:
                     to_drop.append(f)
         else:
             changedfilesset = set(changedfiles)
             to_lookup = changedfilesset & set(allfiles)
             to_drop = changedfilesset - to_lookup
 
         if self._origpl is None:
             self._origpl = self._pl
         self._map.setparents(parent, self._nodeconstants.nullid)
 
         for f in to_lookup:
             self.normallookup(f)
         for f in to_drop:
             self._drop(f)
 
         self._dirty = True
 
     def identity(self):
         """Return identity of dirstate itself to detect changing in storage
 
         If identity of previous dirstate is equal to this, writing
         changes based on the former dirstate out can keep consistency.
         """
         return self._map.identity
 
     def write(self, tr):
         if not self._dirty:
             return
 
         filename = self._filename
         if tr:
             # 'dirstate.write()' is not only for writing in-memory
             # changes out, but also for dropping ambiguous timestamp.
             # delayed writing re-raise "ambiguous timestamp issue".
             # See also the wiki page below for detail:
             # https://www.mercurial-scm.org/wiki/DirstateTransactionPlan
 
             # emulate dropping timestamp in 'parsers.pack_dirstate'
             now = _getfsnow(self._opener)
             self._map.clearambiguoustimes(self._updatedfiles, now)
 
             # emulate that all 'dirstate.normal' results are written out
             self._lastnormaltime = 0
             self._updatedfiles.clear()
 
             # delay writing in-memory changes out
             tr.addfilegenerator(
                 b'dirstate',
                 (self._filename,),
-                self._writedirstate,
+                lambda f: self._writedirstate(tr, f),
                 location=b'plain',
             )
             return
 
         st = self._opener(filename, b"w", atomictemp=True, checkambig=True)
-        self._writedirstate(st)
+        self._writedirstate(tr, st)
 
     def addparentchangecallback(self, category, callback):
         """add a callback to be called when the wd parents are changed
 
         Callback will be called with the following arguments:
             dirstate, (oldp1, oldp2), (newp1, newp2)
 
         Category is a unique identifier to allow overwriting an old callback
         with a newer callback.
         """
         self._plchangecallbacks[category] = callback
 
-    def _writedirstate(self, st):
+    def _writedirstate(self, tr, st):
         # notify callbacks about parents change
         if self._origpl is not None and self._origpl != self._pl:
             for c, callback in sorted(
                 pycompat.iteritems(self._plchangecallbacks)
             ):
                 callback(self, self._origpl, self._pl)
             self._origpl = None
         # use the modification time of the newly created temporary file as the
         # filesystem's notion of 'now'
         now = util.fstat(st)[stat.ST_MTIME] & _rangemask
 
         # enough 'delaywrite' prevents 'pack_dirstate' from dropping
         # timestamp of each entries in dirstate, because of 'now > mtime'
         delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite')
         if delaywrite > 0:
             # do we have any files to delay for?
             for f, e in pycompat.iteritems(self._map):
                 if e.need_delay(now):
                     import time  # to avoid useless import
 
                     # rather than sleep n seconds, sleep until the next
                     # multiple of n seconds
                     clock = time.time()
                     start = int(clock) - (int(clock) % delaywrite)
                     end = start + delaywrite
                     time.sleep(end - clock)
                     now = end  # trust our estimate that the end is near now
                     break
 
-        self._map.write(st, now)
+        self._map.write(tr, st, now)
         self._lastnormaltime = 0
         self._dirty = False
 
     def _dirignore(self, f):
         if self._ignore(f):
             return True
         for p in pathutil.finddirs(f):
             if self._ignore(p):
                 return True
         return False
 
     def _ignorefiles(self):
         files = []
         if os.path.exists(self._join(b'.hgignore')):
             files.append(self._join(b'.hgignore'))
         for name, path in self._ui.configitems(b"ui"):
             if name == b'ignore' or name.startswith(b'ignore.'):
                 # we need to use os.path.join here rather than self._join
                 # because path is arbitrary and user-specified
                 files.append(os.path.join(self._rootdir, util.expandpath(path)))
         return files
 
     def _ignorefileandline(self, f):
         files = collections.deque(self._ignorefiles())
         visited = set()
         while files:
             i = files.popleft()
             patterns = matchmod.readpatternfile(
                 i, self._ui.warn, sourceinfo=True
             )
             for pattern, lineno, line in patterns:
                 kind, p = matchmod._patsplit(pattern, b'glob')
                 if kind == b"subinclude":
                     if p not in visited:
                         files.append(p)
                     continue
                 m = matchmod.match(
                     self._root, b'', [], [pattern], warn=self._ui.warn
                 )
                 if m(f):
                     return (i, lineno, line)
             visited.add(i)
         return (None, -1, b"")
 
     def _walkexplicit(self, match, subrepos):
         """Get stat data about the files explicitly specified by match.
 
         Return a triple (results, dirsfound, dirsnotfound).
         - results is a mapping from filename to stat result. It also contains
           listings mapping subrepos and .hg to None.
         - dirsfound is a list of files found to be directories.
         - dirsnotfound is a list of files that the dirstate thinks are
           directories and that were not found."""
 
         def badtype(mode):
             kind = _(b'unknown')
             if stat.S_ISCHR(mode):
                 kind = _(b'character device')
             elif stat.S_ISBLK(mode):
                 kind = _(b'block device')
             elif stat.S_ISFIFO(mode):
                 kind = _(b'fifo')
             elif stat.S_ISSOCK(mode):
                 kind = _(b'socket')
             elif stat.S_ISDIR(mode):
                 kind = _(b'directory')
             return _(b'unsupported file type (type is %s)') % kind
 
         badfn = match.bad
         dmap = self._map
         lstat = os.lstat
         getkind = stat.S_IFMT
         dirkind = stat.S_IFDIR
         regkind = stat.S_IFREG
         lnkkind = stat.S_IFLNK
         join = self._join
         dirsfound = []
         foundadd = dirsfound.append
         dirsnotfound = []
         notfoundadd = dirsnotfound.append
 
         if not match.isexact() and self._checkcase:
             normalize = self._normalize
         else:
             normalize = None
 
         files = sorted(match.files())
         subrepos.sort()
         i, j = 0, 0
         while i < len(files) and j < len(subrepos):
             subpath = subrepos[j] + b"/"
             if files[i] < subpath:
                 i += 1
                 continue
             while i < len(files) and files[i].startswith(subpath):
                 del files[i]
             j += 1
 
         if not files or b'' in files:
             files = [b'']
             # constructing the foldmap is expensive, so don't do it for the
             # common case where files is ['']
             normalize = None
         results = dict.fromkeys(subrepos)
         results[b'.hg'] = None
 
         for ff in files:
             if normalize:
                 nf = normalize(ff, False, True)
             else:
                 nf = ff
             if nf in results:
                 continue
 
             try:
                 st = lstat(join(nf))
                 kind = getkind(st.st_mode)
                 if kind == dirkind:
                     if nf in dmap:
                         # file replaced by dir on disk but still in dirstate
                         results[nf] = None
                     foundadd((nf, ff))
                 elif kind == regkind or kind == lnkkind:
                     results[nf] = st
                 else:
                     badfn(ff, badtype(kind))
                     if nf in dmap:
                         results[nf] = None
             except OSError as inst:  # nf not found on disk - it is dirstate only
                 if nf in dmap:  # does it exactly match a missing file?
                     results[nf] = None
                 else:  # does it match a missing directory?
                     if self._map.hasdir(nf):
                         notfoundadd(nf)
                     else:
                         badfn(ff, encoding.strtolocal(inst.strerror))
 
         # match.files() may contain explicitly-specified paths that shouldn't
         # be taken; drop them from the list of files found. dirsfound/notfound
         # aren't filtered here because they will be tested later.
         if match.anypats():
             for f in list(results):
                 if f == b'.hg' or f in subrepos:
                     # keep sentinel to disable further out-of-repo walks
                     continue
                 if not match(f):
                     del results[f]
 
         # Case insensitive filesystems cannot rely on lstat() failing to detect
         # a case-only rename.  Prune the stat object for any file that does not
         # match the case in the filesystem, if there are multiple files that
         # normalize to the same path.
         if match.isexact() and self._checkcase:
             normed = {}
 
             for f, st in pycompat.iteritems(results):
                 if st is None:
                     continue
 
                 nc = util.normcase(f)
                 paths = normed.get(nc)
 
                 if paths is None:
                     paths = set()
                     normed[nc] = paths
 
                 paths.add(f)
 
             for norm, paths in pycompat.iteritems(normed):
                 if len(paths) > 1:
                     for path in paths:
                         folded = self._discoverpath(
                             path, norm, True, None, self._map.dirfoldmap
                         )
                         if path != folded:
                             results[path] = None
 
         return results, dirsfound, dirsnotfound
 
     def walk(self, match, subrepos, unknown, ignored, full=True):
         """
         Walk recursively through the directory tree, finding all files
         matched by match.
 
         If full is False, maybe skip some known-clean files.
 
         Return a dict mapping filename to stat-like object (either
         mercurial.osutil.stat instance or return value of os.stat()).
 
         """
         # full is a flag that extensions that hook into walk can use -- this
         # implementation doesn't use it at all. This satisfies the contract
         # because we only guarantee a "maybe".
 
         if ignored:
             ignore = util.never
             dirignore = util.never
         elif unknown:
             ignore = self._ignore
             dirignore = self._dirignore
         else:
             # if not unknown and not ignored, drop dir recursion and step 2
             ignore = util.always
             dirignore = util.always
 
         matchfn = match.matchfn
         matchalways = match.always()
         matchtdir = match.traversedir
         dmap = self._map
         listdir = util.listdir
         lstat = os.lstat
         dirkind = stat.S_IFDIR
         regkind = stat.S_IFREG
         lnkkind = stat.S_IFLNK
         join = self._join
 
         exact = skipstep3 = False
         if match.isexact():  # match.exact
             exact = True
             dirignore = util.always  # skip step 2
         elif match.prefix():  # match.match, no patterns
             skipstep3 = True
 
         if not exact and self._checkcase:
             normalize = self._normalize
             normalizefile = self._normalizefile
             skipstep3 = False
         else:
             normalize = self._normalize
             normalizefile = None
 
         # step 1: find all explicit files
         results, work, dirsnotfound = self._walkexplicit(match, subrepos)
         if matchtdir:
             for d in work:
                 matchtdir(d[0])
             for d in dirsnotfound:
                 matchtdir(d)
 
         skipstep3 = skipstep3 and not (work or dirsnotfound)
         work = [d for d in work if not dirignore(d[0])]
 
         # step 2: visit subdirectories
         def traverse(work, alreadynormed):
             wadd = work.append
             while work:
                 tracing.counter('dirstate.walk work', len(work))
                 nd = work.pop()
                 visitentries = match.visitchildrenset(nd)
                 if not visitentries:
                     continue
                 if visitentries == b'this' or visitentries == b'all':
                     visitentries = None
                 skip = None
                 if nd != b'':
                     skip = b'.hg'
                 try:
                     with tracing.log('dirstate.walk.traverse listdir %s', nd):
                         entries = listdir(join(nd), stat=True, skip=skip)
                 except OSError as inst:
                     if inst.errno in (errno.EACCES, errno.ENOENT):
                         match.bad(
                             self.pathto(nd), encoding.strtolocal(inst.strerror)
                         )
                         continue
                     raise
                 for f, kind, st in entries:
                     # Some matchers may return files in the visitentries set,
                     # instead of 'this', if the matcher explicitly mentions them
                     # and is not an exactmatcher. This is acceptable; we do not
                     # make any hard assumptions about file-or-directory below
                     # based on the presence of `f` in visitentries. If
                     # visitchildrenset returned a set, we can always skip the
                     # entries *not* in the set it provided regardless of whether
                     # they're actually a file or a directory.
                     if visitentries and f not in visitentries:
                         continue
                     if normalizefile:
                         # even though f might be a directory, we're only
                         # interested in comparing it to files currently in the
                         # dmap -- therefore normalizefile is enough
                         nf = normalizefile(
                             nd and (nd + b"/" + f) or f, True, True
                         )
                     else:
                         nf = nd and (nd + b"/" + f) or f
                     if nf not in results:
                         if kind == dirkind:
                             if not ignore(nf):
                                 if matchtdir:
                                     matchtdir(nf)
                                 wadd(nf)
                             if nf in dmap and (matchalways or matchfn(nf)):
                                 results[nf] = None
                         elif kind == regkind or kind == lnkkind:
                             if nf in dmap:
                                 if matchalways or matchfn(nf):
                                     results[nf] = st
                             elif (matchalways or matchfn(nf)) and not ignore(
                                 nf
                             ):
                                 # unknown file -- normalize if necessary
                                 if not alreadynormed:
                                     nf = normalize(nf, False, True)
                                 results[nf] = st
                         elif nf in dmap and (matchalways or matchfn(nf)):
                             results[nf] = None
 
         for nd, d in work:
             # alreadynormed means that processwork doesn't have to do any
             # expensive directory normalization
             alreadynormed = not normalize or nd == d
             traverse([d], alreadynormed)
 
         for s in subrepos:
             del results[s]
         del results[b'.hg']
 
         # step 3: visit remaining files from dmap
         if not skipstep3 and not exact:
             # If a dmap file is not in results yet, it was either
             # a) not matching matchfn b) ignored, c) missing, or d) under a
             # symlink directory.
             if not results and matchalways:
                 visit = [f for f in dmap]
             else:
                 visit = [f for f in dmap if f not in results and matchfn(f)]
             visit.sort()
 
             if unknown:
                 # unknown == True means we walked all dirs under the roots
                 # that wasn't ignored, and everything that matched was stat'ed
                 # and is already in results.
                 # The rest must thus be ignored or under a symlink.
                 audit_path = pathutil.pathauditor(self._root, cached=True)
 
                 for nf in iter(visit):
                     # If a stat for the same file was already added with a
                     # different case, don't add one for this, since that would
                     # make it appear as if the file exists under both names
                     # on disk.
                     if (
                         normalizefile
                         and normalizefile(nf, True, True) in results
                     ):
                         results[nf] = None
                     # Report ignored items in the dmap as long as they are not
                     # under a symlink directory.
                     elif audit_path.check(nf):
                         try:
                             results[nf] = lstat(join(nf))
                             # file was just ignored, no links, and exists
                         except OSError:
                             # file doesn't exist
                             results[nf] = None
                     else:
                         # It's either missing or under a symlink directory
                         # which we in this case report as missing
                         results[nf] = None
             else:
                 # We may not have walked the full directory tree above,
                 # so stat and check everything we missed.
                 iv = iter(visit)
                 for st in util.statfiles([join(i) for i in visit]):
                     results[next(iv)] = st
         return results
 
     def _rust_status(self, matcher, list_clean, list_ignored, list_unknown):
         # Force Rayon (Rust parallelism library) to respect the number of
         # workers. This is a temporary workaround until Rust code knows
         # how to read the config file.
         numcpus = self._ui.configint(b"worker", b"numcpus")
         if numcpus is not None:
             encoding.environ.setdefault(b'RAYON_NUM_THREADS', b'%d' % numcpus)
 
         workers_enabled = self._ui.configbool(b"worker", b"enabled", True)
         if not workers_enabled:
             encoding.environ[b"RAYON_NUM_THREADS"] = b"1"
 
         (
             lookup,
             modified,
             added,
             removed,
             deleted,
             clean,
             ignored,
             unknown,
             warnings,
             bad,
             traversed,
             dirty,
         ) = rustmod.status(
             self._map._rustmap,
             matcher,
             self._rootdir,
             self._ignorefiles(),
             self._checkexec,
             self._lastnormaltime,
             bool(list_clean),
             bool(list_ignored),
             bool(list_unknown),
             bool(matcher.traversedir),
         )
 
         self._dirty |= dirty
 
         if matcher.traversedir:
             for dir in traversed:
                 matcher.traversedir(dir)
 
         if self._ui.warn:
             for item in warnings:
                 if isinstance(item, tuple):
                     file_path, syntax = item
                     msg = _(b"%s: ignoring invalid syntax '%s'\n") % (
                         file_path,
                         syntax,
                     )
                     self._ui.warn(msg)
                 else:
                     msg = _(b"skipping unreadable pattern file '%s': %s\n")
                     self._ui.warn(
                         msg
                         % (
                             pathutil.canonpath(
                                 self._rootdir, self._rootdir, item
                             ),
                             b"No such file or directory",
                         )
                     )
 
         for (fn, message) in bad:
             matcher.bad(fn, encoding.strtolocal(message))
 
         status = scmutil.status(
             modified=modified,
             added=added,
             removed=removed,
             deleted=deleted,
             unknown=unknown,
             ignored=ignored,
             clean=clean,
         )
         return (lookup, status)
 
     def status(self, match, subrepos, ignored, clean, unknown):
         """Determine the status of the working copy relative to the
         dirstate and return a pair of (unsure, status), where status is of type
         scmutil.status and:
 
           unsure:
             files that might have been modified since the dirstate was
             written, but need to be read to be sure (size is the same
             but mtime differs)
           status.modified:
             files that have definitely been modified since the dirstate
             was written (different size or mode)
           status.clean:
             files that have definitely not been modified since the
             dirstate was written
         """
         listignored, listclean, listunknown = ignored, clean, unknown
         lookup, modified, added, unknown, ignored = [], [], [], [], []
         removed, deleted, clean = [], [], []
 
         dmap = self._map
         dmap.preload()
 
         use_rust = True
 
         allowed_matchers = (
             matchmod.alwaysmatcher,
             matchmod.exactmatcher,
             matchmod.includematcher,
         )
 
         if rustmod is None:
             use_rust = False
         elif self._checkcase:
             # Case-insensitive filesystems are not handled yet
             use_rust = False
         elif subrepos:
             use_rust = False
         elif sparse.enabled:
             use_rust = False
         elif not isinstance(match, allowed_matchers):
             # Some matchers have yet to be implemented
             use_rust = False
 
         if use_rust:
             try:
                 return self._rust_status(
                     match, listclean, listignored, listunknown
                 )
             except rustmod.FallbackError:
                 pass
 
         def noop(f):
             pass
 
         dcontains = dmap.__contains__
         dget = dmap.__getitem__
         ladd = lookup.append  # aka "unsure"
         madd = modified.append
         aadd = added.append
         uadd = unknown.append if listunknown else noop
         iadd = ignored.append if listignored else noop
         radd = removed.append
         dadd = deleted.append
         cadd = clean.append if listclean else noop
         mexact = match.exact
         dirignore = self._dirignore
         checkexec = self._checkexec
         copymap = self._map.copymap
         lastnormaltime = self._lastnormaltime
 
         # We need to do full walks when either
         # - we're listing all clean files, or
         # - match.traversedir does something, because match.traversedir should
         #   be called for every dir in the working dir
         full = listclean or match.traversedir is not None
         for fn, st in pycompat.iteritems(
             self.walk(match, subrepos, listunknown, listignored, full=full)
         ):
             if not dcontains(fn):
                 if (listignored or mexact(fn)) and dirignore(fn):
                     if listignored:
                         iadd(fn)
                 else:
                     uadd(fn)
                 continue
 
             # This is equivalent to 'state, mode, size, time = dmap[fn]' but not
             # written like that for performance reasons. dmap[fn] is not a
             # Python tuple in compiled builds. The CPython UNPACK_SEQUENCE
             # opcode has fast paths when the value to be unpacked is a tuple or
             # a list, but falls back to creating a full-fledged iterator in
             # general. That is much slower than simply accessing and storing the
             # tuple members one by one.
             t = dget(fn)
             mode = t.mode
             size = t.size
             time = t.mtime
 
             if not st and t.tracked:
                 dadd(fn)
             elif t.merged:
                 madd(fn)
             elif t.added:
                 aadd(fn)
             elif t.removed:
                 radd(fn)
             elif t.tracked:
                 if (
                     size >= 0
                     and (
                         (size != st.st_size and size != st.st_size & _rangemask)
                         or ((mode ^ st.st_mode) & 0o100 and checkexec)
                     )
                     or t.from_p2
                     or fn in copymap
                 ):
                     if stat.S_ISLNK(st.st_mode) and size != st.st_size:
                         # issue6456: Size returned may be longer due to
                         # encryption on EXT-4 fscrypt, undecided.
                         ladd(fn)
                     else:
                         madd(fn)
                 elif (
                     time != st[stat.ST_MTIME]
                     and time != st[stat.ST_MTIME] & _rangemask
                 ):
                     ladd(fn)
                 elif st[stat.ST_MTIME] == lastnormaltime:
                     # fn may have just been marked as normal and it may have
                     # changed in the same second without changing its size.
                     # This can happen if we quickly do multiple commits.
                     # Force lookup, so we don't miss such a racy file change.
                     ladd(fn)
                 elif listclean:
                     cadd(fn)
         status = scmutil.status(
             modified, added, removed, deleted, unknown, ignored, clean
         )
         return (lookup, status)
 
     def matches(self, match):
         """
         return files in the dirstate (in whatever state) filtered by match
         """
         dmap = self._map
         if rustmod is not None:
             dmap = self._map._rustmap
 
         if match.always():
             return dmap.keys()
         files = match.files()
         if match.isexact():
             # fast path -- filter the other way around, since typically files is
             # much smaller than dmap
             return [f for f in files if f in dmap]
         if match.prefix() and all(fn in dmap for fn in files):
             # fast path -- all the values are known to be files, so just return
             # that
             return list(files)
         return [f for f in dmap if match(f)]
 
     def _actualfilename(self, tr):
         if tr:
             return self._pendingfilename
         else:
             return self._filename
 
     def savebackup(self, tr, backupname):
         '''Save current dirstate into backup file'''
         filename = self._actualfilename(tr)
         assert backupname != filename
 
         # use '_writedirstate' instead of 'write' to write changes certainly,
         # because the latter omits writing out if transaction is running.
         # output file will be used to create backup of dirstate at this point.
         if self._dirty or not self._opener.exists(filename):
             self._writedirstate(
-                self._opener(filename, b"w", atomictemp=True, checkambig=True)
+                tr,
+                self._opener(filename, b"w", atomictemp=True, checkambig=True),
             )
 
         if tr:
             # ensure that subsequent tr.writepending returns True for
             # changes written out above, even if dirstate is never
             # changed after this
             tr.addfilegenerator(
                 b'dirstate',
                 (self._filename,),
-                self._writedirstate,
+                lambda f: self._writedirstate(tr, f),
                 location=b'plain',
             )
 
             # ensure that pending file written above is unlinked at
             # failure, even if tr.writepending isn't invoked until the
             # end of this transaction
             tr.registertmp(filename, location=b'plain')
 
         self._opener.tryunlink(backupname)
         # hardlink backup is okay because _writedirstate is always called
         # with an "atomictemp=True" file.
         util.copyfile(
             self._opener.join(filename),
             self._opener.join(backupname),
             hardlink=True,
         )
 
     def restorebackup(self, tr, backupname):
         '''Restore dirstate by backup file'''
         # this "invalidate()" prevents "wlock.release()" from writing
         # changes of dirstate out after restoring from backup file
         self.invalidate()
         filename = self._actualfilename(tr)
         o = self._opener
         if util.samefile(o.join(backupname), o.join(filename)):
             o.unlink(backupname)
         else:
             o.rename(backupname, filename, checkambig=True)
 
     def clearbackup(self, tr, backupname):
         '''Clear backup file'''
         self._opener.unlink(backupname)

mercurial/dirstatemap.py

@@ -1,687 +1,717 b''
 # dirstatemap.py
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 
 from .i18n import _
 
 from . import (
     error,
     pathutil,
     policy,
     pycompat,
     txnutil,
     util,
 )
 
+from .dirstateutils import (
+    docket as docketmod,
+)
+
 parsers = policy.importmod('parsers')
 rustmod = policy.importrust('dirstate')
 
 propertycache = util.propertycache
 
 DirstateItem = parsers.DirstateItem
 
 
 # a special value used internally for `size` if the file come from the other parent
 FROM_P2 = -2
 
 # a special value used internally for `size` if the file is modified/merged/added
 NONNORMAL = -1
 
 # a special value used internally for `time` if the time is ambigeous
 AMBIGUOUS_TIME = -1
 
 rangemask = 0x7FFFFFFF
 
 
 class dirstatemap(object):
     """Map encapsulating the dirstate's contents.
 
     The dirstate contains the following state:
 
     - `identity` is the identity of the dirstate file, which can be used to
       detect when changes have occurred to the dirstate file.
 
     - `parents` is a pair containing the parents of the working copy. The
       parents are updated by calling `setparents`.
 
     - the state map maps filenames to tuples of (state, mode, size, mtime),
       where state is a single character representing 'normal', 'added',
       'removed', or 'merged'. It is read by treating the dirstate as a
       dict.  File state is updated by calling the `addfile`, `removefile` and
       `dropfile` methods.
 
     - `copymap` maps destination filenames to their source filename.
 
     The dirstate also provides the following views onto the state:
 
     - `nonnormalset` is a set of the filenames that have state other
       than 'normal', or are normal but have an mtime of -1 ('normallookup').
 
     - `otherparentset` is a set of the filenames that are marked as coming
       from the second parent when the dirstate is currently being merged.
 
     - `filefoldmap` is a dict mapping normalized filenames to the denormalized
       form that they appear as in the dirstate.
 
     - `dirfoldmap` is a dict mapping normalized directory names to the
       denormalized form that they appear as in the dirstate.
     """
 
     def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
         self._ui = ui
         self._opener = opener
         self._root = root
         self._filename = b'dirstate'
         self._nodelen = 20
         self._nodeconstants = nodeconstants
         assert (
             not use_dirstate_v2
         ), "should have detected unsupported requirement"
 
         self._parents = None
         self._dirtyparents = False
 
         # for consistent view between _pl() and _read() invocations
         self._pendingmode = None
 
     @propertycache
     def _map(self):
         self._map = {}
         self.read()
         return self._map
 
     @propertycache
     def copymap(self):
         self.copymap = {}
         self._map
         return self.copymap
 
     def directories(self):
         # Rust / dirstate-v2 only
         return []
 
     def clear(self):
         self._map.clear()
         self.copymap.clear()
         self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
         util.clearcachedproperty(self, b"_dirs")
         util.clearcachedproperty(self, b"_alldirs")
         util.clearcachedproperty(self, b"filefoldmap")
         util.clearcachedproperty(self, b"dirfoldmap")
         util.clearcachedproperty(self, b"nonnormalset")
         util.clearcachedproperty(self, b"otherparentset")
 
     def items(self):
         return pycompat.iteritems(self._map)
 
     # forward for python2,3 compat
     iteritems = items
 
     def __len__(self):
         return len(self._map)
 
     def __iter__(self):
         return iter(self._map)
 
     def get(self, key, default=None):
         return self._map.get(key, default)
 
     def __contains__(self, key):
         return key in self._map
 
     def __getitem__(self, key):
         return self._map[key]
 
     def keys(self):
         return self._map.keys()
 
     def preload(self):
         """Loads the underlying data, if it's not already loaded"""
         self._map
 
     def addfile(
         self,
         f,
         mode=0,
         size=None,
         mtime=None,
         added=False,
         merged=False,
         from_p2=False,
         possibly_dirty=False,
     ):
         """Add a tracked file to the dirstate."""
         if added:
             assert not merged
             assert not possibly_dirty
             assert not from_p2
             state = b'a'
             size = NONNORMAL
             mtime = AMBIGUOUS_TIME
         elif merged:
             assert not possibly_dirty
             assert not from_p2
             state = b'm'
             size = FROM_P2
             mtime = AMBIGUOUS_TIME
         elif from_p2:
             assert not possibly_dirty
             state = b'n'
             size = FROM_P2
             mtime = AMBIGUOUS_TIME
         elif possibly_dirty:
             state = b'n'
             size = NONNORMAL
             mtime = AMBIGUOUS_TIME
         else:
             assert size != FROM_P2
             assert size != NONNORMAL
             state = b'n'
             size = size & rangemask
             mtime = mtime & rangemask
         assert state is not None
         assert size is not None
         assert mtime is not None
         old_entry = self.get(f)
         if (
             old_entry is None or old_entry.removed
         ) and "_dirs" in self.__dict__:
             self._dirs.addpath(f)
         if old_entry is None and "_alldirs" in self.__dict__:
             self._alldirs.addpath(f)
         self._map[f] = DirstateItem(state, mode, size, mtime)
         if state != b'n' or mtime == AMBIGUOUS_TIME:
             self.nonnormalset.add(f)
         if size == FROM_P2:
             self.otherparentset.add(f)
 
     def removefile(self, f, in_merge=False):
         """
         Mark a file as removed in the dirstate.
 
         The `size` parameter is used to store sentinel values that indicate
         the file's previous state.  In the future, we should refactor this
         to be more explicit about what that state is.
         """
         entry = self.get(f)
         size = 0
         if in_merge:
             # XXX we should not be able to have 'm' state and 'FROM_P2' if not
             # during a merge. So I (marmoute) am not sure we need the
             # conditionnal at all. Adding double checking this with assert
             # would be nice.
             if entry is not None:
                 # backup the previous state
                 if entry.merged:  # merge
                     size = NONNORMAL
                 elif entry.from_p2:
                     size = FROM_P2
                     self.otherparentset.add(f)
         if entry is not None and not (entry.merged or entry.from_p2):
             self.copymap.pop(f, None)
 
         if entry is not None and not entry.removed and "_dirs" in self.__dict__:
             self._dirs.delpath(f)
         if entry is None and "_alldirs" in self.__dict__:
             self._alldirs.addpath(f)
         if "filefoldmap" in self.__dict__:
             normed = util.normcase(f)
             self.filefoldmap.pop(normed, None)
         self._map[f] = DirstateItem(b'r', 0, size, 0)
         self.nonnormalset.add(f)
 
     def dropfile(self, f):
         """
         Remove a file from the dirstate.  Returns True if the file was
         previously recorded.
         """
         old_entry = self._map.pop(f, None)
         exists = False
         oldstate = b'?'
         if old_entry is not None:
             exists = True
             oldstate = old_entry.state
         if exists:
             if oldstate != b"r" and "_dirs" in self.__dict__:
                 self._dirs.delpath(f)
             if "_alldirs" in self.__dict__:
                 self._alldirs.delpath(f)
         if "filefoldmap" in self.__dict__:
             normed = util.normcase(f)
             self.filefoldmap.pop(normed, None)
         self.nonnormalset.discard(f)
         return exists
 
     def clearambiguoustimes(self, files, now):
         for f in files:
             e = self.get(f)
             if e is not None and e.need_delay(now):
                 e.set_possibly_dirty()
                 self.nonnormalset.add(f)
 
     def nonnormalentries(self):
         '''Compute the nonnormal dirstate entries from the dmap'''
         try:
             return parsers.nonnormalotherparententries(self._map)
         except AttributeError:
             nonnorm = set()
             otherparent = set()
             for fname, e in pycompat.iteritems(self._map):
                 if e.state != b'n' or e.mtime == AMBIGUOUS_TIME:
                     nonnorm.add(fname)
                 if e.from_p2:
                     otherparent.add(fname)
             return nonnorm, otherparent
 
     @propertycache
     def filefoldmap(self):
         """Returns a dictionary mapping normalized case paths to their
         non-normalized versions.
         """
         try:
             makefilefoldmap = parsers.make_file_foldmap
         except AttributeError:
             pass
         else:
             return makefilefoldmap(
                 self._map, util.normcasespec, util.normcasefallback
             )
 
         f = {}
         normcase = util.normcase
         for name, s in pycompat.iteritems(self._map):
             if not s.removed:
                 f[normcase(name)] = name
         f[b'.'] = b'.'  # prevents useless util.fspath() invocation
         return f
 
     def hastrackeddir(self, d):
         """
         Returns True if the dirstate contains a tracked (not removed) file
         in this directory.
         """
         return d in self._dirs
 
     def hasdir(self, d):
         """
         Returns True if the dirstate contains a file (tracked or removed)
         in this directory.
         """
         return d in self._alldirs
 
     @propertycache
     def _dirs(self):
         return pathutil.dirs(self._map, b'r')
 
     @propertycache
     def _alldirs(self):
         return pathutil.dirs(self._map)
 
     def _opendirstatefile(self):
         fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
         if self._pendingmode is not None and self._pendingmode != mode:
             fp.close()
             raise error.Abort(
                 _(b'working directory state may be changed parallelly')
             )
         self._pendingmode = mode
         return fp
 
     def parents(self):
         if not self._parents:
             try:
                 fp = self._opendirstatefile()
                 st = fp.read(2 * self._nodelen)
                 fp.close()
             except IOError as err:
                 if err.errno != errno.ENOENT:
                     raise
                 # File doesn't exist, so the current state is empty
                 st = b''
 
             l = len(st)
             if l == self._nodelen * 2:
                 self._parents = (
                     st[: self._nodelen],
                     st[self._nodelen : 2 * self._nodelen],
                 )
             elif l == 0:
                 self._parents = (
                     self._nodeconstants.nullid,
                     self._nodeconstants.nullid,
                 )
             else:
                 raise error.Abort(
                     _(b'working directory state appears damaged!')
                 )
 
         return self._parents
 
     def setparents(self, p1, p2):
         self._parents = (p1, p2)
         self._dirtyparents = True
 
     def read(self):
         # ignore HG_PENDING because identity is used only for writing
         self.identity = util.filestat.frompath(
             self._opener.join(self._filename)
         )
 
         try:
             fp = self._opendirstatefile()
             try:
                 st = fp.read()
             finally:
                 fp.close()
         except IOError as err:
             if err.errno != errno.ENOENT:
                 raise
             return
         if not st:
             return
 
         if util.safehasattr(parsers, b'dict_new_presized'):
             # Make an estimate of the number of files in the dirstate based on
             # its size. This trades wasting some memory for avoiding costly
             # resizes. Each entry have a prefix of 17 bytes followed by one or
             # two path names. Studies on various large-scale real-world repositories
             # found 54 bytes a reasonable upper limit for the average path names.
             # Copy entries are ignored for the sake of this estimate.
             self._map = parsers.dict_new_presized(len(st) // 71)
 
         # Python's garbage collector triggers a GC each time a certain number
         # of container objects (the number being defined by
         # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
         # for each file in the dirstate. The C version then immediately marks
         # them as not to be tracked by the collector. However, this has no
         # effect on when GCs are triggered, only on what objects the GC looks
         # into. This means that O(number of files) GCs are unavoidable.
         # Depending on when in the process's lifetime the dirstate is parsed,
         # this can get very expensive. As a workaround, disable GC while
         # parsing the dirstate.
         #
         # (we cannot decorate the function directly since it is in a C module)
         parse_dirstate = util.nogc(parsers.parse_dirstate)
         p = parse_dirstate(self._map, self.copymap, st)
         if not self._dirtyparents:
             self.setparents(*p)
 
         # Avoid excess attribute lookups by fast pathing certain checks
         self.__contains__ = self._map.__contains__
         self.__getitem__ = self._map.__getitem__
         self.get = self._map.get
 
-    def write(self, st, now):
+    def write(self, _tr, st, now):
         st.write(
             parsers.pack_dirstate(self._map, self.copymap, self.parents(), now)
         )
         st.close()
         self._dirtyparents = False
         self.nonnormalset, self.otherparentset = self.nonnormalentries()
 
     @propertycache
     def nonnormalset(self):
         nonnorm, otherparents = self.nonnormalentries()
         self.otherparentset = otherparents
         return nonnorm
 
     @propertycache
     def otherparentset(self):
         nonnorm, otherparents = self.nonnormalentries()
         self.nonnormalset = nonnorm
         return otherparents
 
     def non_normal_or_other_parent_paths(self):
         return self.nonnormalset.union(self.otherparentset)
 
     @propertycache
     def identity(self):
         self._map
         return self.identity
 
     @propertycache
     def dirfoldmap(self):
         f = {}
         normcase = util.normcase
         for name in self._dirs:
             f[normcase(name)] = name
         return f
 
 
 if rustmod is not None:
 
     class dirstatemap(object):
         def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
             self._use_dirstate_v2 = use_dirstate_v2
             self._nodeconstants = nodeconstants
             self._ui = ui
             self._opener = opener
             self._root = root
             self._filename = b'dirstate'
             self._nodelen = 20  # Also update Rust code when changing this!
             self._parents = None
             self._dirtyparents = False
+            self._docket = None
 
             # for consistent view between _pl() and _read() invocations
             self._pendingmode = None
 
             self._use_dirstate_tree = self._ui.configbool(
                 b"experimental",
                 b"dirstate-tree.in-memory",
                 False,
             )
 
         def addfile(
             self,
             f,
             mode=0,
             size=None,
             mtime=None,
             added=False,
             merged=False,
             from_p2=False,
             possibly_dirty=False,
         ):
             return self._rustmap.addfile(
                 f,
                 mode,
                 size,
                 mtime,
                 added,
                 merged,
                 from_p2,
                 possibly_dirty,
             )
 
         def removefile(self, *args, **kwargs):
             return self._rustmap.removefile(*args, **kwargs)
 
         def dropfile(self, *args, **kwargs):
             return self._rustmap.dropfile(*args, **kwargs)
 
         def clearambiguoustimes(self, *args, **kwargs):
             return self._rustmap.clearambiguoustimes(*args, **kwargs)
 
         def nonnormalentries(self):
             return self._rustmap.nonnormalentries()
 
         def get(self, *args, **kwargs):
             return self._rustmap.get(*args, **kwargs)
 
         @property
         def copymap(self):
             return self._rustmap.copymap()
 
         def directories(self):
             return self._rustmap.directories()
 
         def preload(self):
             self._rustmap
 
         def clear(self):
             self._rustmap.clear()
             self.setparents(
                 self._nodeconstants.nullid, self._nodeconstants.nullid
             )
             util.clearcachedproperty(self, b"_dirs")
             util.clearcachedproperty(self, b"_alldirs")
             util.clearcachedproperty(self, b"dirfoldmap")
 
         def items(self):
             return self._rustmap.items()
 
         def keys(self):
             return iter(self._rustmap)
 
         def __contains__(self, key):
             return key in self._rustmap
 
         def __getitem__(self, item):
             return self._rustmap[item]
 
         def __len__(self):
             return len(self._rustmap)
 
         def __iter__(self):
             return iter(self._rustmap)
 
         # forward for python2,3 compat
         iteritems = items
 
         def _opendirstatefile(self):
             fp, mode = txnutil.trypending(
                 self._root, self._opener, self._filename
             )
             if self._pendingmode is not None and self._pendingmode != mode:
                 fp.close()
                 raise error.Abort(
                     _(b'working directory state may be changed parallelly')
                 )
             self._pendingmode = mode
             return fp
 
+        def _readdirstatefile(self, size=-1):
+            try:
+                with self._opendirstatefile() as fp:
+                    return fp.read(size)
+            except IOError as err:
+                if err.errno != errno.ENOENT:
+                    raise
+                # File doesn't exist, so the current state is empty
+                return b''
+
         def setparents(self, p1, p2):
             self._parents = (p1, p2)
             self._dirtyparents = True
 
         def parents(self):
             if not self._parents:
                 if self._use_dirstate_v2:
-                    offset = len(rustmod.V2_FORMAT_MARKER)
+                    self._parents = self.docket.parents
                 else:
-                    offset = 0
-                read_len = offset + self._nodelen * 2
-                try:
-                    fp = self._opendirstatefile()
-                    st = fp.read(read_len)
-                    fp.close()
-                except IOError as err:
-                    if err.errno != errno.ENOENT:
-                        raise
-                    # File doesn't exist, so the current state is empty
-                    st = b''
-
-                l = len(st)
-                if l == read_len:
-                    st = st[offset:]
-                    self._parents = (
-                        st[: self._nodelen],
-                        st[self._nodelen : 2 * self._nodelen],
-                    )
-                elif l == 0:
-                    self._parents = (
-                        self._nodeconstants.nullid,
-                        self._nodeconstants.nullid,
-                    )
-                else:
-                    raise error.Abort(
-                        _(b'working directory state appears damaged!')
-                    )
+                    read_len = self._nodelen * 2
+                    st = self._readdirstatefile(read_len)
+                    l = len(st)
+                    if l == read_len:
+                        self._parents = (
+                            st[: self._nodelen],
+                            st[self._nodelen : 2 * self._nodelen],
+                        )
+                    elif l == 0:
+                        self._parents = (
+                            self._nodeconstants.nullid,
+                            self._nodeconstants.nullid,
+                        )
+                    else:
+                        raise error.Abort(
+                            _(b'working directory state appears damaged!')
+                        )
 
             return self._parents
 
+        @property
+        def docket(self):
+            if not self._docket:
+                if not self._use_dirstate_v2:
+                    raise error.ProgrammingError(
+                        b'dirstate only has a docket in v2 format'
+                    )
+                self._docket = docketmod.DirstateDocket.parse(
+                    self._readdirstatefile(), self._nodeconstants
+                )
+            return self._docket
+
         @propertycache
         def _rustmap(self):
             """
             Fills the Dirstatemap when called.
             """
             # ignore HG_PENDING because identity is used only for writing
             self.identity = util.filestat.frompath(
                 self._opener.join(self._filename)
             )
 
-            try:
-                fp = self._opendirstatefile()
-                try:
-                    st = fp.read()
-                finally:
-                    fp.close()
-            except IOError as err:
-                if err.errno != errno.ENOENT:
-                    raise
-                st = b''
-
-            self._rustmap, parents = rustmod.DirstateMap.new(
-                self._use_dirstate_tree, self._use_dirstate_v2, st
-            )
+            if self._use_dirstate_v2:
+                if self.docket.uuid:
+                    # TODO: use mmap when possible
+                    data = self._opener.read(self.docket.data_filename())
+                else:
+                    data = b''
+                self._rustmap = rustmod.DirstateMap.new_v2(data)
+                parents = self.docket.parents
+            else:
+                self._rustmap, parents = rustmod.DirstateMap.new_v1(
+                    self._use_dirstate_tree, self._readdirstatefile()
+                )
 
             if parents and not self._dirtyparents:
                 self.setparents(*parents)
 
             self.__contains__ = self._rustmap.__contains__
             self.__getitem__ = self._rustmap.__getitem__
             self.get = self._rustmap.get
             return self._rustmap
 
-        def write(self, st, now):
-            parents = self.parents()
-            packed = self._rustmap.write(
-                self._use_dirstate_v2, parents[0], parents[1], now
-            )
-            st.write(packed)
-            st.close()
+        def write(self, tr, st, now):
+            if self._use_dirstate_v2:
+                packed = self._rustmap.write_v2(now)
+                old_docket = self.docket
+                new_docket = docketmod.DirstateDocket.with_new_uuid(
+                    self.parents(), len(packed)
+                )
+                self._opener.write(new_docket.data_filename(), packed)
+                # Write the new docket after the new data file has been
+                # written. Because `st` was opened with `atomictemp=True`,
+                # the actual `.hg/dirstate` file is only affected on close.
+                st.write(new_docket.serialize())
+                st.close()
+                # Remove the old data file after the new docket pointing to
+                # the new data file was written.
+                if old_docket.uuid:
+                    self._opener.unlink(old_docket.data_filename())
+                self._docket = new_docket
+            else:
+                p1, p2 = self.parents()
+                packed = self._rustmap.write_v1(p1, p2, now)
+                st.write(packed)
+                st.close()
             self._dirtyparents = False
 
         @propertycache
         def filefoldmap(self):
             """Returns a dictionary mapping normalized case paths to their
             non-normalized versions.
             """
             return self._rustmap.filefoldmapasdict()
 
         def hastrackeddir(self, d):
             return self._rustmap.hastrackeddir(d)
 
         def hasdir(self, d):
             return self._rustmap.hasdir(d)
 
         @propertycache
         def identity(self):
             self._rustmap
             return self.identity
 
         @property
         def nonnormalset(self):
             nonnorm = self._rustmap.non_normal_entries()
             return nonnorm
 
         @propertycache
         def otherparentset(self):
             otherparents = self._rustmap.other_parent_entries()
             return otherparents
 
         def non_normal_or_other_parent_paths(self):
             return self._rustmap.non_normal_or_other_parent_paths()
 
         @propertycache
         def dirfoldmap(self):
             f = {}
             normcase = util.normcase
             for name, _pseudo_entry in self.directories():
                 f[normcase(name)] = name
             return f

mercurial/upgrade_utils/engine.py

@@ -1,648 +1,649 b''
 # upgrade.py - functions for in place upgrade of Mercurial repository
 #
 # Copyright (c) 2016-present, Gregory Szorc
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import stat
 
 from ..i18n import _
 from ..pycompat import getattr
 from .. import (
     changelog,
     error,
     filelog,
     manifest,
     metadata,
     pycompat,
     requirements,
     scmutil,
     store,
     util,
     vfs as vfsmod,
 )
 from ..revlogutils import (
     constants as revlogconst,
     flagutil,
     nodemap,
     sidedata as sidedatamod,
 )
 from . import actions as upgrade_actions
 
 
 def get_sidedata_helpers(srcrepo, dstrepo):
     use_w = srcrepo.ui.configbool(b'experimental', b'worker.repository-upgrade')
     sequential = pycompat.iswindows or not use_w
     if not sequential:
         srcrepo.register_sidedata_computer(
             revlogconst.KIND_CHANGELOG,
             sidedatamod.SD_FILES,
             (sidedatamod.SD_FILES,),
             metadata._get_worker_sidedata_adder(srcrepo, dstrepo),
             flagutil.REVIDX_HASCOPIESINFO,
             replace=True,
         )
     return sidedatamod.get_sidedata_helpers(srcrepo, dstrepo._wanted_sidedata)
 
 
 def _revlogfrompath(repo, rl_type, path):
     """Obtain a revlog from a repo path.
 
     An instance of the appropriate class is returned.
     """
     if rl_type & store.FILEFLAGS_CHANGELOG:
         return changelog.changelog(repo.svfs)
     elif rl_type & store.FILEFLAGS_MANIFESTLOG:
         mandir = b''
         if b'/' in path:
             mandir = path.rsplit(b'/', 1)[0]
         return manifest.manifestrevlog(
             repo.nodeconstants, repo.svfs, tree=mandir
         )
     else:
         # drop the extension and the `data/` prefix
         path_part = path.rsplit(b'.', 1)[0].split(b'/', 1)
         if len(path_part) < 2:
             msg = _('cannot recognize revlog from filename: %s')
             msg %= path
             raise error.Abort(msg)
         path = path_part[1]
         return filelog.filelog(repo.svfs, path)
 
 
 def _copyrevlog(tr, destrepo, oldrl, rl_type, unencodedname):
     """copy all relevant files for `oldrl` into `destrepo` store
 
     Files are copied "as is" without any transformation. The copy is performed
     without extra checks. Callers are responsible for making sure the copied
     content is compatible with format of the destination repository.
     """
     oldrl = getattr(oldrl, '_revlog', oldrl)
     newrl = _revlogfrompath(destrepo, rl_type, unencodedname)
     newrl = getattr(newrl, '_revlog', newrl)
 
     oldvfs = oldrl.opener
     newvfs = newrl.opener
     oldindex = oldvfs.join(oldrl._indexfile)
     newindex = newvfs.join(newrl._indexfile)
     olddata = oldvfs.join(oldrl._datafile)
     newdata = newvfs.join(newrl._datafile)
 
     with newvfs(newrl._indexfile, b'w'):
         pass  # create all the directories
 
     util.copyfile(oldindex, newindex)
     copydata = oldrl.opener.exists(oldrl._datafile)
     if copydata:
         util.copyfile(olddata, newdata)
 
     if rl_type & store.FILEFLAGS_FILELOG:
         destrepo.svfs.fncache.add(unencodedname)
         if copydata:
             destrepo.svfs.fncache.add(unencodedname[:-2] + b'.d')
 
 
 UPGRADE_CHANGELOG = b"changelog"
 UPGRADE_MANIFEST = b"manifest"
 UPGRADE_FILELOGS = b"all-filelogs"
 
 UPGRADE_ALL_REVLOGS = frozenset(
     [UPGRADE_CHANGELOG, UPGRADE_MANIFEST, UPGRADE_FILELOGS]
 )
 
 
 def matchrevlog(revlogfilter, rl_type):
     """check if a revlog is selected for cloning.
 
     In other words, are there any updates which need to be done on revlog
     or it can be blindly copied.
 
     The store entry is checked against the passed filter"""
     if rl_type & store.FILEFLAGS_CHANGELOG:
         return UPGRADE_CHANGELOG in revlogfilter
     elif rl_type & store.FILEFLAGS_MANIFESTLOG:
         return UPGRADE_MANIFEST in revlogfilter
     assert rl_type & store.FILEFLAGS_FILELOG
     return UPGRADE_FILELOGS in revlogfilter
 
 
 def _perform_clone(
     ui,
     dstrepo,
     tr,
     old_revlog,
     rl_type,
     unencoded,
     upgrade_op,
     sidedata_helpers,
     oncopiedrevision,
 ):
     """returns the new revlog object created"""
     newrl = None
     if matchrevlog(upgrade_op.revlogs_to_process, rl_type):
         ui.note(
             _(b'cloning %d revisions from %s\n') % (len(old_revlog), unencoded)
         )
         newrl = _revlogfrompath(dstrepo, rl_type, unencoded)
         old_revlog.clone(
             tr,
             newrl,
             addrevisioncb=oncopiedrevision,
             deltareuse=upgrade_op.delta_reuse_mode,
             forcedeltabothparents=upgrade_op.force_re_delta_both_parents,
             sidedata_helpers=sidedata_helpers,
         )
     else:
         msg = _(b'blindly copying %s containing %i revisions\n')
         ui.note(msg % (unencoded, len(old_revlog)))
         _copyrevlog(tr, dstrepo, old_revlog, rl_type, unencoded)
 
         newrl = _revlogfrompath(dstrepo, rl_type, unencoded)
     return newrl
 
 
 def _clonerevlogs(
     ui,
     srcrepo,
     dstrepo,
     tr,
     upgrade_op,
 ):
     """Copy revlogs between 2 repos."""
     revcount = 0
     srcsize = 0
     srcrawsize = 0
     dstsize = 0
     fcount = 0
     frevcount = 0
     fsrcsize = 0
     frawsize = 0
     fdstsize = 0
     mcount = 0
     mrevcount = 0
     msrcsize = 0
     mrawsize = 0
     mdstsize = 0
     crevcount = 0
     csrcsize = 0
     crawsize = 0
     cdstsize = 0
 
     alldatafiles = list(srcrepo.store.walk())
     # mapping of data files which needs to be cloned
     # key is unencoded filename
     # value is revlog_object_from_srcrepo
     manifests = {}
     changelogs = {}
     filelogs = {}
 
     # Perform a pass to collect metadata. This validates we can open all
     # source files and allows a unified progress bar to be displayed.
     for rl_type, unencoded, encoded, size in alldatafiles:
         if not rl_type & store.FILEFLAGS_REVLOG_MAIN:
             continue
 
         # the store.walk function will wrongly pickup transaction backup and
         # get confused. As a quick fix for 5.9 release, we ignore those.
         # (this is not a module constants because it seems better to keep the
         # hack together)
         skip_undo = (
             b'undo.backup.00changelog.i',
             b'undo.backup.00manifest.i',
         )
         if unencoded in skip_undo:
             continue
 
         rl = _revlogfrompath(srcrepo, rl_type, unencoded)
 
         info = rl.storageinfo(
             exclusivefiles=True,
             revisionscount=True,
             trackedsize=True,
             storedsize=True,
         )
 
         revcount += info[b'revisionscount'] or 0
         datasize = info[b'storedsize'] or 0
         rawsize = info[b'trackedsize'] or 0
 
         srcsize += datasize
         srcrawsize += rawsize
 
         # This is for the separate progress bars.
         if rl_type & store.FILEFLAGS_CHANGELOG:
             changelogs[unencoded] = (rl_type, rl)
             crevcount += len(rl)
             csrcsize += datasize
             crawsize += rawsize
         elif rl_type & store.FILEFLAGS_MANIFESTLOG:
             manifests[unencoded] = (rl_type, rl)
             mcount += 1
             mrevcount += len(rl)
             msrcsize += datasize
             mrawsize += rawsize
         elif rl_type & store.FILEFLAGS_FILELOG:
             filelogs[unencoded] = (rl_type, rl)
             fcount += 1
             frevcount += len(rl)
             fsrcsize += datasize
             frawsize += rawsize
         else:
             error.ProgrammingError(b'unknown revlog type')
 
     if not revcount:
         return
 
     ui.status(
         _(
             b'migrating %d total revisions (%d in filelogs, %d in manifests, '
             b'%d in changelog)\n'
         )
         % (revcount, frevcount, mrevcount, crevcount)
     )
     ui.status(
         _(b'migrating %s in store; %s tracked data\n')
         % ((util.bytecount(srcsize), util.bytecount(srcrawsize)))
     )
 
     # Used to keep track of progress.
     progress = None
 
     def oncopiedrevision(rl, rev, node):
         progress.increment()
 
     sidedata_helpers = get_sidedata_helpers(srcrepo, dstrepo)
 
     # Migrating filelogs
     ui.status(
         _(
             b'migrating %d filelogs containing %d revisions '
             b'(%s in store; %s tracked data)\n'
         )
         % (
             fcount,
             frevcount,
             util.bytecount(fsrcsize),
             util.bytecount(frawsize),
         )
     )
     progress = srcrepo.ui.makeprogress(_(b'file revisions'), total=frevcount)
     for unencoded, (rl_type, oldrl) in sorted(filelogs.items()):
         newrl = _perform_clone(
             ui,
             dstrepo,
             tr,
             oldrl,
             rl_type,
             unencoded,
             upgrade_op,
             sidedata_helpers,
             oncopiedrevision,
         )
         info = newrl.storageinfo(storedsize=True)
         fdstsize += info[b'storedsize'] or 0
     ui.status(
         _(
             b'finished migrating %d filelog revisions across %d '
             b'filelogs; change in size: %s\n'
         )
         % (frevcount, fcount, util.bytecount(fdstsize - fsrcsize))
     )
 
     # Migrating manifests
     ui.status(
         _(
             b'migrating %d manifests containing %d revisions '
             b'(%s in store; %s tracked data)\n'
         )
         % (
             mcount,
             mrevcount,
             util.bytecount(msrcsize),
             util.bytecount(mrawsize),
         )
     )
     if progress:
         progress.complete()
     progress = srcrepo.ui.makeprogress(
         _(b'manifest revisions'), total=mrevcount
     )
     for unencoded, (rl_type, oldrl) in sorted(manifests.items()):
         newrl = _perform_clone(
             ui,
             dstrepo,
             tr,
             oldrl,
             rl_type,
             unencoded,
             upgrade_op,
             sidedata_helpers,
             oncopiedrevision,
         )
         info = newrl.storageinfo(storedsize=True)
         mdstsize += info[b'storedsize'] or 0
     ui.status(
         _(
             b'finished migrating %d manifest revisions across %d '
             b'manifests; change in size: %s\n'
         )
         % (mrevcount, mcount, util.bytecount(mdstsize - msrcsize))
     )
 
     # Migrating changelog
     ui.status(
         _(
             b'migrating changelog containing %d revisions '
             b'(%s in store; %s tracked data)\n'
         )
         % (
             crevcount,
             util.bytecount(csrcsize),
             util.bytecount(crawsize),
         )
     )
     if progress:
         progress.complete()
     progress = srcrepo.ui.makeprogress(
         _(b'changelog revisions'), total=crevcount
     )
     for unencoded, (rl_type, oldrl) in sorted(changelogs.items()):
         newrl = _perform_clone(
             ui,
             dstrepo,
             tr,
             oldrl,
             rl_type,
             unencoded,
             upgrade_op,
             sidedata_helpers,
             oncopiedrevision,
         )
         info = newrl.storageinfo(storedsize=True)
         cdstsize += info[b'storedsize'] or 0
     progress.complete()
     ui.status(
         _(
             b'finished migrating %d changelog revisions; change in size: '
             b'%s\n'
         )
         % (crevcount, util.bytecount(cdstsize - csrcsize))
     )
 
     dstsize = fdstsize + mdstsize + cdstsize
     ui.status(
         _(
             b'finished migrating %d total revisions; total change in store '
             b'size: %s\n'
         )
         % (revcount, util.bytecount(dstsize - srcsize))
     )
 
 
 def _files_to_copy_post_revlog_clone(srcrepo):
     """yields files which should be copied to destination after revlogs
     are cloned"""
     for path, kind, st in sorted(srcrepo.store.vfs.readdir(b'', stat=True)):
         # don't copy revlogs as they are already cloned
         if store.revlog_type(path) is not None:
             continue
         # Skip transaction related files.
         if path.startswith(b'undo'):
             continue
         # Only copy regular files.
         if kind != stat.S_IFREG:
             continue
         # Skip other skipped files.
         if path in (b'lock', b'fncache'):
             continue
         # TODO: should we skip cache too?
 
         yield path
 
 
 def _replacestores(currentrepo, upgradedrepo, backupvfs, upgrade_op):
     """Replace the stores after current repository is upgraded
 
     Creates a backup of current repository store at backup path
     Replaces upgraded store files in current repo from upgraded one
 
     Arguments:
       currentrepo: repo object of current repository
       upgradedrepo: repo object of the upgraded data
       backupvfs: vfs object for the backup path
       upgrade_op: upgrade operation object
                   to be used to decide what all is upgraded
     """
     # TODO: don't blindly rename everything in store
     # There can be upgrades where store is not touched at all
     if upgrade_op.backup_store:
         util.rename(currentrepo.spath, backupvfs.join(b'store'))
     else:
         currentrepo.vfs.rmtree(b'store', forcibly=True)
     util.rename(upgradedrepo.spath, currentrepo.spath)
 
 
 def finishdatamigration(ui, srcrepo, dstrepo, requirements):
     """Hook point for extensions to perform additional actions during upgrade.
 
     This function is called after revlogs and store files have been copied but
     before the new store is swapped into the original location.
     """
 
 
 def upgrade(ui, srcrepo, dstrepo, upgrade_op):
     """Do the low-level work of upgrading a repository.
 
     The upgrade is effectively performed as a copy between a source
     repository and a temporary destination repository.
 
     The source repository is unmodified for as long as possible so the
     upgrade can abort at any time without causing loss of service for
     readers and without corrupting the source repository.
     """
     assert srcrepo.currentwlock()
     assert dstrepo.currentwlock()
     backuppath = None
     backupvfs = None
 
     ui.status(
         _(
             b'(it is safe to interrupt this process any time before '
             b'data migration completes)\n'
         )
     )
 
     if upgrade_actions.dirstatev2 in upgrade_op.upgrade_actions:
         ui.status(_(b'upgrading to dirstate-v2 from v1\n'))
         upgrade_dirstate(ui, srcrepo, upgrade_op, b'v1', b'v2')
         upgrade_op.upgrade_actions.remove(upgrade_actions.dirstatev2)
 
     if upgrade_actions.dirstatev2 in upgrade_op.removed_actions:
         ui.status(_(b'downgrading from dirstate-v2 to v1\n'))
         upgrade_dirstate(ui, srcrepo, upgrade_op, b'v2', b'v1')
         upgrade_op.removed_actions.remove(upgrade_actions.dirstatev2)
 
     if not (upgrade_op.upgrade_actions or upgrade_op.removed_actions):
         return
 
     if upgrade_op.requirements_only:
         ui.status(_(b'upgrading repository requirements\n'))
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
     # if there is only one action and that is persistent nodemap upgrade
     # directly write the nodemap file and update requirements instead of going
     # through the whole cloning process
     elif (
         len(upgrade_op.upgrade_actions) == 1
         and b'persistent-nodemap' in upgrade_op.upgrade_actions_names
         and not upgrade_op.removed_actions
     ):
         ui.status(
             _(b'upgrading repository to use persistent nodemap feature\n')
         )
         with srcrepo.transaction(b'upgrade') as tr:
             unfi = srcrepo.unfiltered()
             cl = unfi.changelog
             nodemap.persist_nodemap(tr, cl, force=True)
             # we want to directly operate on the underlying revlog to force
             # create a nodemap file. This is fine since this is upgrade code
             # and it heavily relies on repository being revlog based
             # hence accessing private attributes can be justified
             nodemap.persist_nodemap(
                 tr, unfi.manifestlog._rootstore._revlog, force=True
             )
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
     elif (
         len(upgrade_op.removed_actions) == 1
         and [
             x
             for x in upgrade_op.removed_actions
             if x.name == b'persistent-nodemap'
         ]
         and not upgrade_op.upgrade_actions
     ):
         ui.status(
             _(b'downgrading repository to not use persistent nodemap feature\n')
         )
         with srcrepo.transaction(b'upgrade') as tr:
             unfi = srcrepo.unfiltered()
             cl = unfi.changelog
             nodemap.delete_nodemap(tr, srcrepo, cl)
             # check comment 20 lines above for accessing private attributes
             nodemap.delete_nodemap(
                 tr, srcrepo, unfi.manifestlog._rootstore._revlog
             )
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
     else:
         with dstrepo.transaction(b'upgrade') as tr:
             _clonerevlogs(
                 ui,
                 srcrepo,
                 dstrepo,
                 tr,
                 upgrade_op,
             )
 
         # Now copy other files in the store directory.
         for p in _files_to_copy_post_revlog_clone(srcrepo):
             srcrepo.ui.status(_(b'copying %s\n') % p)
             src = srcrepo.store.rawvfs.join(p)
             dst = dstrepo.store.rawvfs.join(p)
             util.copyfile(src, dst, copystat=True)
 
         finishdatamigration(ui, srcrepo, dstrepo, requirements)
 
         ui.status(_(b'data fully upgraded in a temporary repository\n'))
 
         if upgrade_op.backup_store:
             backuppath = pycompat.mkdtemp(
                 prefix=b'upgradebackup.', dir=srcrepo.path
             )
             backupvfs = vfsmod.vfs(backuppath)
 
             # Make a backup of requires file first, as it is the first to be modified.
             util.copyfile(
                 srcrepo.vfs.join(b'requires'), backupvfs.join(b'requires')
             )
 
         # We install an arbitrary requirement that clients must not support
         # as a mechanism to lock out new clients during the data swap. This is
         # better than allowing a client to continue while the repository is in
         # an inconsistent state.
         ui.status(
             _(
                 b'marking source repository as being upgraded; clients will be '
                 b'unable to read from repository\n'
             )
         )
         scmutil.writereporequirements(
             srcrepo, srcrepo.requirements | {b'upgradeinprogress'}
         )
 
         ui.status(_(b'starting in-place swap of repository data\n'))
         if upgrade_op.backup_store:
             ui.status(
                 _(b'replaced files will be backed up at %s\n') % backuppath
             )
 
         # Now swap in the new store directory. Doing it as a rename should make
         # the operation nearly instantaneous and atomic (at least in well-behaved
         # environments).
         ui.status(_(b'replacing store...\n'))
         tstart = util.timer()
         _replacestores(srcrepo, dstrepo, backupvfs, upgrade_op)
         elapsed = util.timer() - tstart
         ui.status(
             _(
                 b'store replacement complete; repository was inconsistent for '
                 b'%0.1fs\n'
             )
             % elapsed
         )
 
         # We first write the requirements file. Any new requirements will lock
         # out legacy clients.
         ui.status(
             _(
                 b'finalizing requirements file and making repository readable '
                 b'again\n'
             )
         )
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
 
         if upgrade_op.backup_store:
             # The lock file from the old store won't be removed because nothing has a
             # reference to its new location. So clean it up manually. Alternatively, we
             # could update srcrepo.svfs and other variables to point to the new
             # location. This is simpler.
             assert backupvfs is not None  # help pytype
             backupvfs.unlink(b'store/lock')
 
     return backuppath
 
 
 def upgrade_dirstate(ui, srcrepo, upgrade_op, old, new):
     if upgrade_op.backup_store:
         backuppath = pycompat.mkdtemp(
             prefix=b'upgradebackup.', dir=srcrepo.path
         )
         ui.status(_(b'replaced files will be backed up at %s\n') % backuppath)
         backupvfs = vfsmod.vfs(backuppath)
         util.copyfile(
             srcrepo.vfs.join(b'requires'), backupvfs.join(b'requires')
         )
         util.copyfile(
             srcrepo.vfs.join(b'dirstate'), backupvfs.join(b'dirstate')
         )
 
     assert srcrepo.dirstate._use_dirstate_v2 == (old == b'v2')
     srcrepo.dirstate._map._use_dirstate_tree = True
     srcrepo.dirstate._map.preload()
     srcrepo.dirstate._use_dirstate_v2 = new == b'v2'
     srcrepo.dirstate._map._use_dirstate_v2 = srcrepo.dirstate._use_dirstate_v2
     srcrepo.dirstate._dirty = True
+    srcrepo.vfs.unlink(b'dirstate')
     srcrepo.dirstate.write(None)
 
     scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)

rust/hg-core/src/dirstate_tree/dirstate_map.rs

@@ -1,1206 +1,1200 b''
 use bytes_cast::BytesCast;
 use micro_timer::timed;
 use std::borrow::Cow;
 use std::convert::TryInto;
 use std::path::PathBuf;
 
 use super::on_disk;
 use super::on_disk::DirstateV2ParseError;
 use super::path_with_basename::WithBasename;
 use crate::dirstate::parsers::pack_entry;
 use crate::dirstate::parsers::packed_entry_size;
 use crate::dirstate::parsers::parse_dirstate_entries;
 use crate::dirstate::parsers::Timestamp;
 use crate::dirstate::MTIME_UNSET;
 use crate::dirstate::SIZE_FROM_OTHER_PARENT;
 use crate::dirstate::SIZE_NON_NORMAL;
 use crate::dirstate::V1_RANGEMASK;
 use crate::matchers::Matcher;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 use crate::CopyMapIter;
 use crate::DirstateEntry;
 use crate::DirstateError;
 use crate::DirstateParents;
 use crate::DirstateStatus;
 use crate::EntryState;
 use crate::FastHashMap;
 use crate::PatternFileWarning;
 use crate::StateMapIter;
 use crate::StatusError;
 use crate::StatusOptions;
 
 pub struct DirstateMap<'on_disk> {
     /// Contents of the `.hg/dirstate` file
     pub(super) on_disk: &'on_disk [u8],
 
     pub(super) root: ChildNodes<'on_disk>,
 
     /// Number of nodes anywhere in the tree that have `.entry.is_some()`.
     pub(super) nodes_with_entry_count: u32,
 
     /// Number of nodes anywhere in the tree that have
     /// `.copy_source.is_some()`.
     pub(super) nodes_with_copy_source_count: u32,
 
     /// See on_disk::Header
     pub(super) ignore_patterns_hash: on_disk::IgnorePatternsHash,
 }
 
 /// Using a plain `HgPathBuf` of the full path from the repository root as a
 /// map key would also work: all paths in a given map have the same parent
 /// path, so comparing full paths gives the same result as comparing base
 /// names. However `HashMap` would waste time always re-hashing the same
 /// string prefix.
 pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>;
 
 /// Similar to `&'tree Cow<'on_disk, HgPath>`, but can also be returned
 /// for on-disk nodes that don’t actually have a `Cow` to borrow.
 pub(super) enum BorrowedPath<'tree, 'on_disk> {
     InMemory(&'tree HgPathBuf),
     OnDisk(&'on_disk HgPath),
 }
 
 pub(super) enum ChildNodes<'on_disk> {
     InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
     OnDisk(&'on_disk [on_disk::Node]),
 }
 
 pub(super) enum ChildNodesRef<'tree, 'on_disk> {
     InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
     OnDisk(&'on_disk [on_disk::Node]),
 }
 
 pub(super) enum NodeRef<'tree, 'on_disk> {
     InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>),
     OnDisk(&'on_disk on_disk::Node),
 }
 
 impl<'tree, 'on_disk> BorrowedPath<'tree, 'on_disk> {
     pub fn detach_from_tree(&self) -> Cow<'on_disk, HgPath> {
         match *self {
             BorrowedPath::InMemory(in_memory) => Cow::Owned(in_memory.clone()),
             BorrowedPath::OnDisk(on_disk) => Cow::Borrowed(on_disk),
         }
     }
 }
 
 impl<'tree, 'on_disk> std::ops::Deref for BorrowedPath<'tree, 'on_disk> {
     type Target = HgPath;
 
     fn deref(&self) -> &HgPath {
         match *self {
             BorrowedPath::InMemory(in_memory) => in_memory,
             BorrowedPath::OnDisk(on_disk) => on_disk,
         }
     }
 }
 
 impl Default for ChildNodes<'_> {
     fn default() -> Self {
         ChildNodes::InMemory(Default::default())
     }
 }
 
 impl<'on_disk> ChildNodes<'on_disk> {
     pub(super) fn as_ref<'tree>(
         &'tree self,
     ) -> ChildNodesRef<'tree, 'on_disk> {
         match self {
             ChildNodes::InMemory(nodes) => ChildNodesRef::InMemory(nodes),
             ChildNodes::OnDisk(nodes) => ChildNodesRef::OnDisk(nodes),
         }
     }
 
     pub(super) fn is_empty(&self) -> bool {
         match self {
             ChildNodes::InMemory(nodes) => nodes.is_empty(),
             ChildNodes::OnDisk(nodes) => nodes.is_empty(),
         }
     }
 
     pub(super) fn make_mut(
         &mut self,
         on_disk: &'on_disk [u8],
     ) -> Result<
         &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>,
         DirstateV2ParseError,
     > {
         match self {
             ChildNodes::InMemory(nodes) => Ok(nodes),
             ChildNodes::OnDisk(nodes) => {
                 let nodes = nodes
                     .iter()
                     .map(|node| {
                         Ok((
                             node.path(on_disk)?,
                             node.to_in_memory_node(on_disk)?,
                         ))
                     })
                     .collect::<Result<_, _>>()?;
                 *self = ChildNodes::InMemory(nodes);
                 match self {
                     ChildNodes::InMemory(nodes) => Ok(nodes),
                     ChildNodes::OnDisk(_) => unreachable!(),
                 }
             }
         }
     }
 }
 
 impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> {
     pub(super) fn get(
         &self,
         base_name: &HgPath,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
         match self {
             ChildNodesRef::InMemory(nodes) => Ok(nodes
                 .get_key_value(base_name)
                 .map(|(k, v)| NodeRef::InMemory(k, v))),
             ChildNodesRef::OnDisk(nodes) => {
                 let mut parse_result = Ok(());
                 let search_result = nodes.binary_search_by(|node| {
                     match node.base_name(on_disk) {
                         Ok(node_base_name) => node_base_name.cmp(base_name),
                         Err(e) => {
                             parse_result = Err(e);
                             // Dummy comparison result, `search_result` won’t
                             // be used since `parse_result` is an error
                             std::cmp::Ordering::Equal
                         }
                     }
                 });
                 parse_result.map(|()| {
                     search_result.ok().map(|i| NodeRef::OnDisk(&nodes[i]))
                 })
             }
         }
     }
 
     /// Iterate in undefined order
     pub(super) fn iter(
         &self,
     ) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> {
         match self {
             ChildNodesRef::InMemory(nodes) => itertools::Either::Left(
                 nodes.iter().map(|(k, v)| NodeRef::InMemory(k, v)),
             ),
             ChildNodesRef::OnDisk(nodes) => {
                 itertools::Either::Right(nodes.iter().map(NodeRef::OnDisk))
             }
         }
     }
 
     /// Iterate in parallel in undefined order
     pub(super) fn par_iter(
         &self,
     ) -> impl rayon::iter::ParallelIterator<Item = NodeRef<'tree, 'on_disk>>
     {
         use rayon::prelude::*;
         match self {
             ChildNodesRef::InMemory(nodes) => rayon::iter::Either::Left(
                 nodes.par_iter().map(|(k, v)| NodeRef::InMemory(k, v)),
             ),
             ChildNodesRef::OnDisk(nodes) => rayon::iter::Either::Right(
                 nodes.par_iter().map(NodeRef::OnDisk),
             ),
         }
     }
 
     pub(super) fn sorted(&self) -> Vec<NodeRef<'tree, 'on_disk>> {
         match self {
             ChildNodesRef::InMemory(nodes) => {
                 let mut vec: Vec<_> = nodes
                     .iter()
                     .map(|(k, v)| NodeRef::InMemory(k, v))
                     .collect();
                 fn sort_key<'a>(node: &'a NodeRef) -> &'a HgPath {
                     match node {
                         NodeRef::InMemory(path, _node) => path.base_name(),
                         NodeRef::OnDisk(_) => unreachable!(),
                     }
                 }
                 // `sort_unstable_by_key` doesn’t allow keys borrowing from the
                 // value: https://github.com/rust-lang/rust/issues/34162
                 vec.sort_unstable_by(|a, b| sort_key(a).cmp(sort_key(b)));
                 vec
             }
             ChildNodesRef::OnDisk(nodes) => {
                 // Nodes on disk are already sorted
                 nodes.iter().map(NodeRef::OnDisk).collect()
             }
         }
     }
 }
 
 impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> {
     pub(super) fn full_path(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'tree HgPath, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => Ok(path.full_path()),
             NodeRef::OnDisk(node) => node.full_path(on_disk),
         }
     }
 
     /// Returns a `BorrowedPath`, which can be turned into a `Cow<'on_disk,
     /// HgPath>` detached from `'tree`
     pub(super) fn full_path_borrowed(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<BorrowedPath<'tree, 'on_disk>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => match path.full_path() {
                 Cow::Borrowed(on_disk) => Ok(BorrowedPath::OnDisk(on_disk)),
                 Cow::Owned(in_memory) => Ok(BorrowedPath::InMemory(in_memory)),
             },
             NodeRef::OnDisk(node) => {
                 Ok(BorrowedPath::OnDisk(node.full_path(on_disk)?))
             }
         }
     }
 
     pub(super) fn base_name(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'tree HgPath, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => Ok(path.base_name()),
             NodeRef::OnDisk(node) => node.base_name(on_disk),
         }
     }
 
     pub(super) fn children(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()),
             NodeRef::OnDisk(node) => {
                 Ok(ChildNodesRef::OnDisk(node.children(on_disk)?))
             }
         }
     }
 
     pub(super) fn has_copy_source(&self) -> bool {
         match self {
             NodeRef::InMemory(_path, node) => node.copy_source.is_some(),
             NodeRef::OnDisk(node) => node.has_copy_source(),
         }
     }
 
     pub(super) fn copy_source(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => {
                 Ok(node.copy_source.as_ref().map(|s| &**s))
             }
             NodeRef::OnDisk(node) => node.copy_source(on_disk),
         }
     }
 
     pub(super) fn entry(
         &self,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => {
                 Ok(node.data.as_entry().copied())
             }
             NodeRef::OnDisk(node) => node.entry(),
         }
     }
 
     pub(super) fn state(
         &self,
     ) -> Result<Option<EntryState>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => {
                 Ok(node.data.as_entry().map(|entry| entry.state))
             }
             NodeRef::OnDisk(node) => node.state(),
         }
     }
 
     pub(super) fn cached_directory_mtime(
         &self,
     ) -> Option<&'tree on_disk::Timestamp> {
         match self {
             NodeRef::InMemory(_path, node) => match &node.data {
                 NodeData::CachedDirectory { mtime } => Some(mtime),
                 _ => None,
             },
             NodeRef::OnDisk(node) => node.cached_directory_mtime(),
         }
     }
 
     pub(super) fn descendants_with_entry_count(&self) -> u32 {
         match self {
             NodeRef::InMemory(_path, node) => {
                 node.descendants_with_entry_count
             }
             NodeRef::OnDisk(node) => node.descendants_with_entry_count.get(),
         }
     }
 
     pub(super) fn tracked_descendants_count(&self) -> u32 {
         match self {
             NodeRef::InMemory(_path, node) => node.tracked_descendants_count,
             NodeRef::OnDisk(node) => node.tracked_descendants_count.get(),
         }
     }
 }
 
 /// Represents a file or a directory
 #[derive(Default)]
 pub(super) struct Node<'on_disk> {
     pub(super) data: NodeData,
 
     pub(super) copy_source: Option<Cow<'on_disk, HgPath>>,
 
     pub(super) children: ChildNodes<'on_disk>,
 
     /// How many (non-inclusive) descendants of this node have an entry.
     pub(super) descendants_with_entry_count: u32,
 
     /// How many (non-inclusive) descendants of this node have an entry whose
     /// state is "tracked".
     pub(super) tracked_descendants_count: u32,
 }
 
 pub(super) enum NodeData {
     Entry(DirstateEntry),
     CachedDirectory { mtime: on_disk::Timestamp },
     None,
 }
 
 impl Default for NodeData {
     fn default() -> Self {
         NodeData::None
     }
 }
 
 impl NodeData {
     fn has_entry(&self) -> bool {
         match self {
             NodeData::Entry(_) => true,
             _ => false,
         }
     }
 
     fn as_entry(&self) -> Option<&DirstateEntry> {
         match self {
             NodeData::Entry(entry) => Some(entry),
             _ => None,
         }
     }
 }
 
 impl<'on_disk> DirstateMap<'on_disk> {
     pub(super) fn empty(on_disk: &'on_disk [u8]) -> Self {
         Self {
             on_disk,
             root: ChildNodes::default(),
             nodes_with_entry_count: 0,
             nodes_with_copy_source_count: 0,
             ignore_patterns_hash: [0; on_disk::IGNORE_PATTERNS_HASH_LEN],
         }
     }
 
     #[timed]
-    pub fn new_v2(
-        on_disk: &'on_disk [u8],
-    ) -> Result<(Self, Option<DirstateParents>), DirstateError> {
+    pub fn new_v2(on_disk: &'on_disk [u8]) -> Result<Self, DirstateError> {
         Ok(on_disk::read(on_disk)?)
     }
 
     #[timed]
     pub fn new_v1(
         on_disk: &'on_disk [u8],
     ) -> Result<(Self, Option<DirstateParents>), DirstateError> {
         let mut map = Self::empty(on_disk);
         if map.on_disk.is_empty() {
             return Ok((map, None));
         }
 
         let parents = parse_dirstate_entries(
             map.on_disk,
             |path, entry, copy_source| {
                 let tracked = entry.state.is_tracked();
                 let node = Self::get_or_insert_node(
                     map.on_disk,
                     &mut map.root,
                     path,
                     WithBasename::to_cow_borrowed,
                     |ancestor| {
                         if tracked {
                             ancestor.tracked_descendants_count += 1
                         }
                         ancestor.descendants_with_entry_count += 1
                     },
                 )?;
                 assert!(
                     !node.data.has_entry(),
                     "duplicate dirstate entry in read"
                 );
                 assert!(
                     node.copy_source.is_none(),
                     "duplicate dirstate entry in read"
                 );
                 node.data = NodeData::Entry(*entry);
                 node.copy_source = copy_source.map(Cow::Borrowed);
                 map.nodes_with_entry_count += 1;
                 if copy_source.is_some() {
                     map.nodes_with_copy_source_count += 1
                 }
                 Ok(())
             },
         )?;
         let parents = Some(parents.clone());
 
         Ok((map, parents))
     }
 
     fn get_node<'tree>(
         &'tree self,
         path: &HgPath,
     ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
         let mut children = self.root.as_ref();
         let mut components = path.components();
         let mut component =
             components.next().expect("expected at least one components");
         loop {
             if let Some(child) = children.get(component, self.on_disk)? {
                 if let Some(next_component) = components.next() {
                     component = next_component;
                     children = child.children(self.on_disk)?;
                 } else {
                     return Ok(Some(child));
                 }
             } else {
                 return Ok(None);
             }
         }
     }
 
     /// Returns a mutable reference to the node at `path` if it exists
     ///
     /// This takes `root` instead of `&mut self` so that callers can mutate
     /// other fields while the returned borrow is still valid
     fn get_node_mut<'tree>(
         on_disk: &'on_disk [u8],
         root: &'tree mut ChildNodes<'on_disk>,
         path: &HgPath,
     ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {
         let mut children = root;
         let mut components = path.components();
         let mut component =
             components.next().expect("expected at least one components");
         loop {
             if let Some(child) = children.make_mut(on_disk)?.get_mut(component)
             {
                 if let Some(next_component) = components.next() {
                     component = next_component;
                     children = &mut child.children;
                 } else {
                     return Ok(Some(child));
                 }
             } else {
                 return Ok(None);
             }
         }
     }
 
     pub(super) fn get_or_insert<'tree, 'path>(
         &'tree mut self,
         path: &HgPath,
     ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> {
         Self::get_or_insert_node(
             self.on_disk,
             &mut self.root,
             path,
             WithBasename::to_cow_owned,
             |_| {},
         )
     }
 
     pub(super) fn get_or_insert_node<'tree, 'path>(
         on_disk: &'on_disk [u8],
         root: &'tree mut ChildNodes<'on_disk>,
         path: &'path HgPath,
         to_cow: impl Fn(
             WithBasename<&'path HgPath>,
         ) -> WithBasename<Cow<'on_disk, HgPath>>,
         mut each_ancestor: impl FnMut(&mut Node),
     ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> {
         let mut child_nodes = root;
         let mut inclusive_ancestor_paths =
             WithBasename::inclusive_ancestors_of(path);
         let mut ancestor_path = inclusive_ancestor_paths
             .next()
             .expect("expected at least one inclusive ancestor");
         loop {
             // TODO: can we avoid allocating an owned key in cases where the
             // map already contains that key, without introducing double
             // lookup?
             let child_node = child_nodes
                 .make_mut(on_disk)?
                 .entry(to_cow(ancestor_path))
                 .or_default();
             if let Some(next) = inclusive_ancestor_paths.next() {
                 each_ancestor(child_node);
                 ancestor_path = next;
                 child_nodes = &mut child_node.children;
             } else {
                 return Ok(child_node);
             }
         }
     }
 
     fn add_or_remove_file(
         &mut self,
         path: &HgPath,
         old_state: EntryState,
         new_entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         let had_entry = old_state != EntryState::Unknown;
         let tracked_count_increment =
             match (old_state.is_tracked(), new_entry.state.is_tracked()) {
                 (false, true) => 1,
                 (true, false) => -1,
                 _ => 0,
             };
 
         let node = Self::get_or_insert_node(
             self.on_disk,
             &mut self.root,
             path,
             WithBasename::to_cow_owned,
             |ancestor| {
                 if !had_entry {
                     ancestor.descendants_with_entry_count += 1;
                 }
 
                 // We can’t use `+= increment` because the counter is unsigned,
                 // and we want debug builds to detect accidental underflow
                 // through zero
                 match tracked_count_increment {
                     1 => ancestor.tracked_descendants_count += 1,
                     -1 => ancestor.tracked_descendants_count -= 1,
                     _ => {}
                 }
             },
         )?;
         if !had_entry {
             self.nodes_with_entry_count += 1
         }
         node.data = NodeData::Entry(new_entry);
         Ok(())
     }
 
     fn iter_nodes<'tree>(
         &'tree self,
     ) -> impl Iterator<
         Item = Result<NodeRef<'tree, 'on_disk>, DirstateV2ParseError>,
     > + 'tree {
         // Depth first tree traversal.
         //
         // If we could afford internal iteration and recursion,
         // this would look like:
         //
         // ```
         // fn traverse_children(
         //     children: &ChildNodes,
         //     each: &mut impl FnMut(&Node),
         // ) {
         //     for child in children.values() {
         //         traverse_children(&child.children, each);
         //         each(child);
         //     }
         // }
         // ```
         //
         // However we want an external iterator and therefore can’t use the
         // call stack. Use an explicit stack instead:
         let mut stack = Vec::new();
         let mut iter = self.root.as_ref().iter();
         std::iter::from_fn(move || {
             while let Some(child_node) = iter.next() {
                 let children = match child_node.children(self.on_disk) {
                     Ok(children) => children,
                     Err(error) => return Some(Err(error)),
                 };
                 // Pseudo-recursion
                 let new_iter = children.iter();
                 let old_iter = std::mem::replace(&mut iter, new_iter);
                 stack.push((child_node, old_iter));
             }
             // Found the end of a `children.iter()` iterator.
             if let Some((child_node, next_iter)) = stack.pop() {
                 // "Return" from pseudo-recursion by restoring state from the
                 // explicit stack
                 iter = next_iter;
 
                 Some(Ok(child_node))
             } else {
                 // Reached the bottom of the stack, we’re done
                 None
             }
         })
     }
 
     fn clear_known_ambiguous_mtimes(
         &mut self,
         paths: &[impl AsRef<HgPath>],
     ) -> Result<(), DirstateV2ParseError> {
         for path in paths {
             if let Some(node) = Self::get_node_mut(
                 self.on_disk,
                 &mut self.root,
                 path.as_ref(),
             )? {
                 if let NodeData::Entry(entry) = &mut node.data {
                     entry.clear_mtime();
                 }
             }
         }
         Ok(())
     }
 
     /// Return a faillilble iterator of full paths of nodes that have an
     /// `entry` for which the given `predicate` returns true.
     ///
     /// Fallibility means that each iterator item is a `Result`, which may
     /// indicate a parse error of the on-disk dirstate-v2 format. Such errors
     /// should only happen if Mercurial is buggy or a repository is corrupted.
     fn filter_full_paths<'tree>(
         &'tree self,
         predicate: impl Fn(&DirstateEntry) -> bool + 'tree,
     ) -> impl Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + 'tree
     {
         filter_map_results(self.iter_nodes(), move |node| {
             if let Some(entry) = node.entry()? {
                 if predicate(&entry) {
                     return Ok(Some(node.full_path(self.on_disk)?));
                 }
             }
             Ok(None)
         })
     }
 }
 
 /// Like `Iterator::filter_map`, but over a fallible iterator of `Result`s.
 ///
 /// The callback is only called for incoming `Ok` values. Errors are passed
 /// through as-is. In order to let it use the `?` operator the callback is
 /// expected to return a `Result` of `Option`, instead of an `Option` of
 /// `Result`.
 fn filter_map_results<'a, I, F, A, B, E>(
     iter: I,
     f: F,
 ) -> impl Iterator<Item = Result<B, E>> + 'a
 where
     I: Iterator<Item = Result<A, E>> + 'a,
     F: Fn(A) -> Result<Option<B>, E> + 'a,
 {
     iter.filter_map(move |result| match result {
         Ok(node) => f(node).transpose(),
         Err(e) => Some(Err(e)),
     })
 }
 
 impl<'on_disk> super::dispatch::DirstateMapMethods for DirstateMap<'on_disk> {
     fn clear(&mut self) {
         self.root = Default::default();
         self.nodes_with_entry_count = 0;
         self.nodes_with_copy_source_count = 0;
     }
 
     fn add_file(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
         added: bool,
         merged: bool,
         from_p2: bool,
         possibly_dirty: bool,
     ) -> Result<(), DirstateError> {
         let mut entry = entry;
         if added {
             assert!(!possibly_dirty);
             assert!(!from_p2);
             entry.state = EntryState::Added;
             entry.size = SIZE_NON_NORMAL;
             entry.mtime = MTIME_UNSET;
         } else if merged {
             assert!(!possibly_dirty);
             assert!(!from_p2);
             entry.state = EntryState::Merged;
             entry.size = SIZE_FROM_OTHER_PARENT;
             entry.mtime = MTIME_UNSET;
         } else if from_p2 {
             assert!(!possibly_dirty);
             entry.state = EntryState::Normal;
             entry.size = SIZE_FROM_OTHER_PARENT;
             entry.mtime = MTIME_UNSET;
         } else if possibly_dirty {
             entry.state = EntryState::Normal;
             entry.size = SIZE_NON_NORMAL;
             entry.mtime = MTIME_UNSET;
         } else {
             entry.state = EntryState::Normal;
             entry.size = entry.size & V1_RANGEMASK;
             entry.mtime = entry.mtime & V1_RANGEMASK;
         }
 
         let old_state = match self.get(filename)? {
             Some(e) => e.state,
             None => EntryState::Unknown,
         };
 
         Ok(self.add_or_remove_file(filename, old_state, entry)?)
     }
 
     fn remove_file(
         &mut self,
         filename: &HgPath,
         in_merge: bool,
     ) -> Result<(), DirstateError> {
         let old_entry_opt = self.get(filename)?;
         let old_state = match old_entry_opt {
             Some(e) => e.state,
             None => EntryState::Unknown,
         };
         let mut size = 0;
         if in_merge {
             // XXX we should not be able to have 'm' state and 'FROM_P2' if not
             // during a merge. So I (marmoute) am not sure we need the
             // conditionnal at all. Adding double checking this with assert
             // would be nice.
             if let Some(old_entry) = old_entry_opt {
                 // backup the previous state
                 if old_entry.state == EntryState::Merged {
                     size = SIZE_NON_NORMAL;
                 } else if old_entry.state == EntryState::Normal
                     && old_entry.size == SIZE_FROM_OTHER_PARENT
                 {
                     // other parent
                     size = SIZE_FROM_OTHER_PARENT;
                 }
             }
         }
         if size == 0 {
             self.copy_map_remove(filename)?;
         }
         let entry = DirstateEntry {
             state: EntryState::Removed,
             mode: 0,
             size,
             mtime: 0,
         };
         Ok(self.add_or_remove_file(filename, old_state, entry)?)
     }
 
     fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError> {
         let old_state = match self.get(filename)? {
             Some(e) => e.state,
             None => EntryState::Unknown,
         };
         struct Dropped {
             was_tracked: bool,
             had_entry: bool,
             had_copy_source: bool,
         }
 
         /// If this returns `Ok(Some((dropped, removed)))`, then
         ///
         /// * `dropped` is about the leaf node that was at `filename`
         /// * `removed` is whether this particular level of recursion just
         ///   removed a node in `nodes`.
         fn recur<'on_disk>(
             on_disk: &'on_disk [u8],
             nodes: &mut ChildNodes<'on_disk>,
             path: &HgPath,
         ) -> Result<Option<(Dropped, bool)>, DirstateV2ParseError> {
             let (first_path_component, rest_of_path) =
                 path.split_first_component();
             let node = if let Some(node) =
                 nodes.make_mut(on_disk)?.get_mut(first_path_component)
             {
                 node
             } else {
                 return Ok(None);
             };
             let dropped;
             if let Some(rest) = rest_of_path {
                 if let Some((d, removed)) =
                     recur(on_disk, &mut node.children, rest)?
                 {
                     dropped = d;
                     if dropped.had_entry {
                         node.descendants_with_entry_count -= 1;
                     }
                     if dropped.was_tracked {
                         node.tracked_descendants_count -= 1;
                     }
 
                     // Directory caches must be invalidated when removing a
                     // child node
                     if removed {
                         if let NodeData::CachedDirectory { .. } = &node.data {
                             node.data = NodeData::None
                         }
                     }
                 } else {
                     return Ok(None);
                 }
             } else {
                 let had_entry = node.data.has_entry();
                 if had_entry {
                     node.data = NodeData::None
                 }
                 dropped = Dropped {
                     was_tracked: node
                         .data
                         .as_entry()
                         .map_or(false, |entry| entry.state.is_tracked()),
                     had_entry,
                     had_copy_source: node.copy_source.take().is_some(),
                 };
             }
             // After recursion, for both leaf (rest_of_path is None) nodes and
             // parent nodes, remove a node if it just became empty.
             let remove = !node.data.has_entry()
                 && node.copy_source.is_none()
                 && node.children.is_empty();
             if remove {
                 nodes.make_mut(on_disk)?.remove(first_path_component);
             }
             Ok(Some((dropped, remove)))
         }
 
         if let Some((dropped, _removed)) =
             recur(self.on_disk, &mut self.root, filename)?
         {
             if dropped.had_entry {
                 self.nodes_with_entry_count -= 1
             }
             if dropped.had_copy_source {
                 self.nodes_with_copy_source_count -= 1
             }
             Ok(dropped.had_entry)
         } else {
             debug_assert!(!old_state.is_tracked());
             Ok(false)
         }
     }
 
     fn clear_ambiguous_times(
         &mut self,
         filenames: Vec<HgPathBuf>,
         now: i32,
     ) -> Result<(), DirstateV2ParseError> {
         for filename in filenames {
             if let Some(node) =
                 Self::get_node_mut(self.on_disk, &mut self.root, &filename)?
             {
                 if let NodeData::Entry(entry) = &mut node.data {
                     entry.clear_ambiguous_mtime(now);
                 }
             }
         }
         Ok(())
     }
 
     fn non_normal_entries_contains(
         &mut self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         Ok(if let Some(node) = self.get_node(key)? {
             node.entry()?.map_or(false, |entry| entry.is_non_normal())
         } else {
             false
         })
     }
 
     fn non_normal_entries_remove(&mut self, _key: &HgPath) {
         // Do nothing, this `DirstateMap` does not have a separate "non normal
         // entries" set that need to be kept up to date
     }
 
     fn non_normal_or_other_parent_paths(
         &mut self,
     ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
     {
         Box::new(self.filter_full_paths(|entry| {
             entry.is_non_normal() || entry.is_from_other_parent()
         }))
     }
 
     fn set_non_normal_other_parent_entries(&mut self, _force: bool) {
         // Do nothing, this `DirstateMap` does not have a separate "non normal
         // entries" and "from other parent" sets that need to be recomputed
     }
 
     fn iter_non_normal_paths(
         &mut self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         self.iter_non_normal_paths_panic()
     }
 
     fn iter_non_normal_paths_panic(
         &self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         Box::new(self.filter_full_paths(|entry| entry.is_non_normal()))
     }
 
     fn iter_other_parent_paths(
         &mut self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         Box::new(self.filter_full_paths(|entry| entry.is_from_other_parent()))
     }
 
     fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         if let Some(node) = self.get_node(directory)? {
             // A node without a `DirstateEntry` was created to hold child
             // nodes, and is therefore a directory.
             let state = node.state()?;
             Ok(state.is_none() && node.tracked_descendants_count() > 0)
         } else {
             Ok(false)
         }
     }
 
     fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {
         if let Some(node) = self.get_node(directory)? {
             // A node without a `DirstateEntry` was created to hold child
             // nodes, and is therefore a directory.
             let state = node.state()?;
             Ok(state.is_none() && node.descendants_with_entry_count() > 0)
         } else {
             Ok(false)
         }
     }
 
     #[timed]
     fn pack_v1(
         &mut self,
         parents: DirstateParents,
         now: Timestamp,
     ) -> Result<Vec<u8>, DirstateError> {
         let now: i32 = now.0.try_into().expect("time overflow");
         let mut ambiguous_mtimes = Vec::new();
         // Optizimation (to be measured?): pre-compute size to avoid `Vec`
         // reallocations
         let mut size = parents.as_bytes().len();
         for node in self.iter_nodes() {
             let node = node?;
             if let Some(entry) = node.entry()? {
                 size += packed_entry_size(
                     node.full_path(self.on_disk)?,
                     node.copy_source(self.on_disk)?,
                 );
                 if entry.mtime_is_ambiguous(now) {
                     ambiguous_mtimes.push(
                         node.full_path_borrowed(self.on_disk)?
                             .detach_from_tree(),
                     )
                 }
             }
         }
         self.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?;
 
         let mut packed = Vec::with_capacity(size);
         packed.extend(parents.as_bytes());
 
         for node in self.iter_nodes() {
             let node = node?;
             if let Some(entry) = node.entry()? {
                 pack_entry(
                     node.full_path(self.on_disk)?,
                     &entry,
                     node.copy_source(self.on_disk)?,
                     &mut packed,
                 );
             }
         }
         Ok(packed)
     }
 
     #[timed]
-    fn pack_v2(
-        &mut self,
-        parents: DirstateParents,
-        now: Timestamp,
-    ) -> Result<Vec<u8>, DirstateError> {
+    fn pack_v2(&mut self, now: Timestamp) -> Result<Vec<u8>, DirstateError> {
         // TODO: how do we want to handle this in 2038?
         let now: i32 = now.0.try_into().expect("time overflow");
         let mut paths = Vec::new();
         for node in self.iter_nodes() {
             let node = node?;
             if let Some(entry) = node.entry()? {
                 if entry.mtime_is_ambiguous(now) {
                     paths.push(
                         node.full_path_borrowed(self.on_disk)?
                             .detach_from_tree(),
                     )
                 }
             }
         }
         // Borrow of `self` ends here since we collect cloned paths
 
         self.clear_known_ambiguous_mtimes(&paths)?;
 
-        on_disk::write(self, parents)
+        on_disk::write(self)
     }
 
     fn status<'a>(
         &'a mut self,
         matcher: &'a (dyn Matcher + Sync),
         root_dir: PathBuf,
         ignore_files: Vec<PathBuf>,
         options: StatusOptions,
     ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
     {
         super::status::status(self, matcher, root_dir, ignore_files, options)
     }
 
     fn copy_map_len(&self) -> usize {
         self.nodes_with_copy_source_count as usize
     }
 
     fn copy_map_iter(&self) -> CopyMapIter<'_> {
         Box::new(filter_map_results(self.iter_nodes(), move |node| {
             Ok(if let Some(source) = node.copy_source(self.on_disk)? {
                 Some((node.full_path(self.on_disk)?, source))
             } else {
                 None
             })
         }))
     }
 
     fn copy_map_contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         Ok(if let Some(node) = self.get_node(key)? {
             node.has_copy_source()
         } else {
             false
         })
     }
 
     fn copy_map_get(
         &self,
         key: &HgPath,
     ) -> Result<Option<&HgPath>, DirstateV2ParseError> {
         if let Some(node) = self.get_node(key)? {
             if let Some(source) = node.copy_source(self.on_disk)? {
                 return Ok(Some(source));
             }
         }
         Ok(None)
     }
 
     fn copy_map_remove(
         &mut self,
         key: &HgPath,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         let count = &mut self.nodes_with_copy_source_count;
         Ok(
             Self::get_node_mut(self.on_disk, &mut self.root, key)?.and_then(
                 |node| {
                     if node.copy_source.is_some() {
                         *count -= 1
                     }
                     node.copy_source.take().map(Cow::into_owned)
                 },
             ),
         )
     }
 
     fn copy_map_insert(
         &mut self,
         key: HgPathBuf,
         value: HgPathBuf,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         let node = Self::get_or_insert_node(
             self.on_disk,
             &mut self.root,
             &key,
             WithBasename::to_cow_owned,
             |_ancestor| {},
         )?;
         if node.copy_source.is_none() {
             self.nodes_with_copy_source_count += 1
         }
         Ok(node.copy_source.replace(value.into()).map(Cow::into_owned))
     }
 
     fn len(&self) -> usize {
         self.nodes_with_entry_count as usize
     }
 
     fn contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         Ok(self.get(key)?.is_some())
     }
 
     fn get(
         &self,
         key: &HgPath,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         Ok(if let Some(node) = self.get_node(key)? {
             node.entry()?
         } else {
             None
         })
     }
 
     fn iter(&self) -> StateMapIter<'_> {
         Box::new(filter_map_results(self.iter_nodes(), move |node| {
             Ok(if let Some(entry) = node.entry()? {
                 Some((node.full_path(self.on_disk)?, entry))
             } else {
                 None
             })
         }))
     }
 
     fn iter_directories(
         &self,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, Option<Timestamp>),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     > {
         Box::new(filter_map_results(self.iter_nodes(), move |node| {
             Ok(if node.state()?.is_none() {
                 Some((
                     node.full_path(self.on_disk)?,
                     node.cached_directory_mtime()
                         .map(|mtime| Timestamp(mtime.seconds())),
                 ))
             } else {
                 None
             })
         }))
     }
 }

rust/hg-core/src/dirstate_tree/dispatch.rs

@@ -1,487 +1,479 b''
 use std::path::PathBuf;
 
 use crate::dirstate::parsers::Timestamp;
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::matchers::Matcher;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 use crate::CopyMapIter;
 use crate::DirstateEntry;
 use crate::DirstateError;
 use crate::DirstateMap;
 use crate::DirstateParents;
 use crate::DirstateStatus;
 use crate::PatternFileWarning;
 use crate::StateMapIter;
 use crate::StatusError;
 use crate::StatusOptions;
 
 /// `rust/hg-cpython/src/dirstate/dirstate_map.rs` implements in Rust a
 /// `DirstateMap` Python class that wraps `Box<dyn DirstateMapMethods + Send>`,
 /// a trait object of this trait. Except for constructors, this trait defines
 /// all APIs that the class needs to interact with its inner dirstate map.
 ///
 /// A trait object is used to support two different concrete types:
 ///
 /// * `rust/hg-core/src/dirstate/dirstate_map.rs` defines the "flat dirstate
 ///   map" which is based on a few large `HgPath`-keyed `HashMap` and `HashSet`
 ///   fields.
 /// * `rust/hg-core/src/dirstate_tree/dirstate_map.rs` defines the "tree
 ///   dirstate map" based on a tree data struture with nodes for directories
 ///   containing child nodes for their files and sub-directories. This tree
 ///   enables a more efficient algorithm for `hg status`, but its details are
 ///   abstracted in this trait.
 ///
 /// The dirstate map associates paths of files in the working directory to
 /// various information about the state of those files.
 pub trait DirstateMapMethods {
     /// Remove information about all files in this map
     fn clear(&mut self);
 
     /// Add or change the information associated to a given file.
     ///
     /// `old_state` is the state in the entry that `get` would have returned
     /// before this call, or `EntryState::Unknown` if there was no such entry.
     ///
     /// `entry.state` should never be `EntryState::Unknown`.
     fn add_file(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
         added: bool,
         merged: bool,
         from_p2: bool,
         possibly_dirty: bool,
     ) -> Result<(), DirstateError>;
 
     /// Mark a file as "removed" (as in `hg rm`).
     ///
     /// `old_state` is the state in the entry that `get` would have returned
     /// before this call, or `EntryState::Unknown` if there was no such entry.
     ///
     /// `size` is not actually a size but the 0 or -1 or -2 value that would be
     /// put in the size field in the dirstate-v1 format.
     fn remove_file(
         &mut self,
         filename: &HgPath,
         in_merge: bool,
     ) -> Result<(), DirstateError>;
 
     /// Drop information about this file from the map if any, and return
     /// whether there was any.
     ///
     /// `get` will now return `None` for this filename.
     ///
     /// `old_state` is the state in the entry that `get` would have returned
     /// before this call, or `EntryState::Unknown` if there was no such entry.
     fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError>;
 
     /// Among given files, mark the stored `mtime` as ambiguous if there is one
     /// (if `state == EntryState::Normal`) equal to the given current Unix
     /// timestamp.
     fn clear_ambiguous_times(
         &mut self,
         filenames: Vec<HgPathBuf>,
         now: i32,
     ) -> Result<(), DirstateV2ParseError>;
 
     /// Return whether the map has an "non-normal" entry for the given
     /// filename. That is, any entry with a `state` other than
     /// `EntryState::Normal` or with an ambiguous `mtime`.
     fn non_normal_entries_contains(
         &mut self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError>;
 
     /// Mark the given path as "normal" file. This is only relevant in the flat
     /// dirstate map where there is a separate `HashSet` that needs to be kept
     /// up to date.
     fn non_normal_entries_remove(&mut self, key: &HgPath);
 
     /// Return an iterator of paths whose respective entry are either
     /// "non-normal" (see `non_normal_entries_contains`) or "from other
     /// parent".
     ///
     /// If that information is cached, create the cache as needed.
     ///
     /// "From other parent" is defined as `state == Normal && size == -2`.
     ///
     /// Because parse errors can happen during iteration, the iterated items
     /// are `Result`s.
     fn non_normal_or_other_parent_paths(
         &mut self,
     ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>;
 
     /// Create the cache for `non_normal_or_other_parent_paths` if needed.
     ///
     /// If `force` is true, the cache is re-created even if it already exists.
     fn set_non_normal_other_parent_entries(&mut self, force: bool);
 
     /// Return an iterator of paths whose respective entry are "non-normal"
     /// (see `non_normal_entries_contains`).
     ///
     /// If that information is cached, create the cache as needed.
     ///
     /// Because parse errors can happen during iteration, the iterated items
     /// are `Result`s.
     fn iter_non_normal_paths(
         &mut self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     >;
 
     /// Same as `iter_non_normal_paths`, but takes `&self` instead of `&mut
     /// self`.
     ///
     /// Panics if a cache is necessary but does not exist yet.
     fn iter_non_normal_paths_panic(
         &self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     >;
 
     /// Return an iterator of paths whose respective entry are "from other
     /// parent".
     ///
     /// If that information is cached, create the cache as needed.
     ///
     /// "From other parent" is defined as `state == Normal && size == -2`.
     ///
     /// Because parse errors can happen during iteration, the iterated items
     /// are `Result`s.
     fn iter_other_parent_paths(
         &mut self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     >;
 
     /// Returns whether the sub-tree rooted at the given directory contains any
     /// tracked file.
     ///
     /// A file is tracked if it has a `state` other than `EntryState::Removed`.
     fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError>;
 
     /// Returns whether the sub-tree rooted at the given directory contains any
     /// file with a dirstate entry.
     fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError>;
 
     /// Clear mtimes that are ambigous with `now` (similar to
     /// `clear_ambiguous_times` but for all files in the dirstate map), and
     /// serialize bytes to write the `.hg/dirstate` file to disk in dirstate-v1
     /// format.
     fn pack_v1(
         &mut self,
         parents: DirstateParents,
         now: Timestamp,
     ) -> Result<Vec<u8>, DirstateError>;
 
     /// Clear mtimes that are ambigous with `now` (similar to
     /// `clear_ambiguous_times` but for all files in the dirstate map), and
     /// serialize bytes to write the `.hg/dirstate` file to disk in dirstate-v2
     /// format.
     ///
     /// Note: this is only supported by the tree dirstate map.
-    fn pack_v2(
-        &mut self,
-        parents: DirstateParents,
-        now: Timestamp,
-    ) -> Result<Vec<u8>, DirstateError>;
+    fn pack_v2(&mut self, now: Timestamp) -> Result<Vec<u8>, DirstateError>;
 
     /// Run the status algorithm.
     ///
     /// This is not sematically a method of the dirstate map, but a different
     /// algorithm is used for the flat v.s. tree dirstate map so having it in
     /// this trait enables the same dynamic dispatch as with other methods.
     fn status<'a>(
         &'a mut self,
         matcher: &'a (dyn Matcher + Sync),
         root_dir: PathBuf,
         ignore_files: Vec<PathBuf>,
         options: StatusOptions,
     ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;
 
     /// Returns how many files in the dirstate map have a recorded copy source.
     fn copy_map_len(&self) -> usize;
 
     /// Returns an iterator of `(path, copy_source)` for all files that have a
     /// copy source.
     fn copy_map_iter(&self) -> CopyMapIter<'_>;
 
     /// Returns whether the givef file has a copy source.
     fn copy_map_contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError>;
 
     /// Returns the copy source for the given file.
     fn copy_map_get(
         &self,
         key: &HgPath,
     ) -> Result<Option<&HgPath>, DirstateV2ParseError>;
 
     /// Removes the recorded copy source if any for the given file, and returns
     /// it.
     fn copy_map_remove(
         &mut self,
         key: &HgPath,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError>;
 
     /// Set the given `value` copy source for the given `key` file.
     fn copy_map_insert(
         &mut self,
         key: HgPathBuf,
         value: HgPathBuf,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError>;
 
     /// Returns the number of files that have an entry.
     fn len(&self) -> usize;
 
     /// Returns whether the given file has an entry.
     fn contains_key(&self, key: &HgPath)
         -> Result<bool, DirstateV2ParseError>;
 
     /// Returns the entry, if any, for the given file.
     fn get(
         &self,
         key: &HgPath,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError>;
 
     /// Returns a `(path, entry)` iterator of files that have an entry.
     ///
     /// Because parse errors can happen during iteration, the iterated items
     /// are `Result`s.
     fn iter(&self) -> StateMapIter<'_>;
 
     /// In the tree dirstate, return an iterator of "directory" (entry-less)
     /// nodes with the data stored for them. This is for `hg debugdirstate
     /// --dirs`.
     ///
     /// In the flat dirstate, returns an empty iterator.
     ///
     /// Because parse errors can happen during iteration, the iterated items
     /// are `Result`s.
     fn iter_directories(
         &self,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, Option<Timestamp>),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     >;
 }
 
 impl DirstateMapMethods for DirstateMap {
     fn clear(&mut self) {
         self.clear()
     }
 
     fn add_file(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
         added: bool,
         merged: bool,
         from_p2: bool,
         possibly_dirty: bool,
     ) -> Result<(), DirstateError> {
         self.add_file(filename, entry, added, merged, from_p2, possibly_dirty)
     }
 
     fn remove_file(
         &mut self,
         filename: &HgPath,
         in_merge: bool,
     ) -> Result<(), DirstateError> {
         self.remove_file(filename, in_merge)
     }
 
     fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError> {
         self.drop_file(filename)
     }
 
     fn clear_ambiguous_times(
         &mut self,
         filenames: Vec<HgPathBuf>,
         now: i32,
     ) -> Result<(), DirstateV2ParseError> {
         Ok(self.clear_ambiguous_times(filenames, now))
     }
 
     fn non_normal_entries_contains(
         &mut self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         let (non_normal, _other_parent) =
             self.get_non_normal_other_parent_entries();
         Ok(non_normal.contains(key))
     }
 
     fn non_normal_entries_remove(&mut self, key: &HgPath) {
         self.non_normal_entries_remove(key)
     }
 
     fn non_normal_or_other_parent_paths(
         &mut self,
     ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
     {
         let (non_normal, other_parent) =
             self.get_non_normal_other_parent_entries();
         Box::new(non_normal.union(other_parent).map(|p| Ok(&**p)))
     }
 
     fn set_non_normal_other_parent_entries(&mut self, force: bool) {
         self.set_non_normal_other_parent_entries(force)
     }
 
     fn iter_non_normal_paths(
         &mut self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         let (non_normal, _other_parent) =
             self.get_non_normal_other_parent_entries();
         Box::new(non_normal.iter().map(|p| Ok(&**p)))
     }
 
     fn iter_non_normal_paths_panic(
         &self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         let (non_normal, _other_parent) =
             self.get_non_normal_other_parent_entries_panic();
         Box::new(non_normal.iter().map(|p| Ok(&**p)))
     }
 
     fn iter_other_parent_paths(
         &mut self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         let (_non_normal, other_parent) =
             self.get_non_normal_other_parent_entries();
         Box::new(other_parent.iter().map(|p| Ok(&**p)))
     }
 
     fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.has_tracked_dir(directory)
     }
 
     fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {
         self.has_dir(directory)
     }
 
     fn pack_v1(
         &mut self,
         parents: DirstateParents,
         now: Timestamp,
     ) -> Result<Vec<u8>, DirstateError> {
         self.pack(parents, now)
     }
 
-    fn pack_v2(
-        &mut self,
-        _parents: DirstateParents,
-        _now: Timestamp,
-    ) -> Result<Vec<u8>, DirstateError> {
+    fn pack_v2(&mut self, _now: Timestamp) -> Result<Vec<u8>, DirstateError> {
         panic!(
             "should have used dirstate_tree::DirstateMap to use the v2 format"
         )
     }
 
     fn status<'a>(
         &'a mut self,
         matcher: &'a (dyn Matcher + Sync),
         root_dir: PathBuf,
         ignore_files: Vec<PathBuf>,
         options: StatusOptions,
     ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
     {
         crate::status(self, matcher, root_dir, ignore_files, options)
     }
 
     fn copy_map_len(&self) -> usize {
         self.copy_map.len()
     }
 
     fn copy_map_iter(&self) -> CopyMapIter<'_> {
         Box::new(
             self.copy_map
                 .iter()
                 .map(|(key, value)| Ok((&**key, &**value))),
         )
     }
 
     fn copy_map_contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         Ok(self.copy_map.contains_key(key))
     }
 
     fn copy_map_get(
         &self,
         key: &HgPath,
     ) -> Result<Option<&HgPath>, DirstateV2ParseError> {
         Ok(self.copy_map.get(key).map(|p| &**p))
     }
 
     fn copy_map_remove(
         &mut self,
         key: &HgPath,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         Ok(self.copy_map.remove(key))
     }
 
     fn copy_map_insert(
         &mut self,
         key: HgPathBuf,
         value: HgPathBuf,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         Ok(self.copy_map.insert(key, value))
     }
 
     fn len(&self) -> usize {
         (&**self).len()
     }
 
     fn contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         Ok((&**self).contains_key(key))
     }
 
     fn get(
         &self,
         key: &HgPath,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         Ok((&**self).get(key).cloned())
     }
 
     fn iter(&self) -> StateMapIter<'_> {
         Box::new((&**self).iter().map(|(key, value)| Ok((&**key, *value))))
     }
 
     fn iter_directories(
         &self,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, Option<Timestamp>),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     > {
         Box::new(std::iter::empty())
     }
 }

rust/hg-core/src/dirstate_tree/on_disk.rs

@@ -1,609 +1,636 b''
 //! The "version 2" disk representation of the dirstate
 //!
 //! # File format
 //!
 //! The file starts with a fixed-sized header, whose layout is defined by the
 //! `Header` struct. Its `root` field contains the slice (offset and length) to
 //! the nodes representing the files and directories at the root of the
 //! repository. Each node is also fixed-size, defined by the `Node` struct.
 //! Nodes in turn contain slices to variable-size paths, and to their own child
 //! nodes (if any) for nested files and directories.
 
 use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef};
 use crate::dirstate_tree::path_with_basename::WithBasename;
 use crate::errors::HgError;
 use crate::utils::hg_path::HgPath;
 use crate::DirstateEntry;
 use crate::DirstateError;
 use crate::DirstateParents;
 use crate::EntryState;
 use bytes_cast::unaligned::{I32Be, I64Be, U32Be};
 use bytes_cast::BytesCast;
+use format_bytes::format_bytes;
 use std::borrow::Cow;
 use std::convert::TryFrom;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 /// Added at the start of `.hg/dirstate` when the "v2" format is used.
 /// This a redundant sanity check more than an actual "magic number" since
 /// `.hg/requires` already governs which format should be used.
 pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n";
 
+/// Keep space for 256-bit hashes
+const STORED_NODE_ID_BYTES: usize = 32;
+
+/// … even though only 160 bits are used for now, with SHA-1
+const USED_NODE_ID_BYTES: usize = 20;
+
 pub(super) const IGNORE_PATTERNS_HASH_LEN: usize = 20;
 pub(super) type IgnorePatternsHash = [u8; IGNORE_PATTERNS_HASH_LEN];
 
+// Must match `HEADER` in `mercurial/dirstateutils/docket.py`
+#[derive(BytesCast)]
+#[repr(C)]
+struct DocketHeader {
+    marker: [u8; V2_FORMAT_MARKER.len()],
+    parent_1: [u8; STORED_NODE_ID_BYTES],
+    parent_2: [u8; STORED_NODE_ID_BYTES],
+    data_size: Size,
+    uuid_size: u8,
+}
+
+pub struct Docket<'on_disk> {
+    header: &'on_disk DocketHeader,
+    uuid: &'on_disk [u8],
+}
+
 #[derive(BytesCast)]
 #[repr(C)]
 struct Header {
-    marker: [u8; V2_FORMAT_MARKER.len()],
-
-    /// `dirstatemap.parents()` in `mercurial/dirstate.py` relies on this
-    /// `parents` field being at this offset, immediately after `marker`.
-    parents: DirstateParents,
-
     root: ChildNodes,
     nodes_with_entry_count: Size,
     nodes_with_copy_source_count: Size,
 
     /// If non-zero, a hash of ignore files that were used for some previous
     /// run of the `status` algorithm.
     ///
     /// We define:
     ///
     /// * "Root" ignore files are `.hgignore` at the root of the repository if
     ///   it exists, and files from `ui.ignore.*` config. This set of files is
     ///   then sorted by the string representation of their path.
     /// * The "expanded contents" of an ignore files is the byte string made
     ///   by concatenating its contents with the "expanded contents" of other
     ///   files included with `include:` or `subinclude:` files, in inclusion
     ///   order. This definition is recursive, as included files can
     ///   themselves include more files.
     ///
     /// This hash is defined as the SHA-1 of the concatenation (in sorted
     /// order) of the "expanded contents" of each "root" ignore file.
     /// (Note that computing this does not require actually concatenating byte
     /// strings into contiguous memory, instead SHA-1 hashing can be done
     /// incrementally.)
     ignore_patterns_hash: IgnorePatternsHash,
 }
 
 #[derive(BytesCast)]
 #[repr(C)]
 pub(super) struct Node {
     full_path: PathSlice,
 
     /// In bytes from `self.full_path.start`
     base_name_start: Size,
 
     copy_source: OptPathSlice,
     children: ChildNodes,
     pub(super) descendants_with_entry_count: Size,
     pub(super) tracked_descendants_count: Size,
 
     /// Depending on the value of `state`:
     ///
     /// * A null byte: `data` is not used.
     ///
     /// * A `n`, `a`, `r`, or `m` ASCII byte: `state` and `data` together
     ///   represent a dirstate entry like in the v1 format.
     ///
     /// * A `d` ASCII byte: the bytes of `data` should instead be interpreted
     ///   as the `Timestamp` for the mtime of a cached directory.
     ///
     ///   The presence of this state means that at some point, this path in
     ///   the working directory was observed:
     ///
     ///   - To be a directory
     ///   - With the modification time as given by `Timestamp`
     ///   - That timestamp was already strictly in the past when observed,
     ///     meaning that later changes cannot happen in the same clock tick
     ///     and must cause a different modification time (unless the system
     ///     clock jumps back and we get unlucky, which is not impossible but
     ///     but deemed unlikely enough).
     ///   - All direct children of this directory (as returned by
     ///     `std::fs::read_dir`) either have a corresponding dirstate node, or
     ///     are ignored by ignore patterns whose hash is in
     ///     `Header::ignore_patterns_hash`.
     ///
     ///   This means that if `std::fs::symlink_metadata` later reports the
     ///   same modification time and ignored patterns haven’t changed, a run
     ///   of status that is not listing ignored   files can skip calling
     ///   `std::fs::read_dir` again for this directory,   iterate child
     ///   dirstate nodes instead.
     state: u8,
     data: Entry,
 }
 
 #[derive(BytesCast, Copy, Clone)]
 #[repr(C)]
 struct Entry {
     mode: I32Be,
     mtime: I32Be,
     size: I32Be,
 }
 
 /// Duration since the Unix epoch
 #[derive(BytesCast, Copy, Clone, PartialEq)]
 #[repr(C)]
 pub(super) struct Timestamp {
     seconds: I64Be,
 
     /// In `0 .. 1_000_000_000`.
     ///
     /// This timestamp is later or earlier than `(seconds, 0)` by this many
     /// nanoseconds, if `seconds` is non-negative or negative, respectively.
     nanoseconds: U32Be,
 }
 
 /// Counted in bytes from the start of the file
 ///
 /// NOTE: not supporting `.hg/dirstate` files larger than 4 GiB.
 type Offset = U32Be;
 
 /// Counted in number of items
 ///
 /// NOTE: not supporting directories with more than 4 billion direct children,
 /// or filenames more than 4 GiB.
 type Size = U32Be;
 
 /// Location of consecutive, fixed-size items.
 ///
 /// An item can be a single byte for paths, or a struct with
 /// `derive(BytesCast)`.
 #[derive(BytesCast, Copy, Clone)]
 #[repr(C)]
 struct Slice {
     start: Offset,
     len: Size,
 }
 
 /// A contiguous sequence of `len` times `Node`, representing the child nodes
 /// of either some other node or of the repository root.
 ///
 /// Always sorted by ascending `full_path`, to allow binary search.
 /// Since nodes with the same parent nodes also have the same parent path,
 /// only the `base_name`s need to be compared during binary search.
 type ChildNodes = Slice;
 
 /// A `HgPath` of `len` bytes
 type PathSlice = Slice;
 
 /// Either nothing if `start == 0`, or a `HgPath` of `len` bytes
 type OptPathSlice = Slice;
 
 /// Make sure that size-affecting changes are made knowingly
 fn _static_assert_size_of() {
-    let _ = std::mem::transmute::<Header, [u8; 88]>;
+    let _ = std::mem::transmute::<DocketHeader, [u8; 81]>;
+    let _ = std::mem::transmute::<Header, [u8; 36]>;
     let _ = std::mem::transmute::<Node, [u8; 49]>;
 }
 
 /// Unexpected file format found in `.hg/dirstate` with the "v2" format.
 ///
 /// This should only happen if Mercurial is buggy or a repository is corrupted.
 #[derive(Debug)]
 pub struct DirstateV2ParseError;
 
 impl From<DirstateV2ParseError> for HgError {
     fn from(_: DirstateV2ParseError) -> Self {
         HgError::corrupted("dirstate-v2 parse error")
     }
 }
 
 impl From<DirstateV2ParseError> for crate::DirstateError {
     fn from(error: DirstateV2ParseError) -> Self {
         HgError::from(error).into()
     }
 }
 
-fn read_header(on_disk: &[u8]) -> Result<&Header, DirstateV2ParseError> {
-    let (header, _) =
-        Header::from_bytes(on_disk).map_err(|_| DirstateV2ParseError)?;
-    if header.marker == *V2_FORMAT_MARKER {
-        Ok(header)
+impl<'on_disk> Docket<'on_disk> {
+    pub fn parents(&self) -> DirstateParents {
+        use crate::Node;
+        let p1 = Node::try_from(&self.header.parent_1[..USED_NODE_ID_BYTES])
+            .unwrap()
+            .clone();
+        let p2 = Node::try_from(&self.header.parent_2[..USED_NODE_ID_BYTES])
+            .unwrap()
+            .clone();
+        DirstateParents { p1, p2 }
+    }
+
+    pub fn data_filename(&self) -> String {
+        String::from_utf8(format_bytes!(b"dirstate.{}.d", self.uuid)).unwrap()
+    }
+}
+
+pub fn read_docket(
+    on_disk: &[u8],
+) -> Result<Docket<'_>, DirstateV2ParseError> {
+    let (header, uuid) =
+        DocketHeader::from_bytes(on_disk).map_err(|_| DirstateV2ParseError)?;
+    let uuid_size = header.uuid_size as usize;
+    if header.marker == *V2_FORMAT_MARKER && uuid.len() == uuid_size {
+        Ok(Docket { header, uuid })
     } else {
         Err(DirstateV2ParseError)
     }
 }
 
 pub(super) fn read<'on_disk>(
     on_disk: &'on_disk [u8],
-) -> Result<
-    (DirstateMap<'on_disk>, Option<DirstateParents>),
-    DirstateV2ParseError,
-> {
+) -> Result<DirstateMap<'on_disk>, DirstateV2ParseError> {
     if on_disk.is_empty() {
-        return Ok((DirstateMap::empty(on_disk), None));
+        return Ok(DirstateMap::empty(on_disk));
     }
-    let header = read_header(on_disk)?;
+    let (header, _) =
+        Header::from_bytes(on_disk).map_err(|_| DirstateV2ParseError)?;
     let dirstate_map = DirstateMap {
         on_disk,
         root: dirstate_map::ChildNodes::OnDisk(read_slice::<Node>(
             on_disk,
             header.root,
         )?),
         nodes_with_entry_count: header.nodes_with_entry_count.get(),
         nodes_with_copy_source_count: header
             .nodes_with_copy_source_count
             .get(),
         ignore_patterns_hash: header.ignore_patterns_hash,
     };
-    let parents = Some(header.parents.clone());
-    Ok((dirstate_map, parents))
+    Ok(dirstate_map)
 }
 
 impl Node {
     pub(super) fn full_path<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
         read_hg_path(on_disk, self.full_path)
     }
 
     pub(super) fn base_name_start<'on_disk>(
         &self,
     ) -> Result<usize, DirstateV2ParseError> {
         let start = self.base_name_start.get();
         if start < self.full_path.len.get() {
             let start = usize::try_from(start)
                 // u32 -> usize, could only panic on a 16-bit CPU
                 .expect("dirstate-v2 base_name_start out of bounds");
             Ok(start)
         } else {
             Err(DirstateV2ParseError)
         }
     }
 
     pub(super) fn base_name<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
         let full_path = self.full_path(on_disk)?;
         let base_name_start = self.base_name_start()?;
         Ok(HgPath::new(&full_path.as_bytes()[base_name_start..]))
     }
 
     pub(super) fn path<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<dirstate_map::NodeKey<'on_disk>, DirstateV2ParseError> {
         Ok(WithBasename::from_raw_parts(
             Cow::Borrowed(self.full_path(on_disk)?),
             self.base_name_start()?,
         ))
     }
 
     pub(super) fn has_copy_source<'on_disk>(&self) -> bool {
         self.copy_source.start.get() != 0
     }
 
     pub(super) fn copy_source<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<&'on_disk HgPath>, DirstateV2ParseError> {
         Ok(if self.has_copy_source() {
             Some(read_hg_path(on_disk, self.copy_source)?)
         } else {
             None
         })
     }
 
     pub(super) fn node_data(
         &self,
     ) -> Result<dirstate_map::NodeData, DirstateV2ParseError> {
         let entry = |state| {
             dirstate_map::NodeData::Entry(self.entry_with_given_state(state))
         };
 
         match self.state {
             b'\0' => Ok(dirstate_map::NodeData::None),
             b'd' => Ok(dirstate_map::NodeData::CachedDirectory {
                 mtime: *self.data.as_timestamp(),
             }),
             b'n' => Ok(entry(EntryState::Normal)),
             b'a' => Ok(entry(EntryState::Added)),
             b'r' => Ok(entry(EntryState::Removed)),
             b'm' => Ok(entry(EntryState::Merged)),
             _ => Err(DirstateV2ParseError),
         }
     }
 
     pub(super) fn cached_directory_mtime(&self) -> Option<&Timestamp> {
         if self.state == b'd' {
             Some(self.data.as_timestamp())
         } else {
             None
         }
     }
 
     pub(super) fn state(
         &self,
     ) -> Result<Option<EntryState>, DirstateV2ParseError> {
         match self.state {
             b'\0' | b'd' => Ok(None),
             b'n' => Ok(Some(EntryState::Normal)),
             b'a' => Ok(Some(EntryState::Added)),
             b'r' => Ok(Some(EntryState::Removed)),
             b'm' => Ok(Some(EntryState::Merged)),
             _ => Err(DirstateV2ParseError),
         }
     }
 
     fn entry_with_given_state(&self, state: EntryState) -> DirstateEntry {
         DirstateEntry {
             state,
             mode: self.data.mode.get(),
             mtime: self.data.mtime.get(),
             size: self.data.size.get(),
         }
     }
 
     pub(super) fn entry(
         &self,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         Ok(self
             .state()?
             .map(|state| self.entry_with_given_state(state)))
     }
 
     pub(super) fn children<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk [Node], DirstateV2ParseError> {
         read_slice::<Node>(on_disk, self.children)
     }
 
     pub(super) fn to_in_memory_node<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<dirstate_map::Node<'on_disk>, DirstateV2ParseError> {
         Ok(dirstate_map::Node {
             children: dirstate_map::ChildNodes::OnDisk(
                 self.children(on_disk)?,
             ),
             copy_source: self.copy_source(on_disk)?.map(Cow::Borrowed),
             data: self.node_data()?,
             descendants_with_entry_count: self
                 .descendants_with_entry_count
                 .get(),
             tracked_descendants_count: self.tracked_descendants_count.get(),
         })
     }
 }
 
 impl Entry {
     fn from_timestamp(timestamp: Timestamp) -> Self {
         // Safety: both types implement the `ByteCast` trait, so we could
         // safely use `as_bytes` and `from_bytes` to do this conversion. Using
         // `transmute` instead makes the compiler check that the two types
         // have the same size, which eliminates the error case of
         // `from_bytes`.
         unsafe { std::mem::transmute::<Timestamp, Entry>(timestamp) }
     }
 
     fn as_timestamp(&self) -> &Timestamp {
         // Safety: same as above in `from_timestamp`
         unsafe { &*(self as *const Entry as *const Timestamp) }
     }
 }
 
 impl Timestamp {
     pub fn seconds(&self) -> i64 {
         self.seconds.get()
     }
 }
 
 impl From<SystemTime> for Timestamp {
     fn from(system_time: SystemTime) -> Self {
         let (secs, nanos) = match system_time.duration_since(UNIX_EPOCH) {
             Ok(duration) => {
                 (duration.as_secs() as i64, duration.subsec_nanos())
             }
             Err(error) => {
                 let negative = error.duration();
                 (-(negative.as_secs() as i64), negative.subsec_nanos())
             }
         };
         Timestamp {
             seconds: secs.into(),
             nanoseconds: nanos.into(),
         }
     }
 }
 
 impl From<&'_ Timestamp> for SystemTime {
     fn from(timestamp: &'_ Timestamp) -> Self {
         let secs = timestamp.seconds.get();
         let nanos = timestamp.nanoseconds.get();
         if secs >= 0 {
             UNIX_EPOCH + Duration::new(secs as u64, nanos)
         } else {
             UNIX_EPOCH - Duration::new((-secs) as u64, nanos)
         }
     }
 }
 
 fn read_hg_path(
     on_disk: &[u8],
     slice: Slice,
 ) -> Result<&HgPath, DirstateV2ParseError> {
     let bytes = read_slice::<u8>(on_disk, slice)?;
     Ok(HgPath::new(bytes))
 }
 
 fn read_slice<T>(
     on_disk: &[u8],
     slice: Slice,
 ) -> Result<&[T], DirstateV2ParseError>
 where
     T: BytesCast,
 {
     // Either `usize::MAX` would result in "out of bounds" error since a single
     // `&[u8]` cannot occupy the entire addess space.
     let start = usize::try_from(slice.start.get()).unwrap_or(std::usize::MAX);
     let len = usize::try_from(slice.len.get()).unwrap_or(std::usize::MAX);
     on_disk
         .get(start..)
         .and_then(|bytes| T::slice_from_bytes(bytes, len).ok())
         .map(|(slice, _rest)| slice)
         .ok_or_else(|| DirstateV2ParseError)
 }
 
-pub(crate) fn parse_dirstate_parents(
-    on_disk: &[u8],
-) -> Result<&DirstateParents, HgError> {
-    Ok(&read_header(on_disk)?.parents)
-}
-
 pub(crate) fn for_each_tracked_path<'on_disk>(
     on_disk: &'on_disk [u8],
     mut f: impl FnMut(&'on_disk HgPath),
 ) -> Result<(), DirstateV2ParseError> {
-    let header = read_header(on_disk)?;
+    let (header, _) =
+        Header::from_bytes(on_disk).map_err(|_| DirstateV2ParseError)?;
     fn recur<'on_disk>(
         on_disk: &'on_disk [u8],
         nodes: Slice,
         f: &mut impl FnMut(&'on_disk HgPath),
     ) -> Result<(), DirstateV2ParseError> {
         for node in read_slice::<Node>(on_disk, nodes)? {
             if let Some(state) = node.state()? {
                 if state.is_tracked() {
                     f(node.full_path(on_disk)?)
                 }
             }
             recur(on_disk, node.children, f)?
         }
         Ok(())
     }
     recur(on_disk, header.root, &mut f)
 }
 
 pub(super) fn write(
     dirstate_map: &mut DirstateMap,
-    parents: DirstateParents,
 ) -> Result<Vec<u8>, DirstateError> {
     let header_len = std::mem::size_of::<Header>();
 
     // This ignores the space for paths, and for nodes without an entry.
     // TODO: better estimate? Skip the `Vec` and write to a file directly?
     let size_guess = header_len
         + std::mem::size_of::<Node>()
             * dirstate_map.nodes_with_entry_count as usize;
     let mut out = Vec::with_capacity(size_guess);
 
     // Keep space for the header. We’ll fill it out at the end when we know the
     // actual offset for the root nodes.
     out.resize(header_len, 0_u8);
 
     let root =
         write_nodes(dirstate_map, dirstate_map.root.as_ref(), &mut out)?;
 
     let header = Header {
-        marker: *V2_FORMAT_MARKER,
-        parents: parents,
         root,
         nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(),
         nodes_with_copy_source_count: dirstate_map
             .nodes_with_copy_source_count
             .into(),
         ignore_patterns_hash: dirstate_map.ignore_patterns_hash,
     };
     out[..header_len].copy_from_slice(header.as_bytes());
     Ok(out)
 }
 
 fn write_nodes(
     dirstate_map: &DirstateMap,
     nodes: dirstate_map::ChildNodesRef,
     out: &mut Vec<u8>,
 ) -> Result<ChildNodes, DirstateError> {
     // `dirstate_map::ChildNodes` is a `HashMap` with undefined iteration
     // order. Sort to enable binary search in the written file.
     let nodes = nodes.sorted();
 
     // First accumulate serialized nodes in a `Vec`
     let mut on_disk_nodes = Vec::with_capacity(nodes.len());
     for node in nodes {
         let children = write_nodes(
             dirstate_map,
             node.children(dirstate_map.on_disk)?,
             out,
         )?;
         let full_path = node.full_path(dirstate_map.on_disk)?;
         let full_path = write_slice::<u8>(full_path.as_bytes(), out);
         let copy_source =
             if let Some(source) = node.copy_source(dirstate_map.on_disk)? {
                 write_slice::<u8>(source.as_bytes(), out)
             } else {
                 Slice {
                     start: 0.into(),
                     len: 0.into(),
                 }
             };
         on_disk_nodes.push(match node {
             NodeRef::InMemory(path, node) => {
                 let (state, data) = match &node.data {
                     dirstate_map::NodeData::Entry(entry) => (
                         entry.state.into(),
                         Entry {
                             mode: entry.mode.into(),
                             mtime: entry.mtime.into(),
                             size: entry.size.into(),
                         },
                     ),
                     dirstate_map::NodeData::CachedDirectory { mtime } => {
                         (b'd', Entry::from_timestamp(*mtime))
                     }
                     dirstate_map::NodeData::None => (
                         b'\0',
                         Entry {
                             mode: 0.into(),
                             mtime: 0.into(),
                             size: 0.into(),
                         },
                     ),
                 };
                 Node {
                     children,
                     copy_source,
                     full_path,
                     base_name_start: u32::try_from(path.base_name_start())
                         // Could only panic for paths over 4 GiB
                         .expect("dirstate-v2 offset overflow")
                         .into(),
                     descendants_with_entry_count: node
                         .descendants_with_entry_count
                         .into(),
                     tracked_descendants_count: node
                         .tracked_descendants_count
                         .into(),
                     state,
                     data,
                 }
             }
             NodeRef::OnDisk(node) => Node {
                 children,
                 copy_source,
                 full_path,
                 ..*node
             },
         })
     }
     // … so we can write them contiguously
     Ok(write_slice::<Node>(&on_disk_nodes, out))
 }
 
 fn write_slice<T>(slice: &[T], out: &mut Vec<u8>) -> Slice
 where
     T: BytesCast,
 {
     let start = u32::try_from(out.len())
         // Could only panic for a dirstate file larger than 4 GiB
         .expect("dirstate-v2 offset overflow")
         .into();
     let len = u32::try_from(slice.len())
         // Could only panic for paths over 4 GiB or nodes with over 4 billions
         // child nodes
         .expect("dirstate-v2 offset overflow")
         .into();
     out.extend(slice.as_bytes());
     Slice { start, len }
 }

rust/hg-core/src/operations/list_tracked_files.rs

@@ -1,79 +1,84 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[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.
 
 use crate::dirstate::parsers::parse_dirstate_entries;
-use crate::dirstate_tree::on_disk::for_each_tracked_path;
+use crate::dirstate_tree::on_disk::{for_each_tracked_path, read_docket};
 use crate::errors::HgError;
 use crate::repo::Repo;
 use crate::revlog::changelog::Changelog;
 use crate::revlog::manifest::{Manifest, ManifestEntry};
 use crate::revlog::node::Node;
 use crate::revlog::revlog::RevlogError;
 use crate::utils::hg_path::HgPath;
 use crate::DirstateError;
 use rayon::prelude::*;
 
 /// List files under Mercurial control in the working directory
 /// by reading the dirstate
 pub struct Dirstate {
     /// The `dirstate` content.
     content: Vec<u8>,
     dirstate_v2: bool,
 }
 
 impl Dirstate {
     pub fn new(repo: &Repo) -> Result<Self, HgError> {
+        let mut content = repo.hg_vfs().read("dirstate")?;
+        if repo.has_dirstate_v2() {
+            let docket = read_docket(&content)?;
+            content = repo.hg_vfs().read(docket.data_filename())?;
+        }
         Ok(Self {
-            content: repo.hg_vfs().read("dirstate")?,
+            content,
             dirstate_v2: repo.has_dirstate_v2(),
         })
     }
 
     pub fn tracked_files(&self) -> Result<Vec<&HgPath>, DirstateError> {
         let mut files = Vec::new();
         if !self.content.is_empty() {
             if self.dirstate_v2 {
                 for_each_tracked_path(&self.content, |path| files.push(path))?
             } else {
                 let _parents = parse_dirstate_entries(
                     &self.content,
                     |path, entry, _copy_source| {
                         if entry.state.is_tracked() {
                             files.push(path)
                         }
                         Ok(())
                     },
                 )?;
             }
         }
         files.par_sort_unstable();
         Ok(files)
     }
 }
 
 /// List files under Mercurial control at a given revision.
 pub fn list_rev_tracked_files(
     repo: &Repo,
     revset: &str,
 ) -> Result<FilesForRev, RevlogError> {
     let rev = crate::revset::resolve_single(revset, repo)?;
     let changelog = Changelog::open(repo)?;
     let manifest = Manifest::open(repo)?;
     let changelog_entry = changelog.get_rev(rev)?;
     let manifest_node =
         Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
     let manifest_entry = manifest.get_node(manifest_node.into())?;
     Ok(FilesForRev(manifest_entry))
 }
 
 pub struct FilesForRev(ManifestEntry);
 
 impl FilesForRev {
     pub fn iter(&self) -> impl Iterator<Item = &HgPath> {
         self.0.files()
     }
 }

rust/hg-core/src/repo.rs

@@ -1,287 +1,288 b''
 use crate::config::{Config, ConfigError, ConfigParseError};
 use crate::errors::{HgError, IoErrorContext, IoResultExt};
 use crate::exit_codes;
 use crate::requirements;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::SliceExt;
 use memmap::{Mmap, MmapOptions};
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 
 /// A repository on disk
 pub struct Repo {
     working_directory: PathBuf,
     dot_hg: PathBuf,
     store: PathBuf,
     requirements: HashSet<String>,
     config: Config,
 }
 
 #[derive(Debug, derive_more::From)]
 pub enum RepoError {
     NotFound {
         at: PathBuf,
     },
     #[from]
     ConfigParseError(ConfigParseError),
     #[from]
     Other(HgError),
 }
 
 impl From<ConfigError> for RepoError {
     fn from(error: ConfigError) -> Self {
         match error {
             ConfigError::Parse(error) => error.into(),
             ConfigError::Other(error) => error.into(),
         }
     }
 }
 
 /// Filesystem access abstraction for the contents of a given "base" diretory
 #[derive(Clone, Copy)]
 pub struct Vfs<'a> {
     pub(crate) base: &'a Path,
 }
 
 impl Repo {
     /// tries to find nearest repository root in current working directory or
     /// its ancestors
     pub fn find_repo_root() -> Result<PathBuf, RepoError> {
         let current_directory = crate::utils::current_dir()?;
         // ancestors() is inclusive: it first yields `current_directory`
         // as-is.
         for ancestor in current_directory.ancestors() {
             if ancestor.join(".hg").is_dir() {
                 return Ok(ancestor.to_path_buf());
             }
         }
         return Err(RepoError::NotFound {
             at: current_directory,
         });
     }
 
     /// Find a repository, either at the given path (which must contain a `.hg`
     /// sub-directory) or by searching the current directory and its
     /// ancestors.
     ///
     /// A method with two very different "modes" like this usually a code smell
     /// to make two methods instead, but in this case an `Option` is what rhg
     /// sub-commands get from Clap for the `-R` / `--repository` CLI argument.
     /// Having two methods would just move that `if` to almost all callers.
     pub fn find(
         config: &Config,
         explicit_path: Option<PathBuf>,
     ) -> Result<Self, RepoError> {
         if let Some(root) = explicit_path {
             if root.join(".hg").is_dir() {
                 Self::new_at_path(root.to_owned(), config)
             } else if root.is_file() {
                 Err(HgError::unsupported("bundle repository").into())
             } else {
                 Err(RepoError::NotFound {
                     at: root.to_owned(),
                 })
             }
         } else {
             let root = Self::find_repo_root()?;
             Self::new_at_path(root, config)
         }
     }
 
     /// To be called after checking that `.hg` is a sub-directory
     fn new_at_path(
         working_directory: PathBuf,
         config: &Config,
     ) -> Result<Self, RepoError> {
         let dot_hg = working_directory.join(".hg");
 
         let mut repo_config_files = Vec::new();
         repo_config_files.push(dot_hg.join("hgrc"));
         repo_config_files.push(dot_hg.join("hgrc-not-shared"));
 
         let hg_vfs = Vfs { base: &dot_hg };
         let mut reqs = requirements::load_if_exists(hg_vfs)?;
         let relative =
             reqs.contains(requirements::RELATIVE_SHARED_REQUIREMENT);
         let shared =
             reqs.contains(requirements::SHARED_REQUIREMENT) || relative;
 
         // From `mercurial/localrepo.py`:
         //
         // if .hg/requires contains the sharesafe requirement, it means
         // there exists a `.hg/store/requires` too and we should read it
         // NOTE: presence of SHARESAFE_REQUIREMENT imply that store requirement
         // is present. We never write SHARESAFE_REQUIREMENT for a repo if store
         // is not present, refer checkrequirementscompat() for that
         //
         // However, if SHARESAFE_REQUIREMENT is not present, it means that the
         // repository was shared the old way. We check the share source
         // .hg/requires for SHARESAFE_REQUIREMENT to detect whether the
         // current repository needs to be reshared
         let share_safe = reqs.contains(requirements::SHARESAFE_REQUIREMENT);
 
         let store_path;
         if !shared {
             store_path = dot_hg.join("store");
         } else {
             let bytes = hg_vfs.read("sharedpath")?;
             let mut shared_path =
                 get_path_from_bytes(bytes.trim_end_newlines()).to_owned();
             if relative {
                 shared_path = dot_hg.join(shared_path)
             }
             if !shared_path.is_dir() {
                 return Err(HgError::corrupted(format!(
                     ".hg/sharedpath points to nonexistent directory {}",
                     shared_path.display()
                 ))
                 .into());
             }
 
             store_path = shared_path.join("store");
 
             let source_is_share_safe =
                 requirements::load(Vfs { base: &shared_path })?
                     .contains(requirements::SHARESAFE_REQUIREMENT);
 
             if share_safe && !source_is_share_safe {
                 return Err(match config
                     .get(b"share", b"safe-mismatch.source-not-safe")
                 {
                     Some(b"abort") | None => HgError::abort(
                         "abort: share source does not support share-safe requirement\n\
                         (see `hg help config.format.use-share-safe` for more information)",
                         exit_codes::ABORT,
                     ),
                     _ => HgError::unsupported("share-safe downgrade"),
                 }
                 .into());
             } else if source_is_share_safe && !share_safe {
                 return Err(
                     match config.get(b"share", b"safe-mismatch.source-safe") {
                         Some(b"abort") | None => HgError::abort(
                             "abort: version mismatch: source uses share-safe \
                             functionality while the current share does not\n\
                             (see `hg help config.format.use-share-safe` for more information)",
                         exit_codes::ABORT,
                         ),
                         _ => HgError::unsupported("share-safe upgrade"),
                     }
                     .into(),
                 );
             }
 
             if share_safe {
                 repo_config_files.insert(0, shared_path.join("hgrc"))
             }
         }
         if share_safe {
             reqs.extend(requirements::load(Vfs { base: &store_path })?);
         }
 
         let repo_config = if std::env::var_os("HGRCSKIPREPO").is_none() {
             config.combine_with_repo(&repo_config_files)?
         } else {
             config.clone()
         };
 
         let repo = Self {
             requirements: reqs,
             working_directory,
             store: store_path,
             dot_hg,
             config: repo_config,
         };
 
         requirements::check(&repo)?;
 
         Ok(repo)
     }
 
     pub fn working_directory_path(&self) -> &Path {
         &self.working_directory
     }
 
     pub fn requirements(&self) -> &HashSet<String> {
         &self.requirements
     }
 
     pub fn config(&self) -> &Config {
         &self.config
     }
 
     /// For accessing repository files (in `.hg`), except for the store
     /// (`.hg/store`).
     pub fn hg_vfs(&self) -> Vfs<'_> {
         Vfs { base: &self.dot_hg }
     }
 
     /// For accessing repository store files (in `.hg/store`)
     pub fn store_vfs(&self) -> Vfs<'_> {
         Vfs { base: &self.store }
     }
 
     /// For accessing the working copy
     pub fn working_directory_vfs(&self) -> Vfs<'_> {
         Vfs {
             base: &self.working_directory,
         }
     }
 
     pub fn has_dirstate_v2(&self) -> bool {
         self.requirements
             .contains(requirements::DIRSTATE_V2_REQUIREMENT)
     }
 
     pub fn dirstate_parents(
         &self,
     ) -> Result<crate::dirstate::DirstateParents, HgError> {
         let dirstate = self.hg_vfs().mmap_open("dirstate")?;
         if dirstate.is_empty() {
             return Ok(crate::dirstate::DirstateParents::NULL);
         }
         let parents = if self.has_dirstate_v2() {
-            crate::dirstate_tree::on_disk::parse_dirstate_parents(&dirstate)?
+            crate::dirstate_tree::on_disk::read_docket(&dirstate)?.parents()
         } else {
             crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?
+                .clone()
         };
-        Ok(parents.clone())
+        Ok(parents)
     }
 }
 
 impl Vfs<'_> {
     pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
         self.base.join(relative_path)
     }
 
     pub fn read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Vec<u8>, HgError> {
         let path = self.join(relative_path);
         std::fs::read(&path).when_reading_file(&path)
     }
 
     pub fn mmap_open(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Mmap, HgError> {
         let path = self.base.join(relative_path);
         let file = std::fs::File::open(&path).when_reading_file(&path)?;
         // TODO: what are the safety requirements here?
         let mmap = unsafe { MmapOptions::new().map(&file) }
             .when_reading_file(&path)?;
         Ok(mmap)
     }
 
     pub fn rename(
         &self,
         relative_from: impl AsRef<Path>,
         relative_to: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let from = self.join(relative_from);
         let to = self.join(relative_to);
         std::fs::rename(&from, &to)
             .with_context(|| IoErrorContext::RenamingFile { from, to })
     }
 }

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

@@ -1,582 +1,606 b''
 // dirstate_map.rs
 //
 // Copyright 2019 Raphaël Gomès <[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.
 
 //! Bindings for the `hg::dirstate::dirstate_map` file provided by the
 //! `hg-core` package.
 
 use std::cell::{RefCell, RefMut};
 use std::convert::TryInto;
 
 use cpython::{
     exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,
     PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject,
     UnsafePyLeaked,
 };
 
 use crate::{
     dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
     dirstate::make_directory_item,
     dirstate::make_dirstate_item,
     dirstate::non_normal_entries::{
         NonNormalEntries, NonNormalEntriesIterator,
     },
     dirstate::owning::OwningDirstateMap,
     parsers::dirstate_parents_to_pytuple,
 };
 use hg::{
     dirstate::parsers::Timestamp,
     dirstate::MTIME_UNSET,
     dirstate::SIZE_NON_NORMAL,
     dirstate_tree::dispatch::DirstateMapMethods,
     dirstate_tree::on_disk::DirstateV2ParseError,
     revlog::Node,
     utils::files::normalize_case,
     utils::hg_path::{HgPath, HgPathBuf},
     DirstateEntry, DirstateError, DirstateMap as RustDirstateMap,
     DirstateParents, EntryState, StateMapIter,
 };
 
 // TODO
 //     This object needs to share references to multiple members of its Rust
 //     inner struct, namely `copy_map`, `dirs` and `all_dirs`.
 //     Right now `CopyMap` is done, but it needs to have an explicit reference
 //     to `RustDirstateMap` which itself needs to have an encapsulation for
 //     every method in `CopyMap` (copymapcopy, etc.).
 //     This is ugly and hard to maintain.
 //     The same logic applies to `dirs` and `all_dirs`, however the `Dirs`
 //     `py_class!` is already implemented and does not mention
 //     `RustDirstateMap`, rightfully so.
 //     All attributes also have to have a separate refcount data attribute for
 //     leaks, with all methods that go along for reference sharing.
 py_class!(pub class DirstateMap |py| {
     @shared data inner: Box<dyn DirstateMapMethods + Send>;
 
     /// Returns a `(dirstate_map, parents)` tuple
     @staticmethod
-    def new(
+    def new_v1(
         use_dirstate_tree: bool,
-        use_dirstate_v2: bool,
         on_disk: PyBytes,
     ) -> PyResult<PyObject> {
         let dirstate_error = |e: DirstateError| {
             PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
         };
-        let (inner, parents) = if use_dirstate_tree || use_dirstate_v2 {
-            let (map, parents) =
-                OwningDirstateMap::new(py, on_disk, use_dirstate_v2)
+        let (inner, parents) = if use_dirstate_tree {
+            let (map, parents) = OwningDirstateMap::new_v1(py, on_disk)
                 .map_err(dirstate_error)?;
             (Box::new(map) as _, parents)
         } else {
             let bytes = on_disk.data(py);
             let mut map = RustDirstateMap::default();
             let parents = map.read(bytes).map_err(dirstate_error)?;
             (Box::new(map) as _, parents)
         };
         let map = Self::create_instance(py, inner)?;
         let parents = parents.map(|p| dirstate_parents_to_pytuple(py, &p));
         Ok((map, parents).to_py_object(py).into_object())
     }
 
+    /// Returns a DirstateMap
+    @staticmethod
+    def new_v2(
+        on_disk: PyBytes,
+    ) -> PyResult<PyObject> {
+        let dirstate_error = |e: DirstateError| {
+            PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
+        };
+        let inner = OwningDirstateMap::new_v2(py, on_disk)
+                .map_err(dirstate_error)?;
+        let map = Self::create_instance(py, Box::new(inner))?;
+        Ok(map.into_object())
+    }
+
     def clear(&self) -> PyResult<PyObject> {
         self.inner(py).borrow_mut().clear();
         Ok(py.None())
     }
 
     def get(
         &self,
         key: PyObject,
         default: Option<PyObject> = None
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self
             .inner(py)
             .borrow()
             .get(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))?
         {
             Some(entry) => {
                 Ok(Some(make_dirstate_item(py, &entry)?))
             },
             None => Ok(default)
         }
     }
 
     def addfile(
         &self,
         f: PyObject,
         mode: PyObject,
         size: PyObject,
         mtime: PyObject,
         added: PyObject,
         merged: PyObject,
         from_p2: PyObject,
         possibly_dirty: PyObject,
     ) -> PyResult<PyObject> {
         let f = f.extract::<PyBytes>(py)?;
         let filename = HgPath::new(f.data(py));
         let mode = if mode.is_none(py) {
             // fallback default value
             0
         } else {
             mode.extract(py)?
         };
         let size = if size.is_none(py) {
             // fallback default value
             SIZE_NON_NORMAL
         } else {
             size.extract(py)?
         };
         let mtime = if mtime.is_none(py) {
             // fallback default value
             MTIME_UNSET
         } else {
             mtime.extract(py)?
         };
         let entry = DirstateEntry {
             // XXX Arbitrary default value since the value is determined later
             state: EntryState::Normal,
             mode: mode,
             size: size,
             mtime: mtime,
         };
         let added = added.extract::<PyBool>(py)?.is_true();
         let merged = merged.extract::<PyBool>(py)?.is_true();
         let from_p2 = from_p2.extract::<PyBool>(py)?.is_true();
         let possibly_dirty = possibly_dirty.extract::<PyBool>(py)?.is_true();
         self.inner(py).borrow_mut().add_file(
             filename,
             entry,
             added,
             merged,
             from_p2,
             possibly_dirty
         ).and(Ok(py.None())).or_else(|e: DirstateError| {
             Err(PyErr::new::<exc::ValueError, _>(py, e.to_string()))
         })
     }
 
     def removefile(
         &self,
         f: PyObject,
         in_merge: PyObject
     ) -> PyResult<PyObject> {
         self.inner(py).borrow_mut()
             .remove_file(
                 HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
                 in_merge.extract::<PyBool>(py)?.is_true(),
             )
             .or_else(|_| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     "Dirstate error".to_string(),
                 ))
             })?;
         Ok(py.None())
     }
 
     def dropfile(
         &self,
         f: PyObject,
     ) -> PyResult<PyBool> {
         self.inner(py).borrow_mut()
             .drop_file(
                 HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
             )
             .and_then(|b| Ok(b.to_py_object(py)))
             .or_else(|e| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     format!("Dirstate error: {}", e.to_string()),
                 ))
             })
     }
 
     def clearambiguoustimes(
         &self,
         files: PyObject,
         now: PyObject
     ) -> PyResult<PyObject> {
         let files: PyResult<Vec<HgPathBuf>> = files
             .iter(py)?
             .map(|filename| {
                 Ok(HgPathBuf::from_bytes(
                     filename?.extract::<PyBytes>(py)?.data(py),
                 ))
             })
             .collect();
         self.inner(py)
             .borrow_mut()
             .clear_ambiguous_times(files?, now.extract(py)?)
             .map_err(|e| v2_error(py, e))?;
         Ok(py.None())
     }
 
     def other_parent_entries(&self) -> PyResult<PyObject> {
         let mut inner_shared = self.inner(py).borrow_mut();
         let set = PySet::empty(py)?;
         for path in inner_shared.iter_other_parent_paths() {
             let path = path.map_err(|e| v2_error(py, e))?;
             set.add(py, PyBytes::new(py, path.as_bytes()))?;
         }
         Ok(set.into_object())
     }
 
     def non_normal_entries(&self) -> PyResult<NonNormalEntries> {
         NonNormalEntries::from_inner(py, self.clone_ref(py))
     }
 
     def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {
         let key = key.extract::<PyBytes>(py)?;
         self.inner(py)
             .borrow_mut()
             .non_normal_entries_contains(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))
     }
 
     def non_normal_entries_display(&self) -> PyResult<PyString> {
         let mut inner = self.inner(py).borrow_mut();
         let paths = inner
             .iter_non_normal_paths()
             .collect::<Result<Vec<_>, _>>()
             .map_err(|e| v2_error(py, e))?;
         let formatted = format!("NonNormalEntries: {}", hg::utils::join_display(paths, ", "));
         Ok(PyString::new(py, &formatted))
     }
 
     def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         self
             .inner(py)
             .borrow_mut()
             .non_normal_entries_remove(HgPath::new(key.data(py)));
         Ok(py.None())
     }
 
     def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> {
         let mut inner = self.inner(py).borrow_mut();
 
         let ret = PyList::new(py, &[]);
         for filename in inner.non_normal_or_other_parent_paths() {
             let filename = filename.map_err(|e| v2_error(py, e))?;
             let as_pystring = PyBytes::new(py, filename.as_bytes());
             ret.append(py, as_pystring.into_object());
         }
         Ok(ret)
     }
 
     def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> {
         // Make sure the sets are defined before we no longer have a mutable
         // reference to the dmap.
         self.inner(py)
             .borrow_mut()
             .set_non_normal_other_parent_entries(false);
 
         let leaked_ref = self.inner(py).leak_immutable();
 
         NonNormalEntriesIterator::from_inner(py, unsafe {
             leaked_ref.map(py, |o| {
                 o.iter_non_normal_paths_panic()
             })
         })
     }
 
     def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
         let d = d.extract::<PyBytes>(py)?;
         Ok(self.inner(py).borrow_mut()
             .has_tracked_dir(HgPath::new(d.data(py)))
             .map_err(|e| {
                 PyErr::new::<exc::ValueError, _>(py, e.to_string())
             })?
             .to_py_object(py))
     }
 
     def hasdir(&self, d: PyObject) -> PyResult<PyBool> {
         let d = d.extract::<PyBytes>(py)?;
         Ok(self.inner(py).borrow_mut()
             .has_dir(HgPath::new(d.data(py)))
             .map_err(|e| {
                 PyErr::new::<exc::ValueError, _>(py, e.to_string())
             })?
             .to_py_object(py))
     }
 
-    def write(
+    def write_v1(
         &self,
-        use_dirstate_v2: bool,
         p1: PyObject,
         p2: PyObject,
         now: PyObject
     ) -> PyResult<PyBytes> {
         let now = Timestamp(now.extract(py)?);
+
+        let mut inner = self.inner(py).borrow_mut();
         let parents = DirstateParents {
             p1: extract_node_id(py, &p1)?,
             p2: extract_node_id(py, &p2)?,
         };
+        let result = inner.pack_v1(parents, now);
+        match result {
+            Ok(packed) => Ok(PyBytes::new(py, &packed)),
+            Err(_) => Err(PyErr::new::<exc::OSError, _>(
+                py,
+                "Dirstate error".to_string(),
+            )),
+        }
+    }
+
+    def write_v2(
+        &self,
+        now: PyObject
+    ) -> PyResult<PyBytes> {
+        let now = Timestamp(now.extract(py)?);
 
         let mut inner = self.inner(py).borrow_mut();
-        let result = if use_dirstate_v2 {
-            inner.pack_v2(parents, now)
-        } else {
-            inner.pack_v1(parents, now)
-        };
+        let result = inner.pack_v2(now);
         match result {
             Ok(packed) => Ok(PyBytes::new(py, &packed)),
             Err(_) => Err(PyErr::new::<exc::OSError, _>(
                 py,
                 "Dirstate error".to_string(),
             )),
         }
     }
 
     def filefoldmapasdict(&self) -> PyResult<PyDict> {
         let dict = PyDict::new(py);
         for item in self.inner(py).borrow_mut().iter() {
             let (path, entry) = item.map_err(|e| v2_error(py, e))?;
             if entry.state != EntryState::Removed {
                 let key = normalize_case(path);
                 let value = path;
                 dict.set_item(
                     py,
                     PyBytes::new(py, key.as_bytes()).into_object(),
                     PyBytes::new(py, value.as_bytes()).into_object(),
                 )?;
             }
         }
         Ok(dict)
     }
 
     def __len__(&self) -> PyResult<usize> {
         Ok(self.inner(py).borrow().len())
     }
 
     def __contains__(&self, key: PyObject) -> PyResult<bool> {
         let key = key.extract::<PyBytes>(py)?;
         self.inner(py)
             .borrow()
             .contains_key(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))
     }
 
     def __getitem__(&self, key: PyObject) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         let key = HgPath::new(key.data(py));
         match self
             .inner(py)
             .borrow()
             .get(key)
             .map_err(|e| v2_error(py, e))?
         {
             Some(entry) => {
                 Ok(make_dirstate_item(py, &entry)?)
             },
             None => Err(PyErr::new::<exc::KeyError, _>(
                 py,
                 String::from_utf8_lossy(key.as_bytes()),
             )),
         }
     }
 
     def keys(&self) -> PyResult<DirstateMapKeysIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         DirstateMapKeysIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.iter()) },
         )
     }
 
     def items(&self) -> PyResult<DirstateMapItemsIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         DirstateMapItemsIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.iter()) },
         )
     }
 
     def __iter__(&self) -> PyResult<DirstateMapKeysIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         DirstateMapKeysIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.iter()) },
         )
     }
 
     // TODO all copymap* methods, see docstring above
     def copymapcopy(&self) -> PyResult<PyDict> {
         let dict = PyDict::new(py);
         for item in self.inner(py).borrow().copy_map_iter() {
             let (key, value) = item.map_err(|e| v2_error(py, e))?;
             dict.set_item(
                 py,
                 PyBytes::new(py, key.as_bytes()),
                 PyBytes::new(py, value.as_bytes()),
             )?;
         }
         Ok(dict)
     }
 
     def copymapgetitem(&self, key: PyObject) -> PyResult<PyBytes> {
         let key = key.extract::<PyBytes>(py)?;
         match self
             .inner(py)
             .borrow()
             .copy_map_get(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))?
         {
             Some(copy) => Ok(PyBytes::new(py, copy.as_bytes())),
             None => Err(PyErr::new::<exc::KeyError, _>(
                 py,
                 String::from_utf8_lossy(key.data(py)),
             )),
         }
     }
     def copymap(&self) -> PyResult<CopyMap> {
         CopyMap::from_inner(py, self.clone_ref(py))
     }
 
     def copymaplen(&self) -> PyResult<usize> {
         Ok(self.inner(py).borrow().copy_map_len())
     }
     def copymapcontains(&self, key: PyObject) -> PyResult<bool> {
         let key = key.extract::<PyBytes>(py)?;
         self.inner(py)
             .borrow()
             .copy_map_contains_key(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))
     }
     def copymapget(
         &self,
         key: PyObject,
         default: Option<PyObject>
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self
             .inner(py)
             .borrow()
             .copy_map_get(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))?
         {
             Some(copy) => Ok(Some(
                 PyBytes::new(py, copy.as_bytes()).into_object(),
             )),
             None => Ok(default),
         }
     }
     def copymapsetitem(
         &self,
         key: PyObject,
         value: PyObject
     ) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         let value = value.extract::<PyBytes>(py)?;
         self.inner(py)
             .borrow_mut()
             .copy_map_insert(
                 HgPathBuf::from_bytes(key.data(py)),
                 HgPathBuf::from_bytes(value.data(py)),
             )
             .map_err(|e| v2_error(py, e))?;
         Ok(py.None())
     }
     def copymappop(
         &self,
         key: PyObject,
         default: Option<PyObject>
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self
             .inner(py)
             .borrow_mut()
             .copy_map_remove(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))?
         {
             Some(_) => Ok(None),
             None => Ok(default),
         }
     }
 
     def copymapiter(&self) -> PyResult<CopyMapKeysIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         CopyMapKeysIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) },
         )
     }
 
     def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         CopyMapItemsIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) },
         )
     }
 
     def directories(&self) -> PyResult<PyList> {
         let dirs = PyList::new(py, &[]);
         for item in self.inner(py).borrow().iter_directories() {
             let (path, mtime) = item.map_err(|e| v2_error(py, e))?;
             let path = PyBytes::new(py, path.as_bytes());
             let mtime = mtime.map(|t| t.0).unwrap_or(-1);
             let item = make_directory_item(py, mtime as i32)?;
             let tuple = (path, item);
             dirs.append(py, tuple.to_py_object(py).into_object())
         }
         Ok(dirs)
     }
 
 });
 
 impl DirstateMap {
     pub fn get_inner_mut<'a>(
         &'a self,
         py: Python<'a>,
     ) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> {
         self.inner(py).borrow_mut()
     }
     fn translate_key(
         py: Python,
         res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
     ) -> PyResult<Option<PyBytes>> {
         let (f, _entry) = res.map_err(|e| v2_error(py, e))?;
         Ok(Some(PyBytes::new(py, f.as_bytes())))
     }
     fn translate_key_value(
         py: Python,
         res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
     ) -> PyResult<Option<(PyBytes, PyObject)>> {
         let (f, entry) = res.map_err(|e| v2_error(py, e))?;
         Ok(Some((
             PyBytes::new(py, f.as_bytes()),
             make_dirstate_item(py, &entry)?,
         )))
     }
 }
 
 py_shared_iterator!(
     DirstateMapKeysIterator,
     UnsafePyLeaked<StateMapIter<'static>>,
     DirstateMap::translate_key,
     Option<PyBytes>
 );
 
 py_shared_iterator!(
     DirstateMapItemsIterator,
     UnsafePyLeaked<StateMapIter<'static>>,
     DirstateMap::translate_key_value,
     Option<(PyBytes, PyObject)>
 );
 
 fn extract_node_id(py: Python, obj: &PyObject) -> PyResult<Node> {
     let bytes = obj.extract::<PyBytes>(py)?;
     match bytes.data(py).try_into() {
         Ok(s) => Ok(s),
         Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())),
     }
 }
 
 pub(super) fn v2_error(py: Python<'_>, _: DirstateV2ParseError) -> PyErr {
     PyErr::new::<exc::ValueError, _>(py, "corrupted dirstate-v2")
 }

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

@@ -1,219 +1,215 b''
 use crate::dirstate::owning::OwningDirstateMap;
 use hg::dirstate::parsers::Timestamp;
 use hg::dirstate_tree::dispatch::DirstateMapMethods;
 use hg::dirstate_tree::on_disk::DirstateV2ParseError;
 use hg::matchers::Matcher;
 use hg::utils::hg_path::{HgPath, HgPathBuf};
 use hg::CopyMapIter;
 use hg::DirstateEntry;
 use hg::DirstateError;
 use hg::DirstateParents;
 use hg::DirstateStatus;
 use hg::PatternFileWarning;
 use hg::StateMapIter;
 use hg::StatusError;
 use hg::StatusOptions;
 use std::path::PathBuf;
 
 impl DirstateMapMethods for OwningDirstateMap {
     fn clear(&mut self) {
         self.get_mut().clear()
     }
 
     fn add_file(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
         added: bool,
         merged: bool,
         from_p2: bool,
         possibly_dirty: bool,
     ) -> Result<(), DirstateError> {
         self.get_mut().add_file(
             filename,
             entry,
             added,
             merged,
             from_p2,
             possibly_dirty,
         )
     }
 
     fn remove_file(
         &mut self,
         filename: &HgPath,
         in_merge: bool,
     ) -> Result<(), DirstateError> {
         self.get_mut().remove_file(filename, in_merge)
     }
 
     fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError> {
         self.get_mut().drop_file(filename)
     }
 
     fn clear_ambiguous_times(
         &mut self,
         filenames: Vec<HgPathBuf>,
         now: i32,
     ) -> Result<(), DirstateV2ParseError> {
         self.get_mut().clear_ambiguous_times(filenames, now)
     }
 
     fn non_normal_entries_contains(
         &mut self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         self.get_mut().non_normal_entries_contains(key)
     }
 
     fn non_normal_entries_remove(&mut self, key: &HgPath) {
         self.get_mut().non_normal_entries_remove(key)
     }
 
     fn non_normal_or_other_parent_paths(
         &mut self,
     ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
     {
         self.get_mut().non_normal_or_other_parent_paths()
     }
 
     fn set_non_normal_other_parent_entries(&mut self, force: bool) {
         self.get_mut().set_non_normal_other_parent_entries(force)
     }
 
     fn iter_non_normal_paths(
         &mut self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         self.get_mut().iter_non_normal_paths()
     }
 
     fn iter_non_normal_paths_panic(
         &self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         self.get().iter_non_normal_paths_panic()
     }
 
     fn iter_other_parent_paths(
         &mut self,
     ) -> Box<
         dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
     > {
         self.get_mut().iter_other_parent_paths()
     }
 
     fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.get_mut().has_tracked_dir(directory)
     }
 
     fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {
         self.get_mut().has_dir(directory)
     }
 
     fn pack_v1(
         &mut self,
         parents: DirstateParents,
         now: Timestamp,
     ) -> Result<Vec<u8>, DirstateError> {
         self.get_mut().pack_v1(parents, now)
     }
 
-    fn pack_v2(
-        &mut self,
-        parents: DirstateParents,
-        now: Timestamp,
-    ) -> Result<Vec<u8>, DirstateError> {
-        self.get_mut().pack_v2(parents, now)
+    fn pack_v2(&mut self, now: Timestamp) -> Result<Vec<u8>, DirstateError> {
+        self.get_mut().pack_v2(now)
     }
 
     fn status<'a>(
         &'a mut self,
         matcher: &'a (dyn Matcher + Sync),
         root_dir: PathBuf,
         ignore_files: Vec<PathBuf>,
         options: StatusOptions,
     ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
     {
         self.get_mut()
             .status(matcher, root_dir, ignore_files, options)
     }
 
     fn copy_map_len(&self) -> usize {
         self.get().copy_map_len()
     }
 
     fn copy_map_iter(&self) -> CopyMapIter<'_> {
         self.get().copy_map_iter()
     }
 
     fn copy_map_contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         self.get().copy_map_contains_key(key)
     }
 
     fn copy_map_get(
         &self,
         key: &HgPath,
     ) -> Result<Option<&HgPath>, DirstateV2ParseError> {
         self.get().copy_map_get(key)
     }
 
     fn copy_map_remove(
         &mut self,
         key: &HgPath,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         self.get_mut().copy_map_remove(key)
     }
 
     fn copy_map_insert(
         &mut self,
         key: HgPathBuf,
         value: HgPathBuf,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         self.get_mut().copy_map_insert(key, value)
     }
 
     fn len(&self) -> usize {
         self.get().len()
     }
 
     fn contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         self.get().contains_key(key)
     }
 
     fn get(
         &self,
         key: &HgPath,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         self.get().get(key)
     }
 
     fn iter(&self) -> StateMapIter<'_> {
         self.get().iter()
     }
 
     fn iter_directories(
         &self,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, Option<Timestamp>),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     > {
         self.get().iter_directories()
     }
 }

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

@@ -1,102 +1,114 b''
 use cpython::PyBytes;
 use cpython::Python;
 use hg::dirstate_tree::dirstate_map::DirstateMap;
 use hg::DirstateError;
 use hg::DirstateParents;
 
 /// Keep a `DirstateMap<'on_disk>` next to the `on_disk` buffer that it
 /// borrows. This is similar to the owning-ref crate.
 ///
 /// This is similar to [`OwningRef`] which is more limited because it
 /// represents exactly one `&T` reference next to the value it borrows, as
 /// opposed to a struct that may contain an arbitrary number of references in
 /// arbitrarily-nested data structures.
 ///
 /// [`OwningRef`]: https://docs.rs/owning_ref/0.4.1/owning_ref/struct.OwningRef.html
 pub(super) struct OwningDirstateMap {
     /// Owned handle to a bytes buffer with a stable address.
     ///
     /// See <https://docs.rs/owning_ref/0.4.1/owning_ref/trait.StableAddress.html>.
     on_disk: PyBytes,
 
     /// Pointer for `Box<DirstateMap<'on_disk>>`, typed-erased because the
     /// language cannot represent a lifetime referencing a sibling field.
     /// This is not quite a self-referencial struct (moving this struct is not
     /// a problem as it doesn’t change the address of the bytes buffer owned
     /// by `PyBytes`) but touches similar borrow-checker limitations.
     ptr: *mut (),
 }
 
 impl OwningDirstateMap {
-    pub fn new(
+    pub fn new_v1(
         py: Python,
         on_disk: PyBytes,
-        use_dirstate_v2: bool,
     ) -> Result<(Self, Option<DirstateParents>), DirstateError> {
         let bytes: &'_ [u8] = on_disk.data(py);
-        let (map, parents) = if use_dirstate_v2 {
-            DirstateMap::new_v2(bytes)?
-        } else {
-            DirstateMap::new_v1(bytes)?
-        };
+        let (map, parents) = DirstateMap::new_v1(bytes)?;
 
         // Like in `bytes` above, this `'_` lifetime parameter borrows from
         // the bytes buffer owned by `on_disk`.
         let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map));
 
         // Erase the pointed type entirely in order to erase the lifetime.
         let ptr: *mut () = ptr.cast();
 
         Ok((Self { on_disk, ptr }, parents))
     }
 
+    pub fn new_v2(
+        py: Python,
+        on_disk: PyBytes,
+    ) -> Result<Self, DirstateError> {
+        let bytes: &'_ [u8] = on_disk.data(py);
+        let map = DirstateMap::new_v2(bytes)?;
+
+        // Like in `bytes` above, this `'_` lifetime parameter borrows from
+        // the bytes buffer owned by `on_disk`.
+        let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map));
+
+        // Erase the pointed type entirely in order to erase the lifetime.
+        let ptr: *mut () = ptr.cast();
+
+        Ok(Self { on_disk, ptr })
+    }
+
     pub fn get_mut<'a>(&'a mut self) -> &'a mut DirstateMap<'a> {
         // SAFETY: We cast the type-erased pointer back to the same type it had
         // in `new`, except with a different lifetime parameter. This time we
         // connect the lifetime to that of `self`. This cast is valid because
         // `self` owns the same `PyBytes` whose buffer `DirstateMap`
         // references. That buffer has a stable memory address because the byte
         // string value of a `PyBytes` is immutable.
         let ptr: *mut DirstateMap<'a> = self.ptr.cast();
         // SAFETY: we dereference that pointer, connecting the lifetime of the
         // new   `&mut` to that of `self`. This is valid because the
         // raw pointer is   to a boxed value, and `self` owns that box.
         unsafe { &mut *ptr }
     }
 
     pub fn get<'a>(&'a self) -> &'a DirstateMap<'a> {
         // SAFETY: same reasoning as in `get_mut` above.
         let ptr: *mut DirstateMap<'a> = self.ptr.cast();
         unsafe { &*ptr }
     }
 }
 
 impl Drop for OwningDirstateMap {
     fn drop(&mut self) {
         // Silence a "field is never read" warning, and demonstrate that this
         // value is still alive.
         let _ = &self.on_disk;
         // SAFETY: this cast is the same as in `get_mut`, and is valid for the
         // same reason. `self.on_disk` still exists at this point, drop glue
         // will drop it implicitly after this `drop` method returns.
         let ptr: *mut DirstateMap<'_> = self.ptr.cast();
         // SAFETY: `Box::from_raw` takes ownership of the box away from `self`.
         // This is fine because drop glue does nothig for `*mut ()` and we’re
         // in `drop`, so `get` and `get_mut` cannot be called again.
         unsafe { drop(Box::from_raw(ptr)) }
     }
 }
 
 fn _static_assert_is_send<T: Send>() {}
 
 fn _static_assert_fields_are_send() {
     _static_assert_is_send::<PyBytes>();
     _static_assert_is_send::<Box<DirstateMap<'_>>>();
 }
 
 // SAFETY: we don’t get this impl implicitly because `*mut (): !Send` because
 // thread-safety of raw pointers is unknown in the general case. However this
 // particular raw pointer represents a `Box<DirstateMap<'on_disk>>` that we
 // own. Since that `Box` and `PyBytes` are both `Send` as shown in above, it
 // is sound to mark this struct as `Send` too.
 unsafe impl Send for OwningDirstateMap {}

rust/rhg/src/commands/status.rs

@@ -1,322 +1,339 b''
 // status.rs
 //
 // Copyright 2020, Georges Racinet <[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.
 
 use crate::error::CommandError;
 use crate::ui::Ui;
 use clap::{Arg, SubCommand};
 use hg;
 use hg::dirstate_tree::dirstate_map::DirstateMap;
+use hg::dirstate_tree::on_disk;
 use hg::errors::HgResultExt;
 use hg::errors::IoResultExt;
 use hg::matchers::AlwaysMatcher;
 use hg::operations::cat;
 use hg::repo::Repo;
 use hg::revlog::node::Node;
 use hg::utils::hg_path::{hg_path_to_os_string, HgPath};
 use hg::StatusError;
 use hg::{HgPathCow, StatusOptions};
 use log::{info, warn};
 use std::convert::TryInto;
 use std::fs;
 use std::io::BufReader;
 use std::io::Read;
 
 pub const HELP_TEXT: &str = "
 Show changed files in the working directory
 
 This is a pure Rust version of `hg status`.
 
 Some options might be missing, check the list below.
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     SubCommand::with_name("status")
         .alias("st")
         .about(HELP_TEXT)
         .arg(
             Arg::with_name("all")
                 .help("show status of all files")
                 .short("-A")
                 .long("--all"),
         )
         .arg(
             Arg::with_name("modified")
                 .help("show only modified files")
                 .short("-m")
                 .long("--modified"),
         )
         .arg(
             Arg::with_name("added")
                 .help("show only added files")
                 .short("-a")
                 .long("--added"),
         )
         .arg(
             Arg::with_name("removed")
                 .help("show only removed files")
                 .short("-r")
                 .long("--removed"),
         )
         .arg(
             Arg::with_name("clean")
                 .help("show only clean files")
                 .short("-c")
                 .long("--clean"),
         )
         .arg(
             Arg::with_name("deleted")
                 .help("show only deleted files")
                 .short("-d")
                 .long("--deleted"),
         )
         .arg(
             Arg::with_name("unknown")
                 .help("show only unknown (not tracked) files")
                 .short("-u")
                 .long("--unknown"),
         )
         .arg(
             Arg::with_name("ignored")
                 .help("show only ignored files")
                 .short("-i")
                 .long("--ignored"),
         )
 }
 
 /// Pure data type allowing the caller to specify file states to display
 #[derive(Copy, Clone, Debug)]
 pub struct DisplayStates {
     pub modified: bool,
     pub added: bool,
     pub removed: bool,
     pub clean: bool,
     pub deleted: bool,
     pub unknown: bool,
     pub ignored: bool,
 }
 
 pub const DEFAULT_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: false,
     deleted: true,
     unknown: true,
     ignored: false,
 };
 
 pub const ALL_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: true,
     deleted: true,
     unknown: true,
     ignored: true,
 };
 
 impl DisplayStates {
     pub fn is_empty(&self) -> bool {
         !(self.modified
             || self.added
             || self.removed
             || self.clean
             || self.deleted
             || self.unknown
             || self.ignored)
     }
 }
 
 pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
     let status_enabled_default = false;
     let status_enabled = invocation.config.get_option(b"rhg", b"status")?;
     if !status_enabled.unwrap_or(status_enabled_default) {
         return Err(CommandError::unsupported(
             "status is experimental in rhg (enable it with 'rhg.status = true' \
             or enable fallback with 'rhg.on-unsupported = fallback')"
         ));
     }
 
     let ui = invocation.ui;
     let args = invocation.subcommand_args;
     let display_states = if args.is_present("all") {
         // TODO when implementing `--quiet`: it excludes clean files
         // from `--all`
         ALL_DISPLAY_STATES
     } else {
         let requested = DisplayStates {
             modified: args.is_present("modified"),
             added: args.is_present("added"),
             removed: args.is_present("removed"),
             clean: args.is_present("clean"),
             deleted: args.is_present("deleted"),
             unknown: args.is_present("unknown"),
             ignored: args.is_present("ignored"),
         };
         if requested.is_empty() {
             DEFAULT_DISPLAY_STATES
         } else {
             requested
         }
     };
 
     let repo = invocation.repo?;
-    let dirstate_data =
-        repo.hg_vfs().mmap_open("dirstate").io_not_found_as_none()?;
-    let dirstate_data = match &dirstate_data {
-        Some(mmap) => &**mmap,
-        None => b"",
-    };
+    let dirstate_data_mmap;
     let (mut dmap, parents) = if repo.has_dirstate_v2() {
-        DirstateMap::new_v2(dirstate_data)?
+        let parents;
+        let dirstate_data;
+        if let Some(docket_data) =
+            repo.hg_vfs().read("dirstate").io_not_found_as_none()?
+        {
+            let docket = on_disk::read_docket(&docket_data)?;
+            parents = Some(docket.parents());
+            dirstate_data_mmap = repo
+                .hg_vfs()
+                .mmap_open(docket.data_filename())
+                .io_not_found_as_none()?;
+            dirstate_data = dirstate_data_mmap.as_deref().unwrap_or(b"");
+        } else {
+            parents = None;
+            dirstate_data = b"";
+        }
+        let dmap = DirstateMap::new_v2(dirstate_data)?;
+        (dmap, parents)
     } else {
+        dirstate_data_mmap =
+            repo.hg_vfs().mmap_open("dirstate").io_not_found_as_none()?;
+        let dirstate_data = dirstate_data_mmap.as_deref().unwrap_or(b"");
         DirstateMap::new_v1(dirstate_data)?
     };
+
     let options = StatusOptions {
         // TODO should be provided by the dirstate parsing and
         // hence be stored on dmap. Using a value that assumes we aren't
         // below the time resolution granularity of the FS and the
         // dirstate.
         last_normal_time: 0,
         // we're currently supporting file systems with exec flags only
         // anyway
         check_exec: true,
         list_clean: display_states.clean,
         list_unknown: display_states.unknown,
         list_ignored: display_states.ignored,
         collect_traversed_dirs: false,
     };
     let ignore_file = repo.working_directory_vfs().join(".hgignore"); // TODO hardcoded
     let (mut ds_status, pattern_warnings) = hg::dirstate_tree::status::status(
         &mut dmap,
         &AlwaysMatcher,
         repo.working_directory_path().to_owned(),
         vec![ignore_file],
         options,
     )?;
     if !pattern_warnings.is_empty() {
         warn!("Pattern warnings: {:?}", &pattern_warnings);
     }
 
     if !ds_status.bad.is_empty() {
         warn!("Bad matches {:?}", &(ds_status.bad))
     }
     if !ds_status.unsure.is_empty() {
         info!(
             "Files to be rechecked by retrieval from filelog: {:?}",
             &ds_status.unsure
         );
     }
     if !ds_status.unsure.is_empty()
         && (display_states.modified || display_states.clean)
     {
         let p1: Node = parents
             .expect(
                 "Dirstate with no parents should not list any file to
             be rechecked for modifications",
             )
             .p1
             .into();
         let p1_hex = format!("{:x}", p1);
         for to_check in ds_status.unsure {
             if cat_file_is_modified(repo, &to_check, &p1_hex)? {
                 if display_states.modified {
                     ds_status.modified.push(to_check);
                 }
             } else {
                 if display_states.clean {
                     ds_status.clean.push(to_check);
                 }
             }
         }
     }
     if display_states.modified {
         display_status_paths(ui, &mut ds_status.modified, b"M")?;
     }
     if display_states.added {
         display_status_paths(ui, &mut ds_status.added, b"A")?;
     }
     if display_states.removed {
         display_status_paths(ui, &mut ds_status.removed, b"R")?;
     }
     if display_states.deleted {
         display_status_paths(ui, &mut ds_status.deleted, b"!")?;
     }
     if display_states.unknown {
         display_status_paths(ui, &mut ds_status.unknown, b"?")?;
     }
     if display_states.ignored {
         display_status_paths(ui, &mut ds_status.ignored, b"I")?;
     }
     if display_states.clean {
         display_status_paths(ui, &mut ds_status.clean, b"C")?;
     }
     Ok(())
 }
 
 // Probably more elegant to use a Deref or Borrow trait rather than
 // harcode HgPathBuf, but probably not really useful at this point
 fn display_status_paths(
     ui: &Ui,
     paths: &mut [HgPathCow],
     status_prefix: &[u8],
 ) -> Result<(), CommandError> {
     paths.sort_unstable();
     for path in paths {
         // Same TODO as in commands::root
         let bytes: &[u8] = path.as_bytes();
         // TODO optim, probably lots of unneeded copies here, especially
         // if out stream is buffered
         ui.write_stdout(&[status_prefix, b" ", bytes, b"\n"].concat())?;
     }
     Ok(())
 }
 
 /// Check if a file is modified by comparing actual repo store and file system.
 ///
 /// This meant to be used for those that the dirstate cannot resolve, due
 /// to time resolution limits.
 ///
 /// TODO: detect permission bits and similar metadata modifications
 fn cat_file_is_modified(
     repo: &Repo,
     hg_path: &HgPath,
     rev: &str,
 ) -> Result<bool, CommandError> {
     // TODO CatRev expects &[HgPathBuf], something like
     // &[impl Deref<HgPath>] would be nicer and should avoid the copy
     let path_bufs = [hg_path.into()];
     // TODO IIUC CatRev returns a simple Vec<u8> for all files
     //      being able to tell them apart as (path, bytes) would be nicer
     //      and OPTIM would allow manifest resolution just once.
     let output = cat(repo, rev, &path_bufs).map_err(|e| (e, rev))?;
 
     let fs_path = repo
         .working_directory_vfs()
         .join(hg_path_to_os_string(hg_path).expect("HgPath conversion"));
     let hg_data_len: u64 = match output.concatenated.len().try_into() {
         Ok(v) => v,
         Err(_) => {
             // conversion of data length to u64 failed,
             // good luck for any file to have this content
             return Ok(true);
         }
     };
     let fobj = fs::File::open(&fs_path).when_reading_file(&fs_path)?;
     if fobj.metadata().map_err(|e| StatusError::from(e))?.len() != hg_data_len
     {
         return Ok(true);
     }
     for (fs_byte, hg_byte) in
         BufReader::new(fobj).bytes().zip(output.concatenated)
     {
         if fs_byte.map_err(|e| StatusError::from(e))? != hg_byte {
             return Ok(true);
         }
     }
     Ok(false)
 }

rust/rhg/src/error.rs

@@ -1,201 +1,208 b''
 use crate::ui::utf8_to_local;
 use crate::ui::UiError;
 use crate::NoRepoInCwdError;
 use format_bytes::format_bytes;
 use hg::config::{ConfigError, ConfigParseError, ConfigValueParseError};
+use hg::dirstate_tree::on_disk::DirstateV2ParseError;
 use hg::errors::HgError;
 use hg::exit_codes;
 use hg::repo::RepoError;
 use hg::revlog::revlog::RevlogError;
 use hg::utils::files::get_bytes_from_path;
 use hg::{DirstateError, DirstateMapError, StatusError};
 use std::convert::From;
 
 /// The kind of command error
 #[derive(Debug)]
 pub enum CommandError {
     /// Exit with an error message and "standard" failure exit code.
     Abort {
         message: Vec<u8>,
         detailed_exit_code: exit_codes::ExitCode,
     },
 
     /// Exit with a failure exit code but no message.
     Unsuccessful,
 
     /// Encountered something (such as a CLI argument, repository layout, …)
     /// not supported by this version of `rhg`. Depending on configuration
     /// `rhg` may attempt to silently fall back to Python-based `hg`, which
     /// may or may not support this feature.
     UnsupportedFeature { message: Vec<u8> },
 }
 
 impl CommandError {
     pub fn abort(message: impl AsRef<str>) -> Self {
         CommandError::abort_with_exit_code(message, exit_codes::ABORT)
     }
 
     pub fn abort_with_exit_code(
         message: impl AsRef<str>,
         detailed_exit_code: exit_codes::ExitCode,
     ) -> Self {
         CommandError::Abort {
             // TODO: bytes-based (instead of Unicode-based) formatting
             // of error messages to handle non-UTF-8 filenames etc:
             // https://www.mercurial-scm.org/wiki/EncodingStrategy#Mixing_output
             message: utf8_to_local(message.as_ref()).into(),
             detailed_exit_code: detailed_exit_code,
         }
     }
 
     pub fn unsupported(message: impl AsRef<str>) -> Self {
         CommandError::UnsupportedFeature {
             message: utf8_to_local(message.as_ref()).into(),
         }
     }
 }
 
 /// For now we don’t differenciate between invalid CLI args and valid for `hg`
 /// but not supported yet by `rhg`.
 impl From<clap::Error> for CommandError {
     fn from(error: clap::Error) -> Self {
         CommandError::unsupported(error.to_string())
     }
 }
 
 impl From<HgError> for CommandError {
     fn from(error: HgError) -> Self {
         match error {
             HgError::UnsupportedFeature(message) => {
                 CommandError::unsupported(message)
             }
             HgError::Abort {
                 message,
                 detailed_exit_code,
             } => {
                 CommandError::abort_with_exit_code(message, detailed_exit_code)
             }
             _ => CommandError::abort(error.to_string()),
         }
     }
 }
 
 impl From<ConfigValueParseError> for CommandError {
     fn from(error: ConfigValueParseError) -> Self {
         CommandError::abort_with_exit_code(
             error.to_string(),
             exit_codes::CONFIG_ERROR_ABORT,
         )
     }
 }
 
 impl From<UiError> for CommandError {
     fn from(_error: UiError) -> Self {
         // If we already failed writing to stdout or stderr,
         // writing an error message to stderr about it would be likely to fail
         // too.
         CommandError::abort("")
     }
 }
 
 impl From<RepoError> for CommandError {
     fn from(error: RepoError) -> Self {
         match error {
             RepoError::NotFound { at } => CommandError::Abort {
                 message: format_bytes!(
                     b"abort: repository {} not found",
                     get_bytes_from_path(at)
                 ),
                 detailed_exit_code: exit_codes::ABORT,
             },
             RepoError::ConfigParseError(error) => error.into(),
             RepoError::Other(error) => error.into(),
         }
     }
 }
 
 impl<'a> From<&'a NoRepoInCwdError> for CommandError {
     fn from(error: &'a NoRepoInCwdError) -> Self {
         let NoRepoInCwdError { cwd } = error;
         CommandError::Abort {
             message: format_bytes!(
                 b"abort: no repository found in '{}' (.hg not found)!",
                 get_bytes_from_path(cwd)
             ),
             detailed_exit_code: exit_codes::ABORT,
         }
     }
 }
 
 impl From<ConfigError> for CommandError {
     fn from(error: ConfigError) -> Self {
         match error {
             ConfigError::Parse(error) => error.into(),
             ConfigError::Other(error) => error.into(),
         }
     }
 }
 
 impl From<ConfigParseError> for CommandError {
     fn from(error: ConfigParseError) -> Self {
         let ConfigParseError {
             origin,
             line,
             message,
         } = error;
         let line_message = if let Some(line_number) = line {
             format_bytes!(b":{}", line_number.to_string().into_bytes())
         } else {
             Vec::new()
         };
         CommandError::Abort {
             message: format_bytes!(
                 b"config error at {}{}: {}",
                 origin,
                 line_message,
                 message
             ),
             detailed_exit_code: exit_codes::CONFIG_ERROR_ABORT,
         }
     }
 }
 
 impl From<(RevlogError, &str)> for CommandError {
     fn from((err, rev): (RevlogError, &str)) -> CommandError {
         match err {
             RevlogError::WDirUnsupported => CommandError::abort(
                 "abort: working directory revision cannot be specified",
             ),
             RevlogError::InvalidRevision => CommandError::abort(format!(
                 "abort: invalid revision identifier: {}",
                 rev
             )),
             RevlogError::AmbiguousPrefix => CommandError::abort(format!(
                 "abort: ambiguous revision identifier: {}",
                 rev
             )),
             RevlogError::Other(error) => error.into(),
         }
     }
 }
 
 impl From<StatusError> for CommandError {
     fn from(error: StatusError) -> Self {
         CommandError::abort(format!("{}", error))
     }
 }
 
 impl From<DirstateMapError> for CommandError {
     fn from(error: DirstateMapError) -> Self {
         CommandError::abort(format!("{}", error))
     }
 }
 
 impl From<DirstateError> for CommandError {
     fn from(error: DirstateError) -> Self {
         match error {
             DirstateError::Common(error) => error.into(),
             DirstateError::Map(error) => error.into(),
         }
     }
 }
+
+impl From<DirstateV2ParseError> for CommandError {
+    fn from(error: DirstateV2ParseError) -> Self {
+        HgError::from(error).into()
+    }
+}

setup.py

@@ -1,1856 +1,1857 b''
 #
 # This is the mercurial setup script.
 #
 # 'python setup.py install', or
 # 'python setup.py --help' for more options
 import os
 
 # Mercurial will never work on Python 3 before 3.5 due to a lack
 # of % formatting on bytestrings, and can't work on 3.6.0 or 3.6.1
 # due to a bug in % formatting in bytestrings.
 # We cannot support Python 3.5.0, 3.5.1, 3.5.2 because of bug in
 # codecs.escape_encode() where it raises SystemError on empty bytestring
 # bug link: https://bugs.python.org/issue25270
 supportedpy = ','.join(
     [
         '>=2.7.4',
         '!=3.0.*',
         '!=3.1.*',
         '!=3.2.*',
         '!=3.3.*',
         '!=3.4.*',
         '!=3.5.0',
         '!=3.5.1',
         '!=3.5.2',
         '!=3.6.0',
         '!=3.6.1',
     ]
 )
 
 import sys, platform
 import sysconfig
 
 if sys.version_info[0] >= 3:
     printf = eval('print')
     libdir_escape = 'unicode_escape'
 
     def sysstr(s):
         return s.decode('latin-1')
 
 
 else:
     libdir_escape = 'string_escape'
 
     def printf(*args, **kwargs):
         f = kwargs.get('file', sys.stdout)
         end = kwargs.get('end', '\n')
         f.write(b' '.join(args) + end)
 
     def sysstr(s):
         return s
 
 
 # Attempt to guide users to a modern pip - this means that 2.6 users
 # should have a chance of getting a 4.2 release, and when we ratchet
 # the version requirement forward again hopefully everyone will get
 # something that works for them.
 if sys.version_info < (2, 7, 4, 'final'):
     pip_message = (
         'This may be due to an out of date pip. '
         'Make sure you have pip >= 9.0.1.'
     )
     try:
         import pip
 
         pip_version = tuple([int(x) for x in pip.__version__.split('.')[:3]])
         if pip_version < (9, 0, 1):
             pip_message = (
                 'Your pip version is out of date, please install '
                 'pip >= 9.0.1. pip {} detected.'.format(pip.__version__)
             )
         else:
             # pip is new enough - it must be something else
             pip_message = ''
     except Exception:
         pass
     error = """
 Mercurial does not support Python older than 2.7.4.
 Python {py} detected.
 {pip}
 """.format(
         py=sys.version_info, pip=pip_message
     )
     printf(error, file=sys.stderr)
     sys.exit(1)
 
 import ssl
 
 try:
     ssl.SSLContext
 except AttributeError:
     error = """
 The `ssl` module does not have the `SSLContext` class. This indicates an old
 Python version which does not support modern security features (which were
 added to Python 2.7 as part of "PEP 466"). Please make sure you have installed
 at least Python 2.7.9 or a Python version with backports of these security
 features.
 """
     printf(error, file=sys.stderr)
     sys.exit(1)
 
 # ssl.HAS_TLSv1* are preferred to check support but they were added in Python
 # 3.7. Prior to CPython commit 6e8cda91d92da72800d891b2fc2073ecbc134d98
 # (backported to the 3.7 branch), ssl.PROTOCOL_TLSv1_1 / ssl.PROTOCOL_TLSv1_2
 # were defined only if compiled against a OpenSSL version with TLS 1.1 / 1.2
 # support. At the mentioned commit, they were unconditionally defined.
 _notset = object()
 has_tlsv1_1 = getattr(ssl, 'HAS_TLSv1_1', _notset)
 if has_tlsv1_1 is _notset:
     has_tlsv1_1 = getattr(ssl, 'PROTOCOL_TLSv1_1', _notset) is not _notset
 has_tlsv1_2 = getattr(ssl, 'HAS_TLSv1_2', _notset)
 if has_tlsv1_2 is _notset:
     has_tlsv1_2 = getattr(ssl, 'PROTOCOL_TLSv1_2', _notset) is not _notset
 if not (has_tlsv1_1 or has_tlsv1_2):
     error = """
 The `ssl` module does not advertise support for TLS 1.1 or TLS 1.2.
 Please make sure that your Python installation was compiled against an OpenSSL
 version enabling these features (likely this requires the OpenSSL version to
 be at least 1.0.1).
 """
     printf(error, file=sys.stderr)
     sys.exit(1)
 
 if sys.version_info[0] >= 3:
     DYLIB_SUFFIX = sysconfig.get_config_vars()['EXT_SUFFIX']
 else:
     # deprecated in Python 3
     DYLIB_SUFFIX = sysconfig.get_config_vars()['SO']
 
 # Solaris Python packaging brain damage
 try:
     import hashlib
 
     sha = hashlib.sha1()
 except ImportError:
     try:
         import sha
 
         sha.sha  # silence unused import warning
     except ImportError:
         raise SystemExit(
             "Couldn't import standard hashlib (incomplete Python install)."
         )
 
 try:
     import zlib
 
     zlib.compressobj  # silence unused import warning
 except ImportError:
     raise SystemExit(
         "Couldn't import standard zlib (incomplete Python install)."
     )
 
 # The base IronPython distribution (as of 2.7.1) doesn't support bz2
 isironpython = False
 try:
     isironpython = (
         platform.python_implementation().lower().find("ironpython") != -1
     )
 except AttributeError:
     pass
 
 if isironpython:
     sys.stderr.write("warning: IronPython detected (no bz2 support)\n")
 else:
     try:
         import bz2
 
         bz2.BZ2Compressor  # silence unused import warning
     except ImportError:
         raise SystemExit(
             "Couldn't import standard bz2 (incomplete Python install)."
         )
 
 ispypy = "PyPy" in sys.version
 
 import ctypes
 import errno
 import stat, subprocess, time
 import re
 import shutil
 import tempfile
 
 # We have issues with setuptools on some platforms and builders. Until
 # those are resolved, setuptools is opt-in except for platforms where
 # we don't have issues.
 issetuptools = os.name == 'nt' or 'FORCE_SETUPTOOLS' in os.environ
 if issetuptools:
     from setuptools import setup
 else:
     from distutils.core import setup
 from distutils.ccompiler import new_compiler
 from distutils.core import Command, Extension
 from distutils.dist import Distribution
 from distutils.command.build import build
 from distutils.command.build_ext import build_ext
 from distutils.command.build_py import build_py
 from distutils.command.build_scripts import build_scripts
 from distutils.command.install import install
 from distutils.command.install_lib import install_lib
 from distutils.command.install_scripts import install_scripts
 from distutils import log
 from distutils.spawn import spawn, find_executable
 from distutils import file_util
 from distutils.errors import (
     CCompilerError,
     DistutilsError,
     DistutilsExecError,
 )
 from distutils.sysconfig import get_python_inc, get_config_var
 from distutils.version import StrictVersion
 
 # Explain to distutils.StrictVersion how our release candidates are versionned
 StrictVersion.version_re = re.compile(r'^(\d+)\.(\d+)(\.(\d+))?-?(rc(\d+))?$')
 
 
 def write_if_changed(path, content):
     """Write content to a file iff the content hasn't changed."""
     if os.path.exists(path):
         with open(path, 'rb') as fh:
             current = fh.read()
     else:
         current = b''
 
     if current != content:
         with open(path, 'wb') as fh:
             fh.write(content)
 
 
 scripts = ['hg']
 if os.name == 'nt':
     # We remove hg.bat if we are able to build hg.exe.
     scripts.append('contrib/win32/hg.bat')
 
 
 def cancompile(cc, code):
     tmpdir = tempfile.mkdtemp(prefix='hg-install-')
     devnull = oldstderr = None
     try:
         fname = os.path.join(tmpdir, 'testcomp.c')
         f = open(fname, 'w')
         f.write(code)
         f.close()
         # Redirect stderr to /dev/null to hide any error messages
         # from the compiler.
         # This will have to be changed if we ever have to check
         # for a function on Windows.
         devnull = open('/dev/null', 'w')
         oldstderr = os.dup(sys.stderr.fileno())
         os.dup2(devnull.fileno(), sys.stderr.fileno())
         objects = cc.compile([fname], output_dir=tmpdir)
         cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
         return True
     except Exception:
         return False
     finally:
         if oldstderr is not None:
             os.dup2(oldstderr, sys.stderr.fileno())
         if devnull is not None:
             devnull.close()
         shutil.rmtree(tmpdir)
 
 
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
     code = 'int main(void) { %s(); }\n' % funcname
     return cancompile(cc, code)
 
 
 def hasheader(cc, headername):
     code = '#include <%s>\nint main(void) { return 0; }\n' % headername
     return cancompile(cc, code)
 
 
 # py2exe needs to be installed to work
 try:
     import py2exe
 
     py2exe.Distribution  # silence unused import warning
     py2exeloaded = True
     # import py2exe's patched Distribution class
     from distutils.core import Distribution
 except ImportError:
     py2exeloaded = False
 
 
 def runcmd(cmd, env, cwd=None):
     p = subprocess.Popen(
         cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, cwd=cwd
     )
     out, err = p.communicate()
     return p.returncode, out, err
 
 
 class hgcommand(object):
     def __init__(self, cmd, env):
         self.cmd = cmd
         self.env = env
 
     def run(self, args):
         cmd = self.cmd + args
         returncode, out, err = runcmd(cmd, self.env)
         err = filterhgerr(err)
         if err or returncode != 0:
             printf("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)
             printf(err, file=sys.stderr)
             return b''
         return out
 
 
 def filterhgerr(err):
     # If root is executing setup.py, but the repository is owned by
     # another user (as in "sudo python setup.py install") we will get
     # trust warnings since the .hg/hgrc file is untrusted. That is
     # fine, we don't want to load it anyway.  Python may warn about
     # a missing __init__.py in mercurial/locale, we also ignore that.
     err = [
         e
         for e in err.splitlines()
         if (
             not e.startswith(b'not trusting file')
             and not e.startswith(b'warning: Not importing')
             and not e.startswith(b'obsolete feature not enabled')
             and not e.startswith(b'*** failed to import extension')
             and not e.startswith(b'devel-warn:')
             and not (
                 e.startswith(b'(third party extension')
                 and e.endswith(b'or newer of Mercurial; disabling)')
             )
         )
     ]
     return b'\n'.join(b'  ' + e for e in err)
 
 
 def findhg():
     """Try to figure out how we should invoke hg for examining the local
     repository contents.
 
     Returns an hgcommand object."""
     # By default, prefer the "hg" command in the user's path.  This was
     # presumably the hg command that the user used to create this repository.
     #
     # This repository may require extensions or other settings that would not
     # be enabled by running the hg script directly from this local repository.
     hgenv = os.environ.copy()
     # Use HGPLAIN to disable hgrc settings that would change output formatting,
     # and disable localization for the same reasons.
     hgenv['HGPLAIN'] = '1'
     hgenv['LANGUAGE'] = 'C'
     hgcmd = ['hg']
     # Run a simple "hg log" command just to see if using hg from the user's
     # path works and can successfully interact with this repository.  Windows
     # gives precedence to hg.exe in the current directory, so fall back to the
     # python invocation of local hg, where pythonXY.dll can always be found.
     check_cmd = ['log', '-r.', '-Ttest']
     if os.name != 'nt' or not os.path.exists("hg.exe"):
         try:
             retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
         except EnvironmentError:
             retcode = -1
         if retcode == 0 and not filterhgerr(err):
             return hgcommand(hgcmd, hgenv)
 
     # Fall back to trying the local hg installation.
     hgenv = localhgenv()
     hgcmd = [sys.executable, 'hg']
     try:
         retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
     except EnvironmentError:
         retcode = -1
     if retcode == 0 and not filterhgerr(err):
         return hgcommand(hgcmd, hgenv)
 
     raise SystemExit(
         'Unable to find a working hg binary to extract the '
         'version from the repository tags'
     )
 
 
 def localhgenv():
     """Get an environment dictionary to use for invoking or importing
     mercurial from the local repository."""
     # Execute hg out of this directory with a custom environment which takes
     # care to not use any hgrc files and do no localization.
     env = {
         'HGMODULEPOLICY': 'py',
         'HGRCPATH': '',
         'LANGUAGE': 'C',
         'PATH': '',
     }  # make pypi modules that use os.environ['PATH'] happy
     if 'LD_LIBRARY_PATH' in os.environ:
         env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
     if 'SystemRoot' in os.environ:
         # SystemRoot is required by Windows to load various DLLs.  See:
         # https://bugs.python.org/issue13524#msg148850
         env['SystemRoot'] = os.environ['SystemRoot']
     return env
 
 
 version = ''
 
 if os.path.isdir('.hg'):
     hg = findhg()
     cmd = ['log', '-r', '.', '--template', '{tags}\n']
     numerictags = [t for t in sysstr(hg.run(cmd)).split() if t[0:1].isdigit()]
     hgid = sysstr(hg.run(['id', '-i'])).strip()
     if not hgid:
         # Bail out if hg is having problems interacting with this repository,
         # rather than falling through and producing a bogus version number.
         # Continuing with an invalid version number will break extensions
         # that define minimumhgversion.
         raise SystemExit('Unable to determine hg version from local repository')
     if numerictags:  # tag(s) found
         version = numerictags[-1]
         if hgid.endswith('+'):  # propagate the dirty status to the tag
             version += '+'
     else:  # no tag found
         ltagcmd = ['parents', '--template', '{latesttag}']
         ltag = sysstr(hg.run(ltagcmd))
         changessincecmd = ['log', '-T', 'x\n', '-r', "only(.,'%s')" % ltag]
         changessince = len(hg.run(changessincecmd).splitlines())
         version = '%s+hg%s.%s' % (ltag, changessince, hgid)
     if version.endswith('+'):
         version = version[:-1] + 'local' + time.strftime('%Y%m%d')
 elif os.path.exists('.hg_archival.txt'):
     kw = dict(
         [[t.strip() for t in l.split(':', 1)] for l in open('.hg_archival.txt')]
     )
     if 'tag' in kw:
         version = kw['tag']
     elif 'latesttag' in kw:
         if 'changessincelatesttag' in kw:
             version = (
                 '%(latesttag)s+hg%(changessincelatesttag)s.%(node).12s' % kw
             )
         else:
             version = '%(latesttag)s+hg%(latesttagdistance)s.%(node).12s' % kw
     else:
         version = '0+hg' + kw.get('node', '')[:12]
 elif os.path.exists('mercurial/__version__.py'):
     with open('mercurial/__version__.py') as f:
         data = f.read()
     version = re.search('version = b"(.*)"', data).group(1)
 
 if version:
     versionb = version
     if not isinstance(versionb, bytes):
         versionb = versionb.encode('ascii')
 
     write_if_changed(
         'mercurial/__version__.py',
         b''.join(
             [
                 b'# this file is autogenerated by setup.py\n'
                 b'version = b"%s"\n' % versionb,
             ]
         ),
     )
 
 
 class hgbuild(build):
     # Insert hgbuildmo first so that files in mercurial/locale/ are found
     # when build_py is run next.
     sub_commands = [('build_mo', None)] + build.sub_commands
 
 
 class hgbuildmo(build):
 
     description = "build translations (.mo files)"
 
     def run(self):
         if not find_executable('msgfmt'):
             self.warn(
                 "could not find msgfmt executable, no translations "
                 "will be built"
             )
             return
 
         podir = 'i18n'
         if not os.path.isdir(podir):
             self.warn("could not find %s/ directory" % podir)
             return
 
         join = os.path.join
         for po in os.listdir(podir):
             if not po.endswith('.po'):
                 continue
             pofile = join(podir, po)
             modir = join('locale', po[:-3], 'LC_MESSAGES')
             mofile = join(modir, 'hg.mo')
             mobuildfile = join('mercurial', mofile)
             cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
             if sys.platform != 'sunos5':
                 # msgfmt on Solaris does not know about -c
                 cmd.append('-c')
             self.mkpath(join('mercurial', modir))
             self.make_file([pofile], mobuildfile, spawn, (cmd,))
 
 
 class hgdist(Distribution):
     pure = False
     rust = False
     no_rust = False
     cffi = ispypy
 
     global_options = Distribution.global_options + [
         ('pure', None, "use pure (slow) Python code instead of C extensions"),
         ('rust', None, "use Rust extensions additionally to C extensions"),
         (
             'no-rust',
             None,
             "do not use Rust extensions additionally to C extensions",
         ),
     ]
 
     negative_opt = Distribution.negative_opt.copy()
     boolean_options = ['pure', 'rust', 'no-rust']
     negative_opt['no-rust'] = 'rust'
 
     def _set_command_options(self, command_obj, option_dict=None):
         # Not all distutils versions in the wild have boolean_options.
         # This should be cleaned up when we're Python 3 only.
         command_obj.boolean_options = (
             getattr(command_obj, 'boolean_options', []) + self.boolean_options
         )
         return Distribution._set_command_options(
             self, command_obj, option_dict=option_dict
         )
 
     def parse_command_line(self):
         ret = Distribution.parse_command_line(self)
         if not (self.rust or self.no_rust):
             hgrustext = os.environ.get('HGWITHRUSTEXT')
             # TODO record it for proper rebuild upon changes
             # (see mercurial/__modulepolicy__.py)
             if hgrustext != 'cpython' and hgrustext is not None:
                 if hgrustext:
                     msg = 'unkown HGWITHRUSTEXT value: %s' % hgrustext
                     printf(msg, file=sys.stderr)
                 hgrustext = None
             self.rust = hgrustext is not None
             self.no_rust = not self.rust
         return ret
 
     def has_ext_modules(self):
         # self.ext_modules is emptied in hgbuildpy.finalize_options which is
         # too late for some cases
         return not self.pure and Distribution.has_ext_modules(self)
 
 
 # This is ugly as a one-liner. So use a variable.
 buildextnegops = dict(getattr(build_ext, 'negative_options', {}))
 buildextnegops['no-zstd'] = 'zstd'
 buildextnegops['no-rust'] = 'rust'
 
 
 class hgbuildext(build_ext):
     user_options = build_ext.user_options + [
         ('zstd', None, 'compile zstd bindings [default]'),
         ('no-zstd', None, 'do not compile zstd bindings'),
         (
             'rust',
             None,
             'compile Rust extensions if they are in use '
             '(requires Cargo) [default]',
         ),
         ('no-rust', None, 'do not compile Rust extensions'),
     ]
 
     boolean_options = build_ext.boolean_options + ['zstd', 'rust']
     negative_opt = buildextnegops
 
     def initialize_options(self):
         self.zstd = True
         self.rust = True
 
         return build_ext.initialize_options(self)
 
     def finalize_options(self):
         # Unless overridden by the end user, build extensions in parallel.
         # Only influences behavior on Python 3.5+.
         if getattr(self, 'parallel', None) is None:
             self.parallel = True
 
         return build_ext.finalize_options(self)
 
     def build_extensions(self):
         ruststandalones = [
             e for e in self.extensions if isinstance(e, RustStandaloneExtension)
         ]
         self.extensions = [
             e for e in self.extensions if e not in ruststandalones
         ]
         # Filter out zstd if disabled via argument.
         if not self.zstd:
             self.extensions = [
                 e for e in self.extensions if e.name != 'mercurial.zstd'
             ]
 
         # Build Rust standalon extensions if it'll be used
         # and its build is not explictely disabled (for external build
         # as Linux distributions would do)
         if self.distribution.rust and self.rust:
             if not sys.platform.startswith('linux'):
                 self.warn(
                     "rust extensions have only been tested on Linux "
                     "and may not behave correctly on other platforms"
                 )
 
             for rustext in ruststandalones:
                 rustext.build('' if self.inplace else self.build_lib)
 
         return build_ext.build_extensions(self)
 
     def build_extension(self, ext):
         if (
             self.distribution.rust
             and self.rust
             and isinstance(ext, RustExtension)
         ):
             ext.rustbuild()
         try:
             build_ext.build_extension(self, ext)
         except CCompilerError:
             if not getattr(ext, 'optional', False):
                 raise
             log.warn(
                 "Failed to build optional extension '%s' (skipping)", ext.name
             )
 
 
 class hgbuildscripts(build_scripts):
     def run(self):
         if os.name != 'nt' or self.distribution.pure:
             return build_scripts.run(self)
 
         exebuilt = False
         try:
             self.run_command('build_hgexe')
             exebuilt = True
         except (DistutilsError, CCompilerError):
             log.warn('failed to build optional hg.exe')
 
         if exebuilt:
             # Copying hg.exe to the scripts build directory ensures it is
             # installed by the install_scripts command.
             hgexecommand = self.get_finalized_command('build_hgexe')
             dest = os.path.join(self.build_dir, 'hg.exe')
             self.mkpath(self.build_dir)
             self.copy_file(hgexecommand.hgexepath, dest)
 
             # Remove hg.bat because it is redundant with hg.exe.
             self.scripts.remove('contrib/win32/hg.bat')
 
         return build_scripts.run(self)
 
 
 class hgbuildpy(build_py):
     def finalize_options(self):
         build_py.finalize_options(self)
 
         if self.distribution.pure:
             self.distribution.ext_modules = []
         elif self.distribution.cffi:
             from mercurial.cffi import (
                 bdiffbuild,
                 mpatchbuild,
             )
 
             exts = [
                 mpatchbuild.ffi.distutils_extension(),
                 bdiffbuild.ffi.distutils_extension(),
             ]
             # cffi modules go here
             if sys.platform == 'darwin':
                 from mercurial.cffi import osutilbuild
 
                 exts.append(osutilbuild.ffi.distutils_extension())
             self.distribution.ext_modules = exts
         else:
             h = os.path.join(get_python_inc(), 'Python.h')
             if not os.path.exists(h):
                 raise SystemExit(
                     'Python headers are required to build '
                     'Mercurial but weren\'t found in %s' % h
                 )
 
     def run(self):
         basepath = os.path.join(self.build_lib, 'mercurial')
         self.mkpath(basepath)
 
         rust = self.distribution.rust
         if self.distribution.pure:
             modulepolicy = 'py'
         elif self.build_lib == '.':
             # in-place build should run without rebuilding and Rust extensions
             modulepolicy = 'rust+c-allow' if rust else 'allow'
         else:
             modulepolicy = 'rust+c' if rust else 'c'
 
         content = b''.join(
             [
                 b'# this file is autogenerated by setup.py\n',
                 b'modulepolicy = b"%s"\n' % modulepolicy.encode('ascii'),
             ]
         )
         write_if_changed(os.path.join(basepath, '__modulepolicy__.py'), content)
 
         build_py.run(self)
 
 
 class buildhgextindex(Command):
     description = 'generate prebuilt index of hgext (for frozen package)'
     user_options = []
     _indexfilename = 'hgext/__index__.py'
 
     def initialize_options(self):
         pass
 
     def finalize_options(self):
         pass
 
     def run(self):
         if os.path.exists(self._indexfilename):
             with open(self._indexfilename, 'w') as f:
                 f.write('# empty\n')
 
         # here no extension enabled, disabled() lists up everything
         code = (
             'import pprint; from mercurial import extensions; '
             'ext = extensions.disabled();'
             'ext.pop("__index__", None);'
             'pprint.pprint(ext)'
         )
         returncode, out, err = runcmd(
             [sys.executable, '-c', code], localhgenv()
         )
         if err or returncode != 0:
             raise DistutilsExecError(err)
 
         with open(self._indexfilename, 'wb') as f:
             f.write(b'# this file is autogenerated by setup.py\n')
             f.write(b'docs = ')
             f.write(out)
 
 
 class buildhgexe(build_ext):
     description = 'compile hg.exe from mercurial/exewrapper.c'
     user_options = build_ext.user_options + [
         (
             'long-paths-support',
             None,
             'enable support for long paths on '
             'Windows (off by default and '
             'experimental)',
         ),
     ]
 
     LONG_PATHS_MANIFEST = """
     <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
     <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
         <application>
             <windowsSettings
             xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
                 <ws2:longPathAware>true</ws2:longPathAware>
             </windowsSettings>
         </application>
     </assembly>"""
 
     def initialize_options(self):
         build_ext.initialize_options(self)
         self.long_paths_support = False
 
     def build_extensions(self):
         if os.name != 'nt':
             return
         if isinstance(self.compiler, HackedMingw32CCompiler):
             self.compiler.compiler_so = self.compiler.compiler  # no -mdll
             self.compiler.dll_libraries = []  # no -lmsrvc90
 
         pythonlib = None
 
         dir = os.path.dirname(self.get_ext_fullpath('dummy'))
         self.hgtarget = os.path.join(dir, 'hg')
 
         if getattr(sys, 'dllhandle', None):
             # Different Python installs can have different Python library
             # names. e.g. the official CPython distribution uses pythonXY.dll
             # and MinGW uses libpythonX.Y.dll.
             _kernel32 = ctypes.windll.kernel32
             _kernel32.GetModuleFileNameA.argtypes = [
                 ctypes.c_void_p,
                 ctypes.c_void_p,
                 ctypes.c_ulong,
             ]
             _kernel32.GetModuleFileNameA.restype = ctypes.c_ulong
             size = 1000
             buf = ctypes.create_string_buffer(size + 1)
             filelen = _kernel32.GetModuleFileNameA(
                 sys.dllhandle, ctypes.byref(buf), size
             )
 
             if filelen > 0 and filelen != size:
                 dllbasename = os.path.basename(buf.value)
                 if not dllbasename.lower().endswith(b'.dll'):
                     raise SystemExit(
                         'Python DLL does not end with .dll: %s' % dllbasename
                     )
                 pythonlib = dllbasename[:-4]
 
                 # Copy the pythonXY.dll next to the binary so that it runs
                 # without tampering with PATH.
                 fsdecode = lambda x: x
                 if sys.version_info[0] >= 3:
                     fsdecode = os.fsdecode
                 dest = os.path.join(
                     os.path.dirname(self.hgtarget),
                     fsdecode(dllbasename),
                 )
 
                 if not os.path.exists(dest):
                     shutil.copy(buf.value, dest)
 
                 # Also overwrite python3.dll so that hgext.git is usable.
                 # TODO: also handle the MSYS flavor
                 if sys.version_info[0] >= 3:
                     python_x = os.path.join(
                         os.path.dirname(fsdecode(buf.value)),
                         "python3.dll",
                     )
 
                     if os.path.exists(python_x):
                         dest = os.path.join(
                             os.path.dirname(self.hgtarget),
                             os.path.basename(python_x),
                         )
 
                         shutil.copy(python_x, dest)
 
         if not pythonlib:
             log.warn(
                 'could not determine Python DLL filename; assuming pythonXY'
             )
 
             hv = sys.hexversion
             pythonlib = b'python%d%d' % (hv >> 24, (hv >> 16) & 0xFF)
 
         log.info('using %s as Python library name' % pythonlib)
         with open('mercurial/hgpythonlib.h', 'wb') as f:
             f.write(b'/* this file is autogenerated by setup.py */\n')
             f.write(b'#define HGPYTHONLIB "%s"\n' % pythonlib)
 
         macros = None
         if sys.version_info[0] >= 3:
             macros = [('_UNICODE', None), ('UNICODE', None)]
 
         objects = self.compiler.compile(
             ['mercurial/exewrapper.c'],
             output_dir=self.build_temp,
             macros=macros,
         )
         self.compiler.link_executable(
             objects, self.hgtarget, libraries=[], output_dir=self.build_temp
         )
         if self.long_paths_support:
             self.addlongpathsmanifest()
 
     def addlongpathsmanifest(self):
         r"""Add manifest pieces so that hg.exe understands long paths
 
         This is an EXPERIMENTAL feature, use with care.
         To enable long paths support, one needs to do two things:
         - build Mercurial with --long-paths-support option
         - change HKLM\SYSTEM\CurrentControlSet\Control\FileSystem\
                  LongPathsEnabled to have value 1.
 
         Please ignore 'warning 81010002: Unrecognized Element "longPathAware"';
         it happens because Mercurial uses mt.exe circa 2008, which is not
         yet aware of long paths support in the manifest (I think so at least).
         This does not stop mt.exe from embedding/merging the XML properly.
 
         Why resource #1 should be used for .exe manifests? I don't know and
         wasn't able to find an explanation for mortals. But it seems to work.
         """
         exefname = self.compiler.executable_filename(self.hgtarget)
         fdauto, manfname = tempfile.mkstemp(suffix='.hg.exe.manifest')
         os.close(fdauto)
         with open(manfname, 'w') as f:
             f.write(self.LONG_PATHS_MANIFEST)
         log.info("long paths manifest is written to '%s'" % manfname)
         inputresource = '-inputresource:%s;#1' % exefname
         outputresource = '-outputresource:%s;#1' % exefname
         log.info("running mt.exe to update hg.exe's manifest in-place")
         # supplying both -manifest and -inputresource to mt.exe makes
         # it merge the embedded and supplied manifests in the -outputresource
         self.spawn(
             [
                 'mt.exe',
                 '-nologo',
                 '-manifest',
                 manfname,
                 inputresource,
                 outputresource,
             ]
         )
         log.info("done updating hg.exe's manifest")
         os.remove(manfname)
 
     @property
     def hgexepath(self):
         dir = os.path.dirname(self.get_ext_fullpath('dummy'))
         return os.path.join(self.build_temp, dir, 'hg.exe')
 
 
 class hgbuilddoc(Command):
     description = 'build documentation'
     user_options = [
         ('man', None, 'generate man pages'),
         ('html', None, 'generate html pages'),
     ]
 
     def initialize_options(self):
         self.man = None
         self.html = None
 
     def finalize_options(self):
         # If --man or --html are set, only generate what we're told to.
         # Otherwise generate everything.
         have_subset = self.man is not None or self.html is not None
 
         if have_subset:
             self.man = True if self.man else False
             self.html = True if self.html else False
         else:
             self.man = True
             self.html = True
 
     def run(self):
         def normalizecrlf(p):
             with open(p, 'rb') as fh:
                 orig = fh.read()
 
             if b'\r\n' not in orig:
                 return
 
             log.info('normalizing %s to LF line endings' % p)
             with open(p, 'wb') as fh:
                 fh.write(orig.replace(b'\r\n', b'\n'))
 
         def gentxt(root):
             txt = 'doc/%s.txt' % root
             log.info('generating %s' % txt)
             res, out, err = runcmd(
                 [sys.executable, 'gendoc.py', root], os.environ, cwd='doc'
             )
             if res:
                 raise SystemExit(
                     'error running gendoc.py: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             with open(txt, 'wb') as fh:
                 fh.write(out)
 
         def gengendoc(root):
             gendoc = 'doc/%s.gendoc.txt' % root
 
             log.info('generating %s' % gendoc)
             res, out, err = runcmd(
                 [sys.executable, 'gendoc.py', '%s.gendoc' % root],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running gendoc: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             with open(gendoc, 'wb') as fh:
                 fh.write(out)
 
         def genman(root):
             log.info('generating doc/%s' % root)
             res, out, err = runcmd(
                 [
                     sys.executable,
                     'runrst',
                     'hgmanpage',
                     '--halt',
                     'warning',
                     '--strip-elements-with-class',
                     'htmlonly',
                     '%s.txt' % root,
                     root,
                 ],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running runrst: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             normalizecrlf('doc/%s' % root)
 
         def genhtml(root):
             log.info('generating doc/%s.html' % root)
             res, out, err = runcmd(
                 [
                     sys.executable,
                     'runrst',
                     'html',
                     '--halt',
                     'warning',
                     '--link-stylesheet',
                     '--stylesheet-path',
                     'style.css',
                     '%s.txt' % root,
                     '%s.html' % root,
                 ],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running runrst: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             normalizecrlf('doc/%s.html' % root)
 
         # This logic is duplicated in doc/Makefile.
         sources = {
             f
             for f in os.listdir('mercurial/helptext')
             if re.search(r'[0-9]\.txt$', f)
         }
 
         # common.txt is a one-off.
         gentxt('common')
 
         for source in sorted(sources):
             assert source[-4:] == '.txt'
             root = source[:-4]
 
             gentxt(root)
             gengendoc(root)
 
             if self.man:
                 genman(root)
             if self.html:
                 genhtml(root)
 
 
 class hginstall(install):
 
     user_options = install.user_options + [
         (
             'old-and-unmanageable',
             None,
             'noop, present for eggless setuptools compat',
         ),
         (
             'single-version-externally-managed',
             None,
             'noop, present for eggless setuptools compat',
         ),
     ]
 
     # Also helps setuptools not be sad while we refuse to create eggs.
     single_version_externally_managed = True
 
     def get_sub_commands(self):
         # Screen out egg related commands to prevent egg generation.  But allow
         # mercurial.egg-info generation, since that is part of modern
         # packaging.
         excl = {'bdist_egg'}
         return filter(lambda x: x not in excl, install.get_sub_commands(self))
 
 
 class hginstalllib(install_lib):
     """
     This is a specialization of install_lib that replaces the copy_file used
     there so that it supports setting the mode of files after copying them,
     instead of just preserving the mode that the files originally had.  If your
     system has a umask of something like 027, preserving the permissions when
     copying will lead to a broken install.
 
     Note that just passing keep_permissions=False to copy_file would be
     insufficient, as it might still be applying a umask.
     """
 
     def run(self):
         realcopyfile = file_util.copy_file
 
         def copyfileandsetmode(*args, **kwargs):
             src, dst = args[0], args[1]
             dst, copied = realcopyfile(*args, **kwargs)
             if copied:
                 st = os.stat(src)
                 # Persist executable bit (apply it to group and other if user
                 # has it)
                 if st[stat.ST_MODE] & stat.S_IXUSR:
                     setmode = int('0755', 8)
                 else:
                     setmode = int('0644', 8)
                 m = stat.S_IMODE(st[stat.ST_MODE])
                 m = (m & ~int('0777', 8)) | setmode
                 os.chmod(dst, m)
 
         file_util.copy_file = copyfileandsetmode
         try:
             install_lib.run(self)
         finally:
             file_util.copy_file = realcopyfile
 
 
 class hginstallscripts(install_scripts):
     """
     This is a specialization of install_scripts that replaces the @LIBDIR@ with
     the configured directory for modules. If possible, the path is made relative
     to the directory for scripts.
     """
 
     def initialize_options(self):
         install_scripts.initialize_options(self)
 
         self.install_lib = None
 
     def finalize_options(self):
         install_scripts.finalize_options(self)
         self.set_undefined_options('install', ('install_lib', 'install_lib'))
 
     def run(self):
         install_scripts.run(self)
 
         # It only makes sense to replace @LIBDIR@ with the install path if
         # the install path is known. For wheels, the logic below calculates
         # the libdir to be "../..". This is because the internal layout of a
         # wheel archive looks like:
         #
         #   mercurial-3.6.1.data/scripts/hg
         #   mercurial/__init__.py
         #
         # When installing wheels, the subdirectories of the "<pkg>.data"
         # directory are translated to system local paths and files therein
         # are copied in place. The mercurial/* files are installed into the
         # site-packages directory. However, the site-packages directory
         # isn't known until wheel install time. This means we have no clue
         # at wheel generation time what the installed site-packages directory
         # will be. And, wheels don't appear to provide the ability to register
         # custom code to run during wheel installation. This all means that
         # we can't reliably set the libdir in wheels: the default behavior
         # of looking in sys.path must do.
 
         if (
             os.path.splitdrive(self.install_dir)[0]
             != os.path.splitdrive(self.install_lib)[0]
         ):
             # can't make relative paths from one drive to another, so use an
             # absolute path instead
             libdir = self.install_lib
         else:
             libdir = os.path.relpath(self.install_lib, self.install_dir)
 
         for outfile in self.outfiles:
             with open(outfile, 'rb') as fp:
                 data = fp.read()
 
             # skip binary files
             if b'\0' in data:
                 continue
 
             # During local installs, the shebang will be rewritten to the final
             # install path. During wheel packaging, the shebang has a special
             # value.
             if data.startswith(b'#!python'):
                 log.info(
                     'not rewriting @LIBDIR@ in %s because install path '
                     'not known' % outfile
                 )
                 continue
 
             data = data.replace(b'@LIBDIR@', libdir.encode(libdir_escape))
             with open(outfile, 'wb') as fp:
                 fp.write(data)
 
 
 # virtualenv installs custom distutils/__init__.py and
 # distutils/distutils.cfg files which essentially proxy back to the
 # "real" distutils in the main Python install. The presence of this
 # directory causes py2exe to pick up the "hacked" distutils package
 # from the virtualenv and "import distutils" will fail from the py2exe
 # build because the "real" distutils files can't be located.
 #
 # We work around this by monkeypatching the py2exe code finding Python
 # modules to replace the found virtualenv distutils modules with the
 # original versions via filesystem scanning. This is a bit hacky. But
 # it allows us to use virtualenvs for py2exe packaging, which is more
 # deterministic and reproducible.
 #
 # It's worth noting that the common StackOverflow suggestions for this
 # problem involve copying the original distutils files into the
 # virtualenv or into the staging directory after setup() is invoked.
 # The former is very brittle and can easily break setup(). Our hacking
 # of the found modules routine has a similar result as copying the files
 # manually. But it makes fewer assumptions about how py2exe works and
 # is less brittle.
 
 # This only catches virtualenvs made with virtualenv (as opposed to
 # venv, which is likely what Python 3 uses).
 py2exehacked = py2exeloaded and getattr(sys, 'real_prefix', None) is not None
 
 if py2exehacked:
     from distutils.command.py2exe import py2exe as buildpy2exe
     from py2exe.mf import Module as py2exemodule
 
     class hgbuildpy2exe(buildpy2exe):
         def find_needed_modules(self, mf, files, modules):
             res = buildpy2exe.find_needed_modules(self, mf, files, modules)
 
             # Replace virtualenv's distutils modules with the real ones.
             modules = {}
             for k, v in res.modules.items():
                 if k != 'distutils' and not k.startswith('distutils.'):
                     modules[k] = v
 
             res.modules = modules
 
             import opcode
 
             distutilsreal = os.path.join(
                 os.path.dirname(opcode.__file__), 'distutils'
             )
 
             for root, dirs, files in os.walk(distutilsreal):
                 for f in sorted(files):
                     if not f.endswith('.py'):
                         continue
 
                     full = os.path.join(root, f)
 
                     parents = ['distutils']
 
                     if root != distutilsreal:
                         rel = os.path.relpath(root, distutilsreal)
                         parents.extend(p for p in rel.split(os.sep))
 
                     modname = '%s.%s' % ('.'.join(parents), f[:-3])
 
                     if modname.startswith('distutils.tests.'):
                         continue
 
                     if modname.endswith('.__init__'):
                         modname = modname[: -len('.__init__')]
                         path = os.path.dirname(full)
                     else:
                         path = None
 
                     res.modules[modname] = py2exemodule(
                         modname, full, path=path
                     )
 
             if 'distutils' not in res.modules:
                 raise SystemExit('could not find distutils modules')
 
             return res
 
 
 cmdclass = {
     'build': hgbuild,
     'build_doc': hgbuilddoc,
     'build_mo': hgbuildmo,
     'build_ext': hgbuildext,
     'build_py': hgbuildpy,
     'build_scripts': hgbuildscripts,
     'build_hgextindex': buildhgextindex,
     'install': hginstall,
     'install_lib': hginstalllib,
     'install_scripts': hginstallscripts,
     'build_hgexe': buildhgexe,
 }
 
 if py2exehacked:
     cmdclass['py2exe'] = hgbuildpy2exe
 
 packages = [
     'mercurial',
     'mercurial.cext',
     'mercurial.cffi',
     'mercurial.defaultrc',
+    'mercurial.dirstateutils',
     'mercurial.helptext',
     'mercurial.helptext.internals',
     'mercurial.hgweb',
     'mercurial.interfaces',
     'mercurial.pure',
     'mercurial.templates',
     'mercurial.thirdparty',
     'mercurial.thirdparty.attr',
     'mercurial.thirdparty.zope',
     'mercurial.thirdparty.zope.interface',
     'mercurial.upgrade_utils',
     'mercurial.utils',
     'mercurial.revlogutils',
     'mercurial.testing',
     'hgext',
     'hgext.convert',
     'hgext.fsmonitor',
     'hgext.fastannotate',
     'hgext.fsmonitor.pywatchman',
     'hgext.git',
     'hgext.highlight',
     'hgext.hooklib',
     'hgext.infinitepush',
     'hgext.largefiles',
     'hgext.lfs',
     'hgext.narrow',
     'hgext.remotefilelog',
     'hgext.zeroconf',
     'hgext3rd',
     'hgdemandimport',
 ]
 
 # The pygit2 dependency dropped py2 support with the 1.0 release in Dec 2019.
 # Prior releases do not build at all on Windows, because Visual Studio 2008
 # doesn't understand C 11.  Older Linux releases are buggy.
 if sys.version_info[0] == 2:
     packages.remove('hgext.git')
 
 
 for name in os.listdir(os.path.join('mercurial', 'templates')):
     if name != '__pycache__' and os.path.isdir(
         os.path.join('mercurial', 'templates', name)
     ):
         packages.append('mercurial.templates.%s' % name)
 
 if sys.version_info[0] == 2:
     packages.extend(
         [
             'mercurial.thirdparty.concurrent',
             'mercurial.thirdparty.concurrent.futures',
         ]
     )
 
 if 'HG_PY2EXE_EXTRA_INSTALL_PACKAGES' in os.environ:
     # py2exe can't cope with namespace packages very well, so we have to
     # install any hgext3rd.* extensions that we want in the final py2exe
     # image here. This is gross, but you gotta do what you gotta do.
     packages.extend(os.environ['HG_PY2EXE_EXTRA_INSTALL_PACKAGES'].split(' '))
 
 common_depends = [
     'mercurial/bitmanipulation.h',
     'mercurial/compat.h',
     'mercurial/cext/util.h',
 ]
 common_include_dirs = ['mercurial']
 
 common_cflags = []
 
 # MSVC 2008 still needs declarations at the top of the scope, but Python 3.9
 # makes declarations not at the top of a scope in the headers.
 if os.name != 'nt' and sys.version_info[1] < 9:
     common_cflags = ['-Werror=declaration-after-statement']
 
 osutil_cflags = []
 osutil_ldflags = []
 
 # platform specific macros
 for plat, func in [('bsd', 'setproctitle')]:
     if re.search(plat, sys.platform) and hasfunction(new_compiler(), func):
         osutil_cflags.append('-DHAVE_%s' % func.upper())
 
 for plat, macro, code in [
     (
         'bsd|darwin',
         'BSD_STATFS',
         '''
      #include <sys/param.h>
      #include <sys/mount.h>
      int main() { struct statfs s; return sizeof(s.f_fstypename); }
      ''',
     ),
     (
         'linux',
         'LINUX_STATFS',
         '''
      #include <linux/magic.h>
      #include <sys/vfs.h>
      int main() { struct statfs s; return sizeof(s.f_type); }
      ''',
     ),
 ]:
     if re.search(plat, sys.platform) and cancompile(new_compiler(), code):
         osutil_cflags.append('-DHAVE_%s' % macro)
 
 if sys.platform == 'darwin':
     osutil_ldflags += ['-framework', 'ApplicationServices']
 
 if sys.platform == 'sunos5':
     osutil_ldflags += ['-lsocket']
 
 xdiff_srcs = [
     'mercurial/thirdparty/xdiff/xdiffi.c',
     'mercurial/thirdparty/xdiff/xprepare.c',
     'mercurial/thirdparty/xdiff/xutils.c',
 ]
 
 xdiff_headers = [
     'mercurial/thirdparty/xdiff/xdiff.h',
     'mercurial/thirdparty/xdiff/xdiffi.h',
     'mercurial/thirdparty/xdiff/xinclude.h',
     'mercurial/thirdparty/xdiff/xmacros.h',
     'mercurial/thirdparty/xdiff/xprepare.h',
     'mercurial/thirdparty/xdiff/xtypes.h',
     'mercurial/thirdparty/xdiff/xutils.h',
 ]
 
 
 class RustCompilationError(CCompilerError):
     """Exception class for Rust compilation errors."""
 
 
 class RustExtension(Extension):
     """Base classes for concrete Rust Extension classes."""
 
     rusttargetdir = os.path.join('rust', 'target', 'release')
 
     def __init__(
         self, mpath, sources, rustlibname, subcrate, py3_features=None, **kw
     ):
         Extension.__init__(self, mpath, sources, **kw)
         srcdir = self.rustsrcdir = os.path.join('rust', subcrate)
         self.py3_features = py3_features
 
         # adding Rust source and control files to depends so that the extension
         # gets rebuilt if they've changed
         self.depends.append(os.path.join(srcdir, 'Cargo.toml'))
         cargo_lock = os.path.join(srcdir, 'Cargo.lock')
         if os.path.exists(cargo_lock):
             self.depends.append(cargo_lock)
         for dirpath, subdir, fnames in os.walk(os.path.join(srcdir, 'src')):
             self.depends.extend(
                 os.path.join(dirpath, fname)
                 for fname in fnames
                 if os.path.splitext(fname)[1] == '.rs'
             )
 
     @staticmethod
     def rustdylibsuffix():
         """Return the suffix for shared libraries produced by rustc.
 
         See also: https://doc.rust-lang.org/reference/linkage.html
         """
         if sys.platform == 'darwin':
             return '.dylib'
         elif os.name == 'nt':
             return '.dll'
         else:
             return '.so'
 
     def rustbuild(self):
         env = os.environ.copy()
         if 'HGTEST_RESTOREENV' in env:
             # Mercurial tests change HOME to a temporary directory,
             # but, if installed with rustup, the Rust toolchain needs
             # HOME to be correct (otherwise the 'no default toolchain'
             # error message is issued and the build fails).
             # This happens currently with test-hghave.t, which does
             # invoke this build.
 
             # Unix only fix (os.path.expanduser not really reliable if
             # HOME is shadowed like this)
             import pwd
 
             env['HOME'] = pwd.getpwuid(os.getuid()).pw_dir
 
         cargocmd = ['cargo', 'rustc', '--release']
 
         feature_flags = []
 
         if sys.version_info[0] == 3 and self.py3_features is not None:
             feature_flags.append(self.py3_features)
             cargocmd.append('--no-default-features')
 
         rust_features = env.get("HG_RUST_FEATURES")
         if rust_features:
             feature_flags.append(rust_features)
 
         cargocmd.extend(('--features', " ".join(feature_flags)))
 
         cargocmd.append('--')
         if sys.platform == 'darwin':
             cargocmd.extend(
                 ("-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup")
             )
         try:
             subprocess.check_call(cargocmd, env=env, cwd=self.rustsrcdir)
         except OSError as exc:
             if exc.errno == errno.ENOENT:
                 raise RustCompilationError("Cargo not found")
             elif exc.errno == errno.EACCES:
                 raise RustCompilationError(
                     "Cargo found, but permisssion to execute it is denied"
                 )
             else:
                 raise
         except subprocess.CalledProcessError:
             raise RustCompilationError(
                 "Cargo failed. Working directory: %r, "
                 "command: %r, environment: %r"
                 % (self.rustsrcdir, cargocmd, env)
             )
 
 
 class RustStandaloneExtension(RustExtension):
     def __init__(self, pydottedname, rustcrate, dylibname, **kw):
         RustExtension.__init__(
             self, pydottedname, [], dylibname, rustcrate, **kw
         )
         self.dylibname = dylibname
 
     def build(self, target_dir):
         self.rustbuild()
         target = [target_dir]
         target.extend(self.name.split('.'))
         target[-1] += DYLIB_SUFFIX
         shutil.copy2(
             os.path.join(
                 self.rusttargetdir, self.dylibname + self.rustdylibsuffix()
             ),
             os.path.join(*target),
         )
 
 
 extmodules = [
     Extension(
         'mercurial.cext.base85',
         ['mercurial/cext/base85.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.cext.bdiff',
         ['mercurial/bdiff.c', 'mercurial/cext/bdiff.c'] + xdiff_srcs,
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends + ['mercurial/bdiff.h'] + xdiff_headers,
     ),
     Extension(
         'mercurial.cext.mpatch',
         ['mercurial/mpatch.c', 'mercurial/cext/mpatch.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.cext.parsers',
         [
             'mercurial/cext/charencode.c',
             'mercurial/cext/dirs.c',
             'mercurial/cext/manifest.c',
             'mercurial/cext/parsers.c',
             'mercurial/cext/pathencode.c',
             'mercurial/cext/revlog.c',
         ],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends
         + [
             'mercurial/cext/charencode.h',
             'mercurial/cext/revlog.h',
         ],
     ),
     Extension(
         'mercurial.cext.osutil',
         ['mercurial/cext/osutil.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags + osutil_cflags,
         extra_link_args=osutil_ldflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.thirdparty.zope.interface._zope_interface_coptimizations',
         [
             'mercurial/thirdparty/zope/interface/_zope_interface_coptimizations.c',
         ],
         extra_compile_args=common_cflags,
     ),
     Extension(
         'mercurial.thirdparty.sha1dc',
         [
             'mercurial/thirdparty/sha1dc/cext.c',
             'mercurial/thirdparty/sha1dc/lib/sha1.c',
             'mercurial/thirdparty/sha1dc/lib/ubc_check.c',
         ],
         extra_compile_args=common_cflags,
     ),
     Extension(
         'hgext.fsmonitor.pywatchman.bser',
         ['hgext/fsmonitor/pywatchman/bser.c'],
         extra_compile_args=common_cflags,
     ),
     RustStandaloneExtension(
         'mercurial.rustext', 'hg-cpython', 'librusthg', py3_features='python3'
     ),
 ]
 
 
 sys.path.insert(0, 'contrib/python-zstandard')
 import setup_zstd
 
 zstd = setup_zstd.get_c_extension(
     name='mercurial.zstd', root=os.path.abspath(os.path.dirname(__file__))
 )
 zstd.extra_compile_args += common_cflags
 extmodules.append(zstd)
 
 try:
     from distutils import cygwinccompiler
 
     # the -mno-cygwin option has been deprecated for years
     mingw32compilerclass = cygwinccompiler.Mingw32CCompiler
 
     class HackedMingw32CCompiler(cygwinccompiler.Mingw32CCompiler):
         def __init__(self, *args, **kwargs):
             mingw32compilerclass.__init__(self, *args, **kwargs)
             for i in 'compiler compiler_so linker_exe linker_so'.split():
                 try:
                     getattr(self, i).remove('-mno-cygwin')
                 except ValueError:
                     pass
 
     cygwinccompiler.Mingw32CCompiler = HackedMingw32CCompiler
 except ImportError:
     # the cygwinccompiler package is not available on some Python
     # distributions like the ones from the optware project for Synology
     # DiskStation boxes
     class HackedMingw32CCompiler(object):
         pass
 
 
 if os.name == 'nt':
     # Allow compiler/linker flags to be added to Visual Studio builds.  Passing
     # extra_link_args to distutils.extensions.Extension() doesn't have any
     # effect.
     from distutils import msvccompiler
 
     msvccompilerclass = msvccompiler.MSVCCompiler
 
     class HackedMSVCCompiler(msvccompiler.MSVCCompiler):
         def initialize(self):
             msvccompilerclass.initialize(self)
             # "warning LNK4197: export 'func' specified multiple times"
             self.ldflags_shared.append('/ignore:4197')
             self.ldflags_shared_debug.append('/ignore:4197')
 
     msvccompiler.MSVCCompiler = HackedMSVCCompiler
 
 packagedata = {
     'mercurial': [
         'locale/*/LC_MESSAGES/hg.mo',
         'dummycert.pem',
     ],
     'mercurial.defaultrc': [
         '*.rc',
     ],
     'mercurial.helptext': [
         '*.txt',
     ],
     'mercurial.helptext.internals': [
         '*.txt',
     ],
 }
 
 
 def ordinarypath(p):
     return p and p[0] != '.' and p[-1] != '~'
 
 
 for root in ('templates',):
     for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
         packagename = curdir.replace(os.sep, '.')
         packagedata[packagename] = list(filter(ordinarypath, files))
 
 datafiles = []
 
 # distutils expects version to be str/unicode. Converting it to
 # unicode on Python 2 still works because it won't contain any
 # non-ascii bytes and will be implicitly converted back to bytes
 # when operated on.
 assert isinstance(version, str)
 setupversion = version
 
 extra = {}
 
 py2exepackages = [
     'hgdemandimport',
     'hgext3rd',
     'hgext',
     'email',
     # implicitly imported per module policy
     # (cffi wouldn't be used as a frozen exe)
     'mercurial.cext',
     #'mercurial.cffi',
     'mercurial.pure',
 ]
 
 py2exe_includes = []
 
 py2exeexcludes = []
 py2exedllexcludes = ['crypt32.dll']
 
 if issetuptools:
     extra['python_requires'] = supportedpy
 
 if py2exeloaded:
     extra['console'] = [
         {
             'script': 'hg',
             'copyright': 'Copyright (C) 2005-2021 Olivia Mackall and others',
             'product_version': version,
         }
     ]
     # Sub command of 'build' because 'py2exe' does not handle sub_commands.
     # Need to override hgbuild because it has a private copy of
     # build.sub_commands.
     hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
     # put dlls in sub directory so that they won't pollute PATH
     extra['zipfile'] = 'lib/library.zip'
 
     # We allow some configuration to be supplemented via environment
     # variables. This is better than setup.cfg files because it allows
     # supplementing configs instead of replacing them.
     extrapackages = os.environ.get('HG_PY2EXE_EXTRA_PACKAGES')
     if extrapackages:
         py2exepackages.extend(extrapackages.split(' '))
 
     extra_includes = os.environ.get('HG_PY2EXE_EXTRA_INCLUDES')
     if extra_includes:
         py2exe_includes.extend(extra_includes.split(' '))
 
     excludes = os.environ.get('HG_PY2EXE_EXTRA_EXCLUDES')
     if excludes:
         py2exeexcludes.extend(excludes.split(' '))
 
     dllexcludes = os.environ.get('HG_PY2EXE_EXTRA_DLL_EXCLUDES')
     if dllexcludes:
         py2exedllexcludes.extend(dllexcludes.split(' '))
 
 if os.environ.get('PYOXIDIZER'):
     hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
 
 if os.name == 'nt':
     # Windows binary file versions for exe/dll files must have the
     # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
     setupversion = setupversion.split(r'+', 1)[0]
 
 if sys.platform == 'darwin' and os.path.exists('/usr/bin/xcodebuild'):
     version = runcmd(['/usr/bin/xcodebuild', '-version'], {})[1].splitlines()
     if version:
         version = version[0]
         if sys.version_info[0] == 3:
             version = version.decode('utf-8')
         xcode4 = version.startswith('Xcode') and StrictVersion(
             version.split()[1]
         ) >= StrictVersion('4.0')
         xcode51 = re.match(r'^Xcode\s+5\.1', version) is not None
     else:
         # xcodebuild returns empty on OS X Lion with XCode 4.3 not
         # installed, but instead with only command-line tools. Assume
         # that only happens on >= Lion, thus no PPC support.
         xcode4 = True
         xcode51 = False
 
     # XCode 4.0 dropped support for ppc architecture, which is hardcoded in
     # distutils.sysconfig
     if xcode4:
         os.environ['ARCHFLAGS'] = ''
 
     # XCode 5.1 changes clang such that it now fails to compile if the
     # -mno-fused-madd flag is passed, but the version of Python shipped with
     # OS X 10.9 Mavericks includes this flag. This causes problems in all
     # C extension modules, and a bug has been filed upstream at
     # http://bugs.python.org/issue21244. We also need to patch this here
     # so Mercurial can continue to compile in the meantime.
     if xcode51:
         cflags = get_config_var('CFLAGS')
         if cflags and re.search(r'-mno-fused-madd\b', cflags) is not None:
             os.environ['CFLAGS'] = (
                 os.environ.get('CFLAGS', '') + ' -Qunused-arguments'
             )
 
 setup(
     name='mercurial',
     version=setupversion,
     author='Olivia Mackall and many others',
     author_email='[e-mail]',
     url='https://mercurial-scm.org/',
     download_url='https://mercurial-scm.org/release/',
     description=(
         'Fast scalable distributed SCM (revision control, version '
         'control) system'
     ),
     long_description=(
         'Mercurial is a distributed SCM tool written in Python.'
         ' It is used by a number of large projects that require'
         ' fast, reliable distributed revision control, such as '
         'Mozilla.'
     ),
     license='GNU GPLv2 or any later version',
     classifiers=[
         'Development Status :: 6 - Mature',
         'Environment :: Console',
         'Intended Audience :: Developers',
         'Intended Audience :: System Administrators',
         'License :: OSI Approved :: GNU General Public License (GPL)',
         'Natural Language :: Danish',
         'Natural Language :: English',
         'Natural Language :: German',
         'Natural Language :: Italian',
         'Natural Language :: Japanese',
         'Natural Language :: Portuguese (Brazilian)',
         'Operating System :: Microsoft :: Windows',
         'Operating System :: OS Independent',
         'Operating System :: POSIX',
         'Programming Language :: C',
         'Programming Language :: Python',
         'Topic :: Software Development :: Version Control',
     ],
     scripts=scripts,
     packages=packages,
     ext_modules=extmodules,
     data_files=datafiles,
     package_data=packagedata,
     cmdclass=cmdclass,
     distclass=hgdist,
     options={
         'py2exe': {
             'bundle_files': 3,
             'dll_excludes': py2exedllexcludes,
             'includes': py2exe_includes,
             'excludes': py2exeexcludes,
             'packages': py2exepackages,
         },
         'bdist_mpkg': {
             'zipdist': False,
             'license': 'COPYING',
             'readme': 'contrib/packaging/macosx/Readme.html',
             'welcome': 'contrib/packaging/macosx/Welcome.html',
         },
     },
     **extra
 )

tests/fakedirstatewritetime.py

@@ -1,106 +1,106 b''
 # extension to emulate invoking 'dirstate.write()' at the time
 # specified by '[fakedirstatewritetime] fakenow', only when
 # 'dirstate.write()' is invoked via functions below:
 #
 #   - 'workingctx._poststatusfixup()' (= 'repo.status()')
 #   - 'committablectx.markcommitted()'
 
 from __future__ import absolute_import
 
 from mercurial import (
     context,
     dirstate,
     dirstatemap as dirstatemapmod,
     extensions,
     policy,
     registrar,
 )
 from mercurial.utils import dateutil
 
 try:
     from mercurial import rustext
 
     rustext.__name__  # force actual import (see hgdemandimport)
 except ImportError:
     rustext = None
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 configitem(
     b'fakedirstatewritetime',
     b'fakenow',
     default=None,
 )
 
 parsers = policy.importmod('parsers')
 rustmod = policy.importrust('parsers')
 
 
 def pack_dirstate(fakenow, orig, dmap, copymap, pl, now):
     # execute what original parsers.pack_dirstate should do actually
     # for consistency
     actualnow = int(now)
     for f, e in dmap.items():
         if e.need_delay(actualnow):
             e.set_possibly_dirty()
 
     return orig(dmap, copymap, pl, fakenow)
 
 
 def fakewrite(ui, func):
     # fake "now" of 'pack_dirstate' only if it is invoked while 'func'
 
     fakenow = ui.config(b'fakedirstatewritetime', b'fakenow')
     if not fakenow:
         # Execute original one, if fakenow isn't configured. This is
         # useful to prevent subrepos from executing replaced one,
         # because replacing 'parsers.pack_dirstate' is also effective
         # in subrepos.
         return func()
 
     # parsing 'fakenow' in YYYYmmddHHMM format makes comparison between
     # 'fakenow' value and 'touch -t YYYYmmddHHMM' argument easy
     fakenow = dateutil.parsedate(fakenow, [b'%Y%m%d%H%M'])[0]
 
     if rustmod is not None:
         # The Rust implementation does not use public parse/pack dirstate
         # to prevent conversion round-trips
         orig_dirstatemap_write = dirstatemapmod.dirstatemap.write
-        wrapper = lambda self, st, now: orig_dirstatemap_write(
-            self, st, fakenow
+        wrapper = lambda self, tr, st, now: orig_dirstatemap_write(
+            self, tr, st, fakenow
         )
         dirstatemapmod.dirstatemap.write = wrapper
 
     orig_dirstate_getfsnow = dirstate._getfsnow
     wrapper = lambda *args: pack_dirstate(fakenow, orig_pack_dirstate, *args)
 
     orig_module = parsers
     orig_pack_dirstate = parsers.pack_dirstate
 
     orig_module.pack_dirstate = wrapper
     dirstate._getfsnow = lambda *args: fakenow
     try:
         return func()
     finally:
         orig_module.pack_dirstate = orig_pack_dirstate
         dirstate._getfsnow = orig_dirstate_getfsnow
         if rustmod is not None:
             dirstatemapmod.dirstatemap.write = orig_dirstatemap_write
 
 
 def _poststatusfixup(orig, workingctx, status, fixup):
     ui = workingctx.repo().ui
     return fakewrite(ui, lambda: orig(workingctx, status, fixup))
 
 
 def markcommitted(orig, committablectx, node):
     ui = committablectx.repo().ui
     return fakewrite(ui, lambda: orig(committablectx, node))
 
 
 def extsetup(ui):
     extensions.wrapfunction(
         context.workingctx, '_poststatusfixup', _poststatusfixup
     )
     extensions.wrapfunction(context.workingctx, 'markcommitted', markcommitted)

tests/test-completion.t

@@ -1,443 +1,445 b''
 Show all commands except debug commands
   $ hg debugcomplete
   abort
   add
   addremove
   annotate
   archive
   backout
   bisect
   bookmarks
   branch
   branches
   bundle
   cat
   clone
   commit
   config
   continue
   copy
   diff
   export
   files
   forget
   graft
   grep
   heads
   help
   identify
   import
   incoming
   init
   locate
   log
   manifest
   merge
   outgoing
   parents
   paths
   phase
   pull
   purge
   push
   recover
   remove
   rename
   resolve
   revert
   rollback
   root
   serve
   shelve
   status
   summary
   tag
   tags
   tip
   unbundle
   unshelve
   update
   verify
   version
 
 Show all commands that start with "a"
   $ hg debugcomplete a
   abort
   add
   addremove
   annotate
   archive
 
 Do not show debug commands if there are other candidates
   $ hg debugcomplete d
   diff
 
 Show debug commands if there are no other candidates
   $ hg debugcomplete debug
   debugancestor
   debugantivirusrunning
   debugapplystreamclonebundle
   debugbackupbundle
   debugbuilddag
   debugbundle
   debugcapabilities
   debugchangedfiles
   debugcheckstate
   debugcolor
   debugcommands
   debugcomplete
   debugconfig
   debugcreatestreamclonebundle
   debugdag
   debugdata
   debugdate
   debugdeltachain
   debugdirstate
+  debugdirstateignorepatternshash
   debugdiscovery
   debugdownload
   debugextensions
   debugfileset
   debugformat
   debugfsinfo
   debuggetbundle
   debugignore
   debugindex
   debugindexdot
   debugindexstats
   debuginstall
   debugknown
   debuglabelcomplete
   debuglocks
   debugmanifestfulltextcache
   debugmergestate
   debugnamecomplete
   debugnodemap
   debugobsolete
   debugp1copies
   debugp2copies
   debugpathcomplete
   debugpathcopies
   debugpeer
   debugpickmergetool
   debugpushkey
   debugpvec
   debugrebuilddirstate
   debugrebuildfncache
   debugrename
   debugrequires
   debugrevlog
   debugrevlogindex
   debugrevspec
   debugserve
   debugsetparents
   debugshell
   debugsidedata
   debugssl
   debugstrip
   debugsub
   debugsuccessorssets
   debugtagscache
   debugtemplate
   debuguigetpass
   debuguiprompt
   debugupdatecaches
   debugupgraderepo
   debugwalk
   debugwhyunstable
   debugwireargs
   debugwireproto
 
 Do not show the alias of a debug command if there are other candidates
 (this should hide rawcommit)
   $ hg debugcomplete r
   recover
   remove
   rename
   resolve
   revert
   rollback
   root
 Show the alias of a debug command if there are no other candidates
   $ hg debugcomplete rawc
   
 
 Show the global options
   $ hg debugcomplete --options | sort
   --color
   --config
   --cwd
   --debug
   --debugger
   --encoding
   --encodingmode
   --help
   --hidden
   --noninteractive
   --pager
   --profile
   --quiet
   --repository
   --time
   --traceback
   --verbose
   --version
   -R
   -h
   -q
   -v
   -y
 
 Show the options for the "serve" command
   $ hg debugcomplete --options serve | sort
   --accesslog
   --address
   --certificate
   --cmdserver
   --color
   --config
   --cwd
   --daemon
   --daemon-postexec
   --debug
   --debugger
   --encoding
   --encodingmode
   --errorlog
   --help
   --hidden
   --ipv6
   --name
   --noninteractive
   --pager
   --pid-file
   --port
   --prefix
   --print-url
   --profile
   --quiet
   --repository
   --stdio
   --style
   --subrepos
   --templates
   --time
   --traceback
   --verbose
   --version
   --web-conf
   -6
   -A
   -E
   -R
   -S
   -a
   -d
   -h
   -n
   -p
   -q
   -t
   -v
   -y
 
 Show an error if we use --options with an ambiguous abbreviation
   $ hg debugcomplete --options s
   hg: command 's' is ambiguous:
       serve shelve showconfig status summary
   [10]
 
 Show all commands + options
   $ hg debugcommands
   abort: dry-run
   add: include, exclude, subrepos, dry-run
   addremove: similarity, subrepos, include, exclude, dry-run
   annotate: rev, follow, no-follow, text, user, file, date, number, changeset, line-number, skip, ignore-all-space, ignore-space-change, ignore-blank-lines, ignore-space-at-eol, include, exclude, template
   archive: no-decode, prefix, rev, type, subrepos, include, exclude
   backout: merge, commit, no-commit, parent, rev, edit, tool, include, exclude, message, logfile, date, user
   bisect: reset, good, bad, skip, extend, command, noupdate
   bookmarks: force, rev, delete, rename, inactive, list, template
   branch: force, clean, rev
   branches: active, closed, rev, template
   bundle: force, rev, branch, base, all, type, ssh, remotecmd, insecure
   cat: output, rev, decode, include, exclude, template
   clone: noupdate, updaterev, rev, branch, pull, uncompressed, stream, ssh, remotecmd, insecure
   commit: addremove, close-branch, amend, secret, edit, force-close-branch, interactive, include, exclude, message, logfile, date, user, subrepos
   config: untrusted, exp-all-known, edit, local, source, shared, non-shared, global, template
   continue: dry-run
   copy: forget, after, at-rev, force, include, exclude, dry-run
   debugancestor: 
   debugantivirusrunning: 
   debugapplystreamclonebundle: 
   debugbackupbundle: recover, patch, git, limit, no-merges, stat, graph, style, template
   debugbuilddag: mergeable-file, overwritten-file, new-file
   debugbundle: all, part-type, spec
   debugcapabilities: 
   debugchangedfiles: compute
   debugcheckstate: 
   debugcolor: style
   debugcommands: 
   debugcomplete: options
   debugcreatestreamclonebundle: 
   debugdag: tags, branches, dots, spaces
   debugdata: changelog, manifest, dir
   debugdate: extended
   debugdeltachain: changelog, manifest, dir, template
+  debugdirstateignorepatternshash: 
   debugdirstate: nodates, dates, datesort, dirs
   debugdiscovery: old, nonheads, rev, seed, local-as-revs, remote-as-revs, ssh, remotecmd, insecure, template
   debugdownload: output
   debugextensions: template
   debugfileset: rev, all-files, show-matcher, show-stage
   debugformat: template
   debugfsinfo: 
   debuggetbundle: head, common, type
   debugignore: 
   debugindex: changelog, manifest, dir, template
   debugindexdot: changelog, manifest, dir
   debugindexstats: 
   debuginstall: template
   debugknown: 
   debuglabelcomplete: 
   debuglocks: force-free-lock, force-free-wlock, set-lock, set-wlock
   debugmanifestfulltextcache: clear, add
   debugmergestate: style, template
   debugnamecomplete: 
   debugnodemap: dump-new, dump-disk, check, metadata
   debugobsolete: flags, record-parents, rev, exclusive, index, delete, date, user, template
   debugp1copies: rev
   debugp2copies: rev
   debugpathcomplete: full, normal, added, removed
   debugpathcopies: include, exclude
   debugpeer: 
   debugpickmergetool: rev, changedelete, include, exclude, tool
   debugpushkey: 
   debugpvec: 
   debugrebuilddirstate: rev, minimal
   debugrebuildfncache: 
   debugrename: rev
   debugrequires: 
   debugrevlog: changelog, manifest, dir, dump
   debugrevlogindex: changelog, manifest, dir, format
   debugrevspec: optimize, show-revs, show-set, show-stage, no-optimized, verify-optimized
   debugserve: sshstdio, logiofd, logiofile
   debugsetparents: 
   debugshell: 
   debugsidedata: changelog, manifest, dir
   debugssl: 
   debugstrip: rev, force, no-backup, nobackup, , keep, bookmark, soft
   debugsub: rev
   debugsuccessorssets: closest
   debugtagscache: 
   debugtemplate: rev, define
   debuguigetpass: prompt
   debuguiprompt: prompt
   debugupdatecaches: 
   debugupgraderepo: optimize, run, backup, changelog, manifest, filelogs
   debugwalk: include, exclude
   debugwhyunstable: 
   debugwireargs: three, four, five, ssh, remotecmd, insecure
   debugwireproto: localssh, peer, noreadstderr, nologhandshake, ssh, remotecmd, insecure
   diff: rev, from, to, change, text, git, binary, nodates, noprefix, show-function, reverse, ignore-all-space, ignore-space-change, ignore-blank-lines, ignore-space-at-eol, unified, stat, root, include, exclude, subrepos
   export: bookmark, output, switch-parent, rev, text, git, binary, nodates, template
   files: rev, print0, include, exclude, template, subrepos
   forget: interactive, include, exclude, dry-run
   graft: rev, base, continue, stop, abort, edit, log, no-commit, force, currentdate, currentuser, date, user, tool, dry-run
   grep: print0, all, diff, text, follow, ignore-case, files-with-matches, line-number, rev, all-files, user, date, template, include, exclude
   heads: rev, topo, active, closed, style, template
   help: extension, command, keyword, system
   identify: rev, num, id, branch, tags, bookmarks, ssh, remotecmd, insecure, template
   import: strip, base, secret, edit, force, no-commit, bypass, partial, exact, prefix, import-branch, message, logfile, date, user, similarity
   incoming: force, newest-first, bundle, rev, bookmarks, branch, patch, git, limit, no-merges, stat, graph, style, template, ssh, remotecmd, insecure, subrepos
   init: ssh, remotecmd, insecure
   locate: rev, print0, fullpath, include, exclude
   log: follow, follow-first, date, copies, keyword, rev, line-range, removed, only-merges, user, only-branch, branch, bookmark, prune, patch, git, limit, no-merges, stat, graph, style, template, include, exclude
   manifest: rev, all, template
   merge: force, rev, preview, abort, tool
   outgoing: force, rev, newest-first, bookmarks, branch, patch, git, limit, no-merges, stat, graph, style, template, ssh, remotecmd, insecure, subrepos
   parents: rev, style, template
   paths: template
   phase: public, draft, secret, force, rev
   pull: update, force, confirm, rev, bookmark, branch, ssh, remotecmd, insecure
   purge: abort-on-err, all, ignored, dirs, files, print, print0, confirm, include, exclude
   push: force, rev, bookmark, all-bookmarks, branch, new-branch, pushvars, publish, ssh, remotecmd, insecure
   recover: verify
   remove: after, force, subrepos, include, exclude, dry-run
   rename: forget, after, at-rev, force, include, exclude, dry-run
   resolve: all, list, mark, unmark, no-status, re-merge, tool, include, exclude, template
   revert: all, date, rev, no-backup, interactive, include, exclude, dry-run
   rollback: dry-run, force
   root: template
   serve: accesslog, daemon, daemon-postexec, errorlog, port, address, prefix, name, web-conf, webdir-conf, pid-file, stdio, cmdserver, templates, style, ipv6, certificate, print-url, subrepos
   shelve: addremove, unknown, cleanup, date, delete, edit, keep, list, message, name, patch, interactive, stat, include, exclude
   status: all, modified, added, removed, deleted, clean, unknown, ignored, no-status, terse, copies, print0, rev, change, include, exclude, subrepos, template
   summary: remote
   tag: force, local, rev, remove, edit, message, date, user
   tags: template
   tip: patch, git, style, template
   unbundle: update
   unshelve: abort, continue, interactive, keep, name, tool, date
   update: clean, check, merge, date, rev, tool
   verify: full
   version: template
 
   $ hg init a
   $ cd a
   $ echo fee > fee
   $ hg ci -q -Amfee
   $ hg tag fee
   $ mkdir fie
   $ echo dead > fie/dead
   $ echo live > fie/live
   $ hg bookmark fo
   $ hg branch -q fie
   $ hg ci -q -Amfie
   $ echo fo > fo
   $ hg branch -qf default
   $ hg ci -q -Amfo
   $ echo Fum > Fum
   $ hg ci -q -AmFum
   $ hg bookmark Fum
 
 Test debugpathcomplete
 
   $ hg debugpathcomplete f
   fee
   fie
   fo
   $ hg debugpathcomplete -f f
   fee
   fie/dead
   fie/live
   fo
 
   $ hg rm Fum
   $ hg debugpathcomplete -r F
   Fum
 
 Test debugnamecomplete
 
   $ hg debugnamecomplete
   Fum
   default
   fee
   fie
   fo
   tip
   $ hg debugnamecomplete f
   fee
   fie
   fo
 
 Test debuglabelcomplete, a deprecated name for debugnamecomplete that is still
 used for completions in some shells.
 
   $ hg debuglabelcomplete
   Fum
   default
   fee
   fie
   fo
   tip
   $ hg debuglabelcomplete f
   fee
   fie
   fo