This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10749

dirstate-v2: Make more APIs fallible, returning Result
ClosedPublic

Authored by SimonSapin on May 19 2021, 12:37 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGed1583a845d2: dirstate-v2: Make more APIs fallible, returning Result
Summary

When parsing becomes lazy, parse error will potentially happen in more places.
This propagates such errors to callers.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.May 19 2021, 12:37 PM
baymax updated this revision to Diff 28173.May 21 2021, 4:37 AM

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

Alphare added a subscriber: Alphare.May 21 2021, 5:47 AM
Alphare added inline comments.
rust/hg-core/src/dirstate.rs
80–85

Getting to 5 lines-high type declaration without Futures is a feat!

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

Isn't there such an iterator in itertools already? Since we depend on it anyway.

SimonSapin added inline comments.May 21 2021, 8:06 AM
rust/hg-core/src/dirstate.rs
80–85

Oh I hadn’t checked what rustfmt had done to this. Do you think it’d be better with separate type definitions for iterated items, in order to keep each definition on one line?

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

I don’t find exactly this. https://docs.rs/itertools/0.10.0/itertools/trait.Itertools.html#method.filter_map_ok is close but requires the callback to be infallible, whereas we want to potentially emit new errors while filtering/mapping.

baymax updated this revision to Diff 28272.May 30 2021, 3:27 PM

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

Alphare accepted this revision.May 31 2021, 3:46 AM
Alphare added inline comments.
rust/hg-core/src/dirstate.rs
80–85

I don't think it matters too much as far as I'm concerned, but some people might argue the opposite. They can send a patch ;)

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

I wonder if the compiler will optimize the two loops somehow. But we can take a look at this in the profiling phase, later.

This revision is now accepted and ready to land.May 31 2021, 3:46 AM

Revision Contents
Changeset List

Diff 28284

rust/hg-core/src/dirstate.rs

// dirstate module // dirstate module
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::errors::HgError; use crate::errors::HgError;
use crate::revlog::Node; use crate::revlog::Node;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::FastHashMap; use crate::FastHashMap;
use bytes_cast::{unaligned, BytesCast}; use bytes_cast::{unaligned, BytesCast};
use std::convert::TryFrom; use std::convert::TryFrom;
pub mod dirs_multiset; pub mod dirs_multiset;
const MTIME_UNSET: i32 = -1; const MTIME_UNSET: i32 = -1;
/// A `DirstateEntry` with a size of `-2` means that it was merged from the /// A `DirstateEntry` with a size of `-2` means that it was merged from the
/// other parent. This allows revert to pick the right status back during a /// other parent. This allows revert to pick the right status back during a
/// merge. /// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2; pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
pub type StateMap = FastHashMap<HgPathBuf, DirstateEntry>; pub type StateMap = FastHashMap<HgPathBuf, DirstateEntry>;
pub type StateMapIter<'a> = pub type StateMapIter<'a> = Box<
Box<dyn Iterator<Item = (&'a HgPath, DirstateEntry)> + Send + 'a>; dyn Iterator<
Item = Result<(&'a HgPath, DirstateEntry), DirstateV2ParseError>,
> + Send
+ 'a,
>;
AlphareUnsubmitted
Not Done

Getting to 5 lines-high type declaration without Futures is a feat!

Alphare: Getting to 5 lines-high type declaration without Futures is a feat!
SimonSapinAuthorUnsubmitted
Done

Oh I hadn’t checked what rustfmt had done to this. Do you think it’d be better with separate type definitions for iterated items, in order to keep each definition on one line?

SimonSapin: Oh I hadn’t checked what rustfmt had done to this. Do you think it’d be better with separate…
AlphareUnsubmitted
Not Done

I don't think it matters too much as far as I'm concerned, but some people might argue the opposite. They can send a patch ;)

Alphare: I don't think it matters too much as far as I'm concerned, but some people might argue the…
pub type CopyMap = FastHashMap<HgPathBuf, HgPathBuf>; pub type CopyMap = FastHashMap<HgPathBuf, HgPathBuf>;
pub type CopyMapIter<'a> = pub type CopyMapIter<'a> = Box<
Box<dyn Iterator<Item = (&'a HgPath, &'a HgPath)> + Send + 'a>; dyn Iterator<Item = Result<(&'a HgPath, &'a HgPath), DirstateV2ParseError>>
+ Send
+ 'a,
>;
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum EntryState { pub enum EntryState {
Normal, Normal,
Added, Added,
Removed, Removed,
Merged, Merged,
Unknown, Unknown,

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

// dirs_multiset.rs // dirs_multiset.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! A multiset of directory names. //! A multiset of directory names.
//! //!
//! Used to counts the references to directories in a manifest or dirstate. //! Used to counts the references to directories in a manifest or dirstate.
use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::{ use crate::{
dirstate::EntryState, dirstate::EntryState,
utils::{ utils::{
files, files,
hg_path::{HgPath, HgPathBuf, HgPathError}, hg_path::{HgPath, HgPathBuf, HgPathError},
}, },
DirstateEntry, DirstateMapError, FastHashMap, DirstateEntry, DirstateError, DirstateMapError, FastHashMap,
}; };
use std::collections::{hash_map, hash_map::Entry, HashMap, HashSet}; use std::collections::{hash_map, hash_map::Entry, HashMap, HashSet};
// could be encapsulated if we care API stability more seriously // could be encapsulated if we care API stability more seriously
pub type DirsMultisetIter<'a> = hash_map::Keys<'a, HgPathBuf, u32>; pub type DirsMultisetIter<'a> = hash_map::Keys<'a, HgPathBuf, u32>;
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
pub struct DirsMultiset { pub struct DirsMultiset {
inner: FastHashMap<HgPathBuf, u32>, inner: FastHashMap<HgPathBuf, u32>,
} }
impl DirsMultiset { impl DirsMultiset {
/// Initializes the multiset from a dirstate. /// Initializes the multiset from a dirstate.
/// ///
/// If `skip_state` is provided, skips dirstate entries with equal state. /// If `skip_state` is provided, skips dirstate entries with equal state.
pub fn from_dirstate<I, P>( pub fn from_dirstate<I, P>(
dirstate: I, dirstate: I,
skip_state: Option<EntryState>, skip_state: Option<EntryState>,
) -> Result<Self, DirstateMapError> ) -> Result<Self, DirstateError>
where where
I: IntoIterator<Item = (P, DirstateEntry)>, I: IntoIterator<
Item = Result<(P, DirstateEntry), DirstateV2ParseError>,
>,
P: AsRef<HgPath>, P: AsRef<HgPath>,
{ {
let mut multiset = DirsMultiset { let mut multiset = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
for (filename, entry) in dirstate { for item in dirstate {
let (filename, entry) = item?;
let filename = filename.as_ref(); let filename = filename.as_ref();
// This `if` is optimized out of the loop // This `if` is optimized out of the loop
if let Some(skip) = skip_state { if let Some(skip) = skip_state {
if skip != entry.state { if skip != entry.state {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} else { } else {
multiset.add_path(filename)?; multiset.add_path(filename)?;
fn test_dirsmultiset_new_empty() { fn test_dirsmultiset_new_empty() {
let manifest: Vec<HgPathBuf> = vec![]; let manifest: Vec<HgPathBuf> = vec![];
let new = DirsMultiset::from_manifest(&manifest).unwrap(); let new = DirsMultiset::from_manifest(&manifest).unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
let new = let new = DirsMultiset::from_dirstate(
DirsMultiset::from_dirstate(StateMap::default(), None).unwrap(); StateMap::default().into_iter().map(Ok),
None,
)
.unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
#[test] #[test]
fn test_dirsmultiset_new_no_skip() { fn test_dirsmultiset_new_no_skip() {
let input_vec: Vec<HgPathBuf> = ["a/", "b/", "a/c", "a/d/"] let input_vec: Vec<HgPathBuf> = ["a/", "b/", "a/c", "a/d/"]
.iter() .iter()
.map(|e| HgPathBuf::from_bytes(e.as_bytes())) .map(|e| HgPathBuf::from_bytes(e.as_bytes()))
.collect(); .collect();
let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)] let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = DirsMultiset::from_manifest(&input_vec).unwrap(); let new = DirsMultiset::from_manifest(&input_vec).unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
let input_map: HashMap<_, _> = ["b/x", "a/c", "a/d/x"] let input_map = ["b/x", "a/c", "a/d/x"].iter().map(|f| {
.iter() Ok((
.map(|f| {
(
HgPathBuf::from_bytes(f.as_bytes()), HgPathBuf::from_bytes(f.as_bytes()),
DirstateEntry { DirstateEntry {
state: EntryState::Normal, state: EntryState::Normal,
mode: 0, mode: 0,
mtime: 0, mtime: 0,
size: 0, size: 0,
}, },
) ))
}) });
.collect();
let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)] let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = DirsMultiset::from_dirstate(input_map, None).unwrap(); let new = DirsMultiset::from_dirstate(input_map, None).unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
#[test] #[test]
fn test_dirsmultiset_new_skip() { fn test_dirsmultiset_new_skip() {
let input_map: HashMap<_, _> = [ let input_map = [
("a/", EntryState::Normal), ("a/", EntryState::Normal),
("a/b", EntryState::Normal), ("a/b", EntryState::Normal),
("a/c", EntryState::Removed), ("a/c", EntryState::Removed),
("a/d", EntryState::Merged), ("a/d", EntryState::Merged),
] ]
.iter() .iter()
.map(|(f, state)| { .map(|(f, state)| {
( Ok((
HgPathBuf::from_bytes(f.as_bytes()), HgPathBuf::from_bytes(f.as_bytes()),
DirstateEntry { DirstateEntry {
state: *state, state: *state,
mode: 0, mode: 0,
mtime: 0, mtime: 0,
size: 0, size: 0,
}, },
) ))
}) });
.collect();
// "a" incremented with "a/c" and "a/d/" // "a" incremented with "a/c" and "a/d/"
let expected_inner = [("", 1), ("a", 2)] let expected_inner = [("", 1), ("a", 2)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = let new =
DirsMultiset::from_dirstate(input_map, Some(EntryState::Normal)) DirsMultiset::from_dirstate(input_map, Some(EntryState::Normal))
.unwrap(); .unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
} }

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

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::dirstate::parsers::Timestamp; use crate::dirstate::parsers::Timestamp;
use crate::{ use crate::{
dirstate::EntryState, dirstate::EntryState,
pack_dirstate, parse_dirstate, pack_dirstate, parse_dirstate,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError, CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateParents,
DirstateParents, StateMap, StateMap,
}; };
use micro_timer::timed; use micro_timer::timed;
use std::collections::HashSet; use std::collections::HashSet;
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
#[derive(Default)] #[derive(Default)]
pub struct DirstateMap { pub struct DirstateMap {
} }
/// Add a tracked file to the dirstate /// Add a tracked file to the dirstate
pub fn add_file( pub fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateError> {
if old_state == EntryState::Unknown || old_state == EntryState::Removed if old_state == EntryState::Unknown || old_state == EntryState::Removed
{ {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.add_path(filename)?; dirs.add_path(filename)?;
} }
} }
if old_state == EntryState::Unknown { if old_state == EntryState::Unknown {
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
/// The `size` parameter is used to store sentinel values that indicate /// The `size` parameter is used to store sentinel values that indicate
/// the file's previous state. In the future, we should refactor this /// the file's previous state. In the future, we should refactor this
/// to be more explicit about what that state is. /// to be more explicit about what that state is.
pub fn remove_file( pub fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
size: i32, size: i32,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateError> {
if old_state != EntryState::Unknown && old_state != EntryState::Removed if old_state != EntryState::Unknown && old_state != EntryState::Removed
{ {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
if old_state == EntryState::Unknown { if old_state == EntryState::Unknown {
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
} }
/// Remove a file from the dirstate. /// Remove a file from the dirstate.
/// Returns `true` if the file was previously recorded. /// Returns `true` if the file was previously recorded.
pub fn drop_file( pub fn drop_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
let exists = self.state_map.remove(filename).is_some(); let exists = self.state_map.remove(filename).is_some();
if exists { if exists {
if old_state != EntryState::Removed { if old_state != EntryState::Removed {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
self.non_normal_set = Some(non_normal); self.non_normal_set = Some(non_normal);
self.other_parent_set = Some(other_parent); self.other_parent_set = Some(other_parent);
} }
/// Both of these setters and their uses appear to be the simplest way to /// Both of these setters and their uses appear to be the simplest way to
/// emulate a Python lazy property, but it is ugly and unidiomatic. /// emulate a Python lazy property, but it is ugly and unidiomatic.
/// TODO One day, rewriting this struct using the typestate might be a /// TODO One day, rewriting this struct using the typestate might be a
/// good idea. /// good idea.
pub fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { pub fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
if self.all_dirs.is_none() { if self.all_dirs.is_none() {
self.all_dirs = Some(DirsMultiset::from_dirstate( self.all_dirs = Some(DirsMultiset::from_dirstate(
self.state_map.iter().map(|(k, v)| (k, *v)), self.state_map.iter().map(|(k, v)| Ok((k, *v))),
None, None,
)?); )?);
} }
Ok(()) Ok(())
} }
pub fn set_dirs(&mut self) -> Result<(), DirstateMapError> { pub fn set_dirs(&mut self) -> Result<(), DirstateError> {
if self.dirs.is_none() { if self.dirs.is_none() {
self.dirs = Some(DirsMultiset::from_dirstate( self.dirs = Some(DirsMultiset::from_dirstate(
self.state_map.iter().map(|(k, v)| (k, *v)), self.state_map.iter().map(|(k, v)| Ok((k, *v))),
Some(EntryState::Removed), Some(EntryState::Removed),
)?); )?);
} }
Ok(()) Ok(())
} }
pub fn has_tracked_dir( pub fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
self.set_dirs()?; self.set_dirs()?;
Ok(self.dirs.as_ref().unwrap().contains(directory)) Ok(self.dirs.as_ref().unwrap().contains(directory))
} }
pub fn has_dir( pub fn has_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
self.set_all_dirs()?; self.set_all_dirs()?;
Ok(self.all_dirs.as_ref().unwrap().contains(directory)) Ok(self.all_dirs.as_ref().unwrap().contains(directory))
} }
#[timed] #[timed]
pub fn read( pub fn read(
&mut self, &mut self,
file_contents: &[u8], file_contents: &[u8],

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

let mut copies = Vec::new(); let mut copies = Vec::new();
let mut entries = Vec::new(); let mut entries = Vec::new();
let parents = let parents =
parse_dirstate_entries(contents, |path, entry, copy_source| { parse_dirstate_entries(contents, |path, entry, copy_source| {
if let Some(source) = copy_source { if let Some(source) = copy_source {
copies.push((path, source)); copies.push((path, source));
} }
entries.push((path, *entry)); entries.push((path, *entry));
Ok(())
})?; })?;
Ok((parents, entries, copies)) Ok((parents, entries, copies))
} }
pub fn parse_dirstate_entries<'a>( pub fn parse_dirstate_entries<'a>(
mut contents: &'a [u8], mut contents: &'a [u8],
mut each_entry: impl FnMut(&'a HgPath, &DirstateEntry, Option<&'a HgPath>), mut each_entry: impl FnMut(
&'a HgPath,
&DirstateEntry,
Option<&'a HgPath>,
) -> Result<(), HgError>,
) -> Result<&'a DirstateParents, HgError> { ) -> Result<&'a DirstateParents, HgError> {
let (parents, rest) = DirstateParents::from_bytes(contents) let (parents, rest) = DirstateParents::from_bytes(contents)
.map_err(|_| HgError::corrupted("Too little data for dirstate."))?; .map_err(|_| HgError::corrupted("Too little data for dirstate."))?;
contents = rest; contents = rest;
while !contents.is_empty() { while !contents.is_empty() {
let (raw_entry, rest) = RawEntry::from_bytes(contents) let (raw_entry, rest) = RawEntry::from_bytes(contents)
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; .map_err(|_| HgError::corrupted("Overflow in dirstate."))?;
// `paths` is either a single path, or two paths separated by a NULL // `paths` is either a single path, or two paths separated by a NULL
// byte // byte
let mut iter = paths.splitn(2, |&byte| byte == b'\0'); let mut iter = paths.splitn(2, |&byte| byte == b'\0');
let path = HgPath::new( let path = HgPath::new(
iter.next().expect("splitn always yields at least one item"), iter.next().expect("splitn always yields at least one item"),
); );
let copy_source = iter.next().map(HgPath::new); let copy_source = iter.next().map(HgPath::new);
each_entry(path, &entry, copy_source); each_entry(path, &entry, copy_source)?;
contents = rest; contents = rest;
} }
Ok(parents) Ok(parents)
} }
fn packed_filename_and_copy_source_size( fn packed_filename_and_copy_source_size(
filename: &HgPath, filename: &HgPath,

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

// status.rs // status.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Rust implementation of dirstate.status (dirstate.py). //! Rust implementation of dirstate.status (dirstate.py).
//! It is currently missing a lot of functionality compared to the Python one //! It is currently missing a lot of functionality compared to the Python one
//! and will only be triggered in narrow cases. //! and will only be triggered in narrow cases.
use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::utils::path_auditor::PathAuditor; use crate::utils::path_auditor::PathAuditor;
use crate::{ use crate::{
dirstate::SIZE_FROM_OTHER_PARENT, dirstate::SIZE_FROM_OTHER_PARENT,
filepatterns::PatternFileWarning, filepatterns::PatternFileWarning,
matchers::{get_ignore_function, Matcher, VisitChildrenSet}, matchers::{get_ignore_function, Matcher, VisitChildrenSet},
utils::{ utils::{
files::{find_dirs, HgMetadata}, files::{find_dirs, HgMetadata},
hg_path::{ hg_path::{
#[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),
/// An invalid "ignore" pattern was found /// An invalid "ignore" pattern was found
Pattern(PatternError), Pattern(PatternError),
/// Corrupted dirstate
DirstateV2ParseError(DirstateV2ParseError),
} }
pub type StatusResult<T> = Result<T, StatusError>; pub type StatusResult<T> = Result<T, StatusError>;
impl fmt::Display for StatusError { impl fmt::Display for StatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
StatusError::IO(error) => error.fmt(f), StatusError::IO(error) => error.fmt(f),
StatusError::Path(error) => error.fmt(f), StatusError::Path(error) => error.fmt(f),
StatusError::Pattern(error) => error.fmt(f), StatusError::Pattern(error) => error.fmt(f),
StatusError::DirstateV2ParseError(_) => {
f.write_str("dirstate-v2 parse error")
}
} }
} }
} }
/// Gives information about which files are changed in the working directory /// Gives information about which files are changed in the working directory
/// and how, compared to the revision we're based on /// and how, compared to the revision we're based on
pub struct Status<'a, M: ?Sized + Matcher + Sync> { pub struct Status<'a, M: ?Sized + Matcher + Sync> {
dmap: &'a DirstateMap, dmap: &'a DirstateMap,

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

use bytes_cast::BytesCast; use bytes_cast::BytesCast;
use micro_timer::timed; use micro_timer::timed;
use std::borrow::Cow; use std::borrow::Cow;
use std::convert::TryInto; use std::convert::TryInto;
use std::path::PathBuf; use std::path::PathBuf;
use super::on_disk; use super::on_disk;
use super::on_disk::DirstateV2ParseError;
use super::path_with_basename::WithBasename; use super::path_with_basename::WithBasename;
use crate::dirstate::parsers::pack_entry; use crate::dirstate::parsers::pack_entry;
use crate::dirstate::parsers::packed_entry_size; use crate::dirstate::parsers::packed_entry_size;
use crate::dirstate::parsers::parse_dirstate_entries; use crate::dirstate::parsers::parse_dirstate_entries;
use crate::dirstate::parsers::Timestamp; use crate::dirstate::parsers::Timestamp;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::CopyMapIter; use crate::CopyMapIter;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateMapError;
use crate::DirstateParents; use crate::DirstateParents;
use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState; use crate::EntryState;
use crate::FastHashMap; use crate::FastHashMap;
use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StateMapIter; use crate::StateMapIter;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
pub(super) fn is_empty(&self) -> bool { pub(super) fn is_empty(&self) -> bool {
match self { match self {
ChildNodes::InMemory(nodes) => nodes.is_empty(), ChildNodes::InMemory(nodes) => nodes.is_empty(),
} }
} }
pub(super) fn make_mut( pub(super) fn make_mut(
&mut self, &mut self,
) -> &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>> { ) -> Result<
&mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>,
DirstateV2ParseError,
> {
match self { match self {
ChildNodes::InMemory(nodes) => nodes, ChildNodes::InMemory(nodes) => Ok(nodes),
} }
} }
} }
impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> { impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> {
pub(super) fn get( pub(super) fn get(
&self, &self,
base_name: &HgPath, base_name: &HgPath,
) -> Option<NodeRef<'tree, 'on_disk>> { ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
match self { match self {
ChildNodesRef::InMemory(nodes) => nodes ChildNodesRef::InMemory(nodes) => Ok(nodes
.get_key_value(base_name) .get_key_value(base_name)
.map(|(k, v)| NodeRef::InMemory(k, v)), .map(|(k, v)| NodeRef::InMemory(k, v))),
} }
} }
/// Iterate in undefined order /// Iterate in undefined order
pub(super) fn iter( pub(super) fn iter(
&self, &self,
) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> { ) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> {
match self { match self {
pub(super) fn sorted(&self) -> Vec<NodeRef<'tree, 'on_disk>> { pub(super) fn sorted(&self) -> Vec<NodeRef<'tree, 'on_disk>> {
match self { match self {
ChildNodesRef::InMemory(nodes) => { ChildNodesRef::InMemory(nodes) => {
let mut vec: Vec<_> = nodes let mut vec: Vec<_> = nodes
.iter() .iter()
.map(|(k, v)| NodeRef::InMemory(k, v)) .map(|(k, v)| NodeRef::InMemory(k, v))
.collect(); .collect();
fn sort_key<'a>(node: &'a NodeRef) -> &'a HgPath {
match node {
NodeRef::InMemory(path, _node) => path.base_name(),
}
}
// `sort_unstable_by_key` doesn’t allow keys borrowing from the // `sort_unstable_by_key` doesn’t allow keys borrowing from the
// value: https://github.com/rust-lang/rust/issues/34162 // value: https://github.com/rust-lang/rust/issues/34162
vec.sort_unstable_by(|a, b| a.base_name().cmp(b.base_name())); vec.sort_unstable_by(|a, b| sort_key(a).cmp(sort_key(b)));
vec vec
} }
} }
} }
} }
impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> { impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> {
pub(super) fn full_path(&self) -> &'tree HgPath { pub(super) fn full_path(
&self,
) -> Result<&'tree HgPath, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(path, _node) => path.full_path(), NodeRef::InMemory(path, _node) => Ok(path.full_path()),
} }
} }
/// Returns a `Cow` that can borrow 'on_disk but is detached from 'tree /// Returns a `Cow` that can borrow 'on_disk but is detached from 'tree
pub(super) fn full_path_cow(&self) -> Cow<'on_disk, HgPath> { pub(super) fn full_path_cow(
&self,
) -> Result<Cow<'on_disk, HgPath>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(path, _node) => path.full_path().clone(), NodeRef::InMemory(path, _node) => Ok(path.full_path().clone()),
} }
} }
pub(super) fn base_name(&self) -> &'tree HgPath { pub(super) fn base_name(
&self,
) -> Result<&'tree HgPath, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(path, _node) => path.base_name(), NodeRef::InMemory(path, _node) => Ok(path.base_name()),
}
}
pub(super) fn children(
&self,
) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> {
match self {
NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()),
} }
} }
pub(super) fn children(&self) -> ChildNodesRef<'tree, 'on_disk> { pub(super) fn has_copy_source(&self) -> bool {
match self { match self {
NodeRef::InMemory(_path, node) => node.children.as_ref(), NodeRef::InMemory(_path, node) => node.copy_source.is_some(),
} }
} }
pub(super) fn copy_source(&self) -> Option<&'tree HgPath> { pub(super) fn copy_source(
&self,
) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => { NodeRef::InMemory(_path, node) => {
node.copy_source.as_ref().map(|s| &**s) Ok(node.copy_source.as_ref().map(|s| &**s))
} }
} }
} }
pub(super) fn has_entry(&self) -> bool { pub(super) fn has_entry(&self) -> bool {
match self { match self {
NodeRef::InMemory(_path, node) => node.entry.is_some(), NodeRef::InMemory(_path, node) => node.entry.is_some(),
} }
} }
pub(super) fn entry(&self) -> Option<DirstateEntry> { pub(super) fn entry(
&self,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => node.entry, NodeRef::InMemory(_path, node) => Ok(node.entry),
} }
} }
pub(super) fn state(&self) -> Option<EntryState> {
pub(super) fn state(
&self,
) -> Result<Option<EntryState>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => { NodeRef::InMemory(_path, node) => {
node.entry.as_ref().map(|entry| entry.state) Ok(node.entry.as_ref().map(|entry| entry.state))
} }
} }
} }
pub(super) fn tracked_descendants_count(&self) -> u32 { pub(super) fn tracked_descendants_count(&self) -> u32 {
match self { match self {
NodeRef::InMemory(_path, node) => node.tracked_descendants_count, NodeRef::InMemory(_path, node) => node.tracked_descendants_count,
} }
&mut map.root, &mut map.root,
path, path,
WithBasename::to_cow_borrowed, WithBasename::to_cow_borrowed,
|ancestor| { |ancestor| {
if tracked { if tracked {
ancestor.tracked_descendants_count += 1 ancestor.tracked_descendants_count += 1
} }
}, },
); )?;
assert!( assert!(
node.entry.is_none(), node.entry.is_none(),
"duplicate dirstate entry in read" "duplicate dirstate entry in read"
); );
assert!( assert!(
node.copy_source.is_none(), node.copy_source.is_none(),
"duplicate dirstate entry in read" "duplicate dirstate entry in read"
); );
node.entry = Some(*entry); node.entry = Some(*entry);
node.copy_source = copy_source.map(Cow::Borrowed); node.copy_source = copy_source.map(Cow::Borrowed);
map.nodes_with_entry_count += 1; map.nodes_with_entry_count += 1;
if copy_source.is_some() { if copy_source.is_some() {
map.nodes_with_copy_source_count += 1 map.nodes_with_copy_source_count += 1
} }
Ok(())
}, },
)?; )?;
let parents = Some(parents.clone()); let parents = Some(parents.clone());
Ok((map, parents)) Ok((map, parents))
} }
fn get_node<'tree>( fn get_node<'tree>(
&'tree self, &'tree self,
path: &HgPath, path: &HgPath,
) -> Option<NodeRef<'tree, 'on_disk>> { ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
let mut children = self.root.as_ref(); let mut children = self.root.as_ref();
let mut components = path.components(); let mut components = path.components();
let mut component = let mut component =
components.next().expect("expected at least one components"); components.next().expect("expected at least one components");
loop { loop {
let child = children.get(component)?; if let Some(child) = children.get(component)? {
if let Some(next_component) = components.next() { if let Some(next_component) = components.next() {
component = next_component; component = next_component;
children = child.children(); children = child.children()?;
} else { } else {
return Some(child); return Ok(Some(child));
}
} else {
return Ok(None);
} }
} }
} }
/// Returns a mutable reference to the node at `path` if it exists /// Returns a mutable reference to the node at `path` if it exists
/// ///
/// This takes `root` instead of `&mut self` so that callers can mutate /// This takes `root` instead of `&mut self` so that callers can mutate
/// other fields while the returned borrow is still valid /// other fields while the returned borrow is still valid
fn get_node_mut<'tree>( fn get_node_mut<'tree>(
root: &'tree mut ChildNodes<'on_disk>, root: &'tree mut ChildNodes<'on_disk>,
path: &HgPath, path: &HgPath,
) -> Option<&'tree mut Node<'on_disk>> { ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {
let mut children = root; let mut children = root;
let mut components = path.components(); let mut components = path.components();
let mut component = let mut component =
components.next().expect("expected at least one components"); components.next().expect("expected at least one components");
loop { loop {
let child = children.make_mut().get_mut(component)?; if let Some(child) = children.make_mut()?.get_mut(component) {
if let Some(next_component) = components.next() { if let Some(next_component) = components.next() {
component = next_component; component = next_component;
children = &mut child.children; children = &mut child.children;
} else { } else {
return Some(child); return Ok(Some(child));
}
} else {
return Ok(None);
} }
} }
} }
fn get_or_insert_node<'tree, 'path>( fn get_or_insert_node<'tree, 'path>(
root: &'tree mut ChildNodes<'on_disk>, root: &'tree mut ChildNodes<'on_disk>,
path: &'path HgPath, path: &'path HgPath,
to_cow: impl Fn( to_cow: impl Fn(
WithBasename<&'path HgPath>, WithBasename<&'path HgPath>,
) -> WithBasename<Cow<'on_disk, HgPath>>, ) -> WithBasename<Cow<'on_disk, HgPath>>,
mut each_ancestor: impl FnMut(&mut Node), mut each_ancestor: impl FnMut(&mut Node),
) -> &'tree mut Node<'on_disk> { ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> {
let mut child_nodes = root; let mut child_nodes = root;
let mut inclusive_ancestor_paths = let mut inclusive_ancestor_paths =
WithBasename::inclusive_ancestors_of(path); WithBasename::inclusive_ancestors_of(path);
let mut ancestor_path = inclusive_ancestor_paths let mut ancestor_path = inclusive_ancestor_paths
.next() .next()
.expect("expected at least one inclusive ancestor"); .expect("expected at least one inclusive ancestor");
loop { loop {
// TODO: can we avoid allocating an owned key in cases where the // TODO: can we avoid allocating an owned key in cases where the
// map already contains that key, without introducing double // map already contains that key, without introducing double
// lookup? // lookup?
let child_node = child_nodes let child_node = child_nodes
.make_mut() .make_mut()?
.entry(to_cow(ancestor_path)) .entry(to_cow(ancestor_path))
.or_default(); .or_default();
if let Some(next) = inclusive_ancestor_paths.next() { if let Some(next) = inclusive_ancestor_paths.next() {
each_ancestor(child_node); each_ancestor(child_node);
ancestor_path = next; ancestor_path = next;
child_nodes = &mut child_node.children; child_nodes = &mut child_node.children;
} else { } else {
return child_node; return Ok(child_node);
} }
} }
} }
fn add_or_remove_file( fn add_or_remove_file(
&mut self, &mut self,
path: &HgPath, path: &HgPath,
old_state: EntryState, old_state: EntryState,
new_entry: DirstateEntry, new_entry: DirstateEntry,
) { ) -> Result<(), DirstateV2ParseError> {
let tracked_count_increment = let tracked_count_increment =
match (old_state.is_tracked(), new_entry.state.is_tracked()) { match (old_state.is_tracked(), new_entry.state.is_tracked()) {
(false, true) => 1, (false, true) => 1,
(true, false) => -1, (true, false) => -1,
_ => 0, _ => 0,
}; };
let node = Self::get_or_insert_node( let node = Self::get_or_insert_node(
&mut self.root, &mut self.root,
path, path,
WithBasename::to_cow_owned, WithBasename::to_cow_owned,
|ancestor| { |ancestor| {
// We can’t use `+= increment` because the counter is unsigned, // We can’t use `+= increment` because the counter is unsigned,
// and we want debug builds to detect accidental underflow // and we want debug builds to detect accidental underflow
// through zero // through zero
match tracked_count_increment { match tracked_count_increment {
1 => ancestor.tracked_descendants_count += 1, 1 => ancestor.tracked_descendants_count += 1,
-1 => ancestor.tracked_descendants_count -= 1, -1 => ancestor.tracked_descendants_count -= 1,
_ => {} _ => {}
} }
}, },
); )?;
if node.entry.is_none() { if node.entry.is_none() {
self.nodes_with_entry_count += 1 self.nodes_with_entry_count += 1
} }
node.entry = Some(new_entry) node.entry = Some(new_entry);
Ok(())
} }
fn iter_nodes<'tree>( fn iter_nodes<'tree>(
&'tree self, &'tree self,
) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> + 'tree { ) -> impl Iterator<
Item = Result<NodeRef<'tree, 'on_disk>, DirstateV2ParseError>,
> + 'tree {
// Depth first tree traversal. // Depth first tree traversal.
// //
// If we could afford internal iteration and recursion, // If we could afford internal iteration and recursion,
// this would look like: // this would look like:
// //
// ``` // ```
// fn traverse_children( // fn traverse_children(
// children: &ChildNodes, // children: &ChildNodes,
// each: &mut impl FnMut(&Node), // each: &mut impl FnMut(&Node),
// ) { // ) {
// for child in children.values() { // for child in children.values() {
// traverse_children(&child.children, each); // traverse_children(&child.children, each);
// each(child); // each(child);
// } // }
// } // }
// ``` // ```
// //
// However we want an external iterator and therefore can’t use the // However we want an external iterator and therefore can’t use the
// call stack. Use an explicit stack instead: // call stack. Use an explicit stack instead:
let mut stack = Vec::new(); let mut stack = Vec::new();
let mut iter = self.root.as_ref().iter(); let mut iter = self.root.as_ref().iter();
std::iter::from_fn(move || { std::iter::from_fn(move || {
while let Some(child_node) = iter.next() { while let Some(child_node) = iter.next() {
let children = match child_node.children() {
Ok(children) => children,
Err(error) => return Some(Err(error)),
};
// Pseudo-recursion // Pseudo-recursion
let new_iter = child_node.children().iter(); let new_iter = children.iter();
let old_iter = std::mem::replace(&mut iter, new_iter); let old_iter = std::mem::replace(&mut iter, new_iter);
stack.push((child_node, old_iter)); stack.push((child_node, old_iter));
} }
// Found the end of a `children.iter()` iterator. // Found the end of a `children.iter()` iterator.
if let Some((child_node, next_iter)) = stack.pop() { if let Some((child_node, next_iter)) = stack.pop() {
// "Return" from pseudo-recursion by restoring state from the // "Return" from pseudo-recursion by restoring state from the
// explicit stack // explicit stack
iter = next_iter; iter = next_iter;
Some(child_node) Some(Ok(child_node))
} else { } else {
// Reached the bottom of the stack, we’re done // Reached the bottom of the stack, we’re done
None None
} }
}) })
} }
fn clear_known_ambiguous_mtimes(&mut self, paths: &[impl AsRef<HgPath>]) { fn clear_known_ambiguous_mtimes(
&mut self,
paths: &[impl AsRef<HgPath>],
) -> Result<(), DirstateV2ParseError> {
for path in paths { for path in paths {
if let Some(node) = if let Some(node) =
Self::get_node_mut(&mut self.root, path.as_ref()) Self::get_node_mut(&mut self.root, path.as_ref())?
{ {
if let Some(entry) = node.entry.as_mut() { if let Some(entry) = node.entry.as_mut() {
entry.clear_mtime(); entry.clear_mtime();
} }
} }
} }
Ok(())
} }
/// Return a faillilble iterator of full paths of nodes that have an
/// `entry` for which the given `predicate` returns true.
///
/// Fallibility means that each iterator item is a `Result`, which may
/// indicate a parse error of the on-disk dirstate-v2 format. Such errors
/// should only happen if Mercurial is buggy or a repository is corrupted.
fn filter_full_paths<'tree>(
&'tree self,
predicate: impl Fn(&DirstateEntry) -> bool + 'tree,
) -> impl Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + 'tree
{
filter_map_results(self.iter_nodes(), move |node| {
if let Some(entry) = node.entry()? {
if predicate(&entry) {
return Ok(Some(node.full_path()?));
}
}
Ok(None)
})
}
}
/// Like `Iterator::filter_map`, but over a fallible iterator of `Result`s.
///
/// The callback is only called for incoming `Ok` values. Errors are passed
/// through as-is. In order to let it use the `?` operator the callback is
/// expected to return a `Result` of `Option`, instead of an `Option` of
/// `Result`.
fn filter_map_results<'a, I, F, A, B, E>(
AlphareUnsubmitted
Not Done

Isn't there such an iterator in itertools already? Since we depend on it anyway.

Alphare: Isn't there such an iterator in `itertools` already? Since we depend on it anyway.
SimonSapinAuthorUnsubmitted
Done

I don’t find exactly this. https://docs.rs/itertools/0.10.0/itertools/trait.Itertools.html#method.filter_map_ok is close but requires the callback to be infallible, whereas we want to potentially emit new errors while filtering/mapping.

SimonSapin: I don’t find exactly this. https://docs.rs/itertools/0.10.0/itertools/trait.Itertools.
iter: I,
f: F,
) -> impl Iterator<Item = Result<B, E>> + 'a
where
I: Iterator<Item = Result<A, E>> + 'a,
F: Fn(A) -> Result<Option<B>, E> + 'a,
{
iter.filter_map(move |result| match result {
Ok(node) => f(node).transpose(),
Err(e) => Some(Err(e)),
})
} }
impl<'on_disk> super::dispatch::DirstateMapMethods for DirstateMap<'on_disk> { impl<'on_disk> super::dispatch::DirstateMapMethods for DirstateMap<'on_disk> {
fn clear(&mut self) { fn clear(&mut self) {
self.root = Default::default(); self.root = Default::default();
self.nodes_with_entry_count = 0; self.nodes_with_entry_count = 0;
self.nodes_with_copy_source_count = 0; self.nodes_with_copy_source_count = 0;
} }
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateError> {
self.add_or_remove_file(filename, old_state, entry); Ok(self.add_or_remove_file(filename, old_state, entry)?)
Ok(())
} }
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
size: i32, size: i32,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateError> {
let entry = DirstateEntry { let entry = DirstateEntry {
state: EntryState::Removed, state: EntryState::Removed,
mode: 0, mode: 0,
size, size,
mtime: 0, mtime: 0,
}; };
self.add_or_remove_file(filename, old_state, entry); Ok(self.add_or_remove_file(filename, old_state, entry)?)
Ok(())
} }
fn drop_file( fn drop_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
struct Dropped { struct Dropped {
was_tracked: bool, was_tracked: bool,
had_entry: bool, had_entry: bool,
had_copy_source: bool, had_copy_source: bool,
} }
fn recur(nodes: &mut ChildNodes, path: &HgPath) -> Option<Dropped> { fn recur(
nodes: &mut ChildNodes,
path: &HgPath,
) -> Result<Option<Dropped>, DirstateV2ParseError> {
let (first_path_component, rest_of_path) = let (first_path_component, rest_of_path) =
path.split_first_component(); path.split_first_component();
let node = nodes.make_mut().get_mut(first_path_component)?; let node = if let Some(node) =
nodes.make_mut()?.get_mut(first_path_component)
{
node
} else {
return Ok(None);
};
let dropped; let dropped;
if let Some(rest) = rest_of_path { if let Some(rest) = rest_of_path {
dropped = recur(&mut node.children, rest)?; if let Some(d) = recur(&mut node.children, rest)? {
dropped = d;
if dropped.was_tracked { if dropped.was_tracked {
node.tracked_descendants_count -= 1; node.tracked_descendants_count -= 1;
} }
} else { } else {
return Ok(None);
}
} else {
dropped = Dropped { dropped = Dropped {
was_tracked: node was_tracked: node
.entry .entry
.as_ref() .as_ref()
.map_or(false, |entry| entry.state.is_tracked()), .map_or(false, |entry| entry.state.is_tracked()),
had_entry: node.entry.take().is_some(), had_entry: node.entry.take().is_some(),
had_copy_source: node.copy_source.take().is_some(), had_copy_source: node.copy_source.take().is_some(),
}; };
} }
// After recursion, for both leaf (rest_of_path is None) nodes and // After recursion, for both leaf (rest_of_path is None) nodes and
// parent nodes, remove a node if it just became empty. // parent nodes, remove a node if it just became empty.
if node.entry.is_none() if node.entry.is_none()
&& node.copy_source.is_none() && node.copy_source.is_none()
&& node.children.is_empty() && node.children.is_empty()
{ {
nodes.make_mut().remove(first_path_component); nodes.make_mut()?.remove(first_path_component);
} }
Some(dropped) Ok(Some(dropped))
} }
if let Some(dropped) = recur(&mut self.root, filename) { if let Some(dropped) = recur(&mut self.root, filename)? {
if dropped.had_entry { if dropped.had_entry {
self.nodes_with_entry_count -= 1 self.nodes_with_entry_count -= 1
} }
if dropped.had_copy_source { if dropped.had_copy_source {
self.nodes_with_copy_source_count -= 1 self.nodes_with_copy_source_count -= 1
} }
Ok(dropped.had_entry) Ok(dropped.had_entry)
} else { } else {
debug_assert!(!old_state.is_tracked()); debug_assert!(!old_state.is_tracked());
Ok(false) Ok(false)
} }
} }
fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) { fn clear_ambiguous_times(
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) -> Result<(), DirstateV2ParseError> {
for filename in filenames { for filename in filenames {
if let Some(node) = Self::get_node_mut(&mut self.root, &filename) { if let Some(node) = Self::get_node_mut(&mut self.root, &filename)?
{
if let Some(entry) = node.entry.as_mut() { if let Some(entry) = node.entry.as_mut() {
entry.clear_ambiguous_mtime(now); entry.clear_ambiguous_mtime(now);
} }
} }
} }
Ok(())
} }
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool { fn non_normal_entries_contains(
self.get_node(key) &mut self,
.and_then(|node| node.entry()) key: &HgPath,
.map_or(false, |entry| entry.is_non_normal()) ) -> Result<bool, DirstateV2ParseError> {
Ok(if let Some(node) = self.get_node(key)? {
node.entry()?.map_or(false, |entry| entry.is_non_normal())
} else {
false
})
} }
fn non_normal_entries_remove(&mut self, _key: &HgPath) { fn non_normal_entries_remove(&mut self, _key: &HgPath) {
// Do nothing, this `DirstateMap` does not have a separate "non normal // Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" set that need to be kept up to date // entries" set that need to be kept up to date
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + '_> { ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
Box::new(self.iter_nodes().filter_map(|node| { {
node.entry() Box::new(self.filter_full_paths(|entry| {
.filter(|entry| {
entry.is_non_normal() || entry.is_from_other_parent() entry.is_non_normal() || entry.is_from_other_parent()
})
.map(|_| node.full_path())
})) }))
} }
fn set_non_normal_other_parent_entries(&mut self, _force: bool) { fn set_non_normal_other_parent_entries(&mut self, _force: bool) {
// Do nothing, this `DirstateMap` does not have a separate "non normal // Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" and "from other parent" sets that need to be recomputed // entries" and "from other parent" sets that need to be recomputed
} }
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
self.iter_non_normal_paths_panic() self.iter_non_normal_paths_panic()
} }
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
Box::new(self.iter_nodes().filter_map(|node| { dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
node.entry() > {
.filter(|entry| entry.is_non_normal()) Box::new(self.filter_full_paths(|entry| entry.is_non_normal()))
.map(|_| node.full_path())
}))
} }
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
Box::new(self.iter_nodes().filter_map(|node| { dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
node.entry() > {
.filter(|entry| entry.is_from_other_parent()) Box::new(self.filter_full_paths(|entry| entry.is_from_other_parent()))
.map(|_| node.full_path())
}))
} }
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
if let Some(node) = self.get_node(directory) { if let Some(node) = self.get_node(directory)? {
// A node without a `DirstateEntry` was created to hold child // A node without a `DirstateEntry` was created to hold child
// nodes, and is therefore a directory. // nodes, and is therefore a directory.
Ok(!node.has_entry() && node.tracked_descendants_count() > 0) Ok(!node.has_entry() && node.tracked_descendants_count() > 0)
} else { } else {
Ok(false) Ok(false)
} }
} }
fn has_dir( fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {
&mut self, if let Some(node) = self.get_node(directory)? {
directory: &HgPath,
) -> Result<bool, DirstateMapError> {
if let Some(node) = self.get_node(directory) {
// A node without a `DirstateEntry` was created to hold child // A node without a `DirstateEntry` was created to hold child
// nodes, and is therefore a directory. // nodes, and is therefore a directory.
Ok(!node.has_entry()) Ok(!node.has_entry())
} else { } else {
Ok(false) Ok(false)
} }
} }
#[timed] #[timed]
fn pack_v1( fn pack_v1(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
let now: i32 = now.0.try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
let mut ambiguous_mtimes = Vec::new(); let mut ambiguous_mtimes = Vec::new();
// Optizimation (to be measured?): pre-compute size to avoid `Vec` // Optizimation (to be measured?): pre-compute size to avoid `Vec`
// reallocations // reallocations
let mut size = parents.as_bytes().len(); let mut size = parents.as_bytes().len();
for node in self.iter_nodes() { for node in self.iter_nodes() {
if let Some(entry) = node.entry() { let node = node?;
if let Some(entry) = node.entry()? {
size += size +=
packed_entry_size(node.full_path(), node.copy_source()); packed_entry_size(node.full_path()?, node.copy_source()?);
if entry.mtime_is_ambiguous(now) { if entry.mtime_is_ambiguous(now) {
ambiguous_mtimes.push(node.full_path_cow()) ambiguous_mtimes.push(node.full_path_cow()?)
} }
} }
} }
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());
for node in self.iter_nodes() { for node in self.iter_nodes() {
if let Some(entry) = node.entry() { let node = node?;
if let Some(entry) = node.entry()? {
pack_entry( pack_entry(
node.full_path(), node.full_path()?,
&entry, &entry,
node.copy_source(), node.copy_source()?,
&mut packed, &mut packed,
); );
} }
} }
Ok(packed) Ok(packed)
} }
#[timed] #[timed]
fn pack_v2( fn pack_v2(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> 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() {
if let Some(entry) = node.entry() { let node = node?;
if let Some(entry) = node.entry()? {
if entry.mtime_is_ambiguous(now) { if entry.mtime_is_ambiguous(now) {
paths.push(node.full_path_cow()) paths.push(node.full_path_cow()?)
} }
} }
} }
// 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)
} }
fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
// Do nothing, this `DirstateMap` does not a separate `all_dirs` that // Do nothing, this `DirstateMap` does not a separate `all_dirs` that
// needs to be recomputed // needs to be recomputed
Ok(()) Ok(())
} }
fn set_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_dirs(&mut self) -> Result<(), DirstateError> {
// Do nothing, this `DirstateMap` does not a separate `dirs` that needs // Do nothing, this `DirstateMap` does not a separate `dirs` that needs
// to be recomputed // to be recomputed
Ok(()) Ok(())
} }
fn status<'a>( fn status<'a>(
&'a mut self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{ {
super::status::status(self, matcher, root_dir, ignore_files, options) super::status::status(self, matcher, root_dir, ignore_files, options)
} }
fn copy_map_len(&self) -> usize { fn copy_map_len(&self) -> usize {
self.nodes_with_copy_source_count as usize self.nodes_with_copy_source_count as usize
} }
fn copy_map_iter(&self) -> CopyMapIter<'_> { fn copy_map_iter(&self) -> CopyMapIter<'_> {
Box::new(self.iter_nodes().filter_map(|node| { Box::new(filter_map_results(self.iter_nodes(), |node| {
node.copy_source() Ok(if let Some(source) = node.copy_source()? {
.map(|copy_source| (node.full_path(), copy_source)) Some((node.full_path()?, source))
} else {
None
})
})) }))
} }
fn copy_map_contains_key(&self, key: &HgPath) -> bool { fn copy_map_contains_key(
if let Some(node) = self.get_node(key) { &self,
node.copy_source().is_some() key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
Ok(if let Some(node) = self.get_node(key)? {
node.has_copy_source()
} else { } else {
false false
} })
} }
fn copy_map_get(&self, key: &HgPath) -> Option<&HgPath> { fn copy_map_get(
self.get_node(key)?.copy_source() &self,
key: &HgPath,
) -> Result<Option<&HgPath>, DirstateV2ParseError> {
if let Some(node) = self.get_node(key)? {
if let Some(source) = node.copy_source()? {
return Ok(Some(source));
}
}
Ok(None)
} }
fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> { fn copy_map_remove(
&mut self,
key: &HgPath,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
let count = &mut self.nodes_with_copy_source_count; let count = &mut self.nodes_with_copy_source_count;
Self::get_node_mut(&mut self.root, key).and_then(|node| { Ok(Self::get_node_mut(&mut self.root, key)?.and_then(|node| {
if node.copy_source.is_some() { if node.copy_source.is_some() {
*count -= 1 *count -= 1
} }
node.copy_source.take().map(Cow::into_owned) node.copy_source.take().map(Cow::into_owned)
}) }))
} }
fn copy_map_insert( fn copy_map_insert(
&mut self, &mut self,
key: HgPathBuf, key: HgPathBuf,
value: HgPathBuf, value: HgPathBuf,
) -> Option<HgPathBuf> { ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
let node = Self::get_or_insert_node( let node = Self::get_or_insert_node(
&mut self.root, &mut self.root,
&key, &key,
WithBasename::to_cow_owned, WithBasename::to_cow_owned,
|_ancestor| {}, |_ancestor| {},
); )?;
if node.copy_source.is_none() { if node.copy_source.is_none() {
self.nodes_with_copy_source_count += 1 self.nodes_with_copy_source_count += 1
} }
node.copy_source.replace(value.into()).map(Cow::into_owned) Ok(node.copy_source.replace(value.into()).map(Cow::into_owned))
} }
fn len(&self) -> usize { fn len(&self) -> usize {
self.nodes_with_entry_count as usize self.nodes_with_entry_count as usize
} }
fn contains_key(&self, key: &HgPath) -> bool { fn contains_key(
self.get(key).is_some() &self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
Ok(self.get(key)?.is_some())
} }
fn get(&self, key: &HgPath) -> Option<DirstateEntry> { fn get(
self.get_node(key)?.entry() &self,
key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
Ok(if let Some(node) = self.get_node(key)? {
node.entry()?
} else {
None
})
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
Box::new(self.iter_nodes().filter_map(|node| { Box::new(filter_map_results(self.iter_nodes(), |node| {
node.entry().map(|entry| (node.full_path(), entry)) Ok(if let Some(entry) = node.entry()? {
Some((node.full_path()?, entry))
} else {
None
})
})) }))
} }
} }

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

use std::path::PathBuf; use std::path::PathBuf;
use crate::dirstate::parsers::Timestamp; use crate::dirstate::parsers::Timestamp;
use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::CopyMapIter; use crate::CopyMapIter;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateMap; use crate::DirstateMap;
use crate::DirstateMapError;
use crate::DirstateParents; use crate::DirstateParents;
use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState; use crate::EntryState;
use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StateMapIter; use crate::StateMapIter;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
pub trait DirstateMapMethods { pub trait DirstateMapMethods {
fn clear(&mut self); fn clear(&mut self);
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateMapError>; ) -> Result<(), DirstateError>;
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
size: i32, size: i32,
) -> Result<(), DirstateMapError>; ) -> Result<(), DirstateError>;
fn drop_file( fn drop_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
) -> Result<bool, DirstateMapError>; ) -> Result<bool, DirstateError>;
fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32); fn clear_ambiguous_times(
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) -> Result<(), DirstateV2ParseError>;
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool; fn non_normal_entries_contains(
&mut self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError>;
fn non_normal_entries_remove(&mut self, key: &HgPath); fn non_normal_entries_remove(&mut self, key: &HgPath);
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + '_>; ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>;
fn set_non_normal_other_parent_entries(&mut self, force: bool); fn set_non_normal_other_parent_entries(&mut self, force: bool);
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_>; ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
>;
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_>; ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
>;
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_>; ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
>;
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError>; ) -> Result<bool, DirstateError>;
fn has_dir( fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError>;
&mut self,
directory: &HgPath,
) -> Result<bool, DirstateMapError>;
fn pack_v1( fn pack_v1(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError>; ) -> Result<Vec<u8>, DirstateError>;
fn pack_v2( fn pack_v2(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError>; ) -> Result<Vec<u8>, DirstateError>;
fn set_all_dirs(&mut self) -> Result<(), DirstateMapError>; fn set_all_dirs(&mut self) -> Result<(), DirstateError>;
fn set_dirs(&mut self) -> Result<(), DirstateMapError>; fn set_dirs(&mut self) -> Result<(), DirstateError>;
fn status<'a>( fn status<'a>(
&'a mut self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>; ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;
fn copy_map_len(&self) -> usize; fn copy_map_len(&self) -> usize;
fn copy_map_iter(&self) -> CopyMapIter<'_>; fn copy_map_iter(&self) -> CopyMapIter<'_>;
fn copy_map_contains_key(&self, key: &HgPath) -> bool; fn copy_map_contains_key(
&self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError>;
fn copy_map_get(&self, key: &HgPath) -> Option<&HgPath>; fn copy_map_get(
&self,
key: &HgPath,
) -> Result<Option<&HgPath>, DirstateV2ParseError>;
fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf>; fn copy_map_remove(
&mut self,
key: &HgPath,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError>;
fn copy_map_insert( fn copy_map_insert(
&mut self, &mut self,
key: HgPathBuf, key: HgPathBuf,
value: HgPathBuf, value: HgPathBuf,
) -> Option<HgPathBuf>; ) -> Result<Option<HgPathBuf>, DirstateV2ParseError>;
fn len(&self) -> usize; fn len(&self) -> usize;
fn contains_key(&self, key: &HgPath) -> bool; fn contains_key(&self, key: &HgPath)
-> Result<bool, DirstateV2ParseError>;
fn get(&self, key: &HgPath) -> Option<DirstateEntry>; fn get(
&self,
key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError>;
fn iter(&self) -> StateMapIter<'_>; fn iter(&self) -> StateMapIter<'_>;
} }
impl DirstateMapMethods for DirstateMap { impl DirstateMapMethods for DirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
self.clear() self.clear()
} }
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateError> {
self.add_file(filename, old_state, entry) self.add_file(filename, old_state, entry)
} }
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
size: i32, size: i32,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateError> {
self.remove_file(filename, old_state, size) self.remove_file(filename, old_state, size)
} }
fn drop_file( fn drop_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
self.drop_file(filename, old_state) self.drop_file(filename, old_state)
} }
fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) { fn clear_ambiguous_times(
self.clear_ambiguous_times(filenames, now) &mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) -> Result<(), DirstateV2ParseError> {
Ok(self.clear_ambiguous_times(filenames, now))
} }
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool { fn non_normal_entries_contains(
&mut self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
let (non_normal, _other_parent) = let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
non_normal.contains(key) Ok(non_normal.contains(key))
} }
fn non_normal_entries_remove(&mut self, key: &HgPath) { fn non_normal_entries_remove(&mut self, key: &HgPath) {
self.non_normal_entries_remove(key) self.non_normal_entries_remove(key)
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + '_> { ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
{
let (non_normal, other_parent) = let (non_normal, other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
Box::new(non_normal.union(other_parent).map(|p| &**p)) Box::new(non_normal.union(other_parent).map(|p| Ok(&**p)))
} }
fn set_non_normal_other_parent_entries(&mut self, force: bool) { fn set_non_normal_other_parent_entries(&mut self, force: bool) {
self.set_non_normal_other_parent_entries(force) self.set_non_normal_other_parent_entries(force)
} }
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
let (non_normal, _other_parent) = let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
Box::new(non_normal.iter().map(|p| &**p)) Box::new(non_normal.iter().map(|p| Ok(&**p)))
} }
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
let (non_normal, _other_parent) = let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries_panic(); self.get_non_normal_other_parent_entries_panic();
Box::new(non_normal.iter().map(|p| &**p)) Box::new(non_normal.iter().map(|p| Ok(&**p)))
} }
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
let (_non_normal, other_parent) = let (_non_normal, other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
Box::new(other_parent.iter().map(|p| &**p)) Box::new(other_parent.iter().map(|p| Ok(&**p)))
} }
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
self.has_tracked_dir(directory) self.has_tracked_dir(directory)
} }
fn has_dir( fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {
&mut self,
directory: &HgPath,
) -> Result<bool, DirstateMapError> {
self.has_dir(directory) self.has_dir(directory)
} }
fn pack_v1( fn pack_v1(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
self.pack(parents, now) self.pack(parents, now)
} }
fn pack_v2( fn pack_v2(
&mut self, &mut self,
_parents: DirstateParents, _parents: DirstateParents,
_now: Timestamp, _now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
panic!( panic!(
"should have used dirstate_tree::DirstateMap to use the v2 format" "should have used dirstate_tree::DirstateMap to use the v2 format"
) )
} }
fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
self.set_all_dirs() self.set_all_dirs()
} }
fn set_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_dirs(&mut self) -> Result<(), DirstateError> {
self.set_dirs() self.set_dirs()
} }
fn status<'a>( fn status<'a>(
&'a mut self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{ {
crate::status(self, matcher, root_dir, ignore_files, options) crate::status(self, matcher, root_dir, ignore_files, options)
} }
fn copy_map_len(&self) -> usize { fn copy_map_len(&self) -> usize {
self.copy_map.len() self.copy_map.len()
} }
fn copy_map_iter(&self) -> CopyMapIter<'_> { fn copy_map_iter(&self) -> CopyMapIter<'_> {
Box::new(self.copy_map.iter().map(|(key, value)| (&**key, &**value))) Box::new(
self.copy_map
.iter()
.map(|(key, value)| Ok((&**key, &**value))),
)
} }
fn copy_map_contains_key(&self, key: &HgPath) -> bool { fn copy_map_contains_key(
self.copy_map.contains_key(key) &self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
Ok(self.copy_map.contains_key(key))
} }
fn copy_map_get(&self, key: &HgPath) -> Option<&HgPath> { fn copy_map_get(
self.copy_map.get(key).map(|p| &**p) &self,
key: &HgPath,
) -> Result<Option<&HgPath>, DirstateV2ParseError> {
Ok(self.copy_map.get(key).map(|p| &**p))
} }
fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> { fn copy_map_remove(
self.copy_map.remove(key) &mut self,
key: &HgPath,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
Ok(self.copy_map.remove(key))
} }
fn copy_map_insert( fn copy_map_insert(
&mut self, &mut self,
key: HgPathBuf, key: HgPathBuf,
value: HgPathBuf, value: HgPathBuf,
) -> Option<HgPathBuf> { ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
self.copy_map.insert(key, value) Ok(self.copy_map.insert(key, value))
} }
fn len(&self) -> usize { fn len(&self) -> usize {
(&**self).len() (&**self).len()
} }
fn contains_key(&self, key: &HgPath) -> bool { fn contains_key(
(&**self).contains_key(key) &self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
Ok((&**self).contains_key(key))
} }
fn get(&self, key: &HgPath) -> Option<DirstateEntry> { fn get(
(&**self).get(key).cloned() &self,
key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
Ok((&**self).get(key).cloned())
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
Box::new((&**self).iter().map(|(key, value)| (&**key, *value))) Box::new((&**self).iter().map(|(key, value)| Ok((&**key, *value))))
} }
} }

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

/// Make sure that size-affecting changes are made knowingly /// Make sure that size-affecting changes are made knowingly
fn _static_assert_size_of() { fn _static_assert_size_of() {
let _ = std::mem::transmute::<Header, [u8; 72]>; let _ = std::mem::transmute::<Header, [u8; 72]>;
let _ = std::mem::transmute::<Node, [u8; 57]>; let _ = std::mem::transmute::<Node, [u8; 57]>;
} }
/// Unexpected file format found in `.hg/dirstate` with the "v2" format. /// Unexpected file format found in `.hg/dirstate` with the "v2" format.
pub(crate) struct DirstateV2ParseError; ///
/// This should only happen if Mercurial is buggy or a repository is corrupted.
#[derive(Debug)]
pub struct DirstateV2ParseError;
impl From<DirstateV2ParseError> for HgError { impl From<DirstateV2ParseError> for HgError {
fn from(_: DirstateV2ParseError) -> Self { fn from(_: DirstateV2ParseError) -> Self {
HgError::corrupted("dirstate-v2 parse error") HgError::corrupted("dirstate-v2 parse error")
} }
} }
impl From<DirstateV2ParseError> for crate::DirstateError { impl From<DirstateV2ParseError> for crate::DirstateError {
) -> Result<ChildNodes, DirstateError> { ) -> Result<ChildNodes, DirstateError> {
// `dirstate_map::ChildNodes` is a `HashMap` with undefined iteration // `dirstate_map::ChildNodes` is a `HashMap` with undefined iteration
// order. Sort to enable binary search in the written file. // order. Sort to enable binary search in the written file.
let nodes = nodes.sorted(); let nodes = nodes.sorted();
// First accumulate serialized nodes in a `Vec` // First accumulate serialized nodes in a `Vec`
let mut on_disk_nodes = Vec::with_capacity(nodes.len()); let mut on_disk_nodes = Vec::with_capacity(nodes.len());
for node in nodes { for node in nodes {
let children = write_nodes(node.children(), out)?; let children = write_nodes(node.children()?, out)?;
let full_path = write_slice::<u8>(node.full_path().as_bytes(), out); let full_path = write_slice::<u8>(node.full_path()?.as_bytes(), out);
let copy_source = if let Some(source) = node.copy_source() { let copy_source = if let Some(source) = node.copy_source()? {
write_slice::<u8>(source.as_bytes(), out) write_slice::<u8>(source.as_bytes(), out)
} else { } else {
Slice { Slice {
start: 0.into(), start: 0.into(),
len: 0.into(), len: 0.into(),
} }
}; };
on_disk_nodes.push(match node { on_disk_nodes.push(match node {

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

use crate::dirstate::status::IgnoreFnType; use crate::dirstate::status::IgnoreFnType;
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::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::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;
let hg_path = HgPath::new(""); let hg_path = 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> { struct StatusCommon<'tree, 'a> {
options: StatusOptions, options: StatusOptions,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
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, '_>,
directory_hg_path: &'tree HgPath, directory_hg_path: &'tree HgPath,
directory_fs_path: &Path, directory_fs_path: &Path,
is_at_repo_root: bool, is_at_repo_root: bool,
) { ) -> Result<(), DirstateV2ParseError> {
let mut fs_entries = if let Ok(entries) = self.read_dir( let mut fs_entries = if let Ok(entries) = self.read_dir(
directory_hg_path, directory_hg_path,
directory_fs_path, directory_fs_path,
is_at_repo_root, is_at_repo_root,
) { ) {
entries entries
} else { } else {
return; return Ok(());
}; };
// `merge_join_by` requires both its input iterators to be sorted: // `merge_join_by` requires both its input iterators to be sorted:
let dirstate_nodes = dirstate_nodes.sorted(); let dirstate_nodes = dirstate_nodes.sorted();
// `sort_unstable_by_key` doesn’t allow keys borrowing from the value: // `sort_unstable_by_key` doesn’t allow keys borrowing from the value:
// https://github.com/rust-lang/rust/issues/34162 // https://github.com/rust-lang/rust/issues/34162
fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name)); fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name));
// Propagate here any error that would happen inside the comparison
// callback below
for dirstate_node in &dirstate_nodes {
AlphareUnsubmitted
Not Done

I wonder if the compiler will optimize the two loops somehow. But we can take a look at this in the profiling phase, later.

Alphare: I wonder if the compiler will optimize the two loops somehow. But we can take a look at this in…
dirstate_node.base_name()?;
}
itertools::merge_join_by( itertools::merge_join_by(
dirstate_nodes, dirstate_nodes,
&fs_entries, &fs_entries,
|dirstate_node, fs_entry| { |dirstate_node, fs_entry| {
dirstate_node.base_name().cmp(&fs_entry.base_name) // This `unwrap` never panics because we already propagated
// those errors above
dirstate_node.base_name().unwrap().cmp(&fs_entry.base_name)
}, },
) )
.par_bridge() .par_bridge()
.for_each(|pair| { .map(|pair| {
use itertools::EitherOrBoth::*; use itertools::EitherOrBoth::*;
match pair { match pair {
Both(dirstate_node, fs_entry) => { Both(dirstate_node, fs_entry) => self
self.traverse_fs_and_dirstate( .traverse_fs_and_dirstate(
fs_entry, fs_entry,
dirstate_node, dirstate_node,
has_ignored_ancestor, has_ignored_ancestor,
); ),
}
Left(dirstate_node) => { Left(dirstate_node) => {
self.traverse_dirstate_only(dirstate_node) self.traverse_dirstate_only(dirstate_node)
} }
Right(fs_entry) => self.traverse_fs_only( Right(fs_entry) => Ok(self.traverse_fs_only(
has_ignored_ancestor, has_ignored_ancestor,
directory_hg_path, directory_hg_path,
fs_entry, fs_entry,
), )),
} }
}) })
.collect()
} }
fn traverse_fs_and_dirstate( fn traverse_fs_and_dirstate(
&self, &self,
fs_entry: &DirEntry, fs_entry: &DirEntry,
dirstate_node: NodeRef<'tree, '_>, dirstate_node: NodeRef<'tree, '_>,
has_ignored_ancestor: bool, has_ignored_ancestor: bool,
) { ) -> Result<(), DirstateV2ParseError> {
let hg_path = dirstate_node.full_path(); let hg_path = dirstate_node.full_path()?;
let file_type = fs_entry.metadata.file_type(); let file_type = fs_entry.metadata.file_type();
let file_or_symlink = file_type.is_file() || file_type.is_symlink(); let file_or_symlink = file_type.is_file() || file_type.is_symlink();
if !file_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(
dirstate_node.full_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.into())
} }
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(), dirstate_node.children()?,
hg_path, hg_path,
&fs_entry.full_path, &fs_entry.full_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); 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.outcome.lock().unwrap().added.push(full_path) self.outcome.lock().unwrap().added.push(full_path)
} }
EntryState::Removed => self EntryState::Removed => self
.outcome .outcome
.lock() .lock()
.unwrap() .unwrap()
.removed .removed
.push(full_path), .push(full_path),
EntryState::Merged => self EntryState::Merged => self
.outcome .outcome
.lock() .lock()
.unwrap() .unwrap()
.modified .modified
.push(full_path), .push(full_path),
EntryState::Normal => { EntryState::Normal => {
self.handle_normal_file(&dirstate_node, fs_entry); self.handle_normal_file(&dirstate_node, fs_entry)?
} }
// 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, has_ignored_ancestor,
full_path, full_path,
) )
} }
} }
for child_node in dirstate_node.children().iter() { for child_node in dirstate_node.children()?.iter() {
self.traverse_dirstate_only(child_node) self.traverse_dirstate_only(child_node)?
} }
} }
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, '_>,
fs_entry: &DirEntry, fs_entry: &DirEntry,
) { ) -> 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()); let full_path = Cow::from(dirstate_node.full_path()?);
let mode_changed = || { let mode_changed = || {
self.options.check_exec && entry.mode_changed(&fs_entry.metadata) self.options.check_exec && entry.mode_changed(&fs_entry.metadata)
}; };
let size_changed = entry.size != truncate_u64(fs_entry.metadata.len()); let size_changed = entry.size != truncate_u64(fs_entry.metadata.len());
if entry.size >= 0 if entry.size >= 0
&& size_changed && size_changed
&& fs_entry.metadata.file_type().is_symlink() && fs_entry.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(full_path)
} else if dirstate_node.copy_source().is_some() } 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(full_path)
} else { } else {
let mtime = mtime_seconds(&fs_entry.metadata); let mtime = mtime_seconds(&fs_entry.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(full_path)
} 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(full_path)
} }
} }
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(&self, dirstate_node: NodeRef<'tree, '_>) { fn traverse_dirstate_only(
&self,
dirstate_node: NodeRef<'tree, '_>,
) -> Result<(), DirstateV2ParseError> {
self.mark_removed_or_deleted_if_file( self.mark_removed_or_deleted_if_file(
dirstate_node.full_path(), dirstate_node.full_path()?,
dirstate_node.state(), dirstate_node.state()?,
); );
dirstate_node dirstate_node
.children() .children()?
.par_iter() .par_iter()
.for_each(|child_node| self.traverse_dirstate_only(child_node)) .map(|child_node| self.traverse_dirstate_only(child_node))
.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,

rust/hg-core/src/lib.rs

} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum DirstateError { pub enum DirstateError {
Map(DirstateMapError), Map(DirstateMapError),
Common(errors::HgError), Common(errors::HgError),
} }
impl fmt::Display for DirstateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
DirstateError::Map(error) => error.fmt(f),
DirstateError::Common(error) => error.fmt(f),
}
}
}
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum PatternError { pub enum PatternError {
#[from] #[from]
Path(HgPathError), Path(HgPathError),
UnsupportedSyntax(String), UnsupportedSyntax(String),
UnsupportedSyntaxInFile(String, String, usize), UnsupportedSyntaxInFile(String, String, usize),
TooLong(usize), TooLong(usize),
#[from] #[from]

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

// copymap.rs // copymap.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for `hg::dirstate::dirstate_map::CopyMap` provided by the //! Bindings for `hg::dirstate::dirstate_map::CopyMap` provided by the
//! `hg-core` package. //! `hg-core` package.
use cpython::{ use cpython::{
PyBytes, PyClone, PyDict, PyObject, PyResult, Python, UnsafePyLeaked, PyBytes, PyClone, PyDict, PyObject, PyResult, Python, UnsafePyLeaked,
}; };
use std::cell::RefCell; use std::cell::RefCell;
use crate::dirstate::dirstate_map::v2_error;
use crate::dirstate::dirstate_map::DirstateMap; use crate::dirstate::dirstate_map::DirstateMap;
use hg::dirstate_tree::on_disk::DirstateV2ParseError;
use hg::utils::hg_path::HgPath; use hg::utils::hg_path::HgPath;
use hg::CopyMapIter; use hg::CopyMapIter;
py_class!(pub class CopyMap |py| { py_class!(pub class CopyMap |py| {
data dirstate_map: DirstateMap; data dirstate_map: DirstateMap;
def __getitem__(&self, key: PyObject) -> PyResult<PyBytes> { def __getitem__(&self, key: PyObject) -> PyResult<PyBytes> {
(*self.dirstate_map(py)).copymapgetitem(py, key) (*self.dirstate_map(py)).copymapgetitem(py, key)
}); });
impl CopyMap { impl CopyMap {
pub fn from_inner(py: Python, dm: DirstateMap) -> PyResult<Self> { pub fn from_inner(py: Python, dm: DirstateMap) -> PyResult<Self> {
Self::create_instance(py, dm) Self::create_instance(py, dm)
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
res: (&HgPath, &HgPath), res: Result<(&HgPath, &HgPath), DirstateV2ParseError>,
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, res.0.as_bytes()))) let (k, _v) = res.map_err(|e| v2_error(py, e))?;
Ok(Some(PyBytes::new(py, k.as_bytes())))
} }
fn translate_key_value( fn translate_key_value(
py: Python, py: Python,
res: (&HgPath, &HgPath), res: Result<(&HgPath, &HgPath), DirstateV2ParseError>,
) -> PyResult<Option<(PyBytes, PyBytes)>> { ) -> PyResult<Option<(PyBytes, PyBytes)>> {
let (k, v) = res; let (k, v) = res.map_err(|e| v2_error(py, e))?;
Ok(Some(( Ok(Some((
PyBytes::new(py, k.as_bytes()), PyBytes::new(py, k.as_bytes()),
PyBytes::new(py, v.as_bytes()), PyBytes::new(py, v.as_bytes()),
))) )))
} }
} }
py_shared_iterator!( py_shared_iterator!(

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

exc, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyObject, PyResult, exc, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyObject, PyResult,
Python, UnsafePyLeaked, Python, UnsafePyLeaked,
}; };
use crate::dirstate::extract_dirstate; use crate::dirstate::extract_dirstate;
use hg::{ use hg::{
errors::HgError, errors::HgError,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirsMultisetIter, DirstateMapError, EntryState, DirsMultiset, DirsMultisetIter, DirstateError, DirstateMapError,
EntryState,
}; };
py_class!(pub class Dirs |py| { py_class!(pub class Dirs |py| {
@shared data inner: DirsMultiset; @shared data inner: DirsMultiset;
// `map` is either a `dict` or a flat iterator (usually a `set`, sometimes // `map` is either a `dict` or a flat iterator (usually a `set`, sometimes
// a `list`) // a `list`)
def __new__( def __new__(
_cls, _cls,
map: PyObject, map: PyObject,
skip: Option<PyObject> = None skip: Option<PyObject> = None
) -> PyResult<Self> { ) -> PyResult<Self> {
let mut skip_state: Option<EntryState> = None; let mut skip_state: Option<EntryState> = None;
if let Some(skip) = skip { if let Some(skip) = skip {
skip_state = Some( skip_state = Some(
skip.extract::<PyBytes>(py)?.data(py)[0] skip.extract::<PyBytes>(py)?.data(py)[0]
.try_into() .try_into()
.map_err(|e: HgError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?, })?,
); );
} }
let inner = if let Ok(map) = map.cast_as::<PyDict>(py) { let inner = if let Ok(map) = map.cast_as::<PyDict>(py) {
let dirstate = extract_dirstate(py, &map)?; let dirstate = extract_dirstate(py, &map)?;
let dirstate = dirstate.iter().map(|(k, v)| (k, *v)); let dirstate = dirstate.iter().map(|(k, v)| Ok((k, *v)));
DirsMultiset::from_dirstate(dirstate, skip_state) DirsMultiset::from_dirstate(dirstate, skip_state)
.map_err(|e: DirstateMapError| { .map_err(|e: DirstateError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})? })?
} else { } else {
let map: Result<Vec<HgPathBuf>, PyErr> = map let map: Result<Vec<HgPathBuf>, PyErr> = map
.iter(py)? .iter(py)?
.map(|o| { .map(|o| {
Ok(HgPathBuf::from_bytes( Ok(HgPathBuf::from_bytes(
o?.extract::<PyBytes>(py)?.data(py), o?.extract::<PyBytes>(py)?.data(py),

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

}, },
dirstate::owning::OwningDirstateMap, dirstate::owning::OwningDirstateMap,
dirstate::{dirs_multiset::Dirs, make_dirstate_tuple}, dirstate::{dirs_multiset::Dirs, make_dirstate_tuple},
parsers::dirstate_parents_to_pytuple, parsers::dirstate_parents_to_pytuple,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate_tree::dispatch::DirstateMapMethods, dirstate_tree::dispatch::DirstateMapMethods,
dirstate_tree::on_disk::DirstateV2ParseError,
errors::HgError, errors::HgError,
revlog::Node, revlog::Node,
utils::files::normalize_case, utils::files::normalize_case,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirstateEntry, DirstateError, DirsMultiset, DirstateEntry, DirstateError,
DirstateMap as RustDirstateMap, DirstateMapError, DirstateParents, DirstateMap as RustDirstateMap, DirstateParents, EntryState, StateMapIter,
EntryState, StateMapIter,
}; };
// TODO // TODO
// This object needs to share references to multiple members of its Rust // This object needs to share references to multiple members of its Rust
// inner struct, namely `copy_map`, `dirs` and `all_dirs`. // inner struct, namely `copy_map`, `dirs` and `all_dirs`.
// Right now `CopyMap` is done, but it needs to have an explicit reference // Right now `CopyMap` is done, but it needs to have an explicit reference
// to `RustDirstateMap` which itself needs to have an encapsulation for // to `RustDirstateMap` which itself needs to have an encapsulation for
// every method in `CopyMap` (copymapcopy, etc.). // every method in `CopyMap` (copymapcopy, etc.).
} }
def get( def get(
&self, &self,
key: PyObject, key: PyObject,
default: Option<PyObject> = None default: Option<PyObject> = None
) -> PyResult<Option<PyObject>> { ) -> PyResult<Option<PyObject>> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
match self.inner(py).borrow().get(HgPath::new(key.data(py))) { match self
.inner(py)
.borrow()
.get(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))?
{
Some(entry) => { Some(entry) => {
Ok(Some(make_dirstate_tuple(py, &entry)?)) Ok(Some(make_dirstate_tuple(py, &entry)?))
}, },
None => Ok(default) None => Ok(default)
} }
} }
def addfile( def addfile(
.try_into() .try_into()
.map_err(|e: HgError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?, })?,
mode: mode.extract(py)?, mode: mode.extract(py)?,
size: size.extract(py)?, size: size.extract(py)?,
mtime: mtime.extract(py)?, mtime: mtime.extract(py)?,
}, },
).and(Ok(py.None())).or_else(|e: DirstateMapError| { ).and(Ok(py.None())).or_else(|e: DirstateError| {
Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())) Err(PyErr::new::<exc::ValueError, _>(py, e.to_string()))
}) })
} }
def removefile( def removefile(
&self, &self,
f: PyObject, f: PyObject,
oldstate: PyObject, oldstate: PyObject,
let files: PyResult<Vec<HgPathBuf>> = files let files: PyResult<Vec<HgPathBuf>> = files
.iter(py)? .iter(py)?
.map(|filename| { .map(|filename| {
Ok(HgPathBuf::from_bytes( Ok(HgPathBuf::from_bytes(
filename?.extract::<PyBytes>(py)?.data(py), filename?.extract::<PyBytes>(py)?.data(py),
)) ))
}) })
.collect(); .collect();
self.inner(py).borrow_mut() self.inner(py)
.clear_ambiguous_times(files?, now.extract(py)?); .borrow_mut()
.clear_ambiguous_times(files?, now.extract(py)?)
.map_err(|e| v2_error(py, e))?;
Ok(py.None()) Ok(py.None())
} }
def other_parent_entries(&self) -> PyResult<PyObject> { def other_parent_entries(&self) -> PyResult<PyObject> {
let mut inner_shared = self.inner(py).borrow_mut(); let mut inner_shared = self.inner(py).borrow_mut();
let set = PySet::empty(py)?; let set = PySet::empty(py)?;
for path in inner_shared.iter_other_parent_paths() { for path in inner_shared.iter_other_parent_paths() {
let path = path.map_err(|e| v2_error(py, e))?;
set.add(py, PyBytes::new(py, path.as_bytes()))?; set.add(py, PyBytes::new(py, path.as_bytes()))?;
} }
Ok(set.into_object()) Ok(set.into_object())
} }
def non_normal_entries(&self) -> PyResult<NonNormalEntries> { def non_normal_entries(&self) -> PyResult<NonNormalEntries> {
NonNormalEntries::from_inner(py, self.clone_ref(py)) NonNormalEntries::from_inner(py, self.clone_ref(py))
} }
def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> { def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
Ok(self self.inner(py)
.inner(py)
.borrow_mut() .borrow_mut()
.non_normal_entries_contains(HgPath::new(key.data(py)))) .non_normal_entries_contains(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))
} }
def non_normal_entries_display(&self) -> PyResult<PyString> { def non_normal_entries_display(&self) -> PyResult<PyString> {
Ok( let mut inner = self.inner(py).borrow_mut();
PyString::new( let paths = inner
py, .iter_non_normal_paths()
&format!( .collect::<Result<Vec<_>, _>>()
"NonNormalEntries: {}", .map_err(|e| v2_error(py, e))?;
hg::utils::join_display( let formatted = format!("NonNormalEntries: {}", hg::utils::join_display(paths, ", "));
self Ok(PyString::new(py, &formatted))
.inner(py)
.borrow_mut()
.iter_non_normal_paths(),
", "
)
)
)
)
} }
def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> { def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
self self
.inner(py) .inner(py)
.borrow_mut() .borrow_mut()
.non_normal_entries_remove(HgPath::new(key.data(py))); .non_normal_entries_remove(HgPath::new(key.data(py)));
Ok(py.None()) Ok(py.None())
} }
def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> { def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> {
let mut inner = self.inner(py).borrow_mut(); let mut inner = self.inner(py).borrow_mut();
let ret = PyList::new(py, &[]); let ret = PyList::new(py, &[]);
for filename in inner.non_normal_or_other_parent_paths() { for filename in inner.non_normal_or_other_parent_paths() {
let filename = filename.map_err(|e| v2_error(py, e))?;
let as_pystring = PyBytes::new(py, filename.as_bytes()); let as_pystring = PyBytes::new(py, filename.as_bytes());
ret.append(py, as_pystring.into_object()); ret.append(py, as_pystring.into_object());
} }
Ok(ret) Ok(ret)
} }
def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> { def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> {
// Make sure the sets are defined before we no longer have a mutable // Make sure the sets are defined before we no longer have a mutable
py, py,
"Dirstate error".to_string(), "Dirstate error".to_string(),
)), )),
} }
} }
def filefoldmapasdict(&self) -> PyResult<PyDict> { def filefoldmapasdict(&self) -> PyResult<PyDict> {
let dict = PyDict::new(py); let dict = PyDict::new(py);
for (path, entry) in self.inner(py).borrow_mut().iter() { for item in self.inner(py).borrow_mut().iter() {
let (path, entry) = item.map_err(|e| v2_error(py, e))?;
if entry.state != EntryState::Removed { if entry.state != EntryState::Removed {
let key = normalize_case(path); let key = normalize_case(path);
let value = path; let value = path;
dict.set_item( dict.set_item(
py, py,
PyBytes::new(py, key.as_bytes()).into_object(), PyBytes::new(py, key.as_bytes()).into_object(),
PyBytes::new(py, value.as_bytes()).into_object(), PyBytes::new(py, value.as_bytes()).into_object(),
)?; )?;
} }
} }
Ok(dict) Ok(dict)
} }
def __len__(&self) -> PyResult<usize> { def __len__(&self) -> PyResult<usize> {
Ok(self.inner(py).borrow().len()) Ok(self.inner(py).borrow().len())
} }
def __contains__(&self, key: PyObject) -> PyResult<bool> { def __contains__(&self, key: PyObject) -> PyResult<bool> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
Ok(self.inner(py).borrow().contains_key(HgPath::new(key.data(py)))) self.inner(py)
.borrow()
.contains_key(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))
} }
def __getitem__(&self, key: PyObject) -> PyResult<PyObject> { def __getitem__(&self, key: PyObject) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
let key = HgPath::new(key.data(py)); let key = HgPath::new(key.data(py));
match self.inner(py).borrow().get(key) { match self
.inner(py)
.borrow()
.get(key)
.map_err(|e| v2_error(py, e))?
{
Some(entry) => { Some(entry) => {
Ok(make_dirstate_tuple(py, &entry)?) Ok(make_dirstate_tuple(py, &entry)?)
}, },
None => Err(PyErr::new::<exc::KeyError, _>( None => Err(PyErr::new::<exc::KeyError, _>(
py, py,
String::from_utf8_lossy(key.as_bytes()), String::from_utf8_lossy(key.as_bytes()),
)), )),
} }
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?, })?,
) )
} }
// TODO all copymap* methods, see docstring above // TODO all copymap* methods, see docstring above
def copymapcopy(&self) -> PyResult<PyDict> { def copymapcopy(&self) -> PyResult<PyDict> {
let dict = PyDict::new(py); let dict = PyDict::new(py);
for (key, value) in self.inner(py).borrow().copy_map_iter() { for item in self.inner(py).borrow().copy_map_iter() {
let (key, value) = item.map_err(|e| v2_error(py, e))?;
dict.set_item( dict.set_item(
py, py,
PyBytes::new(py, key.as_bytes()), PyBytes::new(py, key.as_bytes()),
PyBytes::new(py, value.as_bytes()), PyBytes::new(py, value.as_bytes()),
)?; )?;
} }
Ok(dict) Ok(dict)
} }
def copymapgetitem(&self, key: PyObject) -> PyResult<PyBytes> { def copymapgetitem(&self, key: PyObject) -> PyResult<PyBytes> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
match self.inner(py).borrow().copy_map_get(HgPath::new(key.data(py))) { match self
.inner(py)
.borrow()
.copy_map_get(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))?
{
Some(copy) => Ok(PyBytes::new(py, copy.as_bytes())), Some(copy) => Ok(PyBytes::new(py, copy.as_bytes())),
None => Err(PyErr::new::<exc::KeyError, _>( None => Err(PyErr::new::<exc::KeyError, _>(
py, py,
String::from_utf8_lossy(key.data(py)), String::from_utf8_lossy(key.data(py)),
)), )),
} }
} }
def copymap(&self) -> PyResult<CopyMap> { def copymap(&self) -> PyResult<CopyMap> {
CopyMap::from_inner(py, self.clone_ref(py)) CopyMap::from_inner(py, self.clone_ref(py))
} }
def copymaplen(&self) -> PyResult<usize> { def copymaplen(&self) -> PyResult<usize> {
Ok(self.inner(py).borrow().copy_map_len()) Ok(self.inner(py).borrow().copy_map_len())
} }
def copymapcontains(&self, key: PyObject) -> PyResult<bool> { def copymapcontains(&self, key: PyObject) -> PyResult<bool> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
Ok(self self.inner(py)
.inner(py)
.borrow() .borrow()
.copy_map_contains_key(HgPath::new(key.data(py)))) .copy_map_contains_key(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))
} }
def copymapget( def copymapget(
&self, &self,
key: PyObject, key: PyObject,
default: Option<PyObject> default: Option<PyObject>
) -> PyResult<Option<PyObject>> { ) -> PyResult<Option<PyObject>> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
match self match self
.inner(py) .inner(py)
.borrow() .borrow()
.copy_map_get(HgPath::new(key.data(py))) .copy_map_get(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))?
{ {
Some(copy) => Ok(Some( Some(copy) => Ok(Some(
PyBytes::new(py, copy.as_bytes()).into_object(), PyBytes::new(py, copy.as_bytes()).into_object(),
)), )),
None => Ok(default), None => Ok(default),
} }
} }
def copymapsetitem( def copymapsetitem(
&self, &self,
key: PyObject, key: PyObject,
value: PyObject value: PyObject
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
let value = value.extract::<PyBytes>(py)?; let value = value.extract::<PyBytes>(py)?;
self.inner(py).borrow_mut().copy_map_insert( self.inner(py)
.borrow_mut()
.copy_map_insert(
HgPathBuf::from_bytes(key.data(py)), HgPathBuf::from_bytes(key.data(py)),
HgPathBuf::from_bytes(value.data(py)), HgPathBuf::from_bytes(value.data(py)),
); )
.map_err(|e| v2_error(py, e))?;
Ok(py.None()) Ok(py.None())
} }
def copymappop( def copymappop(
&self, &self,
key: PyObject, key: PyObject,
default: Option<PyObject> default: Option<PyObject>
) -> PyResult<Option<PyObject>> { ) -> PyResult<Option<PyObject>> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
match self match self
.inner(py) .inner(py)
.borrow_mut() .borrow_mut()
.copy_map_remove(HgPath::new(key.data(py))) .copy_map_remove(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))?
{ {
Some(_) => Ok(None), Some(_) => Ok(None),
None => Ok(default), None => Ok(default),
} }
} }
def copymapiter(&self) -> PyResult<CopyMapKeysIterator> { def copymapiter(&self) -> PyResult<CopyMapKeysIterator> {
let leaked_ref = self.inner(py).leak_immutable(); let leaked_ref = self.inner(py).leak_immutable();
pub fn get_inner_mut<'a>( pub fn get_inner_mut<'a>(
&'a self, &'a self,
py: Python<'a>, py: Python<'a>,
) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> { ) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> {
self.inner(py).borrow_mut() self.inner(py).borrow_mut()
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
res: (&HgPath, DirstateEntry), res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, res.0.as_bytes()))) let (f, _entry) = res.map_err(|e| v2_error(py, e))?;
Ok(Some(PyBytes::new(py, f.as_bytes())))
} }
fn translate_key_value( fn translate_key_value(
py: Python, py: Python,
res: (&HgPath, DirstateEntry), res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
) -> PyResult<Option<(PyBytes, PyObject)>> { ) -> PyResult<Option<(PyBytes, PyObject)>> {
let (f, entry) = res; let (f, entry) = res.map_err(|e| v2_error(py, e))?;
Ok(Some(( Ok(Some((
PyBytes::new(py, f.as_bytes()), PyBytes::new(py, f.as_bytes()),
make_dirstate_tuple(py, &entry)?, make_dirstate_tuple(py, &entry)?,
))) )))
} }
} }
py_shared_iterator!( py_shared_iterator!(
fn extract_node_id(py: Python, obj: &PyObject) -> PyResult<Node> { fn extract_node_id(py: Python, obj: &PyObject) -> PyResult<Node> {
let bytes = obj.extract::<PyBytes>(py)?; let bytes = obj.extract::<PyBytes>(py)?;
match bytes.data(py).try_into() { match bytes.data(py).try_into() {
Ok(s) => Ok(s), Ok(s) => Ok(s),
Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())), Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())),
} }
} }
pub(super) fn v2_error(py: Python<'_>, _: DirstateV2ParseError) -> PyErr {
PyErr::new::<exc::ValueError, _>(py, "corrupted dirstate-v2")
}

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

use crate::dirstate::owning::OwningDirstateMap; use crate::dirstate::owning::OwningDirstateMap;
use hg::dirstate::parsers::Timestamp; use hg::dirstate::parsers::Timestamp;
use hg::dirstate_tree::dispatch::DirstateMapMethods; use hg::dirstate_tree::dispatch::DirstateMapMethods;
use hg::dirstate_tree::on_disk::DirstateV2ParseError;
use hg::matchers::Matcher; use hg::matchers::Matcher;
use hg::utils::hg_path::{HgPath, HgPathBuf}; use hg::utils::hg_path::{HgPath, HgPathBuf};
use hg::CopyMapIter; use hg::CopyMapIter;
use hg::DirstateEntry; use hg::DirstateEntry;
use hg::DirstateError; use hg::DirstateError;
use hg::DirstateMapError;
use hg::DirstateParents; use hg::DirstateParents;
use hg::DirstateStatus; use hg::DirstateStatus;
use hg::EntryState; use hg::EntryState;
use hg::PatternFileWarning; use hg::PatternFileWarning;
use hg::StateMapIter; use hg::StateMapIter;
use hg::StatusError; use hg::StatusError;
use hg::StatusOptions; use hg::StatusOptions;
use std::path::PathBuf; use std::path::PathBuf;
impl DirstateMapMethods for OwningDirstateMap { impl DirstateMapMethods for OwningDirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
self.get_mut().clear() self.get_mut().clear()
} }
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateError> {
self.get_mut().add_file(filename, old_state, entry) self.get_mut().add_file(filename, old_state, entry)
} }
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
size: i32, size: i32,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateError> {
self.get_mut().remove_file(filename, old_state, size) self.get_mut().remove_file(filename, old_state, size)
} }
fn drop_file( fn drop_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
self.get_mut().drop_file(filename, old_state) self.get_mut().drop_file(filename, old_state)
} }
fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) { fn clear_ambiguous_times(
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) -> Result<(), DirstateV2ParseError> {
self.get_mut().clear_ambiguous_times(filenames, now) self.get_mut().clear_ambiguous_times(filenames, now)
} }
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool { fn non_normal_entries_contains(
&mut self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
self.get_mut().non_normal_entries_contains(key) self.get_mut().non_normal_entries_contains(key)
} }
fn non_normal_entries_remove(&mut self, key: &HgPath) { fn non_normal_entries_remove(&mut self, key: &HgPath) {
self.get_mut().non_normal_entries_remove(key) self.get_mut().non_normal_entries_remove(key)
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + '_> { ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
{
self.get_mut().non_normal_or_other_parent_paths() self.get_mut().non_normal_or_other_parent_paths()
} }
fn set_non_normal_other_parent_entries(&mut self, force: bool) { fn set_non_normal_other_parent_entries(&mut self, force: bool) {
self.get_mut().set_non_normal_other_parent_entries(force) self.get_mut().set_non_normal_other_parent_entries(force)
} }
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
self.get_mut().iter_non_normal_paths() self.get_mut().iter_non_normal_paths()
} }
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
self.get().iter_non_normal_paths_panic() self.get().iter_non_normal_paths_panic()
} }
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> { ) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
self.get_mut().iter_other_parent_paths() self.get_mut().iter_other_parent_paths()
} }
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateError> {
self.get_mut().has_tracked_dir(directory) self.get_mut().has_tracked_dir(directory)
} }
fn has_dir( fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {
&mut self,
directory: &HgPath,
) -> Result<bool, DirstateMapError> {
self.get_mut().has_dir(directory) self.get_mut().has_dir(directory)
} }
fn pack_v1( fn pack_v1(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
self.get_mut().pack_v1(parents, now) self.get_mut().pack_v1(parents, now)
} }
fn pack_v2( fn pack_v2(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
self.get_mut().pack_v2(parents, now) self.get_mut().pack_v2(parents, now)
} }
fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
self.get_mut().set_all_dirs() self.get_mut().set_all_dirs()
} }
fn set_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_dirs(&mut self) -> Result<(), DirstateError> {
self.get_mut().set_dirs() self.get_mut().set_dirs()
} }
fn status<'a>( fn status<'a>(
&'a mut self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{ {
self.get_mut() self.get_mut()
.status(matcher, root_dir, ignore_files, options) .status(matcher, root_dir, ignore_files, options)
} }
fn copy_map_len(&self) -> usize { fn copy_map_len(&self) -> usize {
self.get().copy_map_len() self.get().copy_map_len()
} }
fn copy_map_iter(&self) -> CopyMapIter<'_> { fn copy_map_iter(&self) -> CopyMapIter<'_> {
self.get().copy_map_iter() self.get().copy_map_iter()
} }
fn copy_map_contains_key(&self, key: &HgPath) -> bool { fn copy_map_contains_key(
&self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
self.get().copy_map_contains_key(key) self.get().copy_map_contains_key(key)
} }
fn copy_map_get(&self, key: &HgPath) -> Option<&HgPath> { fn copy_map_get(
&self,
key: &HgPath,
) -> Result<Option<&HgPath>, DirstateV2ParseError> {
self.get().copy_map_get(key) self.get().copy_map_get(key)
} }
fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> { fn copy_map_remove(
&mut self,
key: &HgPath,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
self.get_mut().copy_map_remove(key) self.get_mut().copy_map_remove(key)
} }
fn copy_map_insert( fn copy_map_insert(
&mut self, &mut self,
key: HgPathBuf, key: HgPathBuf,
value: HgPathBuf, value: HgPathBuf,
) -> Option<HgPathBuf> { ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
self.get_mut().copy_map_insert(key, value) self.get_mut().copy_map_insert(key, value)
} }
fn len(&self) -> usize { fn len(&self) -> usize {
self.get().len() self.get().len()
} }
fn contains_key(&self, key: &HgPath) -> bool { fn contains_key(
&self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
self.get().contains_key(key) self.get().contains_key(key)
} }
fn get(&self, key: &HgPath) -> Option<DirstateEntry> { fn get(
&self,
key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
self.get().get(key) self.get().get(key)
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
self.get().iter() self.get().iter()
} }
} }

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

// non_normal_other_parent_entries.rs // non_normal_other_parent_entries.rs
// //
// Copyright 2020 Raphaël Gomès <rgomes@octobus.net> // Copyright 2020 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use cpython::{ use cpython::{
exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone, exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone,
PyErr, PyObject, PyResult, PyString, Python, PythonObject, ToPyObject, PyErr, PyObject, PyResult, PyString, Python, PythonObject, ToPyObject,
UnsafePyLeaked, UnsafePyLeaked,
}; };
use crate::dirstate::dirstate_map::v2_error;
use crate::dirstate::DirstateMap; use crate::dirstate::DirstateMap;
use hg::dirstate_tree::on_disk::DirstateV2ParseError;
use hg::utils::hg_path::HgPath; use hg::utils::hg_path::HgPath;
use std::cell::RefCell; use std::cell::RefCell;
py_class!(pub class NonNormalEntries |py| { py_class!(pub class NonNormalEntries |py| {
data dmap: DirstateMap; data dmap: DirstateMap;
def __contains__(&self, key: PyObject) -> PyResult<bool> { def __contains__(&self, key: PyObject) -> PyResult<bool> {
self.dmap(py).non_normal_entries_contains(py, key) self.dmap(py).non_normal_entries_contains(py, key)
for item in other.iter(py)? { for item in other.iter(py)? {
if !self.dmap(py).non_normal_entries_contains(py, item?)? { if !self.dmap(py).non_normal_entries_contains(py, item?)? {
return Ok(false); return Ok(false);
} }
} }
Ok(true) Ok(true)
} }
fn translate_key(py: Python, key: &HgPath) -> PyResult<Option<PyBytes>> { fn translate_key(
py: Python,
key: Result<&HgPath, DirstateV2ParseError>,
) -> PyResult<Option<PyBytes>> {
let key = key.map_err(|e| v2_error(py, e))?;
Ok(Some(PyBytes::new(py, key.as_bytes()))) Ok(Some(PyBytes::new(py, key.as_bytes())))
} }
} }
type NonNormalEntriesIter<'a> = type NonNormalEntriesIter<'a> = Box<
Box<dyn Iterator<Item = &'a HgPath> + Send + 'a>; dyn Iterator<Item = Result<&'a HgPath, DirstateV2ParseError>> + Send + 'a,
>;
py_shared_iterator!( py_shared_iterator!(
NonNormalEntriesIterator, NonNormalEntriesIterator,
UnsafePyLeaked<NonNormalEntriesIter<'static>>, UnsafePyLeaked<NonNormalEntriesIter<'static>>,
NonNormalEntries::translate_key, NonNormalEntries::translate_key,
Option<PyBytes> Option<PyBytes>
); );