rust-dirstate: remove excessive clone() of parameter and return value

I think pass-by-ref is preferred in general.

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

@@ -1,426 +1,426 b''
 // dirstate_map.rs
 //
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::{
     dirstate::{parsers::PARENT_SIZE, EntryState},
     pack_dirstate, parse_dirstate, CopyMap, DirsIterable, DirsMultiset,
     DirstateEntry, DirstateError, DirstateMapError, DirstateParents,
     DirstateParseError, StateMap,
 };
 use core::borrow::Borrow;
 use std::collections::{HashMap, HashSet};
 use std::convert::TryInto;
 use std::iter::FromIterator;
 use std::ops::Deref;
 use std::time::Duration;
 
 pub type FileFoldMap = HashMap<Vec<u8>, Vec<u8>>;
 
 const NULL_ID: [u8; 20] = [0; 20];
 const MTIME_UNSET: i32 = -1;
 const SIZE_DIRTY: i32 = -2;
 
 #[derive(Default)]
 pub struct DirstateMap {
     state_map: StateMap,
     pub copy_map: CopyMap,
     file_fold_map: Option<FileFoldMap>,
     pub dirs: Option<DirsMultiset>,
     pub all_dirs: Option<DirsMultiset>,
     non_normal_set: HashSet<Vec<u8>>,
     other_parent_set: HashSet<Vec<u8>>,
     parents: Option<DirstateParents>,
     dirty_parents: bool,
 }
 
 /// Should only really be used in python interface code, for clarity
 impl Deref for DirstateMap {
     type Target = StateMap;
 
     fn deref(&self) -> &Self::Target {
         &self.state_map
     }
 }
 
 impl FromIterator<(Vec<u8>, DirstateEntry)> for DirstateMap {
     fn from_iter<I: IntoIterator<Item = (Vec<u8>, DirstateEntry)>>(
         iter: I,
     ) -> Self {
         Self {
             state_map: iter.into_iter().collect(),
             ..Self::default()
         }
     }
 }
 
 impl DirstateMap {
     pub fn new() -> Self {
         Self::default()
     }
 
     pub fn clear(&mut self) {
         self.state_map.clear();
         self.copy_map.clear();
         self.file_fold_map = None;
         self.non_normal_set.clear();
         self.other_parent_set.clear();
-        self.set_parents(DirstateParents {
+        self.set_parents(&DirstateParents {
             p1: NULL_ID,
             p2: NULL_ID,
         })
     }
 
     /// Add a tracked file to the dirstate
     pub fn add_file(
         &mut self,
         filename: &[u8],
         old_state: EntryState,
         entry: DirstateEntry,
     ) {
         if old_state == EntryState::Unknown || old_state == EntryState::Removed
         {
             if let Some(ref mut dirs) = self.dirs {
                 dirs.add_path(filename)
             }
         }
         if old_state == EntryState::Unknown {
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.add_path(filename)
             }
         }
         self.state_map.insert(filename.to_owned(), entry.to_owned());
 
         if entry.state != EntryState::Normal || entry.mtime == MTIME_UNSET {
             self.non_normal_set.insert(filename.to_owned());
         }
 
         if entry.size == SIZE_DIRTY {
             self.other_parent_set.insert(filename.to_owned());
         }
     }
 
     /// Mark a file as removed in the dirstate.
     ///
     /// The `size` parameter is used to store sentinel values that indicate
     /// the file's previous state.  In the future, we should refactor this
     /// to be more explicit about what that state is.
     pub fn remove_file(
         &mut self,
         filename: &[u8],
         old_state: EntryState,
         size: i32,
     ) -> Result<(), DirstateMapError> {
         if old_state != EntryState::Unknown && old_state != EntryState::Removed
         {
             if let Some(ref mut dirs) = self.dirs {
                 dirs.delete_path(filename)?;
             }
         }
         if old_state == EntryState::Unknown {
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.add_path(filename);
             }
         }
 
         if let Some(ref mut file_fold_map) = self.file_fold_map {
             file_fold_map.remove(&filename.to_ascii_uppercase());
         }
         self.state_map.insert(
             filename.to_owned(),
             DirstateEntry {
                 state: EntryState::Removed,
                 mode: 0,
                 size,
                 mtime: 0,
             },
         );
         self.non_normal_set.insert(filename.to_owned());
         Ok(())
     }
 
     /// Remove a file from the dirstate.
     /// Returns `true` if the file was previously recorded.
     pub fn drop_file(
         &mut self,
         filename: &[u8],
         old_state: EntryState,
     ) -> Result<bool, DirstateMapError> {
         let exists = self.state_map.remove(filename).is_some();
 
         if exists {
             if old_state != EntryState::Removed {
                 if let Some(ref mut dirs) = self.dirs {
                     dirs.delete_path(filename)?;
                 }
             }
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.delete_path(filename)?;
             }
         }
         if let Some(ref mut file_fold_map) = self.file_fold_map {
             file_fold_map.remove(&filename.to_ascii_uppercase());
         }
         self.non_normal_set.remove(filename);
 
         Ok(exists)
     }
 
     pub fn clear_ambiguous_times(
         &mut self,
         filenames: Vec<Vec<u8>>,
         now: i32,
     ) {
         for filename in filenames {
             let mut changed = false;
             self.state_map
                 .entry(filename.to_owned())
                 .and_modify(|entry| {
                     if entry.state == EntryState::Normal && entry.mtime == now
                     {
                         changed = true;
                         *entry = DirstateEntry {
                             mtime: MTIME_UNSET,
                             ..*entry
                         };
                     }
                 });
             if changed {
                 self.non_normal_set.insert(filename.to_owned());
             }
         }
     }
 
     pub fn non_normal_other_parent_entries(
         &self,
     ) -> (HashSet<Vec<u8>>, HashSet<Vec<u8>>) {
         let mut non_normal = HashSet::new();
         let mut other_parent = HashSet::new();
 
         for (
             filename,
             DirstateEntry {
                 state, size, mtime, ..
             },
         ) in self.state_map.iter()
         {
             if *state != EntryState::Normal || *mtime == MTIME_UNSET {
                 non_normal.insert(filename.to_owned());
             }
             if *state == EntryState::Normal && *size == SIZE_DIRTY {
                 other_parent.insert(filename.to_owned());
             }
         }
 
         (non_normal, other_parent)
     }
 
     /// Both of these setters and their uses appear to be the simplest way to
     /// emulate a Python lazy property, but it is ugly and unidiomatic.
     /// TODO One day, rewriting this struct using the typestate might be a
     /// good idea.
     pub fn set_all_dirs(&mut self) {
         if self.all_dirs.is_none() {
             self.all_dirs = Some(DirsMultiset::new(
                 DirsIterable::Dirstate(&self.state_map),
                 None,
             ));
         }
     }
 
     pub fn set_dirs(&mut self) {
         if self.dirs.is_none() {
             self.dirs = Some(DirsMultiset::new(
                 DirsIterable::Dirstate(&self.state_map),
                 Some(EntryState::Removed),
             ));
         }
     }
 
     pub fn has_tracked_dir(&mut self, directory: &[u8]) -> bool {
         self.set_dirs();
         self.dirs.as_ref().unwrap().contains(directory)
     }
 
     pub fn has_dir(&mut self, directory: &[u8]) -> bool {
         self.set_all_dirs();
         self.all_dirs.as_ref().unwrap().contains(directory)
     }
 
     pub fn parents(
         &mut self,
         file_contents: &[u8],
-    ) -> Result<DirstateParents, DirstateError> {
+    ) -> Result<&DirstateParents, DirstateError> {
         if let Some(ref parents) = self.parents {
-            return Ok(parents.clone());
+            return Ok(parents);
         }
         let parents;
         if file_contents.len() == PARENT_SIZE * 2 {
             parents = DirstateParents {
                 p1: file_contents[..PARENT_SIZE].try_into().unwrap(),
                 p2: file_contents[PARENT_SIZE..PARENT_SIZE * 2]
                     .try_into()
                     .unwrap(),
             };
         } else if file_contents.is_empty() {
             parents = DirstateParents {
                 p1: NULL_ID,
                 p2: NULL_ID,
             };
         } else {
             return Err(DirstateError::Parse(DirstateParseError::Damaged));
         }
 
-        self.parents = Some(parents.to_owned());
-        Ok(parents.clone())
+        self.parents = Some(parents);
+        Ok(self.parents.as_ref().unwrap())
     }
 
-    pub fn set_parents(&mut self, parents: DirstateParents) {
+    pub fn set_parents(&mut self, parents: &DirstateParents) {
         self.parents = Some(parents.clone());
         self.dirty_parents = true;
     }
 
     pub fn read(
         &mut self,
         file_contents: &[u8],
     ) -> Result<Option<DirstateParents>, DirstateError> {
         if file_contents.is_empty() {
             return Ok(None);
         }
 
         let parents = parse_dirstate(
             &mut self.state_map,
             &mut self.copy_map,
             file_contents,
         )?;
 
         if !self.dirty_parents {
-            self.set_parents(parents.to_owned());
+            self.set_parents(&parents);
         }
 
         Ok(Some(parents))
     }
 
     pub fn pack(
         &mut self,
         parents: DirstateParents,
         now: Duration,
     ) -> Result<Vec<u8>, DirstateError> {
         let packed =
             pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?;
 
         self.dirty_parents = false;
 
         let result = self.non_normal_other_parent_entries();
         self.non_normal_set = result.0;
         self.other_parent_set = result.1;
         Ok(packed)
     }
 
-    pub fn build_file_fold_map(&mut self) -> FileFoldMap {
+    pub fn build_file_fold_map(&mut self) -> &FileFoldMap {
         if let Some(ref file_fold_map) = self.file_fold_map {
-            return file_fold_map.to_owned();
+            return file_fold_map;
         }
         let mut new_file_fold_map = FileFoldMap::new();
         for (filename, DirstateEntry { state, .. }) in self.state_map.borrow()
         {
             if *state == EntryState::Removed {
                 new_file_fold_map.insert(
                     filename.to_ascii_uppercase().to_owned(),
                     filename.to_owned(),
                 );
             }
         }
         self.file_fold_map = Some(new_file_fold_map);
-        self.file_fold_map.to_owned().unwrap()
+        self.file_fold_map.as_ref().unwrap()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_dirs_multiset() {
         let mut map = DirstateMap::new();
         assert!(map.dirs.is_none());
         assert!(map.all_dirs.is_none());
 
         assert_eq!(false, map.has_dir(b"nope"));
         assert!(map.all_dirs.is_some());
         assert!(map.dirs.is_none());
 
         assert_eq!(false, map.has_tracked_dir(b"nope"));
         assert!(map.dirs.is_some());
     }
 
     #[test]
     fn test_add_file() {
         let mut map = DirstateMap::new();
 
         assert_eq!(0, map.len());
 
         map.add_file(
             b"meh",
             EntryState::Normal,
             DirstateEntry {
                 state: EntryState::Normal,
                 mode: 1337,
                 mtime: 1337,
                 size: 1337,
             },
         );
 
         assert_eq!(1, map.len());
         assert_eq!(0, map.non_normal_set.len());
         assert_eq!(0, map.other_parent_set.len());
     }
 
     #[test]
     fn test_non_normal_other_parent_entries() {
         let map: DirstateMap = [
             (b"f1", (EntryState::Removed, 1337, 1337, 1337)),
             (b"f2", (EntryState::Normal, 1337, 1337, -1)),
             (b"f3", (EntryState::Normal, 1337, 1337, 1337)),
             (b"f4", (EntryState::Normal, 1337, -2, 1337)),
             (b"f5", (EntryState::Added, 1337, 1337, 1337)),
             (b"f6", (EntryState::Added, 1337, 1337, -1)),
             (b"f7", (EntryState::Merged, 1337, 1337, -1)),
             (b"f8", (EntryState::Merged, 1337, 1337, 1337)),
             (b"f9", (EntryState::Merged, 1337, -2, 1337)),
             (b"fa", (EntryState::Added, 1337, -2, 1337)),
             (b"fb", (EntryState::Removed, 1337, -2, 1337)),
         ]
         .iter()
         .map(|(fname, (state, mode, size, mtime))| {
             (
                 fname.to_vec(),
                 DirstateEntry {
                     state: *state,
                     mode: *mode,
                     size: *size,
                     mtime: *mtime,
                 },
             )
         })
         .collect();
 
         let non_normal = [
             b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb",
         ]
         .iter()
         .map(|x| x.to_vec())
         .collect();
 
         let mut other_parent = HashSet::new();
         other_parent.insert(b"f4".to_vec());
 
         assert_eq!(
             (non_normal, other_parent),
             map.non_normal_other_parent_entries()
         );
     }
 }

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

@@ -1,515 +1,515 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;
 use std::convert::TryInto;
 use std::time::Duration;
 
 use cpython::{
     exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyObject,
     PyResult, PyTuple, Python, PythonObject, ToPyObject,
 };
 use libc::c_char;
 
 use crate::{
     dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
     dirstate::{decapsule_make_dirstate_tuple, dirs_multiset::Dirs},
     ref_sharing::PySharedState,
 };
 use hg::{
     DirsIterable, DirsMultiset, DirstateEntry, DirstateMap as RustDirstateMap,
     DirstateParents, DirstateParseError, EntryState, PARENT_SIZE,
 };
 
 // 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| {
     data inner: RefCell<RustDirstateMap>;
     data py_shared_state: PySharedState;
 
     def __new__(_cls, _root: PyObject) -> PyResult<Self> {
         let inner = RustDirstateMap::default();
         Self::create_instance(
             py,
             RefCell::new(inner),
             PySharedState::default()
         )
     }
 
     def clear(&self) -> PyResult<PyObject> {
         self.borrow_mut(py)?.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(key.data(py)) {
             Some(entry) => {
                 // Explicitly go through u8 first, then cast to
                 // platform-specific `c_char`.
                 let state: u8 = entry.state.into();
                 Ok(Some(decapsule_make_dirstate_tuple(py)?(
                         state as c_char,
                         entry.mode,
                         entry.size,
                         entry.mtime,
                     )))
             },
             None => Ok(default)
         }
     }
 
     def addfile(
         &self,
         f: PyObject,
         oldstate: PyObject,
         state: PyObject,
         mode: PyObject,
         size: PyObject,
         mtime: PyObject
     ) -> PyResult<PyObject> {
         self.borrow_mut(py)?.add_file(
             f.extract::<PyBytes>(py)?.data(py),
             oldstate.extract::<PyBytes>(py)?.data(py)[0]
                 .try_into()
                 .map_err(|e: DirstateParseError| {
                     PyErr::new::<exc::ValueError, _>(py, e.to_string())
                 })?,
             DirstateEntry {
                 state: state.extract::<PyBytes>(py)?.data(py)[0]
                     .try_into()
                     .map_err(|e: DirstateParseError| {
                         PyErr::new::<exc::ValueError, _>(py, e.to_string())
                     })?,
                 mode: mode.extract(py)?,
                 size: size.extract(py)?,
                 mtime: mtime.extract(py)?,
             },
         );
         Ok(py.None())
     }
 
     def removefile(
         &self,
         f: PyObject,
         oldstate: PyObject,
         size: PyObject
     ) -> PyResult<PyObject> {
         self.borrow_mut(py)?
             .remove_file(
                 f.extract::<PyBytes>(py)?.data(py),
                 oldstate.extract::<PyBytes>(py)?.data(py)[0]
                     .try_into()
                     .map_err(|e: DirstateParseError| {
                         PyErr::new::<exc::ValueError, _>(py, e.to_string())
                     })?,
                 size.extract(py)?,
             )
             .or_else(|_| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     "Dirstate error".to_string(),
                 ))
             })?;
         Ok(py.None())
     }
 
     def dropfile(
         &self,
         f: PyObject,
         oldstate: PyObject
     ) -> PyResult<PyBool> {
         self.borrow_mut(py)?
             .drop_file(
                 f.extract::<PyBytes>(py)?.data(py),
                 oldstate.extract::<PyBytes>(py)?.data(py)[0]
                     .try_into()
                     .map_err(|e: DirstateParseError| {
                         PyErr::new::<exc::ValueError, _>(py, e.to_string())
                     })?,
             )
             .and_then(|b| Ok(b.to_py_object(py)))
             .or_else(|_| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     "Dirstate error".to_string(),
                 ))
             })
     }
 
     def clearambiguoustimes(
         &self,
         files: PyObject,
         now: PyObject
     ) -> PyResult<PyObject> {
         let files: PyResult<Vec<Vec<u8>>> = files
             .iter(py)?
             .map(|filename| {
                 Ok(filename?.extract::<PyBytes>(py)?.data(py).to_owned())
             })
             .collect();
         self.inner(py)
             .borrow_mut()
             .clear_ambiguous_times(files?, now.extract(py)?);
         Ok(py.None())
     }
 
     // TODO share the reference
     def nonnormalentries(&self) -> PyResult<PyObject> {
         let (non_normal, other_parent) =
             self.inner(py).borrow().non_normal_other_parent_entries();
 
         let locals = PyDict::new(py);
         locals.set_item(
             py,
             "non_normal",
             non_normal
                 .iter()
                 .map(|v| PyBytes::new(py, &v))
                 .collect::<Vec<PyBytes>>()
                 .to_py_object(py),
         )?;
         locals.set_item(
             py,
             "other_parent",
             other_parent
                 .iter()
                 .map(|v| PyBytes::new(py, &v))
                 .collect::<Vec<PyBytes>>()
                 .to_py_object(py),
         )?;
 
         py.eval("set(non_normal), set(other_parent)", None, Some(&locals))
     }
 
     def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
         let d = d.extract::<PyBytes>(py)?;
         Ok(self
             .inner(py)
             .borrow_mut()
             .has_tracked_dir(d.data(py))
             .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(d.data(py))
             .to_py_object(py))
     }
 
     def parents(&self, st: PyObject) -> PyResult<PyTuple> {
         self.inner(py)
             .borrow_mut()
             .parents(st.extract::<PyBytes>(py)?.data(py))
             .and_then(|d| {
                 Ok((PyBytes::new(py, &d.p1), PyBytes::new(py, &d.p2))
                     .to_py_object(py))
             })
             .or_else(|_| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     "Dirstate error".to_string(),
                 ))
             })
     }
 
     def setparents(&self, p1: PyObject, p2: PyObject) -> PyResult<PyObject> {
         let p1 = extract_node_id(py, &p1)?;
         let p2 = extract_node_id(py, &p2)?;
 
         self.inner(py)
             .borrow_mut()
-            .set_parents(DirstateParents { p1, p2 });
+            .set_parents(&DirstateParents { p1, p2 });
         Ok(py.None())
     }
 
     def read(&self, st: PyObject) -> PyResult<Option<PyObject>> {
         match self
             .inner(py)
             .borrow_mut()
             .read(st.extract::<PyBytes>(py)?.data(py))
         {
             Ok(Some(parents)) => Ok(Some(
                 (PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2))
                     .to_py_object(py)
                     .into_object(),
             )),
             Ok(None) => Ok(Some(py.None())),
             Err(_) => Err(PyErr::new::<exc::OSError, _>(
                 py,
                 "Dirstate error".to_string(),
             )),
         }
     }
     def write(
         &self,
         p1: PyObject,
         p2: PyObject,
         now: PyObject
     ) -> PyResult<PyBytes> {
         let now = Duration::new(now.extract(py)?, 0);
         let parents = DirstateParents {
             p1: extract_node_id(py, &p1)?,
             p2: extract_node_id(py, &p2)?,
         };
 
         match self.borrow_mut(py)?.pack(parents, now) {
             Ok(packed) => Ok(PyBytes::new(py, &packed)),
             Err(_) => Err(PyErr::new::<exc::OSError, _>(
                 py,
                 "Dirstate error".to_string(),
             )),
         }
     }
 
     def filefoldmapasdict(&self) -> PyResult<PyDict> {
         let dict = PyDict::new(py);
         for (key, value) in
             self.borrow_mut(py)?.build_file_fold_map().iter()
         {
             dict.set_item(py, key, value)?;
         }
         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)?;
         Ok(self.inner(py).borrow().contains_key(key.data(py)))
     }
 
     def __getitem__(&self, key: PyObject) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         let key = key.data(py);
         match self.inner(py).borrow().get(key) {
             Some(entry) => {
                 // Explicitly go through u8 first, then cast to
                 // platform-specific `c_char`.
                 let state: u8 = entry.state.into();
                 Ok(decapsule_make_dirstate_tuple(py)?(
                         state as c_char,
                         entry.mode,
                         entry.size,
                         entry.mtime,
                     ))
             },
             None => Err(PyErr::new::<exc::KeyError, _>(
                 py,
                 String::from_utf8_lossy(key),
             )),
         }
     }
 
     def keys(&self) -> PyResult<DirstateMapKeysIterator> {
         DirstateMapKeysIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.iter()),
         )
     }
 
     def items(&self) -> PyResult<DirstateMapItemsIterator> {
         DirstateMapItemsIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.iter()),
         )
     }
 
     def __iter__(&self) -> PyResult<DirstateMapKeysIterator> {
         DirstateMapKeysIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.iter()),
         )
     }
 
     def getdirs(&self) -> PyResult<Dirs> {
         // TODO don't copy, share the reference
         self.inner(py).borrow_mut().set_dirs();
         Dirs::from_inner(
             py,
             DirsMultiset::new(
                 DirsIterable::Dirstate(&self.inner(py).borrow()),
                 Some(EntryState::Removed),
             ),
         )
     }
     def getalldirs(&self) -> PyResult<Dirs> {
         // TODO don't copy, share the reference
         self.inner(py).borrow_mut().set_all_dirs();
         Dirs::from_inner(
             py,
             DirsMultiset::new(
                 DirsIterable::Dirstate(&self.inner(py).borrow()),
                 None,
             ),
         )
     }
 
     // TODO all copymap* methods, see docstring above
     def copymapcopy(&self) -> PyResult<PyDict> {
         let dict = PyDict::new(py);
         for (key, value) in self.inner(py).borrow().copy_map.iter() {
             dict.set_item(py, PyBytes::new(py, key), PyBytes::new(py, value))?;
         }
         Ok(dict)
     }
 
     def copymapgetitem(&self, key: PyObject) -> PyResult<PyBytes> {
         let key = key.extract::<PyBytes>(py)?;
         match self.inner(py).borrow().copy_map.get(key.data(py)) {
             Some(copy) => Ok(PyBytes::new(py, copy)),
             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)?;
         Ok(self.inner(py).borrow().copy_map.contains_key(key.data(py)))
     }
     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(key.data(py)) {
             Some(copy) => Ok(Some(PyBytes::new(py, copy).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(key.data(py).to_vec(), value.data(py).to_vec());
         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(key.data(py)) {
             Some(_) => Ok(None),
             None => Ok(default),
         }
     }
 
     def copymapiter(&self) -> PyResult<CopyMapKeysIterator> {
         CopyMapKeysIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.copy_map.iter()),
         )
     }
 
     def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> {
         CopyMapItemsIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.copy_map.iter()),
         )
     }
 
 });
 
 impl DirstateMap {
     fn translate_key(
         py: Python,
         res: (&Vec<u8>, &DirstateEntry),
     ) -> PyResult<Option<PyBytes>> {
         Ok(Some(PyBytes::new(py, res.0)))
     }
     fn translate_key_value(
         py: Python,
         res: (&Vec<u8>, &DirstateEntry),
     ) -> PyResult<Option<(PyBytes, PyObject)>> {
         let (f, entry) = res;
 
         // Explicitly go through u8 first, then cast to
         // platform-specific `c_char`.
         let state: u8 = entry.state.into();
         Ok(Some((
             PyBytes::new(py, f),
             decapsule_make_dirstate_tuple(py)?(
                 state as c_char,
                 entry.mode,
                 entry.size,
                 entry.mtime,
             ),
         )))
     }
 }
 
 py_shared_ref!(DirstateMap, RustDirstateMap, inner, DirstateMapLeakedRef,);
 
 py_shared_mapping_iterator!(
     DirstateMapKeysIterator,
     DirstateMapLeakedRef,
     Vec<u8>,
     DirstateEntry,
     DirstateMap::translate_key,
     Option<PyBytes>
 );
 
 py_shared_mapping_iterator!(
     DirstateMapItemsIterator,
     DirstateMapLeakedRef,
     Vec<u8>,
     DirstateEntry,
     DirstateMap::translate_key_value,
     Option<(PyBytes, PyObject)>
 );
 
 fn extract_node_id(py: Python, obj: &PyObject) -> PyResult<[u8; PARENT_SIZE]> {
     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())),
     }
 }