mercurial: comparison rust/hg-core/src/dirstate_tree/dirstate

equal deleted inserted replaced

-:20c6c9e43397
+:12adf8c695ed
 })
 }
 impl OwningDirstateMap {
 pub fn clear(&mut self) {
-let map = self.get_map_mut();
+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> {
-let map = self.get_map_mut();
+self.with_dmap_mut(|map| {
 map.get_or_insert(&filename)?.data = NodeData::Entry(entry);
 Ok(())
+})
 }
 pub fn add_file(
 &mut self,
 filename: &HgPath,
 entry: DirstateEntry,
 ) -> Result<(), DirstateError> {
 let old_state = self.get(filename)?.map(|e| e.state());
-let map = self.get_map_mut();
+self.with_dmap_mut(|map| {
 Ok(map.add_or_remove_file(filename, old_state, entry)?)
+})
 }
 pub fn remove_file(
 &mut self,
 filename: &HgPath,
 }
 }
 if size == 0 {
 self.copy_map_remove(filename)?;
 }
-let map = self.get_map_mut();
+self.with_dmap_mut(|map| {
 let entry = DirstateEntry::new_removed(size);
 Ok(map.add_or_remove_file(filename, old_state, entry)?)
+})
 }
 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());
-let map = self.get_map_mut();
 struct Dropped {
 was_tracked: bool,
 had_entry: bool,
 had_copy_source: bool,
 }
 &mut node.children,
 rest,
 )? {
 dropped = d;
 if dropped.had_entry {
-node.descendants_with_entry_count -= 1;
+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 -= 1;
+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 {
 }
 } else {
 return Ok(None);
 }
 } else {
-let had_entry = node.data.has_entry();
+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: node
+was_tracked,
-.data
-.as_entry()
-.map_or(false, |entry| entry.state().is_tracked()),
 had_entry,
-had_copy_source: node.copy_source.take().is_some(),
+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()
 )
 }
 Ok(Some((dropped, remove)))
 }
-if let Some((dropped, _removed)) = recur(
+self.with_dmap_mut(|map| {
-map.on_disk,
+if let Some((dropped, _removed)) = recur(
-&mut map.unreachable_bytes,
+map.on_disk,
-&mut map.root,
+&mut map.unreachable_bytes,
-filename,
+&mut map.root,
-)? {
+filename,
-if dropped.had_entry {
+)? {
-map.nodes_with_entry_count -= 1
+if dropped.had_entry {
-}
+map.nodes_with_entry_count = map
-if dropped.had_copy_source {
+.nodes_with_entry_count
-map.nodes_with_copy_source_count -= 1
+.checked_sub(1)
-}
+.expect("nodes_with_entry_count should be >= 0");
-} else {
+}
-debug_assert!(!was_tracked);
+if dropped.had_copy_source {
-}
+map.nodes_with_copy_source_count = map
-Ok(())
+.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> {
-let map = self.get_map_mut();
+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> {
-let map = self.get_map_mut();
+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,
 ) -> Result<(Vec<u8>, on_disk::TreeMetadata, bool), DirstateError> {
 let map = self.get_map();
 on_disk::write(map, can_append)
 }
-pub fn status<'a>(
+/// `callback` allows the caller to process and do something with the
-&'a mut self,
+/// results of the status. This is needed to do so efficiently (i.e.
-matcher: &'a (dyn Matcher + Sync),
+/// 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,
-) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
+callback: impl for<'r> FnOnce(
-{
+Result<(DirstateStatus<'r>, Vec<PatternFileWarning>), StatusError>,
-let map = self.get_map_mut();
+) -> R,
-super::status::status(map, matcher, root_dir, ignore_files, options)
+) -> 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_remove(
 &mut self,
 key: &HgPath,
 ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
-let map = self.get_map_mut();
+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> {
-let map = self.get_map_mut();
+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
 + Send
 + '_,
 >,
 DirstateError,
 > {
-let map = self.get_map_mut();
+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 {

changeset 49005	12adf8c695ed
parent 48950	11c0411bf4e2
parent 49003	ce919b1a1063
child 49045	a85c123c625a