mercurial-scm/hg: rust/hg-core/src/dirstate

comparison rust/hg-core/src/dirstate_tree/status.rs @ 47475:94e38822d395

status: Extend read_dir caching to directories with ignored files See code comments Differential Revision: https://phab.mercurial-scm.org/D10909

author	Simon Sapin <simon.sapin@octobus.net>
date	Thu, 24 Jun 2021 21:54:14 +0200
parents	c657beacdf2e
children	f2a9db29cb2d

comparison

equal deleted inserted replaced

-:c657beacdf2e
+:94e38822d395
 // All states that we care about listing have corresponding
 // dirstate entries.
 // This happens for example with `hg status -mard`.
 return true;
 }
-if let Some(cached_mtime) = cached_directory_mtime {
+if !self.options.list_ignored
-// The dirstate contains a cached mtime for this directory, set by
+&& self.ignore_patterns_have_changed == Some(false)
-// a previous run of the `status` algorithm which found this
+{
-// directory eligible for `read_dir` caching.
+if let Some(cached_mtime) = cached_directory_mtime {
-if let Some(meta) = directory_metadata {
+// The dirstate contains a cached mtime for this directory, set
-if let Ok(current_mtime) = meta.modified() {
+// by a previous run of the `status` algorithm which found this
-if current_mtime == cached_mtime.into() {
+// directory eligible for `read_dir` caching.
-// The mtime of that directory has not changed since
+if let Some(meta) = directory_metadata {
-// then, which means that the
+if let Ok(current_mtime) = meta.modified() {
-// results of `read_dir` should also
+if current_mtime == cached_mtime.into() {
-// be unchanged.
+// The mtime of that directory has not changed
-return true;
+// since then, which means that the results of
+// `read_dir` should also be unchanged.
+return true;
+}
 }
 }
 }
 }
 false
 }
-/// Returns whether the filesystem directory was found to have any entry
+/// Returns whether all child entries of the filesystem directory have a
-/// that does not have a corresponding dirstate tree node.
+/// corresponding dirstate node or are ignored.
 fn traverse_fs_directory_and_dirstate(
 &self,
 has_ignored_ancestor: bool,
 dirstate_nodes: ChildNodesRef<'tree, 'on_disk>,
 directory_hg_path: &BorrowedPath<'tree, 'on_disk>,
 }
 }
 })
 .collect::<Result<_, _>>()?;
-// Conservatively don’t let the caller assume that there aren’t
+// We don’t know, so conservatively say this isn’t the case
-// any, since we don’t know.
+let children_all_have_dirstate_node_or_are_ignored = false;
-let directory_has_any_fs_only_entry = true;
+return Ok(children_all_have_dirstate_node_or_are_ignored);
-return Ok(directory_has_any_fs_only_entry);
 }
 let mut fs_entries = if let Ok(entries) = self.read_dir(
 directory_hg_path,
 directory_fs_path,
 },
 )
 .par_bridge()
 .map(|pair| {
 use itertools::EitherOrBoth::*;
-let is_fs_only = pair.is_right();
+let has_dirstate_node_or_is_ignored;
 match pair {
-Both(dirstate_node, fs_entry) => self
+Both(dirstate_node, fs_entry) => {
-.traverse_fs_and_dirstate(
+self.traverse_fs_and_dirstate(
 &fs_entry.full_path,
 &fs_entry.metadata,
 dirstate_node,
 has_ignored_ancestor,
-)?,
+)?;
+has_dirstate_node_or_is_ignored = true
+}
 Left(dirstate_node) => {
-self.traverse_dirstate_only(dirstate_node)?
+self.traverse_dirstate_only(dirstate_node)?;
-}
+has_dirstate_node_or_is_ignored = true;
-Right(fs_entry) => self.traverse_fs_only(
+}
-has_ignored_ancestor,
+Right(fs_entry) => {
-directory_hg_path,
+has_dirstate_node_or_is_ignored = self.traverse_fs_only(
-fs_entry,
+has_ignored_ancestor,
-),
+directory_hg_path,
-}
+fs_entry,
-Ok(is_fs_only)
+)
+}
+}
+Ok(has_dirstate_node_or_is_ignored)
 })
-.try_reduce(|| false, |a, b| Ok(a || b))
+.try_reduce(|| true, |a, b| Ok(a && b))
 }
 fn traverse_fs_and_dirstate(
 &self,
 fs_path: &Path,
 .traversed
 .push(hg_path.detach_from_tree())
 }
 let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path);
 let is_at_repo_root = false;
-let directory_has_any_fs_only_entry = self
+let children_all_have_dirstate_node_or_are_ignored = self
 .traverse_fs_directory_and_dirstate(
 is_ignored,
 dirstate_node.children(self.dmap.on_disk)?,
 hg_path,
 fs_path,
 Some(fs_metadata),
 dirstate_node.cached_directory_mtime(),
 is_at_repo_root,
 )?;
 self.maybe_save_directory_mtime(
-directory_has_any_fs_only_entry,
+children_all_have_dirstate_node_or_are_ignored,
 fs_metadata,
 dirstate_node,
 )?
 } else {
 if file_or_symlink && self.matcher.matches(hg_path) {
 EntryState::Unknown => unreachable!(),
 }
 } else {
 // `node.entry.is_none()` indicates a "directory"
 // node, but the filesystem has a file
-self.mark_unknown_or_ignored(has_ignored_ancestor, hg_path)
+self.mark_unknown_or_ignored(
+has_ignored_ancestor,
+hg_path,
+);
 }
 }
 for child_node in dirstate_node.children(self.dmap.on_disk)?.iter()
 {
 Ok(())
 }
 fn maybe_save_directory_mtime(
 &self,
-directory_has_any_fs_only_entry: bool,
+children_all_have_dirstate_node_or_are_ignored: bool,
 directory_metadata: &std::fs::Metadata,
 dirstate_node: NodeRef<'tree, 'on_disk>,
 ) -> Result<(), DirstateV2ParseError> {
-if !directory_has_any_fs_only_entry {
+if children_all_have_dirstate_node_or_are_ignored {
 // All filesystem directory entries from `read_dir` have a
 // corresponding node in the dirstate, so we can reconstitute the
 // names of those entries without calling `read_dir` again.
 if let (Some(status_start), Ok(directory_mtime)) = (
 &self.filesystem_time_at_status_start,
 }
 }
 }
 /// Something in the filesystem has no corresponding dirstate node
+///
+/// Returns whether that path is ignored
 fn traverse_fs_only(
 &self,
 has_ignored_ancestor: bool,
 directory_hg_path: &HgPath,
 fs_entry: &DirEntry,
-) {
+) -> bool {
 let hg_path = directory_hg_path.join(&fs_entry.base_name);
 let file_type = fs_entry.metadata.file_type();
 let file_or_symlink = file_type.is_file() || file_type.is_symlink();
 if file_type.is_dir() {
 let is_ignored =
 children_fs_entries.par_iter().for_each(|child_fs_entry| {
 self.traverse_fs_only(
 is_ignored,
 &hg_path,
 child_fs_entry,
-)
+);
 })
 }
 }
 if self.options.collect_traversed_dirs {
 self.outcome.lock().unwrap().traversed.push(hg_path.into())
 }
-} else if file_or_symlink && self.matcher.matches(&hg_path) {
+is_ignored
-self.mark_unknown_or_ignored(
+} else {
-has_ignored_ancestor,
+if file_or_symlink {
-&BorrowedPath::InMemory(&hg_path),
+if self.matcher.matches(&hg_path) {
-)
+self.mark_unknown_or_ignored(
-}
+has_ignored_ancestor,
-}
+&BorrowedPath::InMemory(&hg_path),
+)
+} else {
+// We haven’t computed whether this path is ignored. It
+// might not be, and a future run of status might have a
+// different matcher that matches it. So treat it as not
+// ignored. That is, inhibit readdir caching of the parent
+// directory.
+false
+}
+} else {
+// This is neither a directory, a plain file, or a symlink.
+// Treat it like an ignored file.
+true
+}
+}
+}
+/// Returns whether that path is ignored
 fn mark_unknown_or_ignored(
 &self,
 has_ignored_ancestor: bool,
 hg_path: &BorrowedPath<'_, 'on_disk>,
-) {
+) -> bool {
 let is_ignored = has_ignored_ancestor || (self.ignore_fn)(&hg_path);
 if is_ignored {
 if self.options.list_ignored {
 self.outcome
 .lock()
 .unwrap()
 .unknown
 .push(hg_path.detach_from_tree())
 }
 }
+is_ignored
 }
 }
 #[cfg(unix)] // TODO
 fn mtime_seconds(metadata: &std::fs::Metadata) -> i64 {

Mercurial > public > mercurial-scm > hg

comparison rust/hg-core/src/dirstate_tree/status.rs @ 47475:94e38822d395