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

comparison rust/hg-core/src/dirstate_tree/status.rs @ 49930:e98fd81bb151

rust-clippy: fix most warnings in `hg-core` All of these are simple changes that for the most part are clear improvements and the rest are at most equivalent. The remaining warnings have to be fixed either with a bigger refactor like for the nested "revlog" module, or in the dependency `bytes-cast`, which we own. This will be done sometime in the future.

author	Rapha?l Gom?s <rgomes@octobus.net>
date	Mon, 09 Jan 2023 19:18:43 +0100
parents	c15b415d1bff
children	bae51b50a5cf

comparison

equal deleted inserted replaced

-:5f1cd6839c69
+:e98fd81bb151
 &has_ignored_ancestor,
 dmap.root.as_ref(),
 hg_path,
 &DirEntry {
 hg_path: Cow::Borrowed(HgPath::new(b"")),
-fs_path: Cow::Borrowed(&root_dir),
+fs_path: Cow::Borrowed(root_dir),
 symlink_metadata: None,
 file_type: FakeFileType::Directory,
 },
 root_cached_mtime,
 is_at_repo_root,
 fn force<'b>(&self, ignore_fn: &IgnoreFnType<'b>) -> bool {
 match self.parent {
 None => false,
 Some(parent) => {
 *(parent.cache.get_or_init(|| {
-parent.force(ignore_fn) || ignore_fn(&self.path)
+parent.force(ignore_fn) || ignore_fn(self.path)
 }))
 }
 }
 }
 }
 Err(_) => return Ok(()),
 };
 let entry = DirEntry {
 hg_path: Cow::Borrowed(
 dirstate_node
-.full_path(&self.dmap.on_disk)?,
+.full_path(self.dmap.on_disk)?,
 ),
 fs_path: Cow::Borrowed(&fs_path),
 symlink_metadata: Some(fs_metadata),
 file_type,
 };
 self.traverse_dirstate_only(dirstate_node)
 }
 Err(error) => {
 let hg_path =
 dirstate_node.full_path(self.dmap.on_disk)?;
-Ok(self.io_error(error, hg_path))
+self.io_error(error, hg_path);
+Ok(())
 }
 }
 })
 .collect::<Result<_, _>>()?;
 },
 )
 .par_bridge()
 .map(|pair| {
 use itertools::EitherOrBoth::*;
-let has_dirstate_node_or_is_ignored;
+let has_dirstate_node_or_is_ignored = match pair {
-match pair {
 Both(dirstate_node, fs_entry) => {
 self.traverse_fs_and_dirstate(
-&fs_entry,
+fs_entry,
 dirstate_node,
 has_ignored_ancestor,
 )?;
-has_dirstate_node_or_is_ignored = true
+true
 }
 Left(dirstate_node) => {
 self.traverse_dirstate_only(dirstate_node)?;
-has_dirstate_node_or_is_ignored = true;
+true
 }
-Right(fs_entry) => {
+Right(fs_entry) => self.traverse_fs_only(
-has_dirstate_node_or_is_ignored = self.traverse_fs_only(
+has_ignored_ancestor.force(&self.ignore_fn),
-has_ignored_ancestor.force(&self.ignore_fn),
+directory_hg_path,
-directory_hg_path,
+fs_entry,
-fs_entry,
+),
-)
+};
-}
-}
 Ok(has_dirstate_node_or_is_ignored)
 })
 .try_reduce(|| true, |a, b| Ok(a && b))
 }
 .unwrap()
 .traversed
 .push(hg_path.detach_from_tree())
 }
 let is_ignored = HasIgnoredAncestor::create(
-Some(&has_ignored_ancestor),
+Some(has_ignored_ancestor),
 hg_path,
 );
 let is_at_repo_root = false;
 let children_all_have_dirstate_node_or_are_ignored = self
 .traverse_fs_directory_and_dirstate(
 fs_entry,
 dirstate_node,
 outdated_dircache,
 )?
 } else {
-if file_or_symlink && self.matcher.matches(&hg_path) {
+if file_or_symlink && self.matcher.matches(hg_path) {
 if let Some(entry) = dirstate_node.entry()? {
 if !entry.any_tracked() {
 // Forward-compat if we start tracking unknown/ignored
 // files for caching reasons
 self.mark_unknown_or_ignored(
 has_ignored_ancestor.force(&self.ignore_fn),
-&hg_path,
+hg_path,
 );
 }
 if entry.added() {
 self.push_outcome(Outcome::Added, &dirstate_node)?;
 } else if entry.removed() {
 // https://stackoverflow.com/a/14393315/1162888), etc.
 let metadata = match directory_entry.symlink_metadata() {
 Ok(meta) => meta,
 Err(_) => return Ok(()),
 };
-let directory_mtime = if let Ok(option) =
-TruncatedTimestamp::for_reliable_mtime_of(&metadata, status_start)
+let directory_mtime = match TruncatedTimestamp::for_reliable_mtime_of(
-{
+&metadata,
-if let Some(directory_mtime) = option {
+status_start,
-directory_mtime
+) {
-} else {
+Ok(Some(directory_mtime)) => directory_mtime,
+Ok(None) => {
 // The directory was modified too recently,
 // don’t cache its `read_dir` results.
 //
 // 1. A change to this directory (direct child was
 //    added or removed) cause its mtime to be set
 // On a system where the time resolution poor, this
 // scenario is not unlikely if all three steps are caused
 // by the same script.
 return Ok(());
 }
-} else {
+Err(_) => {
 // OS/libc does not support mtime?
 return Ok(());
+}
 };
 // We’ve observed (through `status_start`) that time has
 // “progressed” since `directory_mtime`, so any further
 // change to this directory is extremely likely to cause a
 // different mtime.
 || entry.is_from_other_parent()
 || (size >= 0 && (size_changed || mode_changed()))
 {
 self.push_outcome(Outcome::Modified, dirstate_node)?
 } else {
-let mtime_looks_clean;
+let mtime_looks_clean = if let Some(dirstate_mtime) =
-if let Some(dirstate_mtime) = entry.truncated_mtime() {
+entry.truncated_mtime()
+{
 let fs_mtime = TruncatedTimestamp::for_mtime_of(&fs_metadata)
 .expect("OS/libc does not support mtime?");
 // There might be a change in the future if for example the
 // internal clock become off while process run, but this is a
 // case where the issues the user would face
 // would be a lot worse and there is nothing we
 // can really do.
-mtime_looks_clean = fs_mtime.likely_equal(dirstate_mtime)
+fs_mtime.likely_equal(dirstate_mtime)
 } else {
 // No mtime in the dirstate entry
-mtime_looks_clean = false
+false
 };
 if !mtime_looks_clean {
 self.push_outcome(Outcome::Unsure, dirstate_node)?
 } else if self.options.list_clean {
 self.push_outcome(Outcome::Clean, dirstate_node)?
 let path = dirstate_node.full_path(self.dmap.on_disk)?;
 if self.matcher.matches(path) {
 if entry.removed() {
 self.push_outcome(Outcome::Removed, dirstate_node)?
 } else {
-self.push_outcome(Outcome::Deleted, &dirstate_node)?
+self.push_outcome(Outcome::Deleted, dirstate_node)?
 }
 }
 }
 Ok(())
 }
 if self.options.collect_traversed_dirs {
 self.outcome.lock().unwrap().traversed.push(hg_path.into())
 }
 }
 is_ignored
+} else if file_or_symlink {
+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 {
-if file_or_symlink {
+// This is neither a directory, a plain file, or a symlink.
-if self.matcher.matches(&hg_path) {
+// Treat it like an ignored file.
-self.mark_unknown_or_ignored(
+true
-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);
+let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path);
 if is_ignored {
 if self.options.list_ignored {
 self.push_outcome_without_copy_source(
 Outcome::Ignored,
 hg_path,
 )
 }
-} else {
+} else if self.options.list_unknown {
-if self.options.list_unknown {
+self.push_outcome_without_copy_source(Outcome::Unknown, hg_path)
-self.push_outcome_without_copy_source(
-Outcome::Unknown,
-hg_path,
-)
-}
 }
 is_ignored
 }
 }

Mercurial > public > mercurial-scm > hg

comparison rust/hg-core/src/dirstate_tree/status.rs @ 49930:e98fd81bb151