dirstate: split dirstatemap in its own file

The dirstate file is large enough and the dirstatemap is quite insulated logic
already.

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

mercurial/dirstate.py

@@ -19,6 +19,7 b' from .pycompat import delattr'
 from hgdemandimport import tracing
 
 from . import (
+    dirstatemap,
     encoding,
     error,
     match as matchmod,
@@ -27,7 +28,6 b' from . import ('
     pycompat,
     scmutil,
     sparse,
-    txnutil,
     util,
 )
 
@@ -49,13 +49,13 b' dirstatetuple = parsers.dirstatetuple'
 
 
 # a special value used internally for `size` if the file come from the other parent
-FROM_P2 = -2
+FROM_P2 = dirstatemap.FROM_P2
 
 # a special value used internally for `size` if the file is modified/merged/added
-NONNORMAL = -1
+NONNORMAL = dirstatemap.NONNORMAL
 
 # a special value used internally for `time` if the time is ambigeous
-AMBIGUOUS_TIME = -1
+AMBIGUOUS_TIME = dirstatemap.AMBIGUOUS_TIME
 
 
 class repocache(filecache):
@@ -119,7 +119,7 b' class dirstate(object):'
         self._plchangecallbacks = {}
         self._origpl = None
         self._updatedfiles = set()
-        self._mapcls = dirstatemap
+        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).
@@ -1450,567 +1450,3 b' class dirstate(object):'
     def clearbackup(self, tr, backupname):
         '''Clear backup file'''
         self._opener.unlink(backupname)
-
-
-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, oldstate, state, mode, size, mtime):
-        """Add a tracked file to the dirstate."""
-        if oldstate in b"?r" and "_dirs" in self.__dict__:
-            self._dirs.addpath(f)
-        if oldstate == b"?" and "_alldirs" in self.__dict__:
-            self._alldirs.addpath(f)
-        self._map[f] = dirstatetuple(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, oldstate, size):
-        """
-        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.
-        """
-        if oldstate not in b"?r" and "_dirs" in self.__dict__:
-            self._dirs.delpath(f)
-        if oldstate == b"?" 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] = dirstatetuple(b'r', 0, size, 0)
-        self.nonnormalset.add(f)
-
-    def dropfile(self, f, oldstate):
-        """
-        Remove a file from the dirstate.  Returns True if the file was
-        previously recorded.
-        """
-        exists = self._map.pop(f, None) is not None
-        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[0] == b'n' and e[3] == now:
-                self._map[f] = dirstatetuple(e[0], e[1], e[2], AMBIGUOUS_TIME)
-                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[0] != b'n' or e[3] == AMBIGUOUS_TIME:
-                    nonnorm.add(fname)
-                if e[0] == b'n' and e[2] == 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 s[0] != b'r':
-                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):
-        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
-
-            # 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, *args, **kwargs):
-            return self._rustmap.addfile(*args, **kwargs)
-
-        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 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)
-                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!')
-                    )
-
-            return self._parents
-
-        @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 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()
-            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/dirstatemap.py

@@ -1,49 +1,27 b''
-# dirstate.py - working directory tracking for mercurial
-#
-# Copyright 2005-2007 Olivia Mackall <[e-mail]>
+# 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 collections
-import contextlib
 import errno
-import os
-import stat
 
 from .i18n import _
-from .pycompat import delattr
-
-from hgdemandimport import tracing
 
 from . import (
-    encoding,
     error,
-    match as matchmod,
     pathutil,
     policy,
     pycompat,
-    scmutil,
-    sparse,
     txnutil,
     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 = 0x7FFFFFFF
 
 dirstatetuple = parsers.dirstatetuple
 
@@ -58,1400 +36,6 b' NONNORMAL = -1'
 AMBIGUOUS_TIME = -1
 
 
-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)
-
-
[e-mail](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
-        # 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
-        """
-        return self._map.get(key, (b"?",))[0]
-
-    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])
-
-    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, 'm' 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 'm' markers when moving away from a merge state
-                if s[0] == b'm':
-                    source = self._map.copymap.get(f)
-                    if source:
-                        copies[f] = source
-                    self.normallookup(f)
-                # Also fix up otherparent markers
-                elif s[0] == b'n' and s[2] == 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
-
-    def _addpath(
-        self,
-        f,
-        state,
-        mode,
-        size=NONNORMAL,
-        mtime=AMBIGUOUS_TIME,
-        from_p2=False,
-        possibly_dirty=False,
-    ):
-        oldstate = self[f]
-        if state == b'a' or oldstate == b'r':
-            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 entry[0] != b'r':
-                    msg = _(b'file %r in dirstate clashes with %r')
-                    msg %= (pycompat.bytestr(d), pycompat.bytestr(f))
-                    raise error.Abort(msg)
-        if state == b'a':
-            assert not possibly_dirty
-            assert not from_p2
-            size = NONNORMAL
-            mtime = AMBIGUOUS_TIME
-        elif from_p2:
-            assert not possibly_dirty
-            size = FROM_P2
-            mtime = AMBIGUOUS_TIME
-        elif possibly_dirty:
-            mtime = AMBIGUOUS_TIME
-        else:
-            assert size != FROM_P2
-            assert size != NONNORMAL
-            size = size & _rangemask
-            mtime = mtime & _rangemask
-        self._dirty = True
-        self._updatedfiles.add(f)
-        self._map.addfile(f, oldstate, state, mode, size, mtime)
-
-    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, b'n', mode, size, 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._pl[1] != self._nodeconstants.nullid:
-            # if there is a merge going on and the file was either
-            # in state 'm' (-1) or coming from other parent (-2) before
-            # being removed, restore that state.
-            entry = self._map.get(f)
-            if entry is not None:
-                if entry[0] == b'r' and entry[2] in (NONNORMAL, FROM_P2):
-                    source = self._map.copymap.get(f)
-                    if entry[2] == NONNORMAL:
-                        self.merge(f)
-                    elif entry[2] == FROM_P2:
-                        self.otherparent(f)
-                    if source:
-                        self.copy(source, f)
-                    return
-                if entry[0] == b'm' or entry[0] == b'n' and entry[2] == FROM_P2:
-                    return
-        self._addpath(f, b'n', 0, possibly_dirty=True)
-        self._map.copymap.pop(f, None)
-
-    def otherparent(self, f):
-        '''Mark as coming from the other parent, always dirty.'''
-        if self._pl[1] == self._nodeconstants.nullid:
-            msg = _(b"setting %r to other parent only allowed in merges") % f
-            raise error.Abort(msg)
-        if f in self and self[f] == b'n':
-            # merge-like
-            self._addpath(f, b'm', 0, from_p2=True)
-        else:
-            # add-like
-            self._addpath(f, b'n', 0, from_p2=True)
-        self._map.copymap.pop(f, None)
-
-    def add(self, f):
-        '''Mark a file added.'''
-        self._addpath(f, b'a', 0)
-        self._map.copymap.pop(f, None)
-
-    def remove(self, f):
-        '''Mark a file removed.'''
-        self._dirty = True
-        oldstate = self[f]
-        size = 0
-        if self._pl[1] != self._nodeconstants.nullid:
-            entry = self._map.get(f)
-            if entry is not None:
-                # backup the previous state
-                if entry[0] == b'm':  # merge
-                    size = NONNORMAL
-                elif entry[0] == b'n' and entry[2] == FROM_P2:  # other parent
-                    size = FROM_P2
-                    self._map.otherparentset.add(f)
-        self._updatedfiles.add(f)
-        self._map.removefile(f, oldstate, size)
-        if size == 0:
-            self._map.copymap.pop(f, None)
-
-    def merge(self, f):
-        '''Mark a file merged.'''
-        if self._pl[1] == self._nodeconstants.nullid:
-            return self.normallookup(f)
-        return self.otherparent(f)
-
-    def drop(self, f):
-        '''Drop a file from the dirstate'''
-        oldstate = self[f]
-        if self._map.dropfile(f, oldstate):
-            self._dirty = True
-            self._updatedfiles.add(f)
-            self._map.copymap.pop(f, 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,
-                location=b'plain',
-            )
-            return
-
-        st = self._opener(filename, b"w", atomictemp=True, checkambig=True)
-        self._writedirstate(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):
-        # 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[0] == b'n' and e[3] == 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._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)
-            state = t[0]
-            mode = t[1]
-            size = t[2]
-            time = t[3]
-
-            if not st and state in b"nma":
-                dadd(fn)
-            elif state == b'n':
-                if (
-                    size >= 0
-                    and (
-                        (size != st.st_size and size != st.st_size & _rangemask)
-                        or ((mode ^ st.st_mode) & 0o100 and checkexec)
-                    )
-                    or size == FROM_P2  # other parent
-                    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)
-            elif state == b'm':
-                madd(fn)
-            elif state == b'a':
-                aadd(fn)
-            elif state == b'r':
-                radd(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)
-            )
-
-        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,
-                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)
-
-
 class dirstatemap(object):
     """Map encapsulating the dirstate's contents.
 

tests/fakedirstatewritetime.py

@@ -10,6 +10,7 b' from __future__ import absolute_import'
 from mercurial import (
     context,
     dirstate,
+    dirstatemap as dirstatemapmod,
     extensions,
     policy,
     registrar,
@@ -66,11 +67,11 b' def fakewrite(ui, func):'
     if rustmod is not None:
         # The Rust implementation does not use public parse/pack dirstate
         # to prevent conversion round-trips
-        orig_dirstatemap_write = dirstate.dirstatemap.write
+        orig_dirstatemap_write = dirstatemapmod.dirstatemap.write
         wrapper = lambda self, st, now: orig_dirstatemap_write(
             self, st, fakenow
         )
-        dirstate.dirstatemap.write = wrapper
+        dirstatemapmod.dirstatemap.write = wrapper
 
     orig_dirstate_getfsnow = dirstate._getfsnow
     wrapper = lambda *args: pack_dirstate(fakenow, orig_pack_dirstate, *args)
@@ -86,7 +87,7 b' def fakewrite(ui, func):'
         orig_module.pack_dirstate = orig_pack_dirstate
         dirstate._getfsnow = orig_dirstate_getfsnow
         if rustmod is not None:
-            dirstate.dirstatemap.write = orig_dirstatemap_write
+            dirstatemapmod.dirstatemap.write = orig_dirstatemap_write
 
 
 def _poststatusfixup(orig, workingctx, status, fixup):