dirstate: Remove return boolean from dirstatemap.dropfile

None of the remaining callers use it.

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

mercurial/dirstatemap.py

@@ -1,965 +1,965 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
 
 if rustmod is None:
     DirstateItem = parsers.DirstateItem
 else:
     DirstateItem = rustmod.DirstateItem
 
 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 various methods (see each
       documentation for details):
 
       - `reset_state`,
       - `set_tracked`
       - `set_untracked`
       - `set_clean`
       - `set_possibly_dirty`
 
     - `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 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 debug_iter(self, all):
         """
         Return an iterator of (filename, state, mode, size, mtime) tuples
 
         `all` is unused when Rust is not enabled
         """
         for (filename, item) in self.items():
             yield (filename, item.state, item.mode, item.size, item.mtime)
 
     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 _dirs_incr(self, filename, old_entry=None):
         """incremente the dirstate counter if applicable"""
         if (
             old_entry is None or old_entry.removed
         ) and "_dirs" in self.__dict__:
             self._dirs.addpath(filename)
         if old_entry is None and "_alldirs" in self.__dict__:
             self._alldirs.addpath(filename)
 
     def _dirs_decr(self, filename, old_entry=None, remove_variant=False):
         """decremente the dirstate counter if applicable"""
         if old_entry is not None:
             if "_dirs" in self.__dict__ and not old_entry.removed:
                 self._dirs.delpath(filename)
             if "_alldirs" in self.__dict__ and not remove_variant:
                 self._alldirs.delpath(filename)
         elif remove_variant and "_alldirs" in self.__dict__:
             self._alldirs.addpath(filename)
         if "filefoldmap" in self.__dict__:
             normed = util.normcase(filename)
             self.filefoldmap.pop(normed, None)
 
     def set_possibly_dirty(self, filename):
         """record that the current state of the file on disk is unknown"""
         self[filename].set_possibly_dirty()
 
     def set_clean(self, filename, mode, size, mtime):
         """mark a file as back to a clean state"""
         entry = self[filename]
         mtime = mtime & rangemask
         size = size & rangemask
         entry.set_clean(mode, size, mtime)
         self.copymap.pop(filename, None)
         self.nonnormalset.discard(filename)
 
     def reset_state(
         self,
         filename,
         wc_tracked=False,
         p1_tracked=False,
         p2_tracked=False,
         merged=False,
         clean_p1=False,
         clean_p2=False,
         possibly_dirty=False,
         parentfiledata=None,
     ):
         """Set a entry to a given state, diregarding all previous state
 
         This is to be used by the part of the dirstate API dedicated to
         adjusting the dirstate after a update/merge.
 
         note: calling this might result to no entry existing at all if the
         dirstate map does not see any point at having one for this file
         anymore.
         """
         if merged and (clean_p1 or clean_p2):
             msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
             raise error.ProgrammingError(msg)
         # copy information are now outdated
         # (maybe new information should be in directly passed to this function)
         self.copymap.pop(filename, None)
 
         if not (p1_tracked or p2_tracked or wc_tracked):
             old_entry = self._map.pop(filename, None)
             self._dirs_decr(filename, old_entry=old_entry)
             self.nonnormalset.discard(filename)
             self.copymap.pop(filename, None)
             return
         elif merged:
             # XXX might be merged and removed ?
             entry = self.get(filename)
             if entry is None or not entry.tracked:
                 # XXX mostly replicate dirstate.other parent.  We should get
                 # the higher layer to pass us more reliable data where `merged`
                 # actually mean merged. Dropping this clause will show failure
                 # in `test-graft.t`
                 merged = False
                 clean_p2 = True
         elif not (p1_tracked or p2_tracked) and wc_tracked:
             pass  # file is added, nothing special to adjust
         elif (p1_tracked or p2_tracked) and not wc_tracked:
             pass
         elif clean_p2 and wc_tracked:
             if p1_tracked or self.get(filename) is not None:
                 # XXX the `self.get` call is catching some case in
                 # `test-merge-remove.t` where the file is tracked in p1, the
                 # p1_tracked argument is False.
                 #
                 # In addition, this seems to be a case where the file is marked
                 # as merged without actually being the result of a merge
                 # action. So thing are not ideal here.
                 merged = True
                 clean_p2 = False
         elif not p1_tracked and p2_tracked and wc_tracked:
             clean_p2 = True
         elif possibly_dirty:
             pass
         elif wc_tracked:
             # this is a "normal" file
             if parentfiledata is None:
                 msg = b'failed to pass parentfiledata for a normal file: %s'
                 msg %= filename
                 raise error.ProgrammingError(msg)
         else:
             assert False, 'unreachable'
 
         old_entry = self._map.get(filename)
         self._dirs_incr(filename, old_entry)
         entry = DirstateItem(
             wc_tracked=wc_tracked,
             p1_tracked=p1_tracked,
             p2_tracked=p2_tracked,
             merged=merged,
             clean_p1=clean_p1,
             clean_p2=clean_p2,
             possibly_dirty=possibly_dirty,
             parentfiledata=parentfiledata,
         )
         if entry.dm_nonnormal:
             self.nonnormalset.add(filename)
         else:
             self.nonnormalset.discard(filename)
         if entry.dm_otherparent:
             self.otherparentset.add(filename)
         else:
             self.otherparentset.discard(filename)
         self._map[filename] = entry
 
     def set_tracked(self, filename):
         new = False
         entry = self.get(filename)
         if entry is None:
             self._dirs_incr(filename)
             entry = DirstateItem(
                 p1_tracked=False,
                 p2_tracked=False,
                 wc_tracked=True,
                 merged=False,
                 clean_p1=False,
                 clean_p2=False,
                 possibly_dirty=False,
                 parentfiledata=None,
             )
             self._map[filename] = entry
             if entry.dm_nonnormal:
                 self.nonnormalset.add(filename)
             new = True
         elif not entry.tracked:
             self._dirs_incr(filename, entry)
             entry.set_tracked()
             new = True
         else:
             # XXX This is probably overkill for more case, but we need this to
             # fully replace the `normallookup` call with `set_tracked` one.
             # Consider smoothing this in the future.
             self.set_possibly_dirty(filename)
         return new
 
     def set_untracked(self, f):
         """Mark a file as no longer tracked in the dirstate map"""
         entry = self.get(f)
         if entry is None:
             return False
         else:
             self._dirs_decr(f, old_entry=entry, remove_variant=not entry.added)
             if not entry.merged:
                 self.copymap.pop(f, None)
             if entry.added:
                 self.nonnormalset.discard(f)
                 self._map.pop(f, None)
             else:
                 self.nonnormalset.add(f)
                 if entry.from_p2:
                     self.otherparentset.add(f)
                 entry.set_untracked()
             return True
 
     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.dm_nonnormal:
                     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, only_tracked=True)
 
     @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, _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,
         ):
             ret = self._rustmap.addfile(
                 f,
                 mode,
                 size,
                 mtime,
                 added,
                 merged,
                 from_p2,
                 possibly_dirty,
             )
             if added:
                 self.copymap.pop(f, None)
             return ret
 
         def reset_state(
             self,
             filename,
             wc_tracked=False,
             p1_tracked=False,
             p2_tracked=False,
             merged=False,
             clean_p1=False,
             clean_p2=False,
             possibly_dirty=False,
             parentfiledata=None,
         ):
             """Set a entry to a given state, disregarding all previous state
 
             This is to be used by the part of the dirstate API dedicated to
             adjusting the dirstate after a update/merge.
 
             note: calling this might result to no entry existing at all if the
             dirstate map does not see any point at having one for this file
             anymore.
             """
             if merged and (clean_p1 or clean_p2):
                 msg = (
                     b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
                 )
                 raise error.ProgrammingError(msg)
             # copy information are now outdated
             # (maybe new information should be in directly passed to this function)
             self.copymap.pop(filename, None)
 
             if not (p1_tracked or p2_tracked or wc_tracked):
                 self.dropfile(filename)
             elif merged:
                 # XXX might be merged and removed ?
                 entry = self.get(filename)
                 if entry is not None and entry.tracked:
                     # XXX mostly replicate dirstate.other parent.  We should get
                     # the higher layer to pass us more reliable data where `merged`
                     # actually mean merged. Dropping the else clause will show
                     # failure in `test-graft.t`
                     self.addfile(filename, merged=True)
                 else:
                     self.addfile(filename, from_p2=True)
             elif not (p1_tracked or p2_tracked) and wc_tracked:
                 self.addfile(
                     filename, added=True, possibly_dirty=possibly_dirty
                 )
             elif (p1_tracked or p2_tracked) and not wc_tracked:
                 # XXX might be merged and removed ?
                 self[filename] = DirstateItem.from_v1_data(b'r', 0, 0, 0)
                 self.nonnormalset.add(filename)
             elif clean_p2 and wc_tracked:
                 if p1_tracked or self.get(filename) is not None:
                     # XXX the `self.get` call is catching some case in
                     # `test-merge-remove.t` where the file is tracked in p1, the
                     # p1_tracked argument is False.
                     #
                     # In addition, this seems to be a case where the file is marked
                     # as merged without actually being the result of a merge
                     # action. So thing are not ideal here.
                     self.addfile(filename, merged=True)
                 else:
                     self.addfile(filename, from_p2=True)
             elif not p1_tracked and p2_tracked and wc_tracked:
                 self.addfile(
                     filename, from_p2=True, possibly_dirty=possibly_dirty
                 )
             elif possibly_dirty:
                 self.addfile(filename, possibly_dirty=possibly_dirty)
             elif wc_tracked:
                 # this is a "normal" file
                 if parentfiledata is None:
                     msg = b'failed to pass parentfiledata for a normal file: %s'
                     msg %= filename
                     raise error.ProgrammingError(msg)
                 mode, size, mtime = parentfiledata
                 self.addfile(filename, mode=mode, size=size, mtime=mtime)
                 self.nonnormalset.discard(filename)
             else:
                 assert False, 'unreachable'
 
         def set_tracked(self, filename):
             new = False
             entry = self.get(filename)
             if entry is None:
                 self.addfile(filename, added=True)
                 new = True
             elif not entry.tracked:
                 entry.set_tracked()
                 self._rustmap.set_dirstate_item(filename, entry)
                 new = True
             else:
                 # XXX This is probably overkill for more case, but we need this to
                 # fully replace the `normallookup` call with `set_tracked` one.
                 # Consider smoothing this in the future.
                 self.set_possibly_dirty(filename)
             return new
 
         def set_untracked(self, f):
             """Mark a file as no longer tracked in the dirstate map"""
             # in merge is only trigger more logic, so it "fine" to pass it.
             #
             # the inner rust dirstate map code need to be adjusted once the API
             # for dirstate/dirstatemap/DirstateItem is a bit more settled
             entry = self.get(f)
             if entry is None:
                 return False
             else:
                 if entry.added:
                     self._rustmap.copymap().pop(f, None)
                     self._rustmap.dropfile(f)
                 else:
                     self._rustmap.removefile(f, in_merge=True)
                 return True
 
         def removefile(self, *args, **kwargs):
             return self._rustmap.removefile(*args, **kwargs)
 
         def dropfile(self, f, *args, **kwargs):
             self._rustmap.copymap().pop(f, None)
-            return self._rustmap.dropfile(f, *args, **kwargs)
+            self._rustmap.dropfile(f, *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 debug_iter(self, all):
             """
             Return an iterator of (filename, state, mode, size, mtime) tuples
 
             `all`: also include with `state == b' '` dirstate tree nodes that
             don't have an associated `DirstateItem`.
 
             """
             return self._rustmap.debug_iter(all)
 
         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:
                     self._parents = self.docket.parents
                 else:
                     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)
             )
 
             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, self.docket.data_size, self.docket.tree_metadata
                 )
                 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, tr, st, now):
             if not self._use_dirstate_v2:
                 p1, p2 = self.parents()
                 packed = self._rustmap.write_v1(p1, p2, now)
                 st.write(packed)
                 st.close()
                 self._dirtyparents = False
                 return
 
             # We can only append to an existing data file if there is one
             can_append = self.docket.uuid is not None
             packed, meta, append = self._rustmap.write_v2(now, can_append)
             if append:
                 docket = self.docket
                 data_filename = docket.data_filename()
                 if tr:
                     tr.add(data_filename, docket.data_size)
                 with self._opener(data_filename, b'r+b') as fp:
                     fp.seek(docket.data_size)
                     assert fp.tell() == docket.data_size
                     written = fp.write(packed)
                     if written is not None:  # py2 may return None
                         assert written == len(packed), (written, len(packed))
                 docket.data_size += len(packed)
                 docket.parents = self.parents()
                 docket.tree_metadata = meta
                 st.write(docket.serialize())
                 st.close()
             else:
                 old_docket = self.docket
                 new_docket = docketmod.DirstateDocket.with_new_uuid(
                     self.parents(), len(packed), meta
                 )
                 data_filename = new_docket.data_filename()
                 if tr:
                     tr.add(data_filename, 0)
                 self._opener.write(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:
                     data_filename = old_docket.data_filename()
                     unlink = lambda _tr=None: self._opener.unlink(data_filename)
                     if tr:
                         category = b"dirstate-v2-clean-" + old_docket.uuid
                         tr.addpostclose(category, unlink)
                     else:
                         unlink()
                 self._docket = new_docket
             # Reload from the newly-written file
             util.clearcachedproperty(self, b"_rustmap")
             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 in self._rustmap.tracked_dirs():
                 f[normcase(name)] = name
             return f
 
         def set_possibly_dirty(self, filename):
             """record that the current state of the file on disk is unknown"""
             entry = self[filename]
             entry.set_possibly_dirty()
             self._rustmap.set_dirstate_item(filename, entry)
 
         def set_clean(self, filename, mode, size, mtime):
             """mark a file as back to a clean state"""
             entry = self[filename]
             mtime = mtime & rangemask
             size = size & rangemask
             entry.set_clean(mode, size, mtime)
             self._rustmap.set_dirstate_item(filename, entry)
             self._rustmap.copymap().pop(filename, None)
 
         def __setitem__(self, key, value):
             assert isinstance(value, DirstateItem)
             self._rustmap.set_dirstate_item(key, value)

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

@@ -1,471 +1,471 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.
 
 use crate::dirstate::parsers::Timestamp;
 use crate::{
     dirstate::EntryState,
     dirstate::MTIME_UNSET,
     dirstate::SIZE_FROM_OTHER_PARENT,
     dirstate::SIZE_NON_NORMAL,
     dirstate::V1_RANGEMASK,
     pack_dirstate, parse_dirstate,
     utils::hg_path::{HgPath, HgPathBuf},
     CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateParents,
     StateMap,
 };
 use micro_timer::timed;
 use std::collections::HashSet;
 use std::iter::FromIterator;
 use std::ops::Deref;
 
 #[derive(Default)]
 pub struct DirstateMap {
     state_map: StateMap,
     pub copy_map: CopyMap,
     pub dirs: Option<DirsMultiset>,
     pub all_dirs: Option<DirsMultiset>,
     non_normal_set: Option<HashSet<HgPathBuf>>,
     other_parent_set: Option<HashSet<HgPathBuf>>,
 }
 
 /// Should only really be used in python interface code, for clarity
 impl Deref for DirstateMap {
     type Target = StateMap;
 
     fn deref(&self) -> &Self::Target {
         &self.state_map
     }
 }
 
 impl FromIterator<(HgPathBuf, DirstateEntry)> for DirstateMap {
     fn from_iter<I: IntoIterator<Item = (HgPathBuf, DirstateEntry)>>(
         iter: I,
     ) -> Self {
         Self {
             state_map: iter.into_iter().collect(),
             ..Self::default()
         }
     }
 }
 
 impl DirstateMap {
     pub fn new() -> Self {
         Self::default()
     }
 
     pub fn clear(&mut self) {
         self.state_map = StateMap::default();
         self.copy_map.clear();
         self.non_normal_set = None;
         self.other_parent_set = None;
     }
 
     pub fn set_entry(&mut self, filename: &HgPath, entry: DirstateEntry) {
         self.state_map.insert(filename.to_owned(), entry);
     }
 
     /// Add a tracked file to the dirstate
     pub fn add_file(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
         // XXX once the dust settle this should probably become an enum
         added: bool,
         merged: bool,
         from_p2: bool,
         possibly_dirty: bool,
     ) -> Result<(), DirstateError> {
         let state;
         let size;
         let mtime;
         if added {
             assert!(!possibly_dirty);
             assert!(!from_p2);
             state = EntryState::Added;
             size = SIZE_NON_NORMAL;
             mtime = MTIME_UNSET;
         } else if merged {
             assert!(!possibly_dirty);
             assert!(!from_p2);
             state = EntryState::Merged;
             size = SIZE_FROM_OTHER_PARENT;
             mtime = MTIME_UNSET;
         } else if from_p2 {
             assert!(!possibly_dirty);
             state = EntryState::Normal;
             size = SIZE_FROM_OTHER_PARENT;
             mtime = MTIME_UNSET;
         } else if possibly_dirty {
             state = EntryState::Normal;
             size = SIZE_NON_NORMAL;
             mtime = MTIME_UNSET;
         } else {
             state = EntryState::Normal;
             size = entry.size() & V1_RANGEMASK;
             mtime = entry.mtime() & V1_RANGEMASK;
         }
         let mode = entry.mode();
         let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
 
         let old_state = self.get(filename).map(|e| e.state());
         if old_state.is_none() || old_state == Some(EntryState::Removed) {
             if let Some(ref mut dirs) = self.dirs {
                 dirs.add_path(filename)?;
             }
         }
         if old_state.is_none() {
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.add_path(filename)?;
             }
         }
         self.state_map.insert(filename.to_owned(), entry.to_owned());
 
         if entry.is_non_normal() {
             self.get_non_normal_other_parent_entries()
                 .0
                 .insert(filename.to_owned());
         }
 
         if entry.is_from_other_parent() {
             self.get_non_normal_other_parent_entries()
                 .1
                 .insert(filename.to_owned());
         }
         Ok(())
     }
 
     /// 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.
     pub fn remove_file(
         &mut self,
         filename: &HgPath,
         in_merge: bool,
     ) -> Result<(), DirstateError> {
         let old_entry_opt = self.get(filename);
         let old_state = old_entry_opt.map(|e| e.state());
         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;
                     self.get_non_normal_other_parent_entries()
                         .1
                         .insert(filename.to_owned());
                 }
             }
         }
         if old_state.is_some() && old_state != Some(EntryState::Removed) {
             if let Some(ref mut dirs) = self.dirs {
                 dirs.delete_path(filename)?;
             }
         }
         if old_state.is_none() {
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.add_path(filename)?;
             }
         }
         if size == 0 {
             self.copy_map.remove(filename);
         }
 
         self.state_map
             .insert(filename.to_owned(), DirstateEntry::new_removed(size));
         self.get_non_normal_other_parent_entries()
             .0
             .insert(filename.to_owned());
         Ok(())
     }
 
     /// Remove a file from the dirstate.
     /// Returns `true` if the file was previously recorded.
     pub fn drop_file(
         &mut self,
         filename: &HgPath,
-    ) -> Result<bool, DirstateError> {
+    ) -> Result<(), DirstateError> {
         let old_state = self.get(filename).map(|e| e.state());
         let exists = self.state_map.remove(filename).is_some();
 
         if exists {
             if old_state != Some(EntryState::Removed) {
                 if let Some(ref mut dirs) = self.dirs {
                     dirs.delete_path(filename)?;
                 }
             }
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.delete_path(filename)?;
             }
         }
         self.get_non_normal_other_parent_entries()
             .0
             .remove(filename);
 
-        Ok(exists)
+        Ok(())
     }
 
     pub fn clear_ambiguous_times(
         &mut self,
         filenames: Vec<HgPathBuf>,
         now: i32,
     ) {
         for filename in filenames {
             if let Some(entry) = self.state_map.get_mut(&filename) {
                 if entry.clear_ambiguous_mtime(now) {
                     self.get_non_normal_other_parent_entries()
                         .0
                         .insert(filename.to_owned());
                 }
             }
         }
     }
 
     pub fn non_normal_entries_remove(
         &mut self,
         key: impl AsRef<HgPath>,
     ) -> bool {
         self.get_non_normal_other_parent_entries()
             .0
             .remove(key.as_ref())
     }
 
     pub fn non_normal_entries_add(&mut self, key: impl AsRef<HgPath>) {
         self.get_non_normal_other_parent_entries()
             .0
             .insert(key.as_ref().into());
     }
 
     pub fn non_normal_entries_union(
         &mut self,
         other: HashSet<HgPathBuf>,
     ) -> Vec<HgPathBuf> {
         self.get_non_normal_other_parent_entries()
             .0
             .union(&other)
             .map(ToOwned::to_owned)
             .collect()
     }
 
     pub fn get_non_normal_other_parent_entries(
         &mut self,
     ) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) {
         self.set_non_normal_other_parent_entries(false);
         (
             self.non_normal_set.as_mut().unwrap(),
             self.other_parent_set.as_mut().unwrap(),
         )
     }
 
     /// Useful to get immutable references to those sets in contexts where
     /// you only have an immutable reference to the `DirstateMap`, like when
     /// sharing references with Python.
     ///
     /// TODO, get rid of this along with the other "setter/getter" stuff when
     /// a nice typestate plan is defined.
     ///
     /// # Panics
     ///
     /// Will panic if either set is `None`.
     pub fn get_non_normal_other_parent_entries_panic(
         &self,
     ) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>) {
         (
             self.non_normal_set.as_ref().unwrap(),
             self.other_parent_set.as_ref().unwrap(),
         )
     }
 
     pub fn set_non_normal_other_parent_entries(&mut self, force: bool) {
         if !force
             && self.non_normal_set.is_some()
             && self.other_parent_set.is_some()
         {
             return;
         }
         let mut non_normal = HashSet::new();
         let mut other_parent = HashSet::new();
 
         for (filename, entry) in self.state_map.iter() {
             if entry.is_non_normal() {
                 non_normal.insert(filename.to_owned());
             }
             if entry.is_from_other_parent() {
                 other_parent.insert(filename.to_owned());
             }
         }
         self.non_normal_set = Some(non_normal);
         self.other_parent_set = Some(other_parent);
     }
 
     /// Both of these setters and their uses appear to be the simplest way to
     /// emulate a Python lazy property, but it is ugly and unidiomatic.
     /// TODO One day, rewriting this struct using the typestate might be a
     /// good idea.
     pub fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
         if self.all_dirs.is_none() {
             self.all_dirs = Some(DirsMultiset::from_dirstate(
                 self.state_map.iter().map(|(k, v)| Ok((k, *v))),
                 false,
             )?);
         }
         Ok(())
     }
 
     pub fn set_dirs(&mut self) -> Result<(), DirstateError> {
         if self.dirs.is_none() {
             self.dirs = Some(DirsMultiset::from_dirstate(
                 self.state_map.iter().map(|(k, v)| Ok((k, *v))),
                 true,
             )?);
         }
         Ok(())
     }
 
     pub fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.set_dirs()?;
         Ok(self.dirs.as_ref().unwrap().contains(directory))
     }
 
     pub fn has_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.set_all_dirs()?;
         Ok(self.all_dirs.as_ref().unwrap().contains(directory))
     }
 
     #[timed]
     pub fn read(
         &mut self,
         file_contents: &[u8],
     ) -> Result<Option<DirstateParents>, DirstateError> {
         if file_contents.is_empty() {
             return Ok(None);
         }
 
         let (parents, entries, copies) = parse_dirstate(file_contents)?;
         self.state_map.extend(
             entries
                 .into_iter()
                 .map(|(path, entry)| (path.to_owned(), entry)),
         );
         self.copy_map.extend(
             copies
                 .into_iter()
                 .map(|(path, copy)| (path.to_owned(), copy.to_owned())),
         );
         Ok(Some(parents.clone()))
     }
 
     pub fn pack(
         &mut self,
         parents: DirstateParents,
         now: Timestamp,
     ) -> Result<Vec<u8>, DirstateError> {
         let packed =
             pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?;
 
         self.set_non_normal_other_parent_entries(true);
         Ok(packed)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_dirs_multiset() {
         let mut map = DirstateMap::new();
         assert!(map.dirs.is_none());
         assert!(map.all_dirs.is_none());
 
         assert_eq!(map.has_dir(HgPath::new(b"nope")).unwrap(), false);
         assert!(map.all_dirs.is_some());
         assert!(map.dirs.is_none());
 
         assert_eq!(map.has_tracked_dir(HgPath::new(b"nope")).unwrap(), false);
         assert!(map.dirs.is_some());
     }
 
     #[test]
     fn test_add_file() {
         let mut map = DirstateMap::new();
 
         assert_eq!(0, map.len());
 
         map.add_file(
             HgPath::new(b"meh"),
             DirstateEntry::from_v1_data(EntryState::Normal, 1337, 1337, 1337),
             false,
             false,
             false,
             false,
         )
         .unwrap();
 
         assert_eq!(1, map.len());
         assert_eq!(0, map.get_non_normal_other_parent_entries().0.len());
         assert_eq!(0, map.get_non_normal_other_parent_entries().1.len());
     }
 
     #[test]
     fn test_non_normal_other_parent_entries() {
         let mut map: DirstateMap = [
             (b"f1", (EntryState::Removed, 1337, 1337, 1337)),
             (b"f2", (EntryState::Normal, 1337, 1337, -1)),
             (b"f3", (EntryState::Normal, 1337, 1337, 1337)),
             (b"f4", (EntryState::Normal, 1337, -2, 1337)),
             (b"f5", (EntryState::Added, 1337, 1337, 1337)),
             (b"f6", (EntryState::Added, 1337, 1337, -1)),
             (b"f7", (EntryState::Merged, 1337, 1337, -1)),
             (b"f8", (EntryState::Merged, 1337, 1337, 1337)),
             (b"f9", (EntryState::Merged, 1337, -2, 1337)),
             (b"fa", (EntryState::Added, 1337, -2, 1337)),
             (b"fb", (EntryState::Removed, 1337, -2, 1337)),
         ]
         .iter()
         .map(|(fname, (state, mode, size, mtime))| {
             (
                 HgPathBuf::from_bytes(fname.as_ref()),
                 DirstateEntry::from_v1_data(*state, *mode, *size, *mtime),
             )
         })
         .collect();
 
         let mut non_normal = [
             b"f1", b"f2", b"f4", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa",
             b"fb",
         ]
         .iter()
         .map(|x| HgPathBuf::from_bytes(x.as_ref()))
         .collect();
 
         let mut other_parent = HashSet::new();
         other_parent.insert(HgPathBuf::from_bytes(b"f4"));
         let entries = map.get_non_normal_other_parent_entries();
 
         assert_eq!(
             (&mut non_normal, &mut other_parent),
             (entries.0, entries.1)
         );
     }
 }

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

@@ -1,1308 +1,1307 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;
 
 /// Append to an existing data file if the amount of unreachable data (not used
 /// anymore) is less than this fraction of the total amount of existing data.
 const ACCEPTABLE_UNREACHABLE_BYTES_RATIO: f32 = 0.5;
 
 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,
 
     /// How many bytes of `on_disk` are not used anymore
     pub(super) unreachable_bytes: u32,
 }
 
 /// 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(),
         }
     }
 
     fn make_mut(
         &mut self,
         on_disk: &'on_disk [u8],
         unreachable_bytes: &mut u32,
     ) -> Result<
         &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>,
         DirstateV2ParseError,
     > {
         match self {
             ChildNodes::InMemory(nodes) => Ok(nodes),
             ChildNodes::OnDisk(nodes) => {
                 *unreachable_bytes +=
                     std::mem::size_of_val::<[on_disk::Node]>(nodes) as u32;
                 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],
             unreachable_bytes: 0,
         }
     }
 
     #[timed]
     pub fn new_v2(
         on_disk: &'on_disk [u8],
         data_size: usize,
         metadata: &[u8],
     ) -> Result<Self, DirstateError> {
         if let Some(data) = on_disk.get(..data_size) {
             Ok(on_disk::read(data, metadata)?)
         } else {
             Err(DirstateV2ParseError.into())
         }
     }
 
     #[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.unreachable_bytes,
                     &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))
     }
 
     /// Assuming dirstate-v2 format, returns whether the next write should
     /// append to the existing data file that contains `self.on_disk` (true),
     /// or create a new data file from scratch (false).
     pub(super) fn write_should_append(&self) -> bool {
         let ratio = self.unreachable_bytes as f32 / self.on_disk.len() as f32;
         ratio < ACCEPTABLE_UNREACHABLE_BYTES_RATIO
     }
 
     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],
         unreachable_bytes: &mut u32,
         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, unreachable_bytes)?
                 .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.unreachable_bytes,
             &mut self.root,
             path,
             WithBasename::to_cow_owned,
             |_| {},
         )
     }
 
     fn get_or_insert_node<'tree, 'path>(
         on_disk: &'on_disk [u8],
         unreachable_bytes: &mut u32,
         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, unreachable_bytes)?
                 .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: Option<EntryState>,
         new_entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         let had_entry = old_state.is_some();
         let was_tracked = old_state.map_or(false, |s| s.is_tracked());
         let tracked_count_increment =
             match (was_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.unreachable_bytes,
             &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.unreachable_bytes,
                 &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)
         })
     }
 
     fn count_dropped_path(unreachable_bytes: &mut u32, path: &Cow<HgPath>) {
         if let Cow::Borrowed(path) = path {
             *unreachable_bytes += path.len() as u32
         }
     }
 }
 
 /// 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 set_entry(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         self.get_or_insert(&filename)?.data = NodeData::Entry(entry);
         Ok(())
     }
 
     fn add_file(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
         added: bool,
         merged: bool,
         from_p2: bool,
         possibly_dirty: bool,
     ) -> Result<(), DirstateError> {
         let state;
         let size;
         let mtime;
         if added {
             assert!(!possibly_dirty);
             assert!(!from_p2);
             state = EntryState::Added;
             size = SIZE_NON_NORMAL;
             mtime = MTIME_UNSET;
         } else if merged {
             assert!(!possibly_dirty);
             assert!(!from_p2);
             state = EntryState::Merged;
             size = SIZE_FROM_OTHER_PARENT;
             mtime = MTIME_UNSET;
         } else if from_p2 {
             assert!(!possibly_dirty);
             state = EntryState::Normal;
             size = SIZE_FROM_OTHER_PARENT;
             mtime = MTIME_UNSET;
         } else if possibly_dirty {
             state = EntryState::Normal;
             size = SIZE_NON_NORMAL;
             mtime = MTIME_UNSET;
         } else {
             state = EntryState::Normal;
             size = entry.size() & V1_RANGEMASK;
             mtime = entry.mtime() & V1_RANGEMASK;
         }
         let mode = entry.mode();
         let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
 
         let old_state = self.get(filename)?.map(|e| e.state());
 
         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 = old_entry_opt.map(|e| e.state());
         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::new_removed(size);
         Ok(self.add_or_remove_file(filename, old_state, entry)?)
     }
 
-    fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError> {
+    fn drop_file(&mut self, filename: &HgPath) -> Result<(), DirstateError> {
         let was_tracked = self
             .get(filename)?
             .map_or(false, |e| e.state().is_tracked());
         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],
             unreachable_bytes: &mut u32,
             nodes: &mut ChildNodes<'on_disk>,
             path: &HgPath,
         ) -> Result<Option<(Dropped, bool)>, DirstateV2ParseError> {
             let (first_path_component, rest_of_path) =
                 path.split_first_component();
             let nodes = nodes.make_mut(on_disk, unreachable_bytes)?;
             let node = if let Some(node) = nodes.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,
                     unreachable_bytes,
                     &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
                 }
                 if let Some(source) = &node.copy_source {
                     DirstateMap::count_dropped_path(unreachable_bytes, source)
                 }
                 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 {
                 let (key, _) =
                     nodes.remove_entry(first_path_component).unwrap();
                 DirstateMap::count_dropped_path(
                     unreachable_bytes,
                     key.full_path(),
                 )
             }
             Ok(Some((dropped, remove)))
         }
 
         if let Some((dropped, _removed)) = recur(
             self.on_disk,
             &mut self.unreachable_bytes,
             &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!(!was_tracked);
-            Ok(false)
         }
+        Ok(())
     }
 
     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.unreachable_bytes,
                 &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) -> bool {
         // Do nothing, this `DirstateMap` does not have a separate "non normal
         // entries" set that need to be kept up to date.
         if let Ok(Some(v)) = self.get(key) {
             return v.is_non_normal();
         }
         false
     }
 
     fn non_normal_entries_add(&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)
     }
 
     /// Returns new data and metadata together with whether that data should be
     /// appended to the existing data file whose content is at
     /// `self.on_disk` (true), instead of written to a new data file
     /// (false).
     #[timed]
     fn pack_v2(
         &mut self,
         now: Timestamp,
         can_append: bool,
     ) -> Result<(Vec<u8>, Vec<u8>, bool), 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, can_append)
     }
 
     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;
         let unreachable_bytes = &mut self.unreachable_bytes;
         Ok(Self::get_node_mut(
             self.on_disk,
             unreachable_bytes,
             &mut self.root,
             key,
         )?
         .and_then(|node| {
             if let Some(source) = &node.copy_source {
                 *count -= 1;
                 Self::count_dropped_path(unreachable_bytes, source);
             }
             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.unreachable_bytes,
             &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_tracked_dirs(
         &mut self,
     ) -> Result<
         Box<
             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
                 + Send
                 + '_,
         >,
         DirstateError,
     > {
         let on_disk = self.on_disk;
         Ok(Box::new(filter_map_results(
             self.iter_nodes(),
             move |node| {
                 Ok(if node.tracked_descendants_count() > 0 {
                     Some(node.full_path(on_disk)?)
                 } else {
                     None
                 })
             },
         )))
     }
 
     fn debug_iter(
         &self,
         all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, (u8, i32, i32, i32)),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     > {
         Box::new(filter_map_results(self.iter_nodes(), move |node| {
             let debug_tuple = if let Some(entry) = node.entry()? {
                 entry.debug_tuple()
             } else if !all {
                 return Ok(None);
             } else if let Some(mtime) = node.cached_directory_mtime() {
                 (b' ', 0, -1, mtime.seconds() as i32)
             } else {
                 (b' ', 0, -1, -1)
             };
             Ok(Some((node.full_path(self.on_disk)?, debug_tuple)))
         }))
     }
 }

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

@@ -1,573 +1,573 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 the given filename to the map if it is not already there, and
     /// associate the given entry with it.
     fn set_entry(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError>;
 
     /// 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>;
+    fn drop_file(&mut self, filename: &HgPath) -> Result<(), 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.
     /// Returns whether the key was present in the set.
     fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool;
 
     /// Mark the given path as "non-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_add(&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 a dirstate data file to disk in dirstate-v2
     /// format.
     ///
     /// Returns new data and metadata together with whether that data should be
     /// appended to the existing data file whose content is at
     /// `self.on_disk` (true), instead of written to a new data file
     /// (false).
     ///
     /// Note: this is only supported by the tree dirstate map.
     fn pack_v2(
         &mut self,
         now: Timestamp,
         can_append: bool,
     ) -> Result<(Vec<u8>, Vec<u8>, bool), 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<'_>;
 
     /// Returns an iterator of tracked directories.
     ///
     /// This is the paths for which `has_tracked_dir` would return true.
     /// Or, in other words, the union of ancestor paths of all paths that have
     /// an associated entry in a "tracked" state in this dirstate map.
     ///
     /// Because parse errors can happen during iteration, the iterated items
     /// are `Result`s.
     fn iter_tracked_dirs(
         &mut self,
     ) -> Result<
         Box<
             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
                 + Send
                 + '_,
         >,
         DirstateError,
     >;
 
     /// Return an iterator of `(path, (state, mode, size, mtime))` for every
     /// node stored in this dirstate map, for the purpose of the `hg
     /// debugdirstate` command.
     ///
     /// If `all` is true, include  nodes that don’t have an entry.
     /// For such nodes `state` is the ASCII space.
     /// An `mtime` may still be present. It is used to optimize `status`.
     ///
     /// Because parse errors can happen during iteration, the iterated items
     /// are `Result`s.
     fn debug_iter(
         &self,
         all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, (u8, i32, i32, i32)),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     >;
 }
 
 impl DirstateMapMethods for DirstateMap {
     fn clear(&mut self) {
         self.clear()
     }
 
     /// Used to set a value directory.
     ///
     /// XXX Is temporary during a refactor of V1 dirstate and will disappear
     /// shortly.
     fn set_entry(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         self.set_entry(&filename, entry);
         Ok(())
     }
 
     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> {
+    fn drop_file(&mut self, filename: &HgPath) -> Result<(), 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) -> bool {
         self.non_normal_entries_remove(key)
     }
 
     fn non_normal_entries_add(&mut self, key: &HgPath) {
         self.non_normal_entries_add(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,
         _now: Timestamp,
         _can_append: bool,
     ) -> Result<(Vec<u8>, Vec<u8>, bool), 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_tracked_dirs(
         &mut self,
     ) -> Result<
         Box<
             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
                 + Send
                 + '_,
         >,
         DirstateError,
     > {
         self.set_all_dirs()?;
         Ok(Box::new(
             self.all_dirs
                 .as_ref()
                 .unwrap()
                 .iter()
                 .map(|path| Ok(&**path)),
         ))
     }
 
     fn debug_iter(
         &self,
         all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, (u8, i32, i32, i32)),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     > {
         // Not used for the flat (not tree-based) DirstateMap
         let _ = all;
 
         Box::new(
             (&**self)
                 .iter()
                 .map(|(path, entry)| Ok((&**path, entry.debug_tuple()))),
         )
     }
 }

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

@@ -1,245 +1,245 b''
 use crate::dirstate::parsers::Timestamp;
 use crate::dirstate_tree::dispatch::DirstateMapMethods;
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::dirstate_tree::owning::OwningDirstateMap;
 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::PatternFileWarning;
 use crate::StateMapIter;
 use crate::StatusError;
 use crate::StatusOptions;
 use std::path::PathBuf;
 
 impl DirstateMapMethods for OwningDirstateMap {
     fn clear(&mut self) {
         self.get_mut().clear()
     }
 
     fn set_entry(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         self.get_mut().set_entry(filename, entry)
     }
 
     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> {
+    fn drop_file(&mut self, filename: &HgPath) -> Result<(), 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) -> bool {
         self.get_mut().non_normal_entries_remove(key)
     }
 
     fn non_normal_entries_add(&mut self, key: &HgPath) {
         self.get_mut().non_normal_entries_add(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,
         now: Timestamp,
         can_append: bool,
     ) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {
         self.get_mut().pack_v2(now, can_append)
     }
 
     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_tracked_dirs(
         &mut self,
     ) -> Result<
         Box<
             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
                 + Send
                 + '_,
         >,
         DirstateError,
     > {
         self.get_mut().iter_tracked_dirs()
     }
 
     fn debug_iter(
         &self,
         all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, (u8, i32, i32, i32)),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     > {
         self.get().debug_iter(all)
     }
 }

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

@@ -1,674 +1,668 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,
+    PyNone, PyObject, PyResult, PySet, PyString, Python, PythonObject,
+    ToPyObject, UnsafePyLeaked,
 };
 
 use crate::{
     dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
     dirstate::item::DirstateItem,
     dirstate::non_normal_entries::{
         NonNormalEntries, NonNormalEntriesIterator,
     },
     pybytes_deref::PyBytesDeref,
 };
 use hg::{
     dirstate::parsers::Timestamp,
     dirstate::MTIME_UNSET,
     dirstate::SIZE_NON_NORMAL,
     dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap,
     dirstate_tree::dispatch::DirstateMapMethods,
     dirstate_tree::on_disk::DirstateV2ParseError,
     dirstate_tree::owning::OwningDirstateMap,
     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_v1(
         use_dirstate_tree: bool,
         on_disk: PyBytes,
     ) -> PyResult<PyObject> {
         let (inner, parents) = if use_dirstate_tree {
             let on_disk = PyBytesDeref::new(py, on_disk);
             let mut map = OwningDirstateMap::new_empty(on_disk);
             let (on_disk, map_placeholder) = map.get_mut_pair();
 
             let (actual_map, parents) = TreeDirstateMap::new_v1(on_disk)
                 .map_err(|e| dirstate_error(py, e))?;
             *map_placeholder = actual_map;
             (Box::new(map) as _, parents)
         } else {
             let bytes = on_disk.data(py);
             let mut map = RustDirstateMap::default();
             let parents = map.read(bytes).map_err(|e| dirstate_error(py, e))?;
             (Box::new(map) as _, parents)
         };
         let map = Self::create_instance(py, inner)?;
         let parents = parents.map(|p| {
             let p1 = PyBytes::new(py, p.p1.as_bytes());
             let p2 = PyBytes::new(py, p.p2.as_bytes());
             (p1, p2)
         });
         Ok((map, parents).to_py_object(py).into_object())
     }
 
     /// Returns a DirstateMap
     @staticmethod
     def new_v2(
         on_disk: PyBytes,
         data_size: usize,
         tree_metadata: PyBytes,
     ) -> PyResult<PyObject> {
         let dirstate_error = |e: DirstateError| {
             PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
         };
         let on_disk = PyBytesDeref::new(py, on_disk);
         let mut map = OwningDirstateMap::new_empty(on_disk);
         let (on_disk, map_placeholder) = map.get_mut_pair();
         *map_placeholder = TreeDirstateMap::new_v2(
             on_disk, data_size, tree_metadata.data(py),
         ).map_err(dirstate_error)?;
         let map = Self::create_instance(py, Box::new(map))?;
         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(DirstateItem::new_as_pyobject(py, entry)?))
             },
             None => Ok(default)
         }
     }
 
     def set_dirstate_item(
         &self,
         path: PyObject,
         item: DirstateItem
     ) -> PyResult<PyObject> {
         let f = path.extract::<PyBytes>(py)?;
         let filename = HgPath::new(f.data(py));
         self.inner(py)
             .borrow_mut()
             .set_entry(filename, item.get_entry(py))
             .map_err(|e| v2_error(py, e))?;
         Ok(py.None())
     }
 
     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::new_for_add_file(mode, size, 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()),
-                ))
-            })
+        f: PyBytes,
+    ) -> PyResult<PyNone> {
+        self.inner(py)
+            .borrow_mut()
+            .drop_file(HgPath::new(f.data(py)))
+            .map_err(|e |dirstate_error(py, e))?;
+        Ok(PyNone)
     }
 
     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)?;
         let key = key.data(py);
         let was_present = self
             .inner(py)
             .borrow_mut()
             .non_normal_entries_remove(HgPath::new(key));
         if !was_present {
             let msg = String::from_utf8_lossy(key);
             Err(PyErr::new::<exc::KeyError, _>(py, msg))
         } else {
             Ok(py.None())
         }
     }
 
     def non_normal_entries_discard(&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_entries_add(&self, key: PyObject) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         self
             .inner(py)
             .borrow_mut()
             .non_normal_entries_add(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_v1(
         &self,
         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(),
             )),
         }
     }
 
     /// Returns new data together with whether that data should be appended to
     /// the existing data file whose content is at `self.on_disk` (True),
     /// instead of written to a new data file (False).
     def write_v2(
         &self,
         now: PyObject,
         can_append: bool,
     ) -> PyResult<PyObject> {
         let now = Timestamp(now.extract(py)?);
 
         let mut inner = self.inner(py).borrow_mut();
         let result = inner.pack_v2(now, can_append);
         match result {
             Ok((packed, tree_metadata, append)) => {
                 let packed = PyBytes::new(py, &packed);
                 let tree_metadata = PyBytes::new(py, &tree_metadata);
                 let tuple = (packed, tree_metadata, append);
                 Ok(tuple.to_py_object(py).into_object())
             },
             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(DirstateItem::new_as_pyobject(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 tracked_dirs(&self) -> PyResult<PyList> {
         let dirs = PyList::new(py, &[]);
         for path in self.inner(py).borrow_mut().iter_tracked_dirs()
             .map_err(|e |dirstate_error(py, e))?
         {
             let path = path.map_err(|e| v2_error(py, e))?;
             let path = PyBytes::new(py, path.as_bytes());
             dirs.append(py, path.into_object())
         }
         Ok(dirs)
     }
 
     def debug_iter(&self, all: bool) -> PyResult<PyList> {
         let dirs = PyList::new(py, &[]);
         for item in self.inner(py).borrow().debug_iter(all) {
             let (path, (state, mode, size, mtime)) =
                 item.map_err(|e| v2_error(py, e))?;
             let path = PyBytes::new(py, path.as_bytes());
             let item = (path, state, mode, size, mtime);
             dirs.append(py, item.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()),
             DirstateItem::new_as_pyobject(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")
 }
 
 fn dirstate_error(py: Python<'_>, e: DirstateError) -> PyErr {
     PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
 }