rust-dirstatemap: implement part of the `setparents` logic

The Python code does many round-trip calls to the Rust dirstatemap when copy
information needs to be dropped in `setparents`.

This may result in improved performance on `commit`, `update` and other such
commands, but was mostly done to drop the last use of `set_dirstate_item`.
See inline comments for an asterisk about performance, and see next patch for
why `set_dirstate_item` has to go.

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

mercurial/dirstatemap.py

@@ -1,709 +1,694 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.
 
 
 import errno
 
 from .i18n import _
 
 from . import (
     error,
     pathutil,
     policy,
     txnutil,
     util,
 )
 
 from .dirstateutils import (
     docket as docketmod,
     v2,
 )
 
 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 _dirstatemapcommon:
     """
     Methods that are identical for both implementations of the dirstatemap
     class, with and without Rust extensions enabled.
     """
 
     # please pytype
 
     _map = None
     copymap = None
 
     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
 
     def preload(self):
         """Loads the underlying data, if it's not already loaded"""
         self._map
 
     def get(self, key, default=None):
         return self._map.get(key, default)
 
     def __len__(self):
         return len(self._map)
 
     def __iter__(self):
         return iter(self._map)
 
     def __contains__(self, key):
         return key in self._map
 
     def __getitem__(self, item):
         return self._map[item]
 
     ### disk interaction
 
     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''
 
     @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
 
     def write_v2_no_append(self, tr, st, meta, packed):
         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
 
     ### reading/setting parents
 
     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
 
 
 class dirstatemap(_dirstatemapcommon):
     """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:
 
     - `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.
     """
 
     ### Core data storage and access
 
     @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")
 
     def items(self):
         return self._map.items()
 
     # 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 keys(self):
         return self._map.keys()
 
     ### reading/setting parents
 
     def setparents(self, p1, p2, fold_p2=False):
         self._parents = (p1, p2)
         self._dirtyparents = True
         copies = {}
         if fold_p2:
             for f, s in self._map.items():
                 # Discard "merged" markers when moving away from a merge state
                 if s.p2_info:
                     source = self.copymap.pop(f, None)
                     if source:
                         copies[f] = source
                     s.drop_merge_data()
         return copies
 
     ### disk interaction
 
     def read(self):
         # 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 not self.docket.uuid:
                 return
             st = self._opener.read(self.docket.data_filename())
         else:
             st = self._readdirstatefile()
 
         if not st:
             return
 
         # TODO: adjust this estimate for dirstate-v2
         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)
         if self._use_dirstate_v2:
             p = self.docket.parents
             meta = self.docket.tree_metadata
             parse_dirstate = util.nogc(v2.parse_dirstate)
             parse_dirstate(self._map, self.copymap, st, meta)
         else:
             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):
         if self._use_dirstate_v2:
             packed, meta = v2.pack_dirstate(self._map, self.copymap)
             self.write_v2_no_append(tr, st, meta, packed)
         else:
             packed = parsers.pack_dirstate(
                 self._map, self.copymap, self.parents()
             )
             st.write(packed)
             st.close()
         self._dirtyparents = False
 
     @propertycache
     def identity(self):
         self._map
         return self.identity
 
     ### code related to maintaining and accessing "extra" property
     # (e.g. "has_dir")
 
     def _dirs_incr(self, filename, old_entry=None):
         """increment 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):
         """decrement 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)
 
     @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 self._map.items():
             if not s.removed:
                 f[normcase(name)] = name
         f[b'.'] = b'.'  # prevents useless util.fspath() invocation
         return f
 
     @propertycache
     def dirfoldmap(self):
         f = {}
         normcase = util.normcase
         for name in self._dirs:
             f[normcase(name)] = name
         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)
 
     ### code related to manipulation of entries and copy-sources
 
     def reset_state(
         self,
         filename,
         wc_tracked=False,
         p1_tracked=False,
         p2_info=False,
         has_meaningful_mtime=True,
         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.
         """
         # 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_info or wc_tracked):
             old_entry = self._map.get(filename)
             self._drop_entry(filename)
             self._dirs_decr(filename, old_entry=old_entry)
             return
 
         old_entry = self._map.get(filename)
         self._dirs_incr(filename, old_entry)
         entry = DirstateItem(
             wc_tracked=wc_tracked,
             p1_tracked=p1_tracked,
             p2_info=p2_info,
             has_meaningful_mtime=has_meaningful_mtime,
             parentfiledata=parentfiledata,
         )
         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(
                 wc_tracked=True,
             )
 
             self._map[filename] = entry
             new = True
         elif not entry.tracked:
             self._dirs_incr(filename, entry)
             entry.set_tracked()
             self._refresh_entry(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.
             entry.set_possibly_dirty()
             self._refresh_entry(filename, entry)
         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.p2_info:
                 self.copymap.pop(f, None)
             entry.set_untracked()
             self._refresh_entry(f, entry)
             return True
 
     def set_clean(self, filename, mode, size, mtime):
         """mark a file as back to a clean state"""
         entry = self[filename]
         size = size & rangemask
         entry.set_clean(mode, size, mtime)
         self._refresh_entry(filename, entry)
         self.copymap.pop(filename, None)
 
     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._refresh_entry(filename, entry)
 
     def _refresh_entry(self, f, entry):
         """record updated state of an entry"""
         if not entry.any_tracked:
             self._map.pop(f, None)
 
     def _drop_entry(self, f):
         """remove any entry for file f
 
         This should also drop associated copy information
 
         The fact we actually need to drop it is the responsability of the caller"""
         self._map.pop(f, None)
         self.copymap.pop(f, None)
 
 
 if rustmod is not None:
 
     class dirstatemap(_dirstatemapcommon):
 
         ### Core data storage and access
 
         @propertycache
         def _map(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._map = rustmod.DirstateMap.new_v2(
                     data, self.docket.data_size, self.docket.tree_metadata
                 )
                 parents = self.docket.parents
             else:
                 self._map, parents = rustmod.DirstateMap.new_v1(
                     self._readdirstatefile()
                 )
 
             if parents and not self._dirtyparents:
                 self.setparents(*parents)
 
             self.__contains__ = self._map.__contains__
             self.__getitem__ = self._map.__getitem__
             self.get = self._map.get
             return self._map
 
         @property
         def copymap(self):
             return self._map.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._map.debug_iter(all)
 
         def clear(self):
             self._map.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._map.items()
 
         # forward for python2,3 compat
         iteritems = items
 
         def keys(self):
             return iter(self._map)
 
         ### reading/setting parents
 
         def setparents(self, p1, p2, fold_p2=False):
             self._parents = (p1, p2)
             self._dirtyparents = True
             copies = {}
             if fold_p2:
-                # Collect into an intermediate list to avoid a `RuntimeError`
-                # exception due to mutation during iteration.
-                # TODO: move this the whole loop to Rust where `iter_mut`
-                # enables in-place mutation of elements of a collection while
-                # iterating it, without mutating the collection itself.
-                files_with_p2_info = [
-                    f for f, s in self._map.items() if s.p2_info
-                ]
-                rust_map = self._map
-                for f in files_with_p2_info:
-                    e = rust_map.get(f)
-                    source = self.copymap.pop(f, None)
-                    if source:
-                        copies[f] = source
-                    e.drop_merge_data()
-                    rust_map.set_dirstate_item(f, e)
+                copies = self._map.setparents_fixup()
             return copies
 
         ### disk interaction
 
         @propertycache
         def identity(self):
             self._map
             return self.identity
 
         def write(self, tr, st):
             if not self._use_dirstate_v2:
                 p1, p2 = self.parents()
                 packed = self._map.write_v1(p1, p2)
                 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._map.write_v2(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:
                 self.write_v2_no_append(tr, st, meta, packed)
             # Reload from the newly-written file
             util.clearcachedproperty(self, b"_map")
             self._dirtyparents = False
 
         ### code related to maintaining and accessing "extra" property
         # (e.g. "has_dir")
 
         @propertycache
         def filefoldmap(self):
             """Returns a dictionary mapping normalized case paths to their
             non-normalized versions.
             """
             return self._map.filefoldmapasdict()
 
         def hastrackeddir(self, d):
             return self._map.hastrackeddir(d)
 
         def hasdir(self, d):
             return self._map.hasdir(d)
 
         @propertycache
         def dirfoldmap(self):
             f = {}
             normcase = util.normcase
             for name in self._map.tracked_dirs():
                 f[normcase(name)] = name
             return f
 
         ### code related to manipulation of entries and copy-sources
 
         def set_tracked(self, f):
             return self._map.set_tracked(f)
 
         def set_untracked(self, f):
             return self._map.set_untracked(f)
 
         def set_clean(self, filename, mode, size, mtime):
             self._map.set_clean(filename, mode, size, mtime)
 
         def set_possibly_dirty(self, f):
             self._map.set_possibly_dirty(f)
 
         def reset_state(
             self,
             filename,
             wc_tracked=False,
             p1_tracked=False,
             p2_info=False,
             has_meaningful_mtime=True,
             parentfiledata=None,
         ):
             return self._map.reset_state(
                 filename,
                 wc_tracked,
                 p1_tracked,
                 p2_info,
                 has_meaningful_mtime,
                 parentfiledata,
             )

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

@@ -1,1404 +1,1439 b''
 use bytes_cast::BytesCast;
 use micro_timer::timed;
 use std::borrow::Cow;
 use std::path::PathBuf;
 
 use super::on_disk;
 use super::on_disk::DirstateV2ParseError;
 use super::owning::OwningDirstateMap;
 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::CopyMapIter;
 use crate::dirstate::DirstateV2Data;
 use crate::dirstate::ParentFileData;
 use crate::dirstate::StateMapIter;
 use crate::dirstate::TruncatedTimestamp;
 use crate::matchers::Matcher;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 use crate::DirstateEntry;
 use crate::DirstateError;
 use crate::DirstateMapError;
 use crate::DirstateParents;
 use crate::DirstateStatus;
 use crate::EntryState;
 use crate::FastHashbrownMap as FastHashMap;
 use crate::PatternFileWarning;
 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),
         }
     }
     /// Returns a `BorrowedPath`, which can be turned into a `Cow<'on_disk,
     /// HgPath>` detached from `'tree`
     pub(super) fn copy_source_borrowed(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<BorrowedPath<'tree, 'on_disk>>, DirstateV2ParseError>
     {
         Ok(match self {
             NodeRef::InMemory(_path, node) => {
                 node.copy_source.as_ref().map(|source| match source {
                     Cow::Borrowed(on_disk) => BorrowedPath::OnDisk(on_disk),
                     Cow::Owned(in_memory) => BorrowedPath::InMemory(in_memory),
                 })
             }
             NodeRef::OnDisk(node) => node
                 .copy_source(on_disk)?
                 .map(|source| BorrowedPath::OnDisk(source)),
         })
     }
 
     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> {
         Ok(self.entry()?.and_then(|e| {
             if e.any_tracked() {
                 Some(e.state())
             } else {
                 None
             }
         }))
     }
 
     pub(super) fn cached_directory_mtime(
         &self,
     ) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => Ok(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: TruncatedTimestamp },
     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,
         }
     }
 
     fn as_entry_mut(&mut self) -> Option<&mut 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 {
             let (_, child_node) = child_nodes
                 .make_mut(on_disk, unreachable_bytes)?
                 .raw_entry_mut()
                 .from_key(ancestor_path.base_name())
                 .or_insert_with(|| (to_cow(ancestor_path), Node::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 reset_state(
         &mut self,
         filename: &HgPath,
         old_entry_opt: Option<DirstateEntry>,
         wc_tracked: bool,
         p1_tracked: bool,
         p2_info: bool,
         has_meaningful_mtime: bool,
         parent_file_data_opt: Option<ParentFileData>,
     ) -> Result<(), DirstateError> {
         let (had_entry, was_tracked) = match old_entry_opt {
             Some(old_entry) => (true, old_entry.tracked()),
             None => (false, false),
         };
         let node = Self::get_or_insert_node(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             filename,
             WithBasename::to_cow_owned,
             |ancestor| {
                 if !had_entry {
                     ancestor.descendants_with_entry_count += 1;
                 }
                 if was_tracked {
                     if !wc_tracked {
                         ancestor.tracked_descendants_count = ancestor
                             .tracked_descendants_count
                             .checked_sub(1)
                             .expect("tracked count to be >= 0");
                     }
                 } else {
                     if wc_tracked {
                         ancestor.tracked_descendants_count += 1;
                     }
                 }
             },
         )?;
 
         let v2_data = if let Some(parent_file_data) = parent_file_data_opt {
             DirstateV2Data {
                 wc_tracked,
                 p1_tracked,
                 p2_info,
                 mode_size: parent_file_data.mode_size,
                 mtime: if has_meaningful_mtime {
                     parent_file_data.mtime
                 } else {
                     None
                 },
                 ..Default::default()
             }
         } else {
             DirstateV2Data {
                 wc_tracked,
                 p1_tracked,
                 p2_info,
                 ..Default::default()
             }
         };
         if !had_entry {
             self.nodes_with_entry_count += 1;
         }
         node.data = NodeData::Entry(DirstateEntry::from_v2_data(v2_data));
         Ok(())
     }
 
     fn set_tracked(
         &mut self,
         filename: &HgPath,
         old_entry_opt: Option<DirstateEntry>,
     ) -> Result<bool, DirstateV2ParseError> {
         let was_tracked = old_entry_opt.map_or(false, |e| e.tracked());
         let had_entry = old_entry_opt.is_some();
         let tracked_count_increment = if was_tracked { 0 } else { 1 };
         let mut new = false;
 
         let node = Self::get_or_insert_node(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             filename,
             WithBasename::to_cow_owned,
             |ancestor| {
                 if !had_entry {
                     ancestor.descendants_with_entry_count += 1;
                 }
 
                 ancestor.tracked_descendants_count += tracked_count_increment;
             },
         )?;
         let new_entry = if let Some(old_entry) = old_entry_opt {
             let mut e = old_entry.clone();
             if e.tracked() {
                 // 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.
                 e.set_possibly_dirty();
             } else {
                 new = true;
                 e.set_tracked();
             }
             e
         } else {
             self.nodes_with_entry_count += 1;
             new = true;
             DirstateEntry::new_tracked()
         };
         node.data = NodeData::Entry(new_entry);
         Ok(new)
     }
 
     /// It is the responsibility of the caller to know that there was an entry
     /// there before. Does not handle the removal of copy source
     fn set_untracked(
         &mut self,
         filename: &HgPath,
         old_entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         let node = Self::get_or_insert_node(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             filename,
             WithBasename::to_cow_owned,
             |ancestor| {
                 ancestor.tracked_descendants_count = ancestor
                     .tracked_descendants_count
                     .checked_sub(1)
                     .expect("tracked_descendants_count should be >= 0");
             },
         )?;
         let mut new_entry = old_entry.clone();
         new_entry.set_untracked();
         node.data = NodeData::Entry(new_entry);
         Ok(())
     }
 
     fn set_clean(
         &mut self,
         filename: &HgPath,
         old_entry: DirstateEntry,
         mode: u32,
         size: u32,
         mtime: TruncatedTimestamp,
     ) -> Result<(), DirstateError> {
         let node = Self::get_or_insert_node(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             filename,
             WithBasename::to_cow_owned,
             |ancestor| {
                 if !old_entry.tracked() {
                     ancestor.tracked_descendants_count += 1;
                 }
             },
         )?;
         let mut new_entry = old_entry.clone();
         new_entry.set_clean(mode, size, mtime);
         node.data = NodeData::Entry(new_entry);
         Ok(())
     }
 
     fn set_possibly_dirty(
         &mut self,
         filename: &HgPath,
     ) -> Result<(), DirstateError> {
         let node = Self::get_or_insert_node(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             filename,
             WithBasename::to_cow_owned,
             |_ancestor| {},
         )?;
         let entry = node.data.as_entry_mut().expect("entry should exist");
         entry.set_possibly_dirty();
         node.data = NodeData::Entry(*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 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 OwningDirstateMap {
     pub fn clear(&mut self) {
         self.with_dmap_mut(|map| {
             map.root = Default::default();
             map.nodes_with_entry_count = 0;
             map.nodes_with_copy_source_count = 0;
         });
     }
 
     pub fn set_entry(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         self.with_dmap_mut(|map| {
             map.get_or_insert(&filename)?.data = NodeData::Entry(entry);
             Ok(())
         })
     }
 
     pub fn set_tracked(
         &mut self,
         filename: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         let old_entry_opt = self.get(filename)?;
         self.with_dmap_mut(|map| map.set_tracked(filename, old_entry_opt))
     }
 
     pub fn set_untracked(
         &mut self,
         filename: &HgPath,
     ) -> Result<bool, DirstateError> {
         let old_entry_opt = self.get(filename)?;
         match old_entry_opt {
             None => Ok(false),
             Some(old_entry) => {
                 if !old_entry.tracked() {
                     // `DirstateMap::set_untracked` is not a noop if
                     // already not tracked as it will decrement the
                     // tracked counters while going down.
                     return Ok(true);
                 }
                 if old_entry.added() {
                     // Untracking an "added" entry will just result in a
                     // worthless entry (and other parts of the code will
                     // complain about it), just drop it entirely.
                     self.drop_entry_and_copy_source(filename)?;
                     return Ok(true);
                 }
                 if !old_entry.p2_info() {
                     self.copy_map_remove(filename)?;
                 }
 
                 self.with_dmap_mut(|map| {
                     map.set_untracked(filename, old_entry)?;
                     Ok(true)
                 })
             }
         }
     }
 
     pub fn set_clean(
         &mut self,
         filename: &HgPath,
         mode: u32,
         size: u32,
         mtime: TruncatedTimestamp,
     ) -> Result<(), DirstateError> {
         let old_entry = match self.get(filename)? {
             None => {
                 return Err(
                     DirstateMapError::PathNotFound(filename.into()).into()
                 )
             }
             Some(e) => e,
         };
         self.copy_map_remove(filename)?;
         self.with_dmap_mut(|map| {
             map.set_clean(filename, old_entry, mode, size, mtime)
         })
     }
 
     pub fn set_possibly_dirty(
         &mut self,
         filename: &HgPath,
     ) -> Result<(), DirstateError> {
         if self.get(filename)?.is_none() {
             return Err(DirstateMapError::PathNotFound(filename.into()).into());
         }
         self.with_dmap_mut(|map| map.set_possibly_dirty(filename))
     }
 
     pub fn reset_state(
         &mut self,
         filename: &HgPath,
         wc_tracked: bool,
         p1_tracked: bool,
         p2_info: bool,
         has_meaningful_mtime: bool,
         parent_file_data_opt: Option<ParentFileData>,
     ) -> Result<(), DirstateError> {
         if !(p1_tracked || p2_info || wc_tracked) {
             self.drop_entry_and_copy_source(filename)?;
             return Ok(());
         }
         self.copy_map_remove(filename)?;
         let old_entry_opt = self.get(filename)?;
         self.with_dmap_mut(|map| {
             map.reset_state(
                 filename,
                 old_entry_opt,
                 wc_tracked,
                 p1_tracked,
                 p2_info,
                 has_meaningful_mtime,
                 parent_file_data_opt,
             )
         })
     }
 
     pub fn drop_entry_and_copy_source(
         &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 = node
                             .descendants_with_entry_count
                             .checked_sub(1)
                             .expect(
                                 "descendants_with_entry_count should be >= 0",
                             );
                     }
                     if dropped.was_tracked {
                         node.tracked_descendants_count = node
                             .tracked_descendants_count
                             .checked_sub(1)
                             .expect(
                                 "tracked_descendants_count should be >= 0",
                             );
                     }
 
                     // 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 entry = node.data.as_entry();
                 let was_tracked = entry.map_or(false, |entry| entry.tracked());
                 let had_entry = entry.is_some();
                 if had_entry {
                     node.data = NodeData::None
                 }
                 let mut had_copy_source = false;
                 if let Some(source) = &node.copy_source {
                     DirstateMap::count_dropped_path(unreachable_bytes, source);
                     had_copy_source = true;
                     node.copy_source = None
                 }
                 dropped = Dropped {
                     was_tracked,
                     had_entry,
                     had_copy_source,
                 };
             }
             // 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)))
         }
 
         self.with_dmap_mut(|map| {
             if let Some((dropped, _removed)) = recur(
                 map.on_disk,
                 &mut map.unreachable_bytes,
                 &mut map.root,
                 filename,
             )? {
                 if dropped.had_entry {
                     map.nodes_with_entry_count = map
                         .nodes_with_entry_count
                         .checked_sub(1)
                         .expect("nodes_with_entry_count should be >= 0");
                 }
                 if dropped.had_copy_source {
                     map.nodes_with_copy_source_count = map
                         .nodes_with_copy_source_count
                         .checked_sub(1)
                         .expect("nodes_with_copy_source_count should be >= 0");
                 }
             } else {
                 debug_assert!(!was_tracked);
             }
             Ok(())
         })
     }
 
     pub fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.with_dmap_mut(|map| {
             if let Some(node) = map.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)
             }
         })
     }
 
     pub fn has_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.with_dmap_mut(|map| {
             if let Some(node) = map.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]
     pub fn pack_v1(
         &self,
         parents: DirstateParents,
     ) -> Result<Vec<u8>, DirstateError> {
         let map = self.get_map();
         // Optizimation (to be measured?): pre-compute size to avoid `Vec`
         // reallocations
         let mut size = parents.as_bytes().len();
         for node in map.iter_nodes() {
             let node = node?;
             if node.entry()?.is_some() {
                 size += packed_entry_size(
                     node.full_path(map.on_disk)?,
                     node.copy_source(map.on_disk)?,
                 );
             }
         }
 
         let mut packed = Vec::with_capacity(size);
         packed.extend(parents.as_bytes());
 
         for node in map.iter_nodes() {
             let node = node?;
             if let Some(entry) = node.entry()? {
                 pack_entry(
                     node.full_path(map.on_disk)?,
                     &entry,
                     node.copy_source(map.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
     /// `map.on_disk` (true), instead of written to a new data file
     /// (false).
     #[timed]
     pub fn pack_v2(
         &self,
         can_append: bool,
     ) -> Result<(Vec<u8>, on_disk::TreeMetadata, bool), DirstateError> {
         let map = self.get_map();
         on_disk::write(map, can_append)
     }
 
     /// `callback` allows the caller to process and do something with the
     /// results of the status. This is needed to do so efficiently (i.e.
     /// without cloning the `DirstateStatus` object with its paths) because
     /// we need to borrow from `Self`.
     pub fn with_status<R>(
         &mut self,
         matcher: &(dyn Matcher + Sync),
         root_dir: PathBuf,
         ignore_files: Vec<PathBuf>,
         options: StatusOptions,
         callback: impl for<'r> FnOnce(
             Result<(DirstateStatus<'r>, Vec<PatternFileWarning>), StatusError>,
         ) -> R,
     ) -> R {
         self.with_dmap_mut(|map| {
             callback(super::status::status(
                 map,
                 matcher,
                 root_dir,
                 ignore_files,
                 options,
             ))
         })
     }
 
     pub fn copy_map_len(&self) -> usize {
         let map = self.get_map();
         map.nodes_with_copy_source_count as usize
     }
 
     pub fn copy_map_iter(&self) -> CopyMapIter<'_> {
         let map = self.get_map();
         Box::new(filter_map_results(map.iter_nodes(), move |node| {
             Ok(if let Some(source) = node.copy_source(map.on_disk)? {
                 Some((node.full_path(map.on_disk)?, source))
             } else {
                 None
             })
         }))
     }
 
     pub fn copy_map_contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         let map = self.get_map();
         Ok(if let Some(node) = map.get_node(key)? {
             node.has_copy_source()
         } else {
             false
         })
     }
 
     pub fn copy_map_get(
         &self,
         key: &HgPath,
     ) -> Result<Option<&HgPath>, DirstateV2ParseError> {
         let map = self.get_map();
         if let Some(node) = map.get_node(key)? {
             if let Some(source) = node.copy_source(map.on_disk)? {
                 return Ok(Some(source));
             }
         }
         Ok(None)
     }
 
     pub fn copy_map_remove(
         &mut self,
         key: &HgPath,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         self.with_dmap_mut(|map| {
             let count = &mut map.nodes_with_copy_source_count;
             let unreachable_bytes = &mut map.unreachable_bytes;
             Ok(DirstateMap::get_node_mut(
                 map.on_disk,
                 unreachable_bytes,
                 &mut map.root,
                 key,
             )?
             .and_then(|node| {
                 if let Some(source) = &node.copy_source {
                     *count -= 1;
                     DirstateMap::count_dropped_path(unreachable_bytes, source);
                 }
                 node.copy_source.take().map(Cow::into_owned)
             }))
         })
     }
 
     pub fn copy_map_insert(
         &mut self,
         key: HgPathBuf,
         value: HgPathBuf,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         self.with_dmap_mut(|map| {
             let node = DirstateMap::get_or_insert_node(
                 map.on_disk,
                 &mut map.unreachable_bytes,
                 &mut map.root,
                 &key,
                 WithBasename::to_cow_owned,
                 |_ancestor| {},
             )?;
             if node.copy_source.is_none() {
                 map.nodes_with_copy_source_count += 1
             }
             Ok(node.copy_source.replace(value.into()).map(Cow::into_owned))
         })
     }
 
     pub fn len(&self) -> usize {
         let map = self.get_map();
         map.nodes_with_entry_count as usize
     }
 
     pub fn contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         Ok(self.get(key)?.is_some())
     }
 
     pub fn get(
         &self,
         key: &HgPath,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         let map = self.get_map();
         Ok(if let Some(node) = map.get_node(key)? {
             node.entry()?
         } else {
             None
         })
     }
 
     pub fn iter(&self) -> StateMapIter<'_> {
         let map = self.get_map();
         Box::new(filter_map_results(map.iter_nodes(), move |node| {
             Ok(if let Some(entry) = node.entry()? {
                 Some((node.full_path(map.on_disk)?, entry))
             } else {
                 None
             })
         }))
     }
 
     pub fn iter_tracked_dirs(
         &mut self,
     ) -> Result<
         Box<
             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
                 + Send
                 + '_,
         >,
         DirstateError,
     > {
         let map = self.get_map();
         let on_disk = map.on_disk;
         Ok(Box::new(filter_map_results(
             map.iter_nodes(),
             move |node| {
                 Ok(if node.tracked_descendants_count() > 0 {
                     Some(node.full_path(on_disk)?)
                 } else {
                     None
                 })
             },
         )))
     }
 
+    /// Only public because it needs to be exposed to the Python layer.
+    /// It is not the full `setparents` logic, only the parts that mutate the
+    /// entries.
+    pub fn setparents_fixup(
+        &mut self,
+    ) -> Result<Vec<(HgPathBuf, HgPathBuf)>, DirstateV2ParseError> {
+        // XXX
+        // All the copying and re-querying is quite inefficient, but this is
+        // still a lot better than doing it from Python.
+        //
+        // The better solution is to develop a mechanism for `iter_mut`,
+        // which will be a lot more involved: we're dealing with a lazy,
+        // append-mostly, tree-like data structure. This will do for now.
+        let mut copies = vec![];
+        let mut files_with_p2_info = vec![];
+        for res in self.iter() {
+            let (path, entry) = res?;
+            if entry.p2_info() {
+                files_with_p2_info.push(path.to_owned())
+            }
+        }
+        self.with_dmap_mut(|map| {
+            for path in files_with_p2_info.iter() {
+                let node = map.get_or_insert(path)?;
+                let entry =
+                    node.data.as_entry_mut().expect("entry should exist");
+                entry.drop_merge_data();
+                if let Some(source) = node.copy_source.take().as_deref() {
+                    copies.push((path.to_owned(), source.to_owned()));
+                }
+            }
+            Ok(copies)
+        })
+    }
+
     pub fn debug_iter(
         &self,
         all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, (u8, i32, i32, i32)),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     > {
         let map = self.get_map();
         Box::new(filter_map_results(map.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.truncated_seconds() as i32)
             } else {
                 (b' ', 0, -1, -1)
             };
             Ok(Some((node.full_path(map.on_disk)?, debug_tuple)))
         }))
     }
 }

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

@@ -1,559 +1,572 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, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, PyNone, PyObject,
     PyResult, Python, PythonObject, ToPyObject, UnsafePyLeaked,
 };
 use hg::dirstate::{ParentFileData, TruncatedTimestamp};
 
 use crate::{
     dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
     dirstate::item::DirstateItem,
     pybytes_deref::PyBytesDeref,
 };
 use hg::{
     dirstate::StateMapIter,
     dirstate_tree::on_disk::DirstateV2ParseError,
     dirstate_tree::owning::OwningDirstateMap,
     revlog::Node,
     utils::files::normalize_case,
     utils::hg_path::{HgPath, HgPathBuf},
     DirstateEntry, DirstateError, DirstateParents, EntryState,
 };
 
 // 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: OwningDirstateMap;
 
     /// Returns a `(dirstate_map, parents)` tuple
     @staticmethod
     def new_v1(
         on_disk: PyBytes,
     ) -> PyResult<PyObject> {
         let on_disk = PyBytesDeref::new(py, on_disk);
         let (map, parents) = OwningDirstateMap::new_v1(on_disk)
             .map_err(|e| dirstate_error(py, e))?;
         let map = Self::create_instance(py, map)?;
         let p1 = PyBytes::new(py, parents.p1.as_bytes());
         let p2 = PyBytes::new(py, parents.p2.as_bytes());
         let parents = (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 map = OwningDirstateMap::new_v2(
             on_disk, data_size, tree_metadata.data(py),
         ).map_err(dirstate_error)?;
         let map = Self::create_instance(py, 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 set_tracked(&self, f: PyObject) -> PyResult<PyBool> {
         let bytes = f.extract::<PyBytes>(py)?;
         let path = HgPath::new(bytes.data(py));
         let res = self.inner(py).borrow_mut().set_tracked(path);
         let was_tracked = res.or_else(|_| {
             Err(PyErr::new::<exc::OSError, _>(py, "Dirstate error".to_string()))
         })?;
         Ok(was_tracked.to_py_object(py))
     }
 
     def set_untracked(&self, f: PyObject) -> PyResult<PyBool> {
         let bytes = f.extract::<PyBytes>(py)?;
         let path = HgPath::new(bytes.data(py));
         let res = self.inner(py).borrow_mut().set_untracked(path);
         let was_tracked = res.or_else(|_| {
             Err(PyErr::new::<exc::OSError, _>(py, "Dirstate error".to_string()))
         })?;
         Ok(was_tracked.to_py_object(py))
     }
 
     def set_clean(
         &self,
         f: PyObject,
         mode: u32,
         size: u32,
         mtime: (i64, u32, bool)
     ) -> PyResult<PyNone> {
         let (mtime_s, mtime_ns, second_ambiguous) = mtime;
         let timestamp = TruncatedTimestamp::new_truncate(
             mtime_s, mtime_ns, second_ambiguous
         );
         let bytes = f.extract::<PyBytes>(py)?;
         let path = HgPath::new(bytes.data(py));
         let res = self.inner(py).borrow_mut().set_clean(
             path, mode, size, timestamp,
         );
         res.or_else(|_| {
             Err(PyErr::new::<exc::OSError, _>(py, "Dirstate error".to_string()))
         })?;
         Ok(PyNone)
     }
 
     def set_possibly_dirty(&self, f: PyObject) -> PyResult<PyNone> {
         let bytes = f.extract::<PyBytes>(py)?;
         let path = HgPath::new(bytes.data(py));
         let res = self.inner(py).borrow_mut().set_possibly_dirty(path);
         res.or_else(|_| {
             Err(PyErr::new::<exc::OSError, _>(py, "Dirstate error".to_string()))
         })?;
         Ok(PyNone)
     }
 
     def reset_state(
         &self,
         f: PyObject,
         wc_tracked: bool,
         p1_tracked: bool,
         p2_info: bool,
         has_meaningful_mtime: bool,
         parentfiledata: Option<(u32, u32, Option<(i64, u32, bool)>)>,
     ) -> PyResult<PyNone> {
         let mut has_meaningful_mtime = has_meaningful_mtime;
         let parent_file_data = match parentfiledata {
             None => {
                 has_meaningful_mtime = false;
                 None
             },
             Some(data) => {
                 let (mode, size, mtime_info) = data;
                 let mtime = if let Some(mtime_info) = mtime_info {
                     let (mtime_s, mtime_ns, second_ambiguous) = mtime_info;
                     let timestamp = TruncatedTimestamp::new_truncate(
                         mtime_s, mtime_ns, second_ambiguous
                     );
                     Some(timestamp)
                 } else {
                     has_meaningful_mtime = false;
                     None
                 };
                 Some(ParentFileData {
                     mode_size: Some((mode, size)),
                     mtime,
                 })
             }
         };
         let bytes = f.extract::<PyBytes>(py)?;
         let path = HgPath::new(bytes.data(py));
         let res = self.inner(py).borrow_mut().reset_state(
             path,
             wc_tracked,
             p1_tracked,
             p2_info,
             has_meaningful_mtime,
             parent_file_data,
         );
         res.or_else(|_| {
             Err(PyErr::new::<exc::OSError, _>(py, "Dirstate error".to_string()))
         })?;
         Ok(PyNone)
     }
 
     def drop_item_and_copy_source(
         &self,
         f: PyBytes,
     ) -> PyResult<PyNone> {
         self.inner(py)
             .borrow_mut()
             .drop_entry_and_copy_source(HgPath::new(f.data(py)))
             .map_err(|e |dirstate_error(py, e))?;
         Ok(PyNone)
     }
 
     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,
     ) -> PyResult<PyBytes> {
         let inner = self.inner(py).borrow();
         let parents = DirstateParents {
             p1: extract_node_id(py, &p1)?,
             p2: extract_node_id(py, &p2)?,
         };
         let result = inner.pack_v1(parents);
         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,
         can_append: bool,
     ) -> PyResult<PyObject> {
         let inner = self.inner(py).borrow();
         let result = inner.pack_v2(can_append);
         match result {
             Ok((packed, tree_metadata, append)) => {
                 let packed = PyBytes::new(py, &packed);
                 let tree_metadata = PyBytes::new(py, tree_metadata.as_bytes());
                 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(copy) => Ok(Some(
                 PyBytes::new(py, copy.as_bytes()).into_object(),
             )),
             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 setparents_fixup(&self) -> PyResult<PyDict> {
+        let dict = PyDict::new(py);
+        let copies = self.inner(py).borrow_mut().setparents_fixup();
+        for (key, value) in copies.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 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, OwningDirstateMap> {
         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))
 }