rust-status: fix ignore and include not composing (issue6514)

While the fix is pretty simple, the overall dispatch logic has become kind of
ugly. Thankfully we're currently upstreaming a better algorithm, this code is
temporary anyway.

Differential Revision: https://phab.mercurial-scm.org/D10639

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

@@ -1,913 +1,915 b''
 // status.rs
 //
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Rust implementation of dirstate.status (dirstate.py).
 //! It is currently missing a lot of functionality compared to the Python one
 //! and will only be triggered in narrow cases.
 
 use crate::utils::path_auditor::PathAuditor;
 use crate::{
     dirstate::SIZE_FROM_OTHER_PARENT,
     filepatterns::PatternFileWarning,
     matchers::{get_ignore_function, Matcher, VisitChildrenSet},
     utils::{
         files::{find_dirs, HgMetadata},
         hg_path::{
             hg_path_to_path_buf, os_string_to_hg_path_buf, HgPath, HgPathBuf,
             HgPathError,
         },
     },
     CopyMap, DirstateEntry, DirstateMap, EntryState, FastHashMap,
     PatternError,
 };
 use lazy_static::lazy_static;
 use micro_timer::timed;
 use rayon::prelude::*;
 use std::{
     borrow::Cow,
     collections::HashSet,
     fmt,
     fs::{read_dir, DirEntry},
     io::ErrorKind,
     ops::Deref,
     path::{Path, PathBuf},
 };
 
 /// Wrong type of file from a `BadMatch`
 /// Note: a lot of those don't exist on all platforms.
 #[derive(Debug, Copy, Clone)]
 pub enum BadType {
     CharacterDevice,
     BlockDevice,
     FIFO,
     Socket,
     Directory,
     Unknown,
 }
 
 impl fmt::Display for BadType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(match self {
             BadType::CharacterDevice => "character device",
             BadType::BlockDevice => "block device",
             BadType::FIFO => "fifo",
             BadType::Socket => "socket",
             BadType::Directory => "directory",
             BadType::Unknown => "unknown",
         })
     }
 }
 
 /// Was explicitly matched but cannot be found/accessed
 #[derive(Debug, Copy, Clone)]
 pub enum BadMatch {
     OsError(i32),
     BadType(BadType),
 }
 
 /// Enum used to dispatch new status entries into the right collections.
 /// Is similar to `crate::EntryState`, but represents the transient state of
 /// entries during the lifetime of a command.
 #[derive(Debug, Copy, Clone)]
 pub enum Dispatch {
     Unsure,
     Modified,
     Added,
     Removed,
     Deleted,
     Clean,
     Unknown,
     Ignored,
     /// Empty dispatch, the file is not worth listing
     None,
     /// Was explicitly matched but cannot be found/accessed
     Bad(BadMatch),
     Directory {
         /// True if the directory used to be a file in the dmap so we can say
         /// that it's been removed.
         was_file: bool,
     },
 }
 
 type IoResult<T> = std::io::Result<T>;
 
 /// `Box<dyn Trait>` is syntactic sugar for `Box<dyn Trait, 'static>`, so add
 /// an explicit lifetime here to not fight `'static` bounds "out of nowhere".
 type IgnoreFnType<'a> = Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>;
 
 /// We have a good mix of owned (from directory traversal) and borrowed (from
 /// the dirstate/explicit) paths, this comes up a lot.
 pub type HgPathCow<'a> = Cow<'a, HgPath>;
 
 /// A path with its computed ``Dispatch`` information
 type DispatchedPath<'a> = (HgPathCow<'a>, Dispatch);
 
 /// The conversion from `HgPath` to a real fs path failed.
 /// `22` is the error code for "Invalid argument"
 const INVALID_PATH_DISPATCH: Dispatch = Dispatch::Bad(BadMatch::OsError(22));
 
 /// Dates and times that are outside the 31-bit signed range are compared
 /// modulo 2^31. This should prevent hg from behaving badly with very large
 /// files or corrupt dates while still having a high probability of detecting
 /// changes. (issue2608)
 /// TODO I haven't found a way of having `b` be `Into<i32>`, since `From<u64>`
 /// is not defined for `i32`, and there is no `As` trait. This forces the
 /// caller to cast `b` as `i32`.
 fn mod_compare(a: i32, b: i32) -> bool {
     a & i32::max_value() != b & i32::max_value()
 }
 
 /// Return a sorted list containing information about the entries
 /// in the directory.
 ///
 /// * `skip_dot_hg` - Return an empty vec if `path` contains a `.hg` directory
 fn list_directory(
     path: impl AsRef<Path>,
     skip_dot_hg: bool,
 ) -> std::io::Result<Vec<(HgPathBuf, DirEntry)>> {
     let mut results = vec![];
     let entries = read_dir(path.as_ref())?;
 
     for entry in entries {
         let entry = entry?;
         let filename = os_string_to_hg_path_buf(entry.file_name())?;
         let file_type = entry.file_type()?;
         if skip_dot_hg && filename.as_bytes() == b".hg" && file_type.is_dir() {
             return Ok(vec![]);
         } else {
             results.push((filename, entry))
         }
     }
 
     results.sort_unstable_by_key(|e| e.0.clone());
     Ok(results)
 }
 
 /// The file corresponding to the dirstate entry was found on the filesystem.
 fn dispatch_found(
     filename: impl AsRef<HgPath>,
     entry: DirstateEntry,
     metadata: HgMetadata,
     copy_map: &CopyMap,
     options: StatusOptions,
 ) -> Dispatch {
     let DirstateEntry {
         state,
         mode,
         mtime,
         size,
     } = entry;
 
     let HgMetadata {
         st_mode,
         st_size,
         st_mtime,
         ..
     } = metadata;
 
     match state {
         EntryState::Normal => {
             let size_changed = mod_compare(size, st_size as i32);
             let mode_changed =
                 (mode ^ st_mode as i32) & 0o100 != 0o000 && options.check_exec;
             let metadata_changed = size >= 0 && (size_changed || mode_changed);
             let other_parent = size == SIZE_FROM_OTHER_PARENT;
 
             if metadata_changed
                 || other_parent
                 || copy_map.contains_key(filename.as_ref())
             {
                 if metadata.is_symlink() && size_changed {
                     // issue6456: Size returned may be longer due to encryption
                     // on EXT-4 fscrypt. TODO maybe only do it on EXT4?
                     Dispatch::Unsure
                 } else {
                     Dispatch::Modified
                 }
             } else if mod_compare(mtime, st_mtime as i32)
                 || st_mtime == options.last_normal_time
             {
                 // the file may have just been marked as normal and
                 // it may have changed in the same second without
                 // changing its size. This can happen if we quickly
                 // do multiple commits. Force lookup, so we don't
                 // miss such a racy file change.
                 Dispatch::Unsure
             } else if options.list_clean {
                 Dispatch::Clean
             } else {
                 Dispatch::None
             }
         }
         EntryState::Merged => Dispatch::Modified,
         EntryState::Added => Dispatch::Added,
         EntryState::Removed => Dispatch::Removed,
         EntryState::Unknown => Dispatch::Unknown,
     }
 }
 
 /// The file corresponding to this Dirstate entry is missing.
 fn dispatch_missing(state: EntryState) -> Dispatch {
     match state {
         // File was removed from the filesystem during commands
         EntryState::Normal | EntryState::Merged | EntryState::Added => {
             Dispatch::Deleted
         }
         // File was removed, everything is normal
         EntryState::Removed => Dispatch::Removed,
         // File is unknown to Mercurial, everything is normal
         EntryState::Unknown => Dispatch::Unknown,
     }
 }
 
 fn dispatch_os_error(e: &std::io::Error) -> Dispatch {
     Dispatch::Bad(BadMatch::OsError(
         e.raw_os_error().expect("expected real OS error"),
     ))
 }
 
 lazy_static! {
     static ref DEFAULT_WORK: HashSet<&'static HgPath> = {
         let mut h = HashSet::new();
         h.insert(HgPath::new(b""));
         h
     };
 }
 
 #[derive(Debug, Copy, Clone)]
 pub struct StatusOptions {
     /// Remember the most recent modification timeslot for status, to make
     /// sure we won't miss future size-preserving file content modifications
     /// that happen within the same timeslot.
     pub last_normal_time: i64,
     /// Whether we are on a filesystem with UNIX-like exec flags
     pub check_exec: bool,
     pub list_clean: bool,
     pub list_unknown: bool,
     pub list_ignored: bool,
     /// Whether to collect traversed dirs for applying a callback later.
     /// Used by `hg purge` for example.
     pub collect_traversed_dirs: bool,
 }
 
 #[derive(Debug)]
 pub struct DirstateStatus<'a> {
     pub modified: Vec<HgPathCow<'a>>,
     pub added: Vec<HgPathCow<'a>>,
     pub removed: Vec<HgPathCow<'a>>,
     pub deleted: Vec<HgPathCow<'a>>,
     pub clean: Vec<HgPathCow<'a>>,
     pub ignored: Vec<HgPathCow<'a>>,
     pub unknown: Vec<HgPathCow<'a>>,
     pub bad: Vec<(HgPathCow<'a>, BadMatch)>,
     /// Only filled if `collect_traversed_dirs` is `true`
     pub traversed: Vec<HgPathBuf>,
 }
 
 #[derive(Debug, derive_more::From)]
 pub enum StatusError {
     /// Generic IO error
     IO(std::io::Error),
     /// An invalid path that cannot be represented in Mercurial was found
     Path(HgPathError),
     /// An invalid "ignore" pattern was found
     Pattern(PatternError),
 }
 
 pub type StatusResult<T> = Result<T, StatusError>;
 
 impl fmt::Display for StatusError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             StatusError::IO(error) => error.fmt(f),
             StatusError::Path(error) => error.fmt(f),
             StatusError::Pattern(error) => error.fmt(f),
         }
     }
 }
 
 /// Gives information about which files are changed in the working directory
 /// and how, compared to the revision we're based on
 pub struct Status<'a, M: Matcher + Sync> {
     dmap: &'a DirstateMap,
     pub(crate) matcher: &'a M,
     root_dir: PathBuf,
     pub(crate) options: StatusOptions,
     ignore_fn: IgnoreFnType<'a>,
 }
 
 impl<'a, M> Status<'a, M>
 where
     M: Matcher + Sync,
 {
     pub fn new(
         dmap: &'a DirstateMap,
         matcher: &'a M,
         root_dir: PathBuf,
         ignore_files: Vec<PathBuf>,
         options: StatusOptions,
     ) -> StatusResult<(Self, Vec<PatternFileWarning>)> {
         // Needs to outlive `dir_ignore_fn` since it's captured.
 
         let (ignore_fn, warnings): (IgnoreFnType, _) =
             if options.list_ignored || options.list_unknown {
                 get_ignore_function(ignore_files, &root_dir)?
             } else {
                 (Box::new(|&_| true), vec![])
             };
 
         Ok((
             Self {
                 dmap,
                 matcher,
                 root_dir,
                 options,
                 ignore_fn,
             },
             warnings,
         ))
     }
 
     /// Is the path ignored?
     pub fn is_ignored(&self, path: impl AsRef<HgPath>) -> bool {
         (self.ignore_fn)(path.as_ref())
     }
 
     /// Is the path or one of its ancestors ignored?
     pub fn dir_ignore(&self, dir: impl AsRef<HgPath>) -> bool {
         // Only involve ignore mechanism if we're listing unknowns or ignored.
         if self.options.list_ignored || self.options.list_unknown {
             if self.is_ignored(&dir) {
                 true
             } else {
                 for p in find_dirs(dir.as_ref()) {
                     if self.is_ignored(p) {
                         return true;
                     }
                 }
                 false
             }
         } else {
             true
         }
     }
 
     /// Get stat data about the files explicitly specified by the matcher.
     /// Returns a tuple of the directories that need to be traversed and the
     /// files with their corresponding `Dispatch`.
     /// TODO subrepos
     #[timed]
     pub fn walk_explicit(
         &self,
         traversed_sender: crossbeam_channel::Sender<HgPathBuf>,
     ) -> (Vec<DispatchedPath<'a>>, Vec<DispatchedPath<'a>>) {
         self.matcher
             .file_set()
             .unwrap_or(&DEFAULT_WORK)
             .par_iter()
             .flat_map(|&filename| -> Option<_> {
                 // TODO normalization
                 let normalized = filename;
 
                 let buf = match hg_path_to_path_buf(normalized) {
                     Ok(x) => x,
                     Err(_) => {
                         return Some((
                             Cow::Borrowed(normalized),
                             INVALID_PATH_DISPATCH,
                         ))
                     }
                 };
                 let target = self.root_dir.join(buf);
                 let st = target.symlink_metadata();
                 let in_dmap = self.dmap.get(normalized);
                 match st {
                     Ok(meta) => {
                         let file_type = meta.file_type();
                         return if file_type.is_file() || file_type.is_symlink()
                         {
                             if let Some(entry) = in_dmap {
                                 return Some((
                                     Cow::Borrowed(normalized),
                                     dispatch_found(
                                         &normalized,
                                         *entry,
                                         HgMetadata::from_metadata(meta),
                                         &self.dmap.copy_map,
                                         self.options,
                                     ),
                                 ));
                             }
                             Some((
                                 Cow::Borrowed(normalized),
                                 Dispatch::Unknown,
                             ))
                         } else if file_type.is_dir() {
                             if self.options.collect_traversed_dirs {
                                 traversed_sender
                                     .send(normalized.to_owned())
                                     .expect("receiver should outlive sender");
                             }
                             Some((
                                 Cow::Borrowed(normalized),
                                 Dispatch::Directory {
                                     was_file: in_dmap.is_some(),
                                 },
                             ))
                         } else {
                             Some((
                                 Cow::Borrowed(normalized),
                                 Dispatch::Bad(BadMatch::BadType(
                                     // TODO do more than unknown
                                     // Support for all `BadType` variant
                                     // varies greatly between platforms.
                                     // So far, no tests check the type and
                                     // this should be good enough for most
                                     // users.
                                     BadType::Unknown,
                                 )),
                             ))
                         };
                     }
                     Err(_) => {
                         if let Some(entry) = in_dmap {
                             return Some((
                                 Cow::Borrowed(normalized),
                                 dispatch_missing(entry.state),
                             ));
                         }
                     }
                 };
                 None
             })
             .partition(|(_, dispatch)| match dispatch {
                 Dispatch::Directory { .. } => true,
                 _ => false,
             })
     }
 
     /// Walk the working directory recursively to look for changes compared to
     /// the current `DirstateMap`.
     ///
     /// This takes a mutable reference to the results to account for the
     /// `extend` in timings
     #[timed]
     pub fn traverse(
         &self,
         path: impl AsRef<HgPath>,
         old_results: &FastHashMap<HgPathCow<'a>, Dispatch>,
         results: &mut Vec<DispatchedPath<'a>>,
         traversed_sender: crossbeam_channel::Sender<HgPathBuf>,
     ) {
         // The traversal is done in parallel, so use a channel to gather
         // entries. `crossbeam_channel::Sender` is `Sync`, while `mpsc::Sender`
         // is not.
         let (files_transmitter, files_receiver) =
             crossbeam_channel::unbounded();
 
         self.traverse_dir(
             &files_transmitter,
             path,
             &old_results,
             traversed_sender,
         );
 
         // Disconnect the channel so the receiver stops waiting
         drop(files_transmitter);
 
         let new_results = files_receiver
             .into_iter()
             .par_bridge()
             .map(|(f, d)| (Cow::Owned(f), d));
 
         results.par_extend(new_results);
     }
 
     /// Dispatch a single entry (file, folder, symlink...) found during
     /// `traverse`. If the entry is a folder that needs to be traversed, it
     /// will be handled in a separate thread.
     fn handle_traversed_entry<'b>(
         &'a self,
         scope: &rayon::Scope<'b>,
         files_sender: &'b crossbeam_channel::Sender<(HgPathBuf, Dispatch)>,
         old_results: &'a FastHashMap<Cow<HgPath>, Dispatch>,
         filename: HgPathBuf,
         dir_entry: DirEntry,
         traversed_sender: crossbeam_channel::Sender<HgPathBuf>,
     ) -> IoResult<()>
     where
         'a: 'b,
     {
         let file_type = dir_entry.file_type()?;
         let entry_option = self.dmap.get(&filename);
 
         if filename.as_bytes() == b".hg" {
             // Could be a directory or a symlink
             return Ok(());
         }
 
         if file_type.is_dir() {
             self.handle_traversed_dir(
                 scope,
                 files_sender,
                 old_results,
                 entry_option,
                 filename,
                 traversed_sender,
             );
         } else if file_type.is_file() || file_type.is_symlink() {
             if let Some(entry) = entry_option {
                 if self.matcher.matches_everything()
                     || self.matcher.matches(&filename)
                 {
                     let metadata = dir_entry.metadata()?;
                     files_sender
                         .send((
                             filename.to_owned(),
                             dispatch_found(
                                 &filename,
                                 *entry,
                                 HgMetadata::from_metadata(metadata),
                                 &self.dmap.copy_map,
                                 self.options,
                             ),
                         ))
                         .unwrap();
                 }
             } else if (self.matcher.matches_everything()
                 || self.matcher.matches(&filename))
                 && !self.is_ignored(&filename)
             {
                 if (self.options.list_ignored
                     || self.matcher.exact_match(&filename))
                     && self.dir_ignore(&filename)
                 {
                     if self.options.list_ignored {
                         files_sender
                             .send((filename.to_owned(), Dispatch::Ignored))
                             .unwrap();
                     }
                 } else if self.options.list_unknown {
                     files_sender
                         .send((filename.to_owned(), Dispatch::Unknown))
                         .unwrap();
                 }
             } else if self.is_ignored(&filename) && self.options.list_ignored {
-                files_sender
-                    .send((filename.to_owned(), Dispatch::Ignored))
-                    .unwrap();
+                if self.matcher.matches(&filename) {
+                    files_sender
+                        .send((filename.to_owned(), Dispatch::Ignored))
+                        .unwrap();
+                }
             }
         } else if let Some(entry) = entry_option {
             // Used to be a file or a folder, now something else.
             if self.matcher.matches_everything()
                 || self.matcher.matches(&filename)
             {
                 files_sender
                     .send((filename.to_owned(), dispatch_missing(entry.state)))
                     .unwrap();
             }
         }
 
         Ok(())
     }
 
     /// A directory was found in the filesystem and needs to be traversed
     fn handle_traversed_dir<'b>(
         &'a self,
         scope: &rayon::Scope<'b>,
         files_sender: &'b crossbeam_channel::Sender<(HgPathBuf, Dispatch)>,
         old_results: &'a FastHashMap<Cow<HgPath>, Dispatch>,
         entry_option: Option<&'a DirstateEntry>,
         directory: HgPathBuf,
         traversed_sender: crossbeam_channel::Sender<HgPathBuf>,
     ) where
         'a: 'b,
     {
         scope.spawn(move |_| {
             // Nested `if` until `rust-lang/rust#53668` is stable
             if let Some(entry) = entry_option {
                 // Used to be a file, is now a folder
                 if self.matcher.matches_everything()
                     || self.matcher.matches(&directory)
                 {
                     files_sender
                         .send((
                             directory.to_owned(),
                             dispatch_missing(entry.state),
                         ))
                         .unwrap();
                 }
             }
             // Do we need to traverse it?
             if !self.is_ignored(&directory) || self.options.list_ignored {
                 self.traverse_dir(
                     files_sender,
                     directory,
                     &old_results,
                     traversed_sender,
                 )
             }
         });
     }
 
     /// Decides whether the directory needs to be listed, and if so handles the
     /// entries in a separate thread.
     fn traverse_dir(
         &self,
         files_sender: &crossbeam_channel::Sender<(HgPathBuf, Dispatch)>,
         directory: impl AsRef<HgPath>,
         old_results: &FastHashMap<Cow<HgPath>, Dispatch>,
         traversed_sender: crossbeam_channel::Sender<HgPathBuf>,
     ) {
         let directory = directory.as_ref();
 
         if self.options.collect_traversed_dirs {
             traversed_sender
                 .send(directory.to_owned())
                 .expect("receiver should outlive sender");
         }
 
         let visit_entries = match self.matcher.visit_children_set(directory) {
             VisitChildrenSet::Empty => return,
             VisitChildrenSet::This | VisitChildrenSet::Recursive => None,
             VisitChildrenSet::Set(set) => Some(set),
         };
         let buf = match hg_path_to_path_buf(directory) {
             Ok(b) => b,
             Err(_) => {
                 files_sender
                     .send((directory.to_owned(), INVALID_PATH_DISPATCH))
                     .expect("receiver should outlive sender");
                 return;
             }
         };
         let dir_path = self.root_dir.join(buf);
 
         let skip_dot_hg = !directory.as_bytes().is_empty();
         let entries = match list_directory(dir_path, skip_dot_hg) {
             Err(e) => {
                 files_sender
                     .send((directory.to_owned(), dispatch_os_error(&e)))
                     .expect("receiver should outlive sender");
                 return;
             }
             Ok(entries) => entries,
         };
 
         rayon::scope(|scope| {
             for (filename, dir_entry) in entries {
                 if let Some(ref set) = visit_entries {
                     if !set.contains(filename.deref()) {
                         continue;
                     }
                 }
                 // TODO normalize
                 let filename = if directory.is_empty() {
                     filename.to_owned()
                 } else {
                     directory.join(&filename)
                 };
 
                 if !old_results.contains_key(filename.deref()) {
                     match self.handle_traversed_entry(
                         scope,
                         files_sender,
                         old_results,
                         filename,
                         dir_entry,
                         traversed_sender.clone(),
                     ) {
                         Err(e) => {
                             files_sender
                                 .send((
                                     directory.to_owned(),
                                     dispatch_os_error(&e),
                                 ))
                                 .expect("receiver should outlive sender");
                         }
                         Ok(_) => {}
                     }
                 }
             }
         })
     }
 
     /// Add the files in the dirstate to the results.
     ///
     /// This takes a mutable reference to the results to account for the
     /// `extend` in timings
     #[timed]
     pub fn extend_from_dmap(&self, results: &mut Vec<DispatchedPath<'a>>) {
         results.par_extend(
             self.dmap
                 .par_iter()
                 .filter(|(path, _)| self.matcher.matches(path))
                 .map(move |(filename, entry)| {
                     let filename: &HgPath = filename;
                     let filename_as_path = match hg_path_to_path_buf(filename)
                     {
                         Ok(f) => f,
                         Err(_) => {
                             return (
                                 Cow::Borrowed(filename),
                                 INVALID_PATH_DISPATCH,
                             )
                         }
                     };
                     let meta = self
                         .root_dir
                         .join(filename_as_path)
                         .symlink_metadata();
                     match meta {
                         Ok(m)
                             if !(m.file_type().is_file()
                                 || m.file_type().is_symlink()) =>
                         {
                             (
                                 Cow::Borrowed(filename),
                                 dispatch_missing(entry.state),
                             )
                         }
                         Ok(m) => (
                             Cow::Borrowed(filename),
                             dispatch_found(
                                 filename,
                                 *entry,
                                 HgMetadata::from_metadata(m),
                                 &self.dmap.copy_map,
                                 self.options,
                             ),
                         ),
                         Err(e)
                             if e.kind() == ErrorKind::NotFound
                                 || e.raw_os_error() == Some(20) =>
                         {
                             // Rust does not yet have an `ErrorKind` for
                             // `NotADirectory` (errno 20)
                             // It happens if the dirstate contains `foo/bar`
                             // and foo is not a
                             // directory
                             (
                                 Cow::Borrowed(filename),
                                 dispatch_missing(entry.state),
                             )
                         }
                         Err(e) => {
                             (Cow::Borrowed(filename), dispatch_os_error(&e))
                         }
                     }
                 }),
         );
     }
 
     /// Checks all files that are in the dirstate but were not found during the
     /// working directory traversal. This means that the rest must
     /// be either ignored, under a symlink or under a new nested repo.
     ///
     /// This takes a mutable reference to the results to account for the
     /// `extend` in timings
     #[timed]
     pub fn handle_unknowns(&self, results: &mut Vec<DispatchedPath<'a>>) {
         let to_visit: Vec<(&HgPath, &DirstateEntry)> =
             if results.is_empty() && self.matcher.matches_everything() {
                 self.dmap.iter().map(|(f, e)| (f.deref(), e)).collect()
             } else {
                 // Only convert to a hashmap if needed.
                 let old_results: FastHashMap<_, _> =
                     results.iter().cloned().collect();
                 self.dmap
                     .iter()
                     .filter_map(move |(f, e)| {
                         if !old_results.contains_key(f.deref())
                             && self.matcher.matches(f)
                         {
                             Some((f.deref(), e))
                         } else {
                             None
                         }
                     })
                     .collect()
             };
 
         let path_auditor = PathAuditor::new(&self.root_dir);
 
         let new_results = to_visit.into_par_iter().filter_map(
             |(filename, entry)| -> Option<_> {
                 // Report ignored items in the dmap as long as they are not
                 // under a symlink directory.
                 if path_auditor.check(filename) {
                     // TODO normalize for case-insensitive filesystems
                     let buf = match hg_path_to_path_buf(filename) {
                         Ok(x) => x,
                         Err(_) => {
                             return Some((
                                 Cow::Owned(filename.to_owned()),
                                 INVALID_PATH_DISPATCH,
                             ));
                         }
                     };
                     Some((
                         Cow::Owned(filename.to_owned()),
                         match self.root_dir.join(&buf).symlink_metadata() {
                             // File was just ignored, no links, and exists
                             Ok(meta) => {
                                 let metadata = HgMetadata::from_metadata(meta);
                                 dispatch_found(
                                     filename,
                                     *entry,
                                     metadata,
                                     &self.dmap.copy_map,
                                     self.options,
                                 )
                             }
                             // File doesn't exist
                             Err(_) => dispatch_missing(entry.state),
                         },
                     ))
                 } else {
                     // It's either missing or under a symlink directory which
                     // we, in this case, report as missing.
                     Some((
                         Cow::Owned(filename.to_owned()),
                         dispatch_missing(entry.state),
                     ))
                 }
             },
         );
 
         results.par_extend(new_results);
     }
 }
 
 #[timed]
 pub fn build_response<'a>(
     results: impl IntoIterator<Item = DispatchedPath<'a>>,
     traversed: Vec<HgPathBuf>,
 ) -> (Vec<HgPathCow<'a>>, DirstateStatus<'a>) {
     let mut lookup = vec![];
     let mut modified = vec![];
     let mut added = vec![];
     let mut removed = vec![];
     let mut deleted = vec![];
     let mut clean = vec![];
     let mut ignored = vec![];
     let mut unknown = vec![];
     let mut bad = vec![];
 
     for (filename, dispatch) in results.into_iter() {
         match dispatch {
             Dispatch::Unknown => unknown.push(filename),
             Dispatch::Unsure => lookup.push(filename),
             Dispatch::Modified => modified.push(filename),
             Dispatch::Added => added.push(filename),
             Dispatch::Removed => removed.push(filename),
             Dispatch::Deleted => deleted.push(filename),
             Dispatch::Clean => clean.push(filename),
             Dispatch::Ignored => ignored.push(filename),
             Dispatch::None => {}
             Dispatch::Bad(reason) => bad.push((filename, reason)),
             Dispatch::Directory { .. } => {}
         }
     }
 
     (
         lookup,
         DirstateStatus {
             modified,
             added,
             removed,
             deleted,
             clean,
             ignored,
             unknown,
             bad,
             traversed,
         },
     )
 }
 
 /// Get the status of files in the working directory.
 ///
 /// This is the current entry-point for `hg-core` and is realistically unusable
 /// outside of a Python context because its arguments need to provide a lot of
 /// information that will not be necessary in the future.
 #[timed]
 pub fn status<'a>(
     dmap: &'a DirstateMap,
     matcher: &'a (impl Matcher + Sync),
     root_dir: PathBuf,
     ignore_files: Vec<PathBuf>,
     options: StatusOptions,
 ) -> StatusResult<(
     (Vec<HgPathCow<'a>>, DirstateStatus<'a>),
     Vec<PatternFileWarning>,
 )> {
     let (status, warnings) =
         Status::new(dmap, matcher, root_dir, ignore_files, options)?;
 
     Ok((status.run()?, warnings))
 }

tests/test-status.t

@@ -1,711 +1,710 b''
   $ hg init repo1
   $ cd repo1
   $ mkdir a b a/1 b/1 b/2
   $ touch in_root a/in_a b/in_b a/1/in_a_1 b/1/in_b_1 b/2/in_b_2
 
 hg status in repo root:
 
   $ hg status
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
 
 hg status . in repo root:
 
   $ hg status .
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
 
   $ hg status --cwd a
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd a .
   ? 1/in_a_1
   ? in_a
   $ hg status --cwd a ..
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root
 
   $ hg status --cwd b
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd b .
   ? 1/in_b_1
   ? 2/in_b_2
   ? in_b
   $ hg status --cwd b ..
   ? ../a/1/in_a_1
   ? ../a/in_a
   ? 1/in_b_1
   ? 2/in_b_2
   ? in_b
   ? ../in_root
 
   $ hg status --cwd a/1
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd a/1 .
   ? in_a_1
   $ hg status --cwd a/1 ..
   ? in_a_1
   ? ../in_a
 
   $ hg status --cwd b/1
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd b/1 .
   ? in_b_1
   $ hg status --cwd b/1 ..
   ? in_b_1
   ? ../2/in_b_2
   ? ../in_b
 
   $ hg status --cwd b/2
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd b/2 .
   ? in_b_2
   $ hg status --cwd b/2 ..
   ? ../1/in_b_1
   ? in_b_2
   ? ../in_b
 
 combining patterns with root and patterns without a root works
 
   $ hg st a/in_a re:.*b$
   ? a/in_a
   ? b/in_b
 
 tweaking defaults works
   $ hg status --cwd a --config ui.tweakdefaults=yes
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root
   $ HGPLAIN=1 hg status --cwd a --config ui.tweakdefaults=yes
   ? a/1/in_a_1 (glob)
   ? a/in_a (glob)
   ? b/1/in_b_1 (glob)
   ? b/2/in_b_2 (glob)
   ? b/in_b (glob)
   ? in_root
   $ HGPLAINEXCEPT=tweakdefaults hg status --cwd a --config ui.tweakdefaults=yes
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root (glob)
 
 relative paths can be requested
 
   $ hg status --cwd a --config ui.relative-paths=yes
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root
 
   $ hg status --cwd a . --config ui.relative-paths=legacy
   ? 1/in_a_1
   ? in_a
   $ hg status --cwd a . --config ui.relative-paths=no
   ? a/1/in_a_1
   ? a/in_a
 
 commands.status.relative overrides ui.relative-paths
 
   $ cat >> $HGRCPATH <<EOF
   > [ui]
   > relative-paths = False
   > [commands]
   > status.relative = True
   > EOF
   $ hg status --cwd a
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root
   $ HGPLAIN=1 hg status --cwd a
   ? a/1/in_a_1 (glob)
   ? a/in_a (glob)
   ? b/1/in_b_1 (glob)
   ? b/2/in_b_2 (glob)
   ? b/in_b (glob)
   ? in_root
 
 if relative paths are explicitly off, tweakdefaults doesn't change it
   $ cat >> $HGRCPATH <<EOF
   > [commands]
   > status.relative = False
   > EOF
   $ hg status --cwd a --config ui.tweakdefaults=yes
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
 
   $ cd ..
 
   $ hg init repo2
   $ cd repo2
   $ touch modified removed deleted ignored
   $ echo "^ignored$" > .hgignore
   $ hg ci -A -m 'initial checkin'
   adding .hgignore
   adding deleted
   adding modified
   adding removed
   $ touch modified added unknown ignored
   $ hg add added
   $ hg remove removed
   $ rm deleted
 
 hg status:
 
   $ hg status
   A added
   R removed
   ! deleted
   ? unknown
 
 hg status modified added removed deleted unknown never-existed ignored:
 
   $ hg status modified added removed deleted unknown never-existed ignored
   never-existed: * (glob)
   A added
   R removed
   ! deleted
   ? unknown
 
   $ hg copy modified copied
 
 hg status -C:
 
   $ hg status -C
   A added
   A copied
     modified
   R removed
   ! deleted
   ? unknown
 
 hg status -A:
 
   $ hg status -A
   A added
   A copied
     modified
   R removed
   ! deleted
   ? unknown
   I ignored
   C .hgignore
   C modified
 
   $ hg status -A -T '{status} {path} {node|shortest}\n'
   A added ffff
   A copied ffff
   R removed ffff
   ! deleted ffff
   ? unknown ffff
   I ignored ffff
   C .hgignore ffff
   C modified ffff
 
   $ hg status -A -Tjson
   [
    {
     "itemtype": "file",
     "path": "added",
     "status": "A"
    },
    {
     "itemtype": "file",
     "path": "copied",
     "source": "modified",
     "status": "A"
    },
    {
     "itemtype": "file",
     "path": "removed",
     "status": "R"
    },
    {
     "itemtype": "file",
     "path": "deleted",
     "status": "!"
    },
    {
     "itemtype": "file",
     "path": "unknown",
     "status": "?"
    },
    {
     "itemtype": "file",
     "path": "ignored",
     "status": "I"
    },
    {
     "itemtype": "file",
     "path": ".hgignore",
     "status": "C"
    },
    {
     "itemtype": "file",
     "path": "modified",
     "status": "C"
    }
   ]
 
   $ hg status -A -Tpickle > pickle
   >>> from __future__ import print_function
   >>> from mercurial import util
   >>> pickle = util.pickle
   >>> data = sorted((x[b'status'].decode(), x[b'path'].decode()) for x in pickle.load(open("pickle", r"rb")))
   >>> for s, p in data: print("%s %s" % (s, p))
   ! deleted
   ? pickle
   ? unknown
   A added
   A copied
   C .hgignore
   C modified
   I ignored
   R removed
   $ rm pickle
 
   $ echo "^ignoreddir$" > .hgignore
   $ mkdir ignoreddir
   $ touch ignoreddir/file
 
 Test templater support:
 
   $ hg status -AT "[{status}]\t{if(source, '{source} -> ')}{path}\n"
   [M]	.hgignore
   [A]	added
   [A]	modified -> copied
   [R]	removed
   [!]	deleted
   [?]	ignored
   [?]	unknown
   [I]	ignoreddir/file
   [C]	modified
   $ hg status -AT default
   M .hgignore
   A added
   A copied
     modified
   R removed
   ! deleted
   ? ignored
   ? unknown
   I ignoreddir/file
   C modified
   $ hg status -T compact
   abort: "status" not in template map
   [255]
 
 hg status ignoreddir/file:
 
   $ hg status ignoreddir/file
 
 hg status -i ignoreddir/file:
 
   $ hg status -i ignoreddir/file
   I ignoreddir/file
   $ cd ..
 
 Check 'status -q' and some combinations
 
   $ hg init repo3
   $ cd repo3
   $ touch modified removed deleted ignored
   $ echo "^ignored$" > .hgignore
   $ hg commit -A -m 'initial checkin'
   adding .hgignore
   adding deleted
   adding modified
   adding removed
   $ touch added unknown ignored
   $ hg add added
   $ echo "test" >> modified
   $ hg remove removed
   $ rm deleted
   $ hg copy modified copied
 
 Specify working directory revision explicitly, that should be the same as
 "hg status"
 
   $ hg status --change "wdir()"
   M modified
   A added
   A copied
   R removed
   ! deleted
   ? unknown
 
 Run status with 2 different flags.
 Check if result is the same or different.
 If result is not as expected, raise error
 
   $ assert() {
   >     hg status $1 > ../a
   >     hg status $2 > ../b
   >     if diff ../a ../b > /dev/null; then
   >         out=0
   >     else
   >         out=1
   >     fi
   >     if [ $3 -eq 0 ]; then
   >         df="same"
   >     else
   >         df="different"
   >     fi
   >     if [ $out -ne $3 ]; then
   >         echo "Error on $1 and $2, should be $df."
   >     fi
   > }
 
 Assert flag1 flag2 [0-same | 1-different]
 
   $ assert "-q" "-mard"      0
   $ assert "-A" "-marduicC"  0
   $ assert "-qA" "-mardcC"   0
   $ assert "-qAui" "-A"      0
   $ assert "-qAu" "-marducC" 0
   $ assert "-qAi" "-mardicC" 0
   $ assert "-qu" "-u"        0
   $ assert "-q" "-u"         1
   $ assert "-m" "-a"         1
   $ assert "-r" "-d"         1
   $ cd ..
 
   $ hg init repo4
   $ cd repo4
   $ touch modified removed deleted
   $ hg ci -q -A -m 'initial checkin'
   $ touch added unknown
   $ hg add added
   $ hg remove removed
   $ rm deleted
   $ echo x > modified
   $ hg copy modified copied
   $ hg ci -m 'test checkin' -d "1000001 0"
   $ rm *
   $ touch unrelated
   $ hg ci -q -A -m 'unrelated checkin' -d "1000002 0"
 
 hg status --change 1:
 
   $ hg status --change 1
   M modified
   A added
   A copied
   R removed
 
 hg status --change 1 unrelated:
 
   $ hg status --change 1 unrelated
 
 hg status -C --change 1 added modified copied removed deleted:
 
   $ hg status -C --change 1 added modified copied removed deleted
   M modified
   A added
   A copied
     modified
   R removed
 
 hg status -A --change 1 and revset:
 
   $ hg status -A --change '1|1'
   M modified
   A added
   A copied
     modified
   R removed
   C deleted
 
   $ cd ..
 
 hg status with --rev and reverted changes:
 
   $ hg init reverted-changes-repo
   $ cd reverted-changes-repo
   $ echo a > file
   $ hg add file
   $ hg ci -m a
   $ echo b > file
   $ hg ci -m b
 
 reverted file should appear clean
 
   $ hg revert -r 0 .
   reverting file
   $ hg status -A --rev 0
   C file
 
 #if execbit
 reverted file with changed flag should appear modified
 
   $ chmod +x file
   $ hg status -A --rev 0
   M file
 
   $ hg revert -r 0 .
   reverting file
 
 reverted and committed file with changed flag should appear modified
 
   $ hg co -C .
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ chmod +x file
   $ hg ci -m 'change flag'
   $ hg status -A --rev 1 --rev 2
   M file
   $ hg diff -r 1 -r 2
 
 #endif
 
   $ cd ..
 
 hg status of binary file starting with '\1\n', a separator for metadata:
 
   $ hg init repo5
   $ cd repo5
   >>> open("010a", r"wb").write(b"\1\nfoo") and None
   $ hg ci -q -A -m 'initial checkin'
   $ hg status -A
   C 010a
 
   >>> open("010a", r"wb").write(b"\1\nbar") and None
   $ hg status -A
   M 010a
   $ hg ci -q -m 'modify 010a'
   $ hg status -A --rev 0:1
   M 010a
 
   $ touch empty
   $ hg ci -q -A -m 'add another file'
   $ hg status -A --rev 1:2 010a
   C 010a
 
   $ cd ..
 
 test "hg status" with "directory pattern" which matches against files
 only known on target revision.
 
   $ hg init repo6
   $ cd repo6
 
   $ echo a > a.txt
   $ hg add a.txt
   $ hg commit -m '#0'
   $ mkdir -p 1/2/3/4/5
   $ echo b > 1/2/3/4/5/b.txt
   $ hg add 1/2/3/4/5/b.txt
   $ hg commit -m '#1'
 
   $ hg update -C 0 > /dev/null
   $ hg status -A
   C a.txt
 
 the directory matching against specified pattern should be removed,
 because directory existence prevents 'dirstate.walk()' from showing
 warning message about such pattern.
 
   $ test ! -d 1
   $ hg status -A --rev 1 1/2/3/4/5/b.txt
   R 1/2/3/4/5/b.txt
   $ hg status -A --rev 1 1/2/3/4/5
   R 1/2/3/4/5/b.txt
   $ hg status -A --rev 1 1/2/3
   R 1/2/3/4/5/b.txt
   $ hg status -A --rev 1 1
   R 1/2/3/4/5/b.txt
 
   $ hg status --config ui.formatdebug=True --rev 1 1
   status = [
       {
           'itemtype': 'file',
           'path': '1/2/3/4/5/b.txt',
           'status': 'R'
       },
   ]
 
 #if windows
   $ hg --config ui.slash=false status -A --rev 1 1
   R 1\2\3\4\5\b.txt
 #endif
 
   $ cd ..
 
 Status after move overwriting a file (issue4458)
 =================================================
 
 
   $ hg init issue4458
   $ cd issue4458
   $ echo a > a
   $ echo b > b
   $ hg commit -Am base
   adding a
   adding b
 
 
 with --force
 
   $ hg mv b --force a
   $ hg st --copies
   M a
     b
   R b
   $ hg revert --all
   reverting a
   undeleting b
   $ rm *.orig
 
 without force
 
   $ hg rm a
   $ hg st --copies
   R a
   $ hg mv b a
   $ hg st --copies
   M a
     b
   R b
 
 using ui.statuscopies setting
   $ hg st --config ui.statuscopies=true
   M a
     b
   R b
   $ hg st --config ui.statuscopies=false
   M a
   R b
   $ hg st --config ui.tweakdefaults=yes
   M a
     b
   R b
 
 using log status template (issue5155)
   $ hg log -Tstatus -r 'wdir()' -C
   changeset:   2147483647:ffffffffffff
   parent:      0:8c55c58b4c0e
   user:        test
   date:        * (glob)
   files:
   M a
     b
   R b
   
   $ hg log -GTstatus -r 'wdir()' -C
   o  changeset:   2147483647:ffffffffffff
   |  parent:      0:8c55c58b4c0e
   ~  user:        test
      date:        * (glob)
      files:
      M a
        b
      R b
   
 
 Other "bug" highlight, the revision status does not report the copy information.
 This is buggy behavior.
 
   $ hg commit -m 'blah'
   $ hg st --copies --change .
   M a
   R b
 
 using log status template, the copy information is displayed correctly.
   $ hg log -Tstatus -r. -C
   changeset:   1:6685fde43d21
   tag:         tip
   user:        test
   date:        * (glob)
   summary:     blah
   files:
   M a
     b
   R b
   
 
   $ cd ..
 
 Make sure .hg doesn't show up even as a symlink
 
   $ hg init repo0
   $ mkdir symlink-repo0
   $ cd symlink-repo0
   $ ln -s ../repo0/.hg
   $ hg status
 
 Check using include flag with pattern when status does not need to traverse
 the working directory (issue6483)
 
   $ cd ..
   $ hg init issue6483
   $ cd issue6483
   $ touch a.py b.rs
   $ hg add a.py b.rs
   $ hg st -aI "*.py"
   A a.py
 
 Check using include flag while listing ignored composes correctly (issue6514)
 
   $ cd ..
   $ hg init issue6514
   $ cd issue6514
   $ mkdir ignored-folder
   $ touch A.hs B.hs C.hs ignored-folder/other.txt ignored-folder/ctest.hs
   $ cat >.hgignore <<EOF
   > A.hs
   > B.hs
   > ignored-folder/
   > EOF
   $ hg st -i -I 're:.*\.hs$'
   I A.hs
   I B.hs
   I ignored-folder/ctest.hs
-  I ignored-folder/other.txt (known-bad-output rust !)