This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10824

dirstate-tree: Change status() results to not borrow DirstateMap
ClosedPublic

Authored by SimonSapin on Jun 1 2021, 12:50 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG73ddcedeaadf: dirstate-tree: Change status() results to not borrow DirstateMap
Summary

The status function takes a &'tree mut DirstateMap<'on_disk> parameter.
'on_disk borrows a read-only byte buffer with the contents of the
.hg/dirstate file. DirstateMap internally uses represents file paths as
std::borrow::Cow<'on_disk, HgPath>, which borrows the byte buffer when
possible and allocates an owned string if not, such as for files added to the
dirstate after it was loaded from disk.

Previously the return type of of status has a 'tree lifetime, meaning it
could borrow all paths from the DirstateMap. With this changeset, that
lifetime is changed to 'on_disk meaning that only paths from the byte buffer
can be borrowed, and paths allocated by DirstateMap must be copied.

Usually most paths are in the byte buffer, and most paths are not part of the
return value of status, so the number of extra copies should be small.

This change will enable status to mutate the DirstateMap after it has
finished constructing its return value. Previously such mutation would be
prevented by possible on-going borrows.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Jun 1 2021, 12:50 PM
SimonSapin added a commit: rHG73ddcedeaadf: dirstate-tree: Change status() results to not borrow DirstateMap.Jun 1 2021, 3:35 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG73ddcedeaadf: dirstate-tree: Change status() results to not borrow DirstateMap (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.
baymax updated this revision to Diff 28382.Jun 1 2021, 5:05 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 28382

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

pub bad: Vec<(HgPathCow<'a>, BadMatch)>, pub bad: Vec<(HgPathCow<'a>, BadMatch)>,
/// Either clean or modified, but we can’t tell from filesystem metadata /// Either clean or modified, but we can’t tell from filesystem metadata
/// alone. The file contents need to be read and compared with that in /// alone. The file contents need to be read and compared with that in
/// the parent. /// the parent.
pub unsure: Vec<HgPathCow<'a>>, pub unsure: Vec<HgPathCow<'a>>,
/// Only filled if `collect_traversed_dirs` is `true` /// Only filled if `collect_traversed_dirs` is `true`
pub traversed: Vec<HgPathBuf>, pub traversed: Vec<HgPathCow<'a>>,
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum StatusError { pub enum StatusError {
/// Generic IO error /// Generic IO error
IO(std::io::Error), IO(std::io::Error),
/// An invalid path that cannot be represented in Mercurial was found /// An invalid path that cannot be represented in Mercurial was found
Path(HgPathError), Path(HgPathError),
results.par_extend(new_results); results.par_extend(new_results);
} }
} }
#[timed] #[timed]
pub fn build_response<'a>( pub fn build_response<'a>(
results: impl IntoIterator<Item = DispatchedPath<'a>>, results: impl IntoIterator<Item = DispatchedPath<'a>>,
traversed: Vec<HgPathBuf>, traversed: Vec<HgPathCow<'a>>,
) -> DirstateStatus<'a> { ) -> DirstateStatus<'a> {
let mut unsure = vec![]; let mut unsure = vec![];
let mut modified = vec![]; let mut modified = vec![];
let mut added = vec![]; let mut added = vec![];
let mut removed = vec![]; let mut removed = vec![];
let mut deleted = vec![]; let mut deleted = vec![];
let mut clean = vec![]; let mut clean = vec![];
let mut ignored = vec![]; let mut ignored = vec![];

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

/// Using a plain `HgPathBuf` of the full path from the repository root as a /// Using a plain `HgPathBuf` of the full path from the repository root as a
/// map key would also work: all paths in a given map have the same parent /// map key would also work: all paths in a given map have the same parent
/// path, so comparing full paths gives the same result as comparing base /// path, so comparing full paths gives the same result as comparing base
/// names. However `HashMap` would waste time always re-hashing the same /// names. However `HashMap` would waste time always re-hashing the same
/// string prefix. /// string prefix.
pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>; pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>;
/// Similar to `&'tree Cow<'on_disk, HgPath>`, but can also be returned
/// for on-disk nodes that don’t actually have a `Cow` to borrow.
pub(super) enum BorrowedPath<'tree, 'on_disk> {
InMemory(&'tree HgPathBuf),
OnDisk(&'on_disk HgPath),
}
pub(super) enum ChildNodes<'on_disk> { pub(super) enum ChildNodes<'on_disk> {
InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>), InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
OnDisk(&'on_disk [on_disk::Node]), OnDisk(&'on_disk [on_disk::Node]),
} }
pub(super) enum ChildNodesRef<'tree, 'on_disk> { pub(super) enum ChildNodesRef<'tree, 'on_disk> {
InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>), InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
OnDisk(&'on_disk [on_disk::Node]), OnDisk(&'on_disk [on_disk::Node]),
} }
pub(super) enum NodeRef<'tree, 'on_disk> { pub(super) enum NodeRef<'tree, 'on_disk> {
InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>), InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>),
OnDisk(&'on_disk on_disk::Node), OnDisk(&'on_disk on_disk::Node),
} }
impl<'tree, 'on_disk> BorrowedPath<'tree, 'on_disk> {
pub fn detach_from_tree(&self) -> Cow<'on_disk, HgPath> {
match *self {
BorrowedPath::InMemory(in_memory) => Cow::Owned(in_memory.clone()),
BorrowedPath::OnDisk(on_disk) => Cow::Borrowed(on_disk),
}
}
}
impl<'tree, 'on_disk> std::ops::Deref for BorrowedPath<'tree, 'on_disk> {
type Target = HgPath;
fn deref(&self) -> &HgPath {
match *self {
BorrowedPath::InMemory(in_memory) => in_memory,
BorrowedPath::OnDisk(on_disk) => on_disk,
}
}
}
impl Default for ChildNodes<'_> { impl Default for ChildNodes<'_> {
fn default() -> Self { fn default() -> Self {
ChildNodes::InMemory(Default::default()) ChildNodes::InMemory(Default::default())
} }
} }
impl<'on_disk> ChildNodes<'on_disk> { impl<'on_disk> ChildNodes<'on_disk> {
pub(super) fn as_ref<'tree>( pub(super) fn as_ref<'tree>(
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<&'tree HgPath, DirstateV2ParseError> { ) -> Result<&'tree HgPath, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(path, _node) => Ok(path.full_path()), NodeRef::InMemory(path, _node) => Ok(path.full_path()),
NodeRef::OnDisk(node) => node.full_path(on_disk), NodeRef::OnDisk(node) => node.full_path(on_disk),
} }
} }
/// Returns a `Cow` that can borrow 'on_disk but is detached from 'tree /// Returns a `BorrowedPath`, which can be turned into a `Cow<'on_disk,
pub(super) fn full_path_cow( /// HgPath>` detached from `'tree`
pub(super) fn full_path_borrowed(
&self, &self,
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<Cow<'on_disk, HgPath>, DirstateV2ParseError> { ) -> Result<BorrowedPath<'tree, 'on_disk>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(path, _node) => Ok(path.full_path().clone()), NodeRef::InMemory(path, _node) => match path.full_path() {
Cow::Borrowed(on_disk) => Ok(BorrowedPath::OnDisk(on_disk)),
Cow::Owned(in_memory) => Ok(BorrowedPath::InMemory(in_memory)),
},
NodeRef::OnDisk(node) => { NodeRef::OnDisk(node) => {
Ok(Cow::Borrowed(node.full_path(on_disk)?)) Ok(BorrowedPath::OnDisk(node.full_path(on_disk)?))
} }
} }
} }
pub(super) fn base_name( pub(super) fn base_name(
&self, &self,
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<&'tree HgPath, DirstateV2ParseError> { ) -> Result<&'tree HgPath, DirstateV2ParseError> {
for node in self.iter_nodes() { for node in self.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
size += packed_entry_size( size += packed_entry_size(
node.full_path(self.on_disk)?, node.full_path(self.on_disk)?,
node.copy_source(self.on_disk)?, node.copy_source(self.on_disk)?,
); );
if entry.mtime_is_ambiguous(now) { if entry.mtime_is_ambiguous(now) {
ambiguous_mtimes.push(node.full_path_cow(self.on_disk)?) ambiguous_mtimes.push(
node.full_path_borrowed(self.on_disk)?
.detach_from_tree(),
)
} }
} }
} }
self.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?; self.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?;
let mut packed = Vec::with_capacity(size); let mut packed = Vec::with_capacity(size);
packed.extend(parents.as_bytes()); packed.extend(parents.as_bytes());
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
// TODO:!how do we want to handle this in 2038? // TODO:!how do we want to handle this in 2038?
let now: i32 = now.0.try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
let mut paths = Vec::new(); let mut paths = Vec::new();
for node in self.iter_nodes() { for node in self.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
if entry.mtime_is_ambiguous(now) { if entry.mtime_is_ambiguous(now) {
paths.push(node.full_path_cow(self.on_disk)?) paths.push(
node.full_path_borrowed(self.on_disk)?
.detach_from_tree(),
)
} }
} }
} }
// Borrow of `self` ends here since we collect cloned paths // Borrow of `self` ends here since we collect cloned paths
self.clear_known_ambiguous_mtimes(&paths)?; self.clear_known_ambiguous_mtimes(&paths)?;
on_disk::write(self, parents) on_disk::write(self, parents)

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

use crate::dirstate::status::IgnoreFnType; use crate::dirstate::status::IgnoreFnType;
use crate::dirstate_tree::dirstate_map::BorrowedPath;
use crate::dirstate_tree::dirstate_map::ChildNodesRef; use crate::dirstate_tree::dirstate_map::ChildNodesRef;
use crate::dirstate_tree::dirstate_map::DirstateMap; use crate::dirstate_tree::dirstate_map::DirstateMap;
use crate::dirstate_tree::dirstate_map::NodeRef; use crate::dirstate_tree::dirstate_map::NodeRef;
use crate::dirstate_tree::on_disk::DirstateV2ParseError; use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::matchers::get_ignore_function; use crate::matchers::get_ignore_function;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::files::get_bytes_from_os_string; use crate::utils::files::get_bytes_from_os_string;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::BadMatch; use crate::BadMatch;
use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState; use crate::EntryState;
use crate::HgPathBuf; use crate::HgPathBuf;
use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
use micro_timer::timed; use micro_timer::timed;
use rayon::prelude::*; use rayon::prelude::*;
use std::borrow::Cow;
use std::io; use std::io;
use std::path::Path; use std::path::Path;
use std::path::PathBuf; use std::path::PathBuf;
use std::sync::Mutex; use std::sync::Mutex;
/// Returns the status of the working directory compared to its parent /// Returns the status of the working directory compared to its parent
/// changeset. /// changeset.
/// ///
/// This algorithm is based on traversing the filesystem tree (`fs` in function /// This algorithm is based on traversing the filesystem tree (`fs` in function
/// and variable names) and dirstate tree at the same time. The core of this /// and variable names) and dirstate tree at the same time. The core of this
/// traversal is the recursive `traverse_fs_directory_and_dirstate` function /// traversal is the recursive `traverse_fs_directory_and_dirstate` function
/// and its use of `itertools::merge_join_by`. When reaching a path that only /// and its use of `itertools::merge_join_by`. When reaching a path that only
/// exists in one of the two trees, depending on information requested by /// exists in one of the two trees, depending on information requested by
/// `options` we may need to traverse the remaining subtree. /// `options` we may need to traverse the remaining subtree.
#[timed] #[timed]
pub fn status<'tree, 'on_disk: 'tree>( pub fn status<'tree, 'on_disk: 'tree>(
dmap: &'tree mut DirstateMap<'on_disk>, dmap: &'tree mut DirstateMap<'on_disk>,
matcher: &(dyn Matcher + Sync), matcher: &(dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'tree>, Vec<PatternFileWarning>), StatusError> { ) -> Result<(DirstateStatus<'on_disk>, Vec<PatternFileWarning>), StatusError> {
let (ignore_fn, warnings): (IgnoreFnType, _) = let (ignore_fn, warnings): (IgnoreFnType, _) =
if options.list_ignored || options.list_unknown { if options.list_ignored || options.list_unknown {
get_ignore_function(ignore_files, &root_dir)? get_ignore_function(ignore_files, &root_dir)?
} else { } else {
(Box::new(|&_| true), vec![]) (Box::new(|&_| true), vec![])
}; };
let common = StatusCommon { let common = StatusCommon {
dmap, dmap,
options, options,
matcher, matcher,
ignore_fn, ignore_fn,
outcome: Mutex::new(DirstateStatus::default()), outcome: Mutex::new(DirstateStatus::default()),
}; };
let is_at_repo_root = true; let is_at_repo_root = true;
let hg_path = HgPath::new(""); let hg_path = &BorrowedPath::OnDisk(HgPath::new(""));
let has_ignored_ancestor = false; let has_ignored_ancestor = false;
common.traverse_fs_directory_and_dirstate( common.traverse_fs_directory_and_dirstate(
has_ignored_ancestor, has_ignored_ancestor,
dmap.root.as_ref(), dmap.root.as_ref(),
hg_path, hg_path,
&root_dir, &root_dir,
is_at_repo_root, is_at_repo_root,
)?; )?;
Ok((common.outcome.into_inner().unwrap(), warnings)) Ok((common.outcome.into_inner().unwrap(), warnings))
} }
/// Bag of random things needed by various parts of the algorithm. Reduces the /// Bag of random things needed by various parts of the algorithm. Reduces the
/// number of parameters passed to functions. /// number of parameters passed to functions.
struct StatusCommon<'tree, 'a, 'on_disk: 'tree> { struct StatusCommon<'a, 'tree, 'on_disk: 'tree> {
dmap: &'tree DirstateMap<'on_disk>, dmap: &'tree DirstateMap<'on_disk>,
options: StatusOptions, options: StatusOptions,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
ignore_fn: IgnoreFnType<'a>, ignore_fn: IgnoreFnType<'a>,
outcome: Mutex<DirstateStatus<'tree>>, outcome: Mutex<DirstateStatus<'on_disk>>,
} }
impl<'tree, 'a> StatusCommon<'tree, 'a, '_> { impl<'a, 'tree, 'on_disk> StatusCommon<'a, 'tree, 'on_disk> {
fn read_dir( fn read_dir(
&self, &self,
hg_path: &HgPath, hg_path: &HgPath,
fs_path: &Path, fs_path: &Path,
is_at_repo_root: bool, is_at_repo_root: bool,
) -> Result<Vec<DirEntry>, ()> { ) -> Result<Vec<DirEntry>, ()> {
DirEntry::read_dir(fs_path, is_at_repo_root) DirEntry::read_dir(fs_path, is_at_repo_root)
.map_err(|error| self.io_error(error, hg_path)) .map_err(|error| self.io_error(error, hg_path))
} }
fn io_error(&self, error: std::io::Error, hg_path: &HgPath) { fn io_error(&self, error: std::io::Error, hg_path: &HgPath) {
let errno = error.raw_os_error().expect("expected real OS error"); let errno = error.raw_os_error().expect("expected real OS error");
self.outcome self.outcome
.lock() .lock()
.unwrap() .unwrap()
.bad .bad
.push((hg_path.to_owned().into(), BadMatch::OsError(errno))) .push((hg_path.to_owned().into(), BadMatch::OsError(errno)))
} }
fn traverse_fs_directory_and_dirstate( fn traverse_fs_directory_and_dirstate(
&self, &self,
has_ignored_ancestor: bool, has_ignored_ancestor: bool,
dirstate_nodes: ChildNodesRef<'tree, '_>, dirstate_nodes: ChildNodesRef<'tree, 'on_disk>,
directory_hg_path: &'tree HgPath, directory_hg_path: &BorrowedPath<'tree, 'on_disk>,
directory_fs_path: &Path, directory_fs_path: &Path,
is_at_repo_root: bool, is_at_repo_root: bool,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
if !self.options.list_unknown && !self.options.list_ignored { if !self.options.list_unknown && !self.options.list_ignored {
// We only care about files in the dirstate, so we can skip listing // We only care about files in the dirstate, so we can skip listing
// filesystem directories entirely. // filesystem directories entirely.
return dirstate_nodes return dirstate_nodes
.par_iter() .par_iter()
}) })
.collect() .collect()
} }
fn traverse_fs_and_dirstate( fn traverse_fs_and_dirstate(
&self, &self,
fs_path: &Path, fs_path: &Path,
fs_metadata: &std::fs::Metadata, fs_metadata: &std::fs::Metadata,
dirstate_node: NodeRef<'tree, '_>, dirstate_node: NodeRef<'tree, 'on_disk>,
has_ignored_ancestor: bool, has_ignored_ancestor: bool,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
let hg_path = dirstate_node.full_path(self.dmap.on_disk)?; let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?;
let file_type = fs_metadata.file_type(); let file_type = fs_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_or_symlink { if !file_or_symlink {
// If we previously had a file here, it was removed (with // If we previously had a file here, it was removed (with
// `hg rm` or similar) or deleted before it could be // `hg rm` or similar) or deleted before it could be
// replaced by a directory or something else. // replaced by a directory or something else.
self.mark_removed_or_deleted_if_file( self.mark_removed_or_deleted_if_file(
hg_path, &hg_path,
dirstate_node.state()?, dirstate_node.state()?,
); );
} }
if file_type.is_dir() { if file_type.is_dir() {
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.detach_from_tree())
} }
let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path); let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path);
let is_at_repo_root = false; let is_at_repo_root = false;
self.traverse_fs_directory_and_dirstate( self.traverse_fs_directory_and_dirstate(
is_ignored, is_ignored,
dirstate_node.children(self.dmap.on_disk)?, dirstate_node.children(self.dmap.on_disk)?,
hg_path, hg_path,
fs_path, fs_path,
is_at_repo_root, is_at_repo_root,
)? )?
} else { } else {
if file_or_symlink && self.matcher.matches(hg_path) { if file_or_symlink && self.matcher.matches(hg_path) {
let full_path = Cow::from(hg_path);
if let Some(state) = dirstate_node.state()? { if let Some(state) = dirstate_node.state()? {
match state { match state {
EntryState::Added => { EntryState::Added => self
self.outcome.lock().unwrap().added.push(full_path) .outcome
} .lock()
.unwrap()
.added
.push(hg_path.detach_from_tree()),
EntryState::Removed => self EntryState::Removed => self
.outcome .outcome
.lock() .lock()
.unwrap() .unwrap()
.removed .removed
.push(full_path), .push(hg_path.detach_from_tree()),
EntryState::Merged => self EntryState::Merged => self
.outcome .outcome
.lock() .lock()
.unwrap() .unwrap()
.modified .modified
.push(full_path), .push(hg_path.detach_from_tree()),
EntryState::Normal => self EntryState::Normal => 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( self.mark_unknown_or_ignored(has_ignored_ancestor, hg_path)
has_ignored_ancestor,
full_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)?
} }
} }
Ok(()) Ok(())
} }
/// A file with `EntryState::Normal` in the dirstate was found in the /// A file with `EntryState::Normal` in the dirstate was found in the
/// filesystem /// filesystem
fn handle_normal_file( fn handle_normal_file(
&self, &self,
dirstate_node: &NodeRef<'tree, '_>, dirstate_node: &NodeRef<'tree, 'on_disk>,
fs_metadata: &std::fs::Metadata, fs_metadata: &std::fs::Metadata,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
// Keep the low 31 bits // Keep the low 31 bits
fn truncate_u64(value: u64) -> i32 { fn truncate_u64(value: u64) -> i32 {
(value & 0x7FFF_FFFF) as i32 (value & 0x7FFF_FFFF) as i32
} }
fn truncate_i64(value: i64) -> i32 { fn truncate_i64(value: i64) -> i32 {
(value & 0x7FFF_FFFF) as i32 (value & 0x7FFF_FFFF) as i32
} }
let entry = dirstate_node let entry = dirstate_node
.entry()? .entry()?
.expect("handle_normal_file called with entry-less node"); .expect("handle_normal_file called with entry-less node");
let full_path = Cow::from(dirstate_node.full_path(self.dmap.on_disk)?); let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?;
let mode_changed = let mode_changed =
|| self.options.check_exec && entry.mode_changed(fs_metadata); || self.options.check_exec && entry.mode_changed(fs_metadata);
let size_changed = entry.size != truncate_u64(fs_metadata.len()); let size_changed = entry.size != truncate_u64(fs_metadata.len());
if entry.size >= 0 if entry.size >= 0
&& size_changed && size_changed
&& fs_metadata.file_type().is_symlink() && fs_metadata.file_type().is_symlink()
{ {
// issue6456: Size returned may be longer due to encryption // issue6456: Size returned may be longer due to encryption
// on EXT-4 fscrypt. TODO maybe only do it on EXT4? // on EXT-4 fscrypt. TODO maybe only do it on EXT4?
self.outcome.lock().unwrap().unsure.push(full_path) self.outcome
.lock()
.unwrap()
.unsure
.push(hg_path.detach_from_tree())
} else if dirstate_node.has_copy_source() } else if dirstate_node.has_copy_source()
|| entry.is_from_other_parent() || entry.is_from_other_parent()
|| (entry.size >= 0 && (size_changed || mode_changed())) || (entry.size >= 0 && (size_changed || mode_changed()))
{ {
self.outcome.lock().unwrap().modified.push(full_path) self.outcome
.lock()
.unwrap()
.modified
.push(hg_path.detach_from_tree())
} else { } else {
let mtime = mtime_seconds(fs_metadata); let mtime = mtime_seconds(fs_metadata);
if truncate_i64(mtime) != entry.mtime if truncate_i64(mtime) != entry.mtime
|| mtime == self.options.last_normal_time || mtime == self.options.last_normal_time
{ {
self.outcome.lock().unwrap().unsure.push(full_path) self.outcome
.lock()
.unwrap()
.unsure
.push(hg_path.detach_from_tree())
} else if self.options.list_clean { } else if self.options.list_clean {
self.outcome.lock().unwrap().clean.push(full_path) self.outcome
.lock()
.unwrap()
.clean
.push(hg_path.detach_from_tree())
} }
} }
Ok(()) Ok(())
} }
/// A node in the dirstate tree has no corresponding filesystem entry /// A node in the dirstate tree has no corresponding filesystem entry
fn traverse_dirstate_only( fn traverse_dirstate_only(
&self, &self,
dirstate_node: NodeRef<'tree, '_>, dirstate_node: NodeRef<'tree, 'on_disk>,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
self.mark_removed_or_deleted_if_file( self.mark_removed_or_deleted_if_file(
dirstate_node.full_path(self.dmap.on_disk)?, &dirstate_node.full_path_borrowed(self.dmap.on_disk)?,
dirstate_node.state()?, dirstate_node.state()?,
); );
dirstate_node dirstate_node
.children(self.dmap.on_disk)? .children(self.dmap.on_disk)?
.par_iter() .par_iter()
.map(|child_node| self.traverse_dirstate_only(child_node)) .map(|child_node| self.traverse_dirstate_only(child_node))
.collect() .collect()
} }
/// A node in the dirstate tree has no corresponding *file* on the /// A node in the dirstate tree has no corresponding *file* on the
/// filesystem /// filesystem
/// ///
/// Does nothing on a "directory" node /// Does nothing on a "directory" node
fn mark_removed_or_deleted_if_file( fn mark_removed_or_deleted_if_file(
&self, &self,
hg_path: &'tree HgPath, hg_path: &BorrowedPath<'tree, 'on_disk>,
dirstate_node_state: Option<EntryState>, dirstate_node_state: Option<EntryState>,
) { ) {
if let Some(state) = dirstate_node_state { if let Some(state) = dirstate_node_state {
if self.matcher.matches(hg_path) { if self.matcher.matches(hg_path) {
if let EntryState::Removed = state { if let EntryState::Removed = state {
self.outcome.lock().unwrap().removed.push(hg_path.into()) self.outcome
.lock()
.unwrap()
.removed
.push(hg_path.detach_from_tree())
} else { } else {
self.outcome.lock().unwrap().deleted.push(hg_path.into()) self.outcome
.lock()
.unwrap()
.deleted
.push(hg_path.detach_from_tree())
} }
} }
} }
} }
/// 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,
) )
}) })
} }
} }
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(has_ignored_ancestor, hg_path.into()) self.mark_unknown_or_ignored(
has_ignored_ancestor,
&BorrowedPath::InMemory(&hg_path),
)
} }
} }
fn mark_unknown_or_ignored( fn mark_unknown_or_ignored(
&self, &self,
has_ignored_ancestor: bool, has_ignored_ancestor: bool,
hg_path: Cow<'tree, HgPath>, hg_path: &BorrowedPath<'_, 'on_disk>,
) { ) {
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 is_ignored {
if self.options.list_ignored { if self.options.list_ignored {
self.outcome.lock().unwrap().ignored.push(hg_path) self.outcome
.lock()
.unwrap()
.ignored
.push(hg_path.detach_from_tree())
} }
} else { } else {
if self.options.list_unknown { if self.options.list_unknown {
self.outcome.lock().unwrap().unknown.push(hg_path) self.outcome
.lock()
.unwrap()
.unknown
.push(hg_path.detach_from_tree())
} }
} }
} }
} }
#[cfg(unix)] // TODO #[cfg(unix)] // TODO
fn mtime_seconds(metadata: &std::fs::Metadata) -> i64 { fn mtime_seconds(metadata: &std::fs::Metadata) -> i64 {
// Going through `Metadata::modified()` would be portable, but would take // Going through `Metadata::modified()` would be portable, but would take

rust/hg-core/src/operations/dirstate_status.rs

// TODO this is incorrect, see issue6335 // TODO this is incorrect, see issue6335
// This requires a fix in both Python and Rust that can happen // This requires a fix in both Python and Rust that can happen
// with other pending changes to `status`. // with other pending changes to `status`.
self.extend_from_dmap(&mut results); self.extend_from_dmap(&mut results);
} }
} }
drop(traversed_sender); drop(traversed_sender);
let traversed = traversed_receiver.into_iter().collect(); let traversed = traversed_receiver
.into_iter()
.map(std::borrow::Cow::Owned)
.collect();
Ok(build_response(results, traversed)) Ok(build_response(results, traversed))
} }
} }