rust-status: rename `StatusResult` to `DirstateStatus`

"Result" has a special meaning in the Rust world, this should be clearer.

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

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

@@ -1,321 +1,321
 // 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::{
     dirstate::SIZE_FROM_OTHER_PARENT,
     matchers::Matcher,
     utils::{
         files::HgMetadata,
         hg_path::{
             hg_path_to_path_buf, os_string_to_hg_path_buf, HgPath, HgPathBuf,
         },
     },
     CopyMap, DirstateEntry, DirstateMap, EntryState,
 };
 use rayon::prelude::*;
 use std::collections::HashSet;
 use std::fs::{read_dir, DirEntry};
 use std::path::Path;
 
 /// Marker 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.
 enum Dispatch {
     Unsure,
     Modified,
     Added,
     Removed,
     Deleted,
     Clean,
     Unknown,
 }
 
 type IoResult<T> = std::io::Result<T>;
 
 /// 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((HgPathBuf::from(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())
             {
                 Dispatch::Modified
             } else if mod_compare(mtime, st_mtime as i32) {
                 Dispatch::Unsure
             } else if 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::Unknown
             }
         }
         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,
     }
 }
 
 /// Get stat data about the files explicitly specified by match.
 /// TODO subrepos
 fn walk_explicit<'a>(
     files: &'a HashSet<&HgPath>,
     dmap: &'a DirstateMap,
     root_dir: impl AsRef<Path> + Sync + Send,
     options: StatusOptions,
 ) -> impl ParallelIterator<Item = IoResult<(&'a HgPath, Dispatch)>> {
     files.par_iter().filter_map(move |filename| {
         // TODO normalization
         let normalized = filename.as_ref();
 
         let buf = match hg_path_to_path_buf(normalized) {
             Ok(x) => x,
             Err(e) => return Some(Err(e.into())),
         };
         let target = root_dir.as_ref().join(buf);
         let st = target.symlink_metadata();
         match st {
             Ok(meta) => {
                 let file_type = meta.file_type();
                 if file_type.is_file() || file_type.is_symlink() {
                     if let Some(entry) = dmap.get(normalized) {
                         return Some(Ok((
                             normalized,
                             dispatch_found(
                                 &normalized,
                                 *entry,
                                 HgMetadata::from_metadata(meta),
                                 &dmap.copy_map,
                                 options,
                             ),
                         )));
                     }
                 } else {
                     if dmap.contains_key(normalized) {
                         return Some(Ok((normalized, Dispatch::Removed)));
                     }
                 }
             }
             Err(_) => {
                 if let Some(entry) = dmap.get(normalized) {
                     return Some(Ok((
                         normalized,
                         dispatch_missing(entry.state),
                     )));
                 }
             }
         };
         None
     })
 }
 
 #[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,
 }
 
 /// Stat all entries in the `DirstateMap` and mark them for dispatch into
 /// the relevant collections.
 fn stat_dmap_entries(
     dmap: &DirstateMap,
     root_dir: impl AsRef<Path> + Sync + Send,
     options: StatusOptions,
 ) -> impl ParallelIterator<Item = IoResult<(&HgPath, Dispatch)>> {
     dmap.par_iter().map(move |(filename, entry)| {
         let filename: &HgPath = filename;
         let filename_as_path = hg_path_to_path_buf(filename)?;
         let meta = root_dir.as_ref().join(filename_as_path).symlink_metadata();
 
         match meta {
             Ok(ref m)
                 if !(m.file_type().is_file()
                     || m.file_type().is_symlink()) =>
             {
                 Ok((filename, dispatch_missing(entry.state)))
             }
             Ok(m) => Ok((
                 filename,
                 dispatch_found(
                     filename,
                     *entry,
                     HgMetadata::from_metadata(m),
                     &dmap.copy_map,
                     options,
                 ),
             )),
             Err(ref e)
                 if e.kind() == std::io::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
                 Ok((filename, dispatch_missing(entry.state)))
             }
             Err(e) => Err(e),
         }
     })
 }
 
-pub struct StatusResult<'a> {
+pub struct DirstateStatus<'a> {
     pub modified: Vec<&'a HgPath>,
     pub added: Vec<&'a HgPath>,
     pub removed: Vec<&'a HgPath>,
     pub deleted: Vec<&'a HgPath>,
     pub clean: Vec<&'a HgPath>,
     /* TODO ignored
      * TODO unknown */
 }
 
 fn build_response<'a>(
     results: impl IntoIterator<Item = IoResult<(&'a HgPath, Dispatch)>>,
-) -> IoResult<(Vec<&'a HgPath>, StatusResult<'a>)> {
+) -> IoResult<(Vec<&'a HgPath>, 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![];
 
     for res in results.into_iter() {
         let (filename, dispatch) = res?;
         match dispatch {
             Dispatch::Unknown => {}
             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),
         }
     }
 
     Ok((
         lookup,
-        StatusResult {
+        DirstateStatus {
             modified,
             added,
             removed,
             deleted,
             clean,
         },
     ))
 }
 
 pub fn status<'a: 'c, 'b: 'c, 'c>(
     dmap: &'a DirstateMap,
     matcher: &'b impl Matcher,
     root_dir: impl AsRef<Path> + Sync + Send + Copy,
     options: StatusOptions,
-) -> IoResult<(Vec<&'c HgPath>, StatusResult<'c>)> {
+) -> IoResult<(Vec<&'c HgPath>, DirstateStatus<'c>)> {
     let files = matcher.file_set();
     let mut results = vec![];
     if let Some(files) = files {
         results.par_extend(walk_explicit(&files, &dmap, root_dir, options));
     }
 
     if !matcher.is_exact() {
         let stat_results = stat_dmap_entries(&dmap, root_dir, options);
         results.par_extend(stat_results);
     }
 
     build_response(results)
 }

rust/hg-core/src/lib.rs

@@ -1,184 +1,184
 // Copyright 2018-2020 Georges Racinet <[e-mail]>
 //           and Mercurial contributors
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 mod ancestors;
 pub mod dagops;
 pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};
 mod dirstate;
 pub mod discovery;
 pub mod testing; // unconditionally built, for use from integration tests
 pub use dirstate::{
     dirs_multiset::{DirsMultiset, DirsMultisetIter},
     dirstate_map::DirstateMap,
     parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},
-    status::{status, StatusOptions, StatusResult},
+    status::{status, DirstateStatus, StatusOptions},
     CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState,
     StateMap, StateMapIter,
 };
 mod filepatterns;
 pub mod matchers;
 pub mod revlog;
 pub use revlog::*;
 #[cfg(feature = "with-re2")]
 pub mod re2;
 pub mod utils;
 
 use crate::utils::hg_path::{HgPathBuf, HgPathError};
 pub use filepatterns::{
     parse_pattern_syntax, read_pattern_file, IgnorePattern,
     PatternFileWarning, PatternSyntax,
 };
 use std::collections::HashMap;
 use twox_hash::RandomXxHashBuilder64;
 
 pub type LineNumber = usize;
 
 /// Rust's default hasher is too slow because it tries to prevent collision
 /// attacks. We are not concerned about those: if an ill-minded person has
 /// write access to your repository, you have other issues.
 pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>;
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum DirstateParseError {
     TooLittleData,
     Overflow,
     CorruptedEntry(String),
     Damaged,
 }
 
 impl From<std::io::Error> for DirstateParseError {
     fn from(e: std::io::Error) -> Self {
         DirstateParseError::CorruptedEntry(e.to_string())
     }
 }
 
 impl ToString for DirstateParseError {
     fn to_string(&self) -> String {
         use crate::DirstateParseError::*;
         match self {
             TooLittleData => "Too little data for dirstate.".to_string(),
             Overflow => "Overflow in dirstate.".to_string(),
             CorruptedEntry(e) => format!("Corrupted entry: {:?}.", e),
             Damaged => "Dirstate appears to be damaged.".to_string(),
         }
     }
 }
 
 #[derive(Debug, PartialEq)]
 pub enum DirstatePackError {
     CorruptedEntry(String),
     CorruptedParent,
     BadSize(usize, usize),
 }
 
 impl From<std::io::Error> for DirstatePackError {
     fn from(e: std::io::Error) -> Self {
         DirstatePackError::CorruptedEntry(e.to_string())
     }
 }
 #[derive(Debug, PartialEq)]
 pub enum DirstateMapError {
     PathNotFound(HgPathBuf),
     EmptyPath,
     InvalidPath(HgPathError),
 }
 
 impl ToString for DirstateMapError {
     fn to_string(&self) -> String {
         match self {
             DirstateMapError::PathNotFound(_) => {
                 "expected a value, found none".to_string()
             }
             DirstateMapError::EmptyPath => "Overflow in dirstate.".to_string(),
             DirstateMapError::InvalidPath(e) => e.to_string(),
         }
     }
 }
 
 pub enum DirstateError {
     Parse(DirstateParseError),
     Pack(DirstatePackError),
     Map(DirstateMapError),
     IO(std::io::Error),
 }
 
 impl From<DirstateParseError> for DirstateError {
     fn from(e: DirstateParseError) -> Self {
         DirstateError::Parse(e)
     }
 }
 
 impl From<DirstatePackError> for DirstateError {
     fn from(e: DirstatePackError) -> Self {
         DirstateError::Pack(e)
     }
 }
 
 #[derive(Debug)]
 pub enum PatternError {
     Path(HgPathError),
     UnsupportedSyntax(String),
     UnsupportedSyntaxInFile(String, String, usize),
     TooLong(usize),
     IO(std::io::Error),
     /// Needed a pattern that can be turned into a regex but got one that
     /// can't. This should only happen through programmer error.
     NonRegexPattern(IgnorePattern),
     /// This is temporary, see `re2/mod.rs`.
     /// This will cause a fallback to Python.
     Re2NotInstalled,
 }
 
 impl ToString for PatternError {
     fn to_string(&self) -> String {
         match self {
             PatternError::UnsupportedSyntax(syntax) => {
                 format!("Unsupported syntax {}", syntax)
             }
             PatternError::UnsupportedSyntaxInFile(syntax, file_path, line) => {
                 format!(
                     "{}:{}: unsupported syntax {}",
                     file_path, line, syntax
                 )
             }
             PatternError::TooLong(size) => {
                 format!("matcher pattern is too long ({} bytes)", size)
             }
             PatternError::IO(e) => e.to_string(),
             PatternError::Path(e) => e.to_string(),
             PatternError::NonRegexPattern(pattern) => {
                 format!("'{:?}' cannot be turned into a regex", pattern)
             }
             PatternError::Re2NotInstalled => {
                 "Re2 is not installed, cannot use regex functionality."
                     .to_string()
             }
         }
     }
 }
 
 impl From<DirstateMapError> for DirstateError {
     fn from(e: DirstateMapError) -> Self {
         DirstateError::Map(e)
     }
 }
 
 impl From<std::io::Error> for DirstateError {
     fn from(e: std::io::Error) -> Self {
         DirstateError::IO(e)
     }
 }
 
 impl From<std::io::Error> for PatternError {
     fn from(e: std::io::Error) -> Self {
         PatternError::IO(e)
     }
 }
 
 impl From<HgPathError> for PatternError {
     fn from(e: HgPathError) -> Self {
         PatternError::Path(e)
     }
 }

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

@@ -1,129 +1,129
 // 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.
 
 //! Bindings for the `hg::status` module provided by the
 //! `hg-core` crate. From Python, this will be seen as
 //! `rustext.dirstate.status`.
 
 use crate::dirstate::DirstateMap;
 use cpython::exc::ValueError;
 use cpython::{
     ObjectProtocol, PyBytes, PyErr, PyList, PyObject, PyResult, PyTuple,
     Python, PythonObject, ToPyObject,
 };
 use hg::utils::hg_path::HgPathBuf;
 use hg::{
     matchers::{AlwaysMatcher, FileMatcher},
     status,
     utils::{files::get_path_from_bytes, hg_path::HgPath},
-    StatusResult,
+    DirstateStatus,
 };
 use std::borrow::Borrow;
 
 /// This will be useless once trait impls for collection are added to `PyBytes`
 /// upstream.
 fn collect_pybytes_list<P: AsRef<HgPath>>(
     py: Python,
     collection: &[P],
 ) -> PyList {
     let list = PyList::new(py, &[]);
 
     for (i, path) in collection.iter().enumerate() {
         list.insert(
             py,
             i,
             PyBytes::new(py, path.as_ref().as_bytes()).into_object(),
         )
     }
 
     list
 }
 
 pub fn status_wrapper(
     py: Python,
     dmap: DirstateMap,
     matcher: PyObject,
     root_dir: PyObject,
     list_clean: bool,
     last_normal_time: i64,
     check_exec: bool,
 ) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> {
     let bytes = root_dir.extract::<PyBytes>(py)?;
     let root_dir = get_path_from_bytes(bytes.data(py));
 
     let dmap: DirstateMap = dmap.to_py_object(py);
     let dmap = dmap.get_inner(py);
 
     match matcher.get_type(py).name(py).borrow() {
         "alwaysmatcher" => {
             let matcher = AlwaysMatcher;
             let (lookup, status_res) = status(
                 &dmap,
                 &matcher,
                 &root_dir,
                 list_clean,
                 last_normal_time,
                 check_exec,
             )
             .map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
             build_response(lookup, status_res, py)
         }
         "exactmatcher" => {
             let files = matcher.call_method(
                 py,
                 "files",
                 PyTuple::new(py, &[]),
                 None,
             )?;
             let files: PyList = files.cast_into(py)?;
             let files: PyResult<Vec<HgPathBuf>> = files
                 .iter(py)
                 .map(|f| {
                     Ok(HgPathBuf::from_bytes(
                         f.extract::<PyBytes>(py)?.data(py),
                     ))
                 })
                 .collect();
 
             let files = files?;
             let matcher = FileMatcher::new(&files)
                 .map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
             let (lookup, status_res) = status(
                 &dmap,
                 &matcher,
                 &root_dir,
                 list_clean,
                 last_normal_time,
                 check_exec,
             )
             .map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
             build_response(lookup, status_res, py)
         }
         e => {
             return Err(PyErr::new::<ValueError, _>(
                 py,
                 format!("Unsupported matcher {}", e),
             ));
         }
     }
 }
 
 fn build_response(
     lookup: Vec<&HgPath>,
-    status_res: StatusResult,
+    status_res: DirstateStatus,
     py: Python,
 ) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> {
     let modified = collect_pybytes_list(py, status_res.modified.as_ref());
     let added = collect_pybytes_list(py, status_res.added.as_ref());
     let removed = collect_pybytes_list(py, status_res.removed.as_ref());
     let deleted = collect_pybytes_list(py, status_res.deleted.as_ref());
     let clean = collect_pybytes_list(py, status_res.clean.as_ref());
     let lookup = collect_pybytes_list(py, lookup.as_ref());
     let unknown = PyList::new(py, &[]);
 
     Ok((lookup, modified, added, removed, deleted, unknown, clean))
 }