( )⚙ D10908 status: Move some `is_ignored` computation earlier

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10908

status: Move some `is_ignored` computation earlier
AbandonedPublic

Authored by SimonSapin on Jun 24 2021, 4:52 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

This refactor should make have no observable behavior difference, it will make
an upcoming changeset easier.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Jun 24 2021, 4:52 PM
SimonSapin abandoned this revision.Jun 25 2021, 8:54 AM

This makes sense to help the immediate next changeset, but not for further changes that we’ll likely do. So let’s not take this one.

Revision Contents
Changeset List

Diff 28692

rust/hg-core/src/dirstate_tree/status.rs

&fs_entry.full_path, &fs_entry.full_path,
&fs_entry.metadata, &fs_entry.metadata,
dirstate_node, dirstate_node,
has_ignored_ancestor, has_ignored_ancestor,
)?, )?,
Left(dirstate_node) => { Left(dirstate_node) => {
self.traverse_dirstate_only(dirstate_node)? self.traverse_dirstate_only(dirstate_node)?
} }
Right(fs_entry) => self.traverse_fs_only( Right(fs_entry) => {
has_ignored_ancestor, let hg_path = directory_hg_path.join(&fs_entry.base_name);
directory_hg_path, let is_ignored =
fs_entry, has_ignored_ancestor || (self.ignore_fn)(&hg_path);
), self.traverse_fs_only(is_ignored, hg_path, fs_entry);
}
} }
Ok(is_fs_only) Ok(is_fs_only)
}) })
.try_reduce(|| false, |a, b| Ok(a || b)) .try_reduce(|| false, |a, b| Ok(a || b))
} }
fn traverse_fs_and_dirstate( fn traverse_fs_and_dirstate(
&self, &self,
.handle_normal_file(&dirstate_node, fs_metadata)?, .handle_normal_file(&dirstate_node, fs_metadata)?,
// This variant is not used in DirstateMap // This variant is not used in DirstateMap
// nodes // nodes
EntryState::Unknown => unreachable!(), EntryState::Unknown => unreachable!(),
} }
} else { } else {
// `node.entry.is_none()` indicates a "directory" // `node.entry.is_none()` indicates a "directory"
// node, but the filesystem has a file // node, but the filesystem has a file
self.mark_unknown_or_ignored(has_ignored_ancestor, hg_path) let is_ignored =
has_ignored_ancestor || (self.ignore_fn)(&hg_path);
self.mark_unknown_or_ignored(is_ignored, hg_path)
} }
} }
for child_node in dirstate_node.children(self.dmap.on_disk)?.iter() for child_node in dirstate_node.children(self.dmap.on_disk)?.iter()
{ {
self.traverse_dirstate_only(child_node)? self.traverse_dirstate_only(child_node)?
} }
} }
} }
} }
} }
} }
/// Something in the filesystem has no corresponding dirstate node /// Something in the filesystem has no corresponding dirstate node
fn traverse_fs_only( fn traverse_fs_only(
&self, &self,
has_ignored_ancestor: bool, is_ignored: bool,
directory_hg_path: &HgPath, hg_path: HgPathBuf,
fs_entry: &DirEntry, fs_entry: &DirEntry,
) { ) {
let hg_path = directory_hg_path.join(&fs_entry.base_name);
let file_type = fs_entry.metadata.file_type(); let file_type = fs_entry.metadata.file_type();
let file_or_symlink = file_type.is_file() || file_type.is_symlink(); let file_or_symlink = file_type.is_file() || file_type.is_symlink();
if file_type.is_dir() { if file_type.is_dir() {
let is_ignored =
has_ignored_ancestor || (self.ignore_fn)(&hg_path);
let traverse_children = if is_ignored { let traverse_children = if is_ignored {
// Descendants of an ignored directory are all ignored // Descendants of an ignored directory are all ignored
self.options.list_ignored self.options.list_ignored
} else { } else {
// Descendants of an unknown directory may be either unknown or // Descendants of an unknown directory may be either unknown or
// ignored // ignored
self.options.list_unknown || self.options.list_ignored self.options.list_unknown || self.options.list_ignored
}; };
if traverse_children { if traverse_children {
let is_at_repo_root = false; let is_at_repo_root = false;
if let Ok(children_fs_entries) = self.read_dir( if let Ok(children_fs_entries) = self.read_dir(
&hg_path, &hg_path,
&fs_entry.full_path, &fs_entry.full_path,
is_at_repo_root, is_at_repo_root,
) { ) {
children_fs_entries.par_iter().for_each(|child_fs_entry| { children_fs_entries.par_iter().for_each(|child_fs_entry| {
let child_hg_path =
hg_path.join(&child_fs_entry.base_name);
self.traverse_fs_only( self.traverse_fs_only(
is_ignored, is_ignored || (self.ignore_fn)(&child_hg_path),
&hg_path, child_hg_path,
child_fs_entry, child_fs_entry,
) )
}) })
} }
} }
if self.options.collect_traversed_dirs { if self.options.collect_traversed_dirs {
self.outcome.lock().unwrap().traversed.push(hg_path.into()) self.outcome.lock().unwrap().traversed.push(hg_path.into())
} }
} else if file_or_symlink && self.matcher.matches(&hg_path) { } else if file_or_symlink && self.matcher.matches(&hg_path) {
self.mark_unknown_or_ignored( self.mark_unknown_or_ignored(
has_ignored_ancestor, is_ignored,
&BorrowedPath::InMemory(&hg_path), &BorrowedPath::InMemory(&hg_path),
) )
} }
} }
fn mark_unknown_or_ignored( fn mark_unknown_or_ignored(
&self, &self,
has_ignored_ancestor: bool, is_ignored: bool,
hg_path: &BorrowedPath<'_, 'on_disk>, hg_path: &BorrowedPath<'_, 'on_disk>,
) { ) {
let is_ignored = has_ignored_ancestor || (self.ignore_fn)(&hg_path);
if is_ignored { if is_ignored {
if self.options.list_ignored { if self.options.list_ignored {
self.outcome self.outcome
.lock() .lock()
.unwrap() .unwrap()
.ignored .ignored
.push(hg_path.detach_from_tree()) .push(hg_path.detach_from_tree())
} }