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

equal deleted inserted replaced

-:717a94b423b9
+:73f23e7610f8
 use std::convert::TryInto;
 use std::path::PathBuf;
 use super::on_disk;
 use super::path_with_basename::WithBasename;
-use crate::dirstate::parsers::clear_ambiguous_mtime;
 use crate::dirstate::parsers::pack_entry;
 use crate::dirstate::parsers::packed_entry_size;
 use crate::dirstate::parsers::parse_dirstate_entries;
 use crate::dirstate::parsers::Timestamp;
 use crate::matchers::Matcher;
 // https://github.com/rust-lang/rust/issues/34162
 vec.sort_unstable_by(|(path1, _), (path2, _)| path1.cmp(path2));
 vec
 }
 }
-/// `(full_path, entry, copy_source)`
-type NodeDataMut<'tree, 'on_disk> = (
-&'tree HgPath,
-&'tree mut Option<DirstateEntry>,
-&'tree mut Option<Cow<'on_disk, HgPath>>,
-);
 impl<'on_disk> DirstateMap<'on_disk> {
 pub(super) fn empty(on_disk: &'on_disk [u8]) -> Self {
 Self {
 on_disk,
 node.entry = Some(new_entry)
 }
 fn iter_nodes<'a>(
 &'a self,
-) -> impl Iterator<Item = (&'a HgPath, &'a Node)> + 'a {
+) -> impl Iterator<Item = (&'a Cow<'on_disk, HgPath>, &'a Node)> + 'a {
 // Depth first tree traversal.
 //
 // If we could afford internal iteration and recursion,
 // this would look like:
 //
 std::iter::from_fn(move || {
 while let Some((key, child_node)) = iter.next() {
 // Pseudo-recursion
 let new_iter = child_node.children.iter();
 let old_iter = std::mem::replace(&mut iter, new_iter);
-let key = &**key.full_path();
+let key = key.full_path();
 stack.push((key, child_node, old_iter));
 }
 // Found the end of a `children.iter()` iterator.
 if let Some((key, child_node, next_iter)) = stack.pop() {
 // "Return" from pseudo-recursion by restoring state from the
 None
 }
 })
 }
-/// Mutable iterator for the `(entry, copy source)` of each node.
+fn clear_known_ambiguous_mtimes(&mut self, paths: &[impl AsRef<HgPath>]) {
-///
+for path in paths {
-/// It would not be safe to yield mutable references to nodes themeselves
+if let Some(node) =
-/// with `-> impl Iterator<Item = &mut Node>` since child nodes are
+Self::get_node_mut(&mut self.root, path.as_ref())
-/// reachable from their ancestor nodes, potentially creating multiple
+{
-/// `&mut` references to a given node.
+if let Some(entry) = node.entry.as_mut() {
-fn iter_node_data_mut<'tree>(
+entry.clear_mtime();
-&'tree mut self,
+}
-) -> impl Iterator<Item = NodeDataMut<'tree, 'on_disk>> + 'tree {
+}
-// Explict stack for pseudo-recursion, see `iter_nodes` above.
+}
-let mut stack = Vec::new();
-let mut iter = self.root.iter_mut();
-std::iter::from_fn(move || {
-while let Some((key, child_node)) = iter.next() {
-// Pseudo-recursion
-let data = (
-&**key.full_path(),
-&mut child_node.entry,
-&mut child_node.copy_source,
-);
-let new_iter = child_node.children.iter_mut();
-let old_iter = std::mem::replace(&mut iter, new_iter);
-stack.push((data, old_iter));
-}
-// Found the end of a `children.values_mut()` iterator.
-if let Some((data, next_iter)) = stack.pop() {
-// "Return" from pseudo-recursion by restoring state from the
-// explicit stack
-iter = next_iter;
-Some(data)
-} else {
-// Reached the bottom of the stack, we’re done
-None
-}
-})
 }
 }
 impl<'on_disk> super::dispatch::DirstateMapMethods for DirstateMap<'on_disk> {
 fn clear(&mut self) {
 fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) {
 for filename in filenames {
 if let Some(node) = Self::get_node_mut(&mut self.root, &filename) {
 if let Some(entry) = node.entry.as_mut() {
-clear_ambiguous_mtime(entry, now);
+entry.clear_ambiguous_mtime(now);
 }
 }
 }
 }
 node.entry
 .as_ref()
 .filter(|entry| {
 entry.is_non_normal() || entry.is_from_other_parent()
 })
-.map(|_| path)
+.map(|_| &**path)
 }))
 }
 fn set_non_normal_other_parent_entries(&mut self, _force: bool) {
 // Do nothing, this `DirstateMap` does not have a separate "non normal
 ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
 Box::new(self.iter_nodes().filter_map(|(path, node)| {
 node.entry
 .as_ref()
 .filter(|entry| entry.is_non_normal())
-.map(|_| path)
+.map(|_| &**path)
 }))
 }
 fn iter_other_parent_paths(
 &mut self,
 ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
 Box::new(self.iter_nodes().filter_map(|(path, node)| {
 node.entry
 .as_ref()
 .filter(|entry| entry.is_from_other_parent())
-.map(|_| path)
+.map(|_| &**path)
 }))
 }
 fn has_tracked_dir(
 &mut self,
 fn pack_v1(
 &mut self,
 parents: DirstateParents,
 now: Timestamp,
 ) -> Result<Vec<u8>, DirstateError> {
+let now: i32 = now.0.try_into().expect("time overflow");
+let mut ambiguous_mtimes = Vec::new();
 // Optizimation (to be measured?): pre-compute size to avoid `Vec`
 // reallocations
 let mut size = parents.as_bytes().len();
 for (path, node) in self.iter_nodes() {
-if node.entry.is_some() {
+if let Some(entry) = &node.entry {
 size += packed_entry_size(
 path,
 node.copy_source.as_ref().map(|p| &**p),
-)
+);
-}
+if entry.mtime_is_ambiguous(now) {
-}
+ambiguous_mtimes.push(path.clone())
+}
+}
+}
+self.clear_known_ambiguous_mtimes(&ambiguous_mtimes);
 let mut packed = Vec::with_capacity(size);
 packed.extend(parents.as_bytes());
-let now: i32 = now.0.try_into().expect("time overflow");
+for (path, node) in self.iter_nodes() {
-for (path, opt_entry, copy_source) in self.iter_node_data_mut() {
+if let Some(entry) = &node.entry {
-if let Some(entry) = opt_entry {
-clear_ambiguous_mtime(entry, now);
 pack_entry(
 path,
 entry,
-copy_source.as_ref().map(|p| &**p),
+node.copy_source.as_ref().map(|p| &**p),
 &mut packed,
 );
 }
 }
 Ok(packed)
 fn pack_v2(
 &mut self,
 parents: DirstateParents,
 now: Timestamp,
 ) -> Result<Vec<u8>, DirstateError> {
-on_disk::write(self, parents, now)
+// TODO: how do we want to handle this in 2038?
+let now: i32 = now.0.try_into().expect("time overflow");
+let mut paths = Vec::new();
+for (path, node) in self.iter_nodes() {
+if let Some(entry) = &node.entry {
+if entry.mtime_is_ambiguous(now) {
+paths.push(path.clone())
+}
+}
+}
+// Borrow of `self` ends here since we collect cloned paths
+self.clear_known_ambiguous_mtimes(&paths);
+on_disk::write(self, parents)
 }
 fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> {
 // Do nothing, this `DirstateMap` does not a separate `all_dirs` that
 // needs to be recomputed
 fn copy_map_iter(&self) -> CopyMapIter<'_> {
 Box::new(self.iter_nodes().filter_map(|(path, node)| {
 node.copy_source
 .as_ref()
-.map(|copy_source| (path, &**copy_source))
+.map(|copy_source| (&**path, &**copy_source))
 }))
 }
 fn copy_map_contains_key(&self, key: &HgPath) -> bool {
 if let Some(node) = self.get_node(key) {
 self.get_node(key)?.entry.as_ref()
 }
 fn iter(&self) -> StateMapIter<'_> {
 Box::new(self.iter_nodes().filter_map(|(path, node)| {
-node.entry.as_ref().map(|entry| (path, entry))
+node.entry.as_ref().map(|entry| (&**path, entry))
 }))
 }
 }

changeset 47330	73f23e7610f8
parent 47283	2a9ddc8094c7
child 47331	0252600fd1cf