This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8635

rust: do a clippy pass
ClosedPublic

Authored by Alphare on Jun 15 2020, 1:55 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG26114bd6ec60: rust: do a clippy pass
Summary

This is the result of running cargo clippy on hg-core/hg-cpython and fixing
the lints that do not require too much code churn (and would warrant a separate
commit/complete refactor) and only come from our code (a lot of warnings in
hg-cpython come from rust-cpython).

Most of those were good lints, two of them was the linter not being smart
enough (or compiler to get up to clippy's level depending on how you see it).

Maybe in the future we could have clippy be part of the CI.

Diff Detail

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

Event Timeline

Alphare created this revision.Jun 15 2020, 1:55 PM
Alphare added a commit: rHG26114bd6ec60: rust: do a clippy pass.Jun 16 2020, 4:02 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG26114bd6ec60: rust: do a clippy pass (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 21638

rust/hg-core/src/ancestors.rs

graph: G, graph: G,
initrevs: impl IntoIterator<Item = Revision>, initrevs: impl IntoIterator<Item = Revision>,
stoprev: Revision, stoprev: Revision,
inclusive: bool, inclusive: bool,
) -> Result<Self, GraphError> { ) -> Result<Self, GraphError> {
let filtered_initrevs = initrevs.into_iter().filter(|&r| r >= stoprev); let filtered_initrevs = initrevs.into_iter().filter(|&r| r >= stoprev);
if inclusive { if inclusive {
let visit: BinaryHeap<Revision> = filtered_initrevs.collect(); let visit: BinaryHeap<Revision> = filtered_initrevs.collect();
let seen = visit.iter().map(|&x| x).collect(); let seen = visit.iter().cloned().collect();
return Ok(AncestorsIterator { return Ok(AncestorsIterator {
visit: visit, visit,
seen: seen, seen,
stoprev: stoprev, stoprev,
graph: graph, graph,
}); });
} }
let mut this = AncestorsIterator { let mut this = AncestorsIterator {
visit: BinaryHeap::new(), visit: BinaryHeap::new(),
seen: HashSet::new(), seen: HashSet::new(),
stoprev: stoprev, stoprev,
graph: graph, graph,
}; };
this.seen.insert(NULL_REVISION); this.seen.insert(NULL_REVISION);
for rev in filtered_initrevs { for rev in filtered_initrevs {
for parent in this.graph.parents(rev)?.iter().cloned() { for parent in this.graph.parents(rev)?.iter().cloned() {
this.conditionally_push_rev(parent); this.conditionally_push_rev(parent);
} }
} }
Ok(this) Ok(this)
if rev < target { if rev < target {
return Ok(false); return Ok(false);
} }
} }
Ok(false) Ok(false)
} }
pub fn peek(&self) -> Option<Revision> { pub fn peek(&self) -> Option<Revision> {
self.visit.peek().map(|&r| r) self.visit.peek().cloned()
} }
/// Tell if the iterator is about an empty set /// Tell if the iterator is about an empty set
/// ///
/// The result does not depend whether the iterator has been consumed /// The result does not depend whether the iterator has been consumed
/// or not. /// or not.
/// This is mostly meant for iterators backing a lazy ancestors set /// This is mostly meant for iterators backing a lazy ancestors set
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
graph: graph.clone(), graph: graph.clone(),
containsiter: AncestorsIterator::new( containsiter: AncestorsIterator::new(
graph, graph,
v.iter().cloned(), v.iter().cloned(),
stoprev, stoprev,
inclusive, inclusive,
)?, )?,
initrevs: v, initrevs: v,
stoprev: stoprev, stoprev,
inclusive: inclusive, inclusive,
}) })
} }
pub fn contains(&mut self, rev: Revision) -> Result<bool, GraphError> { pub fn contains(&mut self, rev: Revision) -> Result<bool, GraphError> {
self.containsiter.contains(rev) self.containsiter.contains(rev)
} }
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
) )
.unwrap() .unwrap()
} }
} }
impl<G: Graph> MissingAncestors<G> { impl<G: Graph> MissingAncestors<G> {
pub fn new(graph: G, bases: impl IntoIterator<Item = Revision>) -> Self { pub fn new(graph: G, bases: impl IntoIterator<Item = Revision>) -> Self {
let mut created = MissingAncestors { let mut created = MissingAncestors {
graph: graph, graph,
bases: HashSet::new(), bases: HashSet::new(),
max_base: NULL_REVISION, max_base: NULL_REVISION,
}; };
created.add_bases(bases); created.add_bases(bases);
created created
} }
pub fn has_bases(&self) -> bool { pub fn has_bases(&self) -> bool {

rust/hg-core/src/dagops.rs

//! - By *relative heads* of a collection of revision numbers (`Revision`), we //! - By *relative heads* of a collection of revision numbers (`Revision`), we
//! mean those revisions that have no children among the collection. //! mean those revisions that have no children among the collection.
//! - Similarly *relative roots* of a collection of `Revision`, we mean those //! - Similarly *relative roots* of a collection of `Revision`, we mean those
//! whose parents, if any, don't belong to the collection. //! whose parents, if any, don't belong to the collection.
use super::{Graph, GraphError, Revision, NULL_REVISION}; use super::{Graph, GraphError, Revision, NULL_REVISION};
use crate::ancestors::AncestorsIterator; use crate::ancestors::AncestorsIterator;
use std::collections::{BTreeSet, HashSet}; use std::collections::{BTreeSet, HashSet};
fn remove_parents( fn remove_parents<S: std::hash::BuildHasher>(
graph: &impl Graph, graph: &impl Graph,
rev: Revision, rev: Revision,
set: &mut HashSet<Revision>, set: &mut HashSet<Revision, S>,
) -> Result<(), GraphError> { ) -> Result<(), GraphError> {
for parent in graph.parents(rev)?.iter() { for parent in graph.parents(rev)?.iter() {
if *parent != NULL_REVISION { if *parent != NULL_REVISION {
set.remove(parent); set.remove(parent);
} }
} }
Ok(()) Ok(())
} }
/// set is left to the caller. /// set is left to the caller.
/// - a direct Python binding would probably need to build its own `HashSet` /// - a direct Python binding would probably need to build its own `HashSet`
/// from an incoming iterable, even if its sole purpose is to extract the /// from an incoming iterable, even if its sole purpose is to extract the
/// heads. /// heads.
/// - a Rust caller can decide whether cloning beforehand is appropriate /// - a Rust caller can decide whether cloning beforehand is appropriate
/// ///
/// # Performance notes /// # Performance notes
/// Internally, this function will store a full copy of `revs` in a `Vec`. /// Internally, this function will store a full copy of `revs` in a `Vec`.
pub fn retain_heads( pub fn retain_heads<S: std::hash::BuildHasher>(
graph: &impl Graph, graph: &impl Graph,
revs: &mut HashSet<Revision>, revs: &mut HashSet<Revision, S>,
) -> Result<(), GraphError> { ) -> Result<(), GraphError> {
revs.remove(&NULL_REVISION); revs.remove(&NULL_REVISION);
// we need to construct an iterable copy of revs to avoid itering while // we need to construct an iterable copy of revs to avoid itering while
// mutating // mutating
let as_vec: Vec<Revision> = revs.iter().cloned().collect(); let as_vec: Vec<Revision> = revs.iter().cloned().collect();
for rev in as_vec { for rev in as_vec {
if rev != NULL_REVISION { if rev != NULL_REVISION {
remove_parents(graph, rev, revs)?; remove_parents(graph, rev, revs)?;
} }
} }
Ok(()) Ok(())
} }
/// Roots of `revs`, passed as a `HashSet` /// Roots of `revs`, passed as a `HashSet`
/// ///
/// They are returned in arbitrary order /// They are returned in arbitrary order
pub fn roots<G: Graph>( pub fn roots<G: Graph, S: std::hash::BuildHasher>(
graph: &G, graph: &G,
revs: &HashSet<Revision>, revs: &HashSet<Revision, S>,
) -> Result<Vec<Revision>, GraphError> { ) -> Result<Vec<Revision>, GraphError> {
let mut roots: Vec<Revision> = Vec::new(); let mut roots: Vec<Revision> = Vec::new();
for rev in revs { for rev in revs {
if graph if graph
.parents(*rev)? .parents(*rev)?
.iter() .iter()
.filter(|p| **p != NULL_REVISION) .filter(|p| **p != NULL_REVISION)
.all(|p| !revs.contains(p)) .all(|p| !revs.contains(p))
Ok(()) Ok(())
} }
/// Apply `roots()` and sort the result for easier comparison /// Apply `roots()` and sort the result for easier comparison
fn roots_sorted( fn roots_sorted(
graph: &impl Graph, graph: &impl Graph,
revs: &[Revision], revs: &[Revision],
) -> Result<Vec<Revision>, GraphError> { ) -> Result<Vec<Revision>, GraphError> {
let mut as_vec = roots(graph, &revs.iter().cloned().collect())?; let set: HashSet<_> = revs.iter().cloned().collect();
let mut as_vec = roots(graph, &set)?;
as_vec.sort(); as_vec.sort();
Ok(as_vec) Ok(as_vec)
} }
#[test] #[test]
fn test_roots() -> Result<(), GraphError> { fn test_roots() -> Result<(), GraphError> {
assert_eq!(roots_sorted(&SampleGraph, &[4, 5, 6])?, vec![4]); assert_eq!(roots_sorted(&SampleGraph, &[4, 5, 6])?, vec![4]);
assert_eq!( assert_eq!(

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

/// If the directory is not in the map, something horrible has happened. /// If the directory is not in the map, something horrible has happened.
pub fn delete_path( pub fn delete_path(
&mut self, &mut self,
path: impl AsRef<HgPath>, path: impl AsRef<HgPath>,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateMapError> {
for subpath in files::find_dirs(path.as_ref()) { for subpath in files::find_dirs(path.as_ref()) {
match self.inner.entry(subpath.to_owned()) { match self.inner.entry(subpath.to_owned()) {
Entry::Occupied(mut entry) => { Entry::Occupied(mut entry) => {
let val = entry.get().clone(); let val = *entry.get();
if val > 1 { if val > 1 {
entry.insert(val - 1); entry.insert(val - 1);
break; break;
} }
entry.remove(); entry.remove();
} }
Entry::Vacant(_) => { Entry::Vacant(_) => {
return Err(DirstateMapError::PathNotFound( return Err(DirstateMapError::PathNotFound(
pub fn iter(&self) -> DirsMultisetIter { pub fn iter(&self) -> DirsMultisetIter {
self.inner.keys() self.inner.keys()
} }
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.inner.len() self.inner.len()
} }
pub fn is_empty(&self) -> bool {
self.len() == 0
}
} }
/// This is basically a reimplementation of `DirsMultiset` that stores the /// This is basically a reimplementation of `DirsMultiset` that stores the
/// children instead of just a count of them, plus a small optional /// children instead of just a count of them, plus a small optional
/// optimization to avoid some directories we don't need. /// optimization to avoid some directories we don't need.
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
pub struct DirsChildrenMultiset<'a> { pub struct DirsChildrenMultiset<'a> {
inner: FastHashMap<&'a HgPath, HashSet<&'a HgPath>>, inner: FastHashMap<&'a HgPath, HashSet<&'a HgPath>>,
only_include: Option<HashSet<&'a HgPath>>, only_include: Option<HashSet<&'a HgPath>>,
} }
impl<'a> DirsChildrenMultiset<'a> { impl<'a> DirsChildrenMultiset<'a> {
pub fn new( pub fn new(
paths: impl Iterator<Item = &'a HgPathBuf>, paths: impl Iterator<Item = &'a HgPathBuf>,
only_include: Option<&'a HashSet<impl AsRef<HgPath> + 'a>>, only_include: Option<&'a HashSet<impl AsRef<HgPath> + 'a>>,
) -> Self { ) -> Self {
let mut new = Self { let mut new = Self {
inner: HashMap::default(), inner: HashMap::default(),
only_include: only_include only_include: only_include
.map(|s| s.iter().map(|p| p.as_ref()).collect()), .map(|s| s.iter().map(AsRef::as_ref).collect()),
}; };
for path in paths { for path in paths {
new.add_path(path) new.add_path(path)
} }
new new
} }

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

} }
pub fn non_normal_entries_union( pub fn non_normal_entries_union(
&mut self, &mut self,
other: HashSet<HgPathBuf>, other: HashSet<HgPathBuf>,
) -> Vec<HgPathBuf> { ) -> Vec<HgPathBuf> {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.union(&other) .union(&other)
.map(|e| e.to_owned()) .map(ToOwned::to_owned)
.collect() .collect()
} }
pub fn get_non_normal_other_parent_entries( pub fn get_non_normal_other_parent_entries(
&mut self, &mut self,
) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) { ) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) {
self.set_non_normal_other_parent_entries(false); self.set_non_normal_other_parent_entries(false);
( (

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

DirstateEntry { DirstateEntry {
mtime: new_mtime, mtime: new_mtime,
..*entry ..*entry
}, },
)); ));
} }
let mut new_filename = new_filename.into_vec(); let mut new_filename = new_filename.into_vec();
if let Some(copy) = copy_map.get(filename) { if let Some(copy) = copy_map.get(filename) {
new_filename.push('\0' as u8); new_filename.push(b'\0');
new_filename.extend(copy.bytes()); new_filename.extend(copy.bytes());
} }
packed.write_u8(entry.state.into())?; packed.write_u8(entry.state.into())?;
packed.write_i32::<BigEndian>(entry.mode)?; packed.write_i32::<BigEndian>(entry.mode)?;
packed.write_i32::<BigEndian>(entry.size)?; packed.write_i32::<BigEndian>(entry.size)?;
packed.write_i32::<BigEndian>(new_mtime)?; packed.write_i32::<BigEndian>(new_mtime)?;
packed.write_i32::<BigEndian>(new_filename.len() as i32)?; packed.write_i32::<BigEndian>(new_filename.len() as i32)?;

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

for entry in entries { for entry in entries {
let entry = entry?; let entry = entry?;
let filename = os_string_to_hg_path_buf(entry.file_name())?; let filename = os_string_to_hg_path_buf(entry.file_name())?;
let file_type = entry.file_type()?; let file_type = entry.file_type()?;
if skip_dot_hg && filename.as_bytes() == b".hg" && file_type.is_dir() { if skip_dot_hg && filename.as_bytes() == b".hg" && file_type.is_dir() {
return Ok(vec![]); return Ok(vec![]);
} else { } else {
results.push((HgPathBuf::from(filename), entry)) results.push((filename, entry))
} }
} }
results.sort_unstable_by_key(|e| e.0.clone()); results.sort_unstable_by_key(|e| e.0.clone());
Ok(results) Ok(results)
} }
/// The file corresponding to the dirstate entry was found on the filesystem. /// The file corresponding to the dirstate entry was found on the filesystem.
match state { match state {
EntryState::Normal => { EntryState::Normal => {
let size_changed = mod_compare(size, st_size as i32); let size_changed = mod_compare(size, st_size as i32);
let mode_changed = let mode_changed =
(mode ^ st_mode as i32) & 0o100 != 0o000 && options.check_exec; (mode ^ st_mode as i32) & 0o100 != 0o000 && options.check_exec;
let metadata_changed = size >= 0 && (size_changed || mode_changed); let metadata_changed = size >= 0 && (size_changed || mode_changed);
let other_parent = size == SIZE_FROM_OTHER_PARENT; let other_parent = size == SIZE_FROM_OTHER_PARENT;
if metadata_changed if metadata_changed
|| other_parent || other_parent
|| copy_map.contains_key(filename.as_ref()) || copy_map.contains_key(filename.as_ref())
{ {
Dispatch::Modified Dispatch::Modified
} else if mod_compare(mtime, st_mtime as i32) { } else if mod_compare(mtime, st_mtime as i32)
Dispatch::Unsure || st_mtime == options.last_normal_time
} else if st_mtime == options.last_normal_time { {
// the file may have just been marked as normal and // the file may have just been marked as normal and
// it may have changed in the same second without // it may have changed in the same second without
// changing its size. This can happen if we quickly // changing its size. This can happen if we quickly
// do multiple commits. Force lookup, so we don't // do multiple commits. Force lookup, so we don't
// miss such a racy file change. // miss such a racy file change.
Dispatch::Unsure Dispatch::Unsure
} else if options.list_clean { } else if options.list_clean {
Dispatch::Clean Dispatch::Clean
dmap: &'a DirstateMap, dmap: &'a DirstateMap,
root_dir: impl AsRef<Path> + Sync + Send + 'a, root_dir: impl AsRef<Path> + Sync + Send + 'a,
options: StatusOptions, options: StatusOptions,
traversed_sender: crossbeam::Sender<HgPathBuf>, traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> impl ParallelIterator<Item = IoResult<(&'a HgPath, Dispatch)>> { ) -> impl ParallelIterator<Item = IoResult<(&'a HgPath, Dispatch)>> {
files files
.unwrap_or(&DEFAULT_WORK) .unwrap_or(&DEFAULT_WORK)
.par_iter() .par_iter()
.map(move |filename| { .map(move |&filename| {
// TODO normalization // TODO normalization
let normalized = filename.as_ref(); let normalized = filename;
let buf = match hg_path_to_path_buf(normalized) { let buf = match hg_path_to_path_buf(normalized) {
Ok(x) => x, Ok(x) => x,
Err(e) => return Some(Err(e.into())), Err(e) => return Some(Err(e.into())),
}; };
let target = root_dir.as_ref().join(buf); let target = root_dir.as_ref().join(buf);
let st = target.symlink_metadata(); let st = target.symlink_metadata();
let in_dmap = dmap.get(normalized); let in_dmap = dmap.get(normalized);
*entry, *entry,
HgMetadata::from_metadata(meta), HgMetadata::from_metadata(meta),
&dmap.copy_map, &dmap.copy_map,
options, options,
), ),
))); )));
} }
Some(Ok((normalized, Dispatch::Unknown))) Some(Ok((normalized, Dispatch::Unknown)))
} else { } else if file_type.is_dir() {
if file_type.is_dir() {
if options.collect_traversed_dirs { if options.collect_traversed_dirs {
traversed_sender traversed_sender
.send(normalized.to_owned()) .send(normalized.to_owned())
.expect("receiver should outlive sender"); .expect("receiver should outlive sender");
} }
Some(Ok(( Some(Ok((
normalized, normalized,
Dispatch::Directory { Dispatch::Directory {
was_file: in_dmap.is_some(), was_file: in_dmap.is_some(),
}, },
))) )))
} else { } else {
Some(Ok(( Some(Ok((
normalized, normalized,
Dispatch::Bad(BadMatch::BadType( Dispatch::Bad(BadMatch::BadType(
// TODO do more than unknown // TODO do more than unknown
// Support for all `BadType` variant // Support for all `BadType` variant
// varies greatly between platforms. // varies greatly between platforms.
// So far, no tests check the type and // So far, no tests check the type and
// this should be good enough for most // this should be good enough for most
// users. // users.
BadType::Unknown, BadType::Unknown,
)), )),
))) )))
}
}; };
} }
Err(_) => { Err(_) => {
if let Some(entry) = in_dmap { if let Some(entry) = in_dmap {
return Some(Ok(( return Some(Ok((
normalized, normalized,
dispatch_missing(entry.state), dispatch_missing(entry.state),
))); )));
if (options.list_ignored || matcher.exact_match(&filename)) if (options.list_ignored || matcher.exact_match(&filename))
&& dir_ignore_fn(&filename) && dir_ignore_fn(&filename)
{ {
if options.list_ignored { if options.list_ignored {
files_sender files_sender
.send(Ok((filename.to_owned(), Dispatch::Ignored))) .send(Ok((filename.to_owned(), Dispatch::Ignored)))
.unwrap(); .unwrap();
} }
} else { } else if options.list_unknown {
if options.list_unknown {
files_sender files_sender
.send(Ok((filename.to_owned(), Dispatch::Unknown))) .send(Ok((filename.to_owned(), Dispatch::Unknown)))
.unwrap(); .unwrap();
} }
}
} else if ignore_fn(&filename) && options.list_ignored { } else if ignore_fn(&filename) && options.list_ignored {
files_sender files_sender
.send(Ok((filename.to_owned(), Dispatch::Ignored))) .send(Ok((filename.to_owned(), Dispatch::Ignored)))
.unwrap(); .unwrap();
} }
} else if let Some(entry) = entry_option { } else if let Some(entry) = entry_option {
// Used to be a file or a folder, now something else. // Used to be a file or a folder, now something else.
if matcher.matches_everything() || matcher.matches(&filename) { if matcher.matches_everything() || matcher.matches(&filename) {

rust/hg-core/src/discovery.rs

PartialDiscovery { PartialDiscovery {
undecided: None, undecided: None,
children_cache: None, children_cache: None,
target_heads: Some(target_heads), target_heads: Some(target_heads),
graph: graph.clone(), graph: graph.clone(),
common: MissingAncestors::new(graph, vec![]), common: MissingAncestors::new(graph, vec![]),
missing: HashSet::new(), missing: HashSet::new(),
rng: Rng::from_seed(seed), rng: Rng::from_seed(seed),
respect_size: respect_size, respect_size,
randomize: randomize, randomize,
} }
} }
/// Extract at most `size` random elements from sample and return them /// Extract at most `size` random elements from sample and return them
/// as a vector /// as a vector
fn limit_sample( fn limit_sample(
&mut self, &mut self,
mut sample: Vec<Revision>, mut sample: Vec<Revision>,
/// Do we have any information about the peer? /// Do we have any information about the peer?
pub fn has_info(&self) -> bool { pub fn has_info(&self) -> bool {
self.common.has_bases() self.common.has_bases()
} }
/// Did we acquire full knowledge of our Revisions that the peer has? /// Did we acquire full knowledge of our Revisions that the peer has?
pub fn is_complete(&self) -> bool { pub fn is_complete(&self) -> bool {
self.undecided.as_ref().map_or(false, |s| s.is_empty()) self.undecided.as_ref().map_or(false, HashSet::is_empty)
} }
/// Return the heads of the currently known common set of revisions. /// Return the heads of the currently known common set of revisions.
/// ///
/// If the discovery process is not complete (see `is_complete()`), the /// If the discovery process is not complete (see `is_complete()`), the
/// caller must be aware that this is an intermediate state. /// caller must be aware that this is an intermediate state.
/// ///
/// On the other hand, if it is complete, then this is currently /// On the other hand, if it is complete, then this is currently
return Ok(()); return Ok(());
} }
self.ensure_undecided()?; self.ensure_undecided()?;
let mut children: FastHashMap<Revision, Vec<Revision>> = let mut children: FastHashMap<Revision, Vec<Revision>> =
FastHashMap::default(); FastHashMap::default();
for &rev in self.undecided.as_ref().unwrap() { for &rev in self.undecided.as_ref().unwrap() {
for p in ParentsIterator::graph_parents(&self.graph, rev)? { for p in ParentsIterator::graph_parents(&self.graph, rev)? {
children.entry(p).or_insert_with(|| Vec::new()).push(rev); children.entry(p).or_insert_with(Vec::new).push(rev);
} }
} }
self.children_cache = Some(children); self.children_cache = Some(children);
Ok(()) Ok(())
} }
/// Provide statistics about the current state of the discovery process /// Provide statistics about the current state of the discovery process
pub fn stats(&self) -> DiscoveryStats { pub fn stats(&self) -> DiscoveryStats {
DiscoveryStats { DiscoveryStats {
undecided: self.undecided.as_ref().map(|s| s.len()), undecided: self.undecided.as_ref().map(HashSet::len),
} }
} }
pub fn take_quick_sample( pub fn take_quick_sample(
&mut self, &mut self,
headrevs: impl IntoIterator<Item = Revision>, headrevs: impl IntoIterator<Item = Revision>,
size: usize, size: usize,
) -> Result<Vec<Revision>, GraphError> { ) -> Result<Vec<Revision>, GraphError> {

rust/hg-core/src/filepatterns.rs

} }
pub fn parse_pattern_file_contents<P: AsRef<Path>>( pub fn parse_pattern_file_contents<P: AsRef<Path>>(
lines: &[u8], lines: &[u8],
file_path: P, file_path: P,
warn: bool, warn: bool,
) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> { ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> {
let comment_regex = Regex::new(r"((?:^|[^\\])(?:\\\\)*)#.*").unwrap(); let comment_regex = Regex::new(r"((?:^|[^\\])(?:\\\\)*)#.*").unwrap();
#[allow(clippy::trivial_regex)]
let comment_escape_regex = Regex::new(r"\\#").unwrap(); let comment_escape_regex = Regex::new(r"\\#").unwrap();
let mut inputs: Vec<IgnorePattern> = vec![]; let mut inputs: Vec<IgnorePattern> = vec![];
let mut warnings: Vec<PatternFileWarning> = vec![]; let mut warnings: Vec<PatternFileWarning> = vec![];
let mut current_syntax = b"relre:".as_ref(); let mut current_syntax = b"relre:".as_ref();
for (line_number, mut line) in lines.split(|c| *c == b'\n').enumerate() { for (line_number, mut line) in lines.split(|c| *c == b'\n').enumerate() {
let line_number = line_number + 1; let line_number = line_number + 1;
pattern_file: impl AsRef<Path>, pattern_file: impl AsRef<Path>,
root_dir: impl AsRef<Path>, root_dir: impl AsRef<Path>,
) -> PatternResult<(Vec<IgnorePattern>, Vec<PatternFileWarning>)> { ) -> PatternResult<(Vec<IgnorePattern>, Vec<PatternFileWarning>)> {
let (patterns, mut warnings) = read_pattern_file(&pattern_file, true)?; let (patterns, mut warnings) = read_pattern_file(&pattern_file, true)?;
let patterns = patterns let patterns = patterns
.into_iter() .into_iter()
.flat_map(|entry| -> PatternResult<_> { .flat_map(|entry| -> PatternResult<_> {
let IgnorePattern { let IgnorePattern {
syntax, syntax, pattern, ..
pattern,
source: _,
} = &entry; } = &entry;
Ok(match syntax { Ok(match syntax {
PatternSyntax::Include => { PatternSyntax::Include => {
let inner_include = let inner_include =
root_dir.as_ref().join(get_path_from_bytes(&pattern)); root_dir.as_ref().join(get_path_from_bytes(&pattern));
let (inner_pats, inner_warnings) = get_patterns_from_file( let (inner_pats, inner_warnings) = get_patterns_from_file(
&inner_include, &inner_include,
root_dir.as_ref(), root_dir.as_ref(),
root_dir: impl AsRef<Path>, root_dir: impl AsRef<Path>,
pattern: &[u8], pattern: &[u8],
source: impl AsRef<Path>, source: impl AsRef<Path>,
) -> Result<SubInclude, HgPathError> { ) -> Result<SubInclude, HgPathError> {
let normalized_source = let normalized_source =
normalize_path_bytes(&get_bytes_from_path(source)); normalize_path_bytes(&get_bytes_from_path(source));
let source_root = get_path_from_bytes(&normalized_source); let source_root = get_path_from_bytes(&normalized_source);
let source_root = source_root.parent().unwrap_or(source_root.deref()); let source_root =
source_root.parent().unwrap_or_else(|| source_root.deref());
let path = source_root.join(get_path_from_bytes(pattern)); let path = source_root.join(get_path_from_bytes(pattern));
let new_root = path.parent().unwrap_or(path.deref()); let new_root = path.parent().unwrap_or_else(|| path.deref());
let prefix = canonical_path(&root_dir, &root_dir, new_root)?; let prefix = canonical_path(&root_dir, &root_dir, new_root)?;
Ok(Self { Ok(Self {
prefix: path_to_hg_path_buf(prefix).and_then(|mut p| { prefix: path_to_hg_path_buf(prefix).and_then(|mut p| {
if !p.is_empty() { if !p.is_empty() {
p.push(b'/'); p.push(b'/');
} }

rust/hg-core/src/matchers.rs

dirs: DirsMultiset, dirs: DirsMultiset,
} }
impl<'a> FileMatcher<'a> { impl<'a> FileMatcher<'a> {
pub fn new( pub fn new(
files: &'a [impl AsRef<HgPath>], files: &'a [impl AsRef<HgPath>],
) -> Result<Self, DirstateMapError> { ) -> Result<Self, DirstateMapError> {
Ok(Self { Ok(Self {
files: HashSet::from_iter(files.iter().map(|f| f.as_ref())), files: HashSet::from_iter(files.iter().map(AsRef::as_ref)),
dirs: DirsMultiset::from_manifest(files)?, dirs: DirsMultiset::from_manifest(files)?,
}) })
} }
fn inner_matches(&self, filename: impl AsRef<HgPath>) -> bool { fn inner_matches(&self, filename: impl AsRef<HgPath>) -> bool {
self.files.contains(filename.as_ref()) self.files.contains(filename.as_ref())
} }
} }
} }
fn visit_children_set( fn visit_children_set(
&self, &self,
directory: impl AsRef<HgPath>, directory: impl AsRef<HgPath>,
) -> VisitChildrenSet { ) -> VisitChildrenSet {
if self.files.is_empty() || !self.dirs.contains(&directory) { if self.files.is_empty() || !self.dirs.contains(&directory) {
return VisitChildrenSet::Empty; return VisitChildrenSet::Empty;
} }
let dirs_as_set = self.dirs.iter().map(|k| k.deref()).collect(); let dirs_as_set = self.dirs.iter().map(Deref::deref).collect();
let mut candidates: HashSet<&HgPath> = let mut candidates: HashSet<&HgPath> =
self.files.union(&dirs_as_set).map(|k| *k).collect(); self.files.union(&dirs_as_set).cloned().collect();
candidates.remove(HgPath::new(b"")); candidates.remove(HgPath::new(b""));
if !directory.as_ref().is_empty() { if !directory.as_ref().is_empty() {
let directory = [directory.as_ref().as_bytes(), b"/"].concat(); let directory = [directory.as_ref().as_bytes(), b"/"].concat();
candidates = candidates candidates = candidates
.iter() .iter()
.filter_map(|c| { .filter_map(|c| {
if c.as_bytes().starts_with(&directory) { if c.as_bytes().starts_with(&directory) {
parents.extend( parents.extend(
DirsMultiset::from_manifest(&dirs) DirsMultiset::from_manifest(&dirs)
.map_err(|e| match e { .map_err(|e| match e {
DirstateMapError::InvalidPath(e) => e, DirstateMapError::InvalidPath(e) => e,
_ => unreachable!(), _ => unreachable!(),
})? })?
.iter() .iter()
.map(|k| k.to_owned()), .map(ToOwned::to_owned),
); );
parents.extend( parents.extend(
DirsMultiset::from_manifest(&roots) DirsMultiset::from_manifest(&roots)
.map_err(|e| match e { .map_err(|e| match e {
DirstateMapError::InvalidPath(e) => e, DirstateMapError::InvalidPath(e) => e,
_ => unreachable!(), _ => unreachable!(),
})? })?
.iter() .iter()
.map(|k| k.to_owned()), .map(ToOwned::to_owned),
); );
Ok(RootsDirsAndParents { Ok(RootsDirsAndParents {
roots: HashSet::from_iter(roots), roots: HashSet::from_iter(roots),
dirs: HashSet::from_iter(dirs), dirs: HashSet::from_iter(dirs),
parents, parents,
}) })
} }
all_warnings.extend(warnings); all_warnings.extend(warnings);
prefixes.push(prefix.to_owned()); prefixes.push(prefix.to_owned());
submatchers.insert(prefix.to_owned(), match_fn); submatchers.insert(prefix.to_owned(), match_fn);
} }
let match_subinclude = move |filename: &HgPath| { let match_subinclude = move |filename: &HgPath| {
for prefix in prefixes.iter() { for prefix in prefixes.iter() {
if let Some(rel) = filename.relative_to(prefix) { if let Some(rel) = filename.relative_to(prefix) {
if (submatchers.get(prefix).unwrap())(rel) { if (submatchers[prefix])(rel) {
return true; return true;
} }
} }
} }
false false
}; };
match_funcs.push(Box::new(match_subinclude)); match_funcs.push(Box::new(match_subinclude));

rust/hg-core/src/revlog.rs

/// Independently of the actual representation, `NULL_REVISION` is guaranteed /// Independently of the actual representation, `NULL_REVISION` is guaranteed
/// to be smaller than all existing revisions. /// to be smaller than all existing revisions.
pub const NULL_REVISION: Revision = -1; pub const NULL_REVISION: Revision = -1;
/// Same as `mercurial.node.wdirrev` /// Same as `mercurial.node.wdirrev`
/// ///
/// This is also equal to `i32::max_value()`, but it's better to spell /// This is also equal to `i32::max_value()`, but it's better to spell
/// it out explicitely, same as in `mercurial.node` /// it out explicitely, same as in `mercurial.node`
#[allow(clippy::unreadable_literal)]
pub const WORKING_DIRECTORY_REVISION: Revision = 0x7fffffff; pub const WORKING_DIRECTORY_REVISION: Revision = 0x7fffffff;
/// The simplest expression of what we need of Mercurial DAGs. /// The simplest expression of what we need of Mercurial DAGs.
pub trait Graph { pub trait Graph {
/// Return the two parents of the given `Revision`. /// Return the two parents of the given `Revision`.
/// ///
/// Each of the parents can be independently `NULL_REVISION` /// Each of the parents can be independently `NULL_REVISION`
fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError>; fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError>;
} }
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum GraphError { pub enum GraphError {
ParentOutOfRange(Revision), ParentOutOfRange(Revision),
WorkingDirectoryUnsupported, WorkingDirectoryUnsupported,
} }
/// The Mercurial Revlog Index /// The Mercurial Revlog Index
/// ///
/// This is currently limited to the minimal interface that is needed for /// This is currently limited to the minimal interface that is needed for
/// the [`nodemap`](nodemap/index.html) module /// the [`nodemap`](nodemap/index.html) module
pub trait RevlogIndex { pub trait RevlogIndex {
/// Total number of Revisions referenced in this index /// Total number of Revisions referenced in this index
fn len(&self) -> usize; fn len(&self) -> usize;
fn is_empty(&self) -> bool {
self.len() == 0
}
/// Return a reference to the Node or `None` if rev is out of bounds /// Return a reference to the Node or `None` if rev is out of bounds
/// ///
/// `NULL_REVISION` is not considered to be out of bounds. /// `NULL_REVISION` is not considered to be out of bounds.
fn node(&self, rev: Revision) -> Option<&Node>; fn node(&self, rev: Revision) -> Option<&Node>;
} }

rust/hg-core/src/revlog/node.rs

pub fn len(&self) -> usize { pub fn len(&self) -> usize {
if self.is_odd { if self.is_odd {
self.buf.len() * 2 - 1 self.buf.len() * 2 - 1
} else { } else {
self.buf.len() * 2 self.buf.len() * 2
} }
} }
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn is_prefix_of(&self, node: &Node) -> bool { pub fn is_prefix_of(&self, node: &Node) -> bool {
if self.is_odd { if self.is_odd {
let buf = self.buf; let buf = self.buf;
let last_pos = buf.len() - 1; let last_pos = buf.len() - 1;
node.data.starts_with(buf.split_at(last_pos).0) node.data.starts_with(buf.split_at(last_pos).0)
&& node.data[last_pos] >> 4 == buf[last_pos] >> 4 && node.data[last_pos] >> 4 == buf[last_pos] >> 4
} else { } else {
node.data.starts_with(self.buf) node.data.starts_with(self.buf)
/// Returned index is as in `get_nybble`, i.e., starting at 0. /// Returned index is as in `get_nybble`, i.e., starting at 0.
pub fn first_different_nybble(&self, node: &Node) -> Option<usize> { pub fn first_different_nybble(&self, node: &Node) -> Option<usize> {
let buf = self.buf; let buf = self.buf;
let until = if self.is_odd { let until = if self.is_odd {
buf.len() - 1 buf.len() - 1
} else { } else {
buf.len() buf.len()
}; };
for i in 0..until { for (i, item) in buf.iter().enumerate().take(until) {
if buf[i] != node.data[i] { if *item != node.data[i] {
if buf[i] & 0xf0 == node.data[i] & 0xf0 { return if *item & 0xf0 == node.data[i] & 0xf0 {
return Some(2 * i + 1); Some(2 * i + 1)
} else { } else {
return Some(2 * i); Some(2 * i)
} };
} }
} }
if self.is_odd && buf[until] & 0xf0 != node.data[until] & 0xf0 { if self.is_odd && buf[until] & 0xf0 != node.data[until] & 0xf0 {
Some(until * 2) Some(until * 2)
} else { } else {
None None
} }
} }

rust/hg-core/src/revlog/nodemap.rs

/// to be valid. /// to be valid.
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
pub struct Block([u8; BLOCK_SIZE]); pub struct Block([u8; BLOCK_SIZE]);
/// Not derivable for arrays of length >32 until const generics are stable /// Not derivable for arrays of length >32 until const generics are stable
impl PartialEq for Block { impl PartialEq for Block {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
&self.0[..] == &other.0[..] self.0[..] == other.0[..]
} }
} }
pub const BLOCK_SIZE: usize = 64; pub const BLOCK_SIZE: usize = 64;
impl Block { impl Block {
fn new() -> Self { fn new() -> Self {
// -1 in 2's complement to create an absent node // -1 in 2's complement to create an absent node
} }
} }
impl NodeTree { impl NodeTree {
/// Initiate a NodeTree from an immutable slice-like of `Block` /// Initiate a NodeTree from an immutable slice-like of `Block`
/// ///
/// We keep `readonly` and clone its root block if it isn't empty. /// We keep `readonly` and clone its root block if it isn't empty.
fn new(readonly: Box<dyn Deref<Target = [Block]> + Send>) -> Self { fn new(readonly: Box<dyn Deref<Target = [Block]> + Send>) -> Self {
let root = readonly let root = readonly.last().cloned().unwrap_or_else(Block::new);
.last()
.map(|b| b.clone())
.unwrap_or_else(|| Block::new());
NodeTree { NodeTree {
readonly: readonly, readonly,
growable: Vec::new(), growable: Vec::new(),
root: root, root,
masked_inner_blocks: 0, masked_inner_blocks: 0,
} }
} }
/// Create from an opaque bunch of bytes /// Create from an opaque bunch of bytes
/// ///
/// The created `NodeTreeBytes` from `buffer`, /// The created `NodeTreeBytes` from `buffer`,
/// of which exactly `amount` bytes are used. /// of which exactly `amount` bytes are used.
} }
fn visit<'n, 'p>( fn visit<'n, 'p>(
&'n self, &'n self,
prefix: NodePrefixRef<'p>, prefix: NodePrefixRef<'p>,
) -> NodeTreeVisitor<'n, 'p> { ) -> NodeTreeVisitor<'n, 'p> {
NodeTreeVisitor { NodeTreeVisitor {
nt: self, nt: self,
prefix: prefix, prefix,
visit: self.len() - 1, visit: self.len() - 1,
nybble_idx: 0, nybble_idx: 0,
done: false, done: false,
} }
} }
/// Return a mutable reference for `Block` at index `idx`. /// Return a mutable reference for `Block` at index `idx`.
/// ///
/// If `idx` lies in the immutable area, then the reference is to /// If `idx` lies in the immutable area, then the reference is to
/// a newly appended copy. /// a newly appended copy.
/// ///
/// Returns (new_idx, glen, mut_ref) where /// Returns (new_idx, glen, mut_ref) where
/// ///
/// - `new_idx` is the index of the mutable `Block` /// - `new_idx` is the index of the mutable `Block`
/// - `mut_ref` is a mutable reference to the mutable Block. /// - `mut_ref` is a mutable reference to the mutable Block.
/// - `glen` is the new length of `self.growable` /// - `glen` is the new length of `self.growable`
/// ///
/// Note: the caller wouldn't be allowed to query `self.growable.len()` /// Note: the caller wouldn't be allowed to query `self.growable.len()`
/// itself because of the mutable borrow taken with the returned `Block` /// itself because of the mutable borrow taken with the returned `Block`
fn mutable_block(&mut self, idx: usize) -> (usize, &mut Block, usize) { fn mutable_block(&mut self, idx: usize) -> (usize, &mut Block, usize) {
let ro_blocks = &self.readonly; let ro_blocks = &self.readonly;
let ro_len = ro_blocks.len(); let ro_len = ro_blocks.len();
let glen = self.growable.len(); let glen = self.growable.len();
if idx < ro_len { if idx < ro_len {
self.masked_inner_blocks += 1; self.masked_inner_blocks += 1;
// TODO OPTIM I think this makes two copies self.growable.push(ro_blocks[idx]);
self.growable.push(ro_blocks[idx].clone());
(glen + ro_len, &mut self.growable[glen], glen + 1) (glen + ro_len, &mut self.growable[glen], glen + 1)
} else if glen + ro_len == idx { } else if glen + ro_len == idx {
(idx, &mut self.root, glen) (idx, &mut self.root, glen)
} else { } else {
(idx, &mut self.growable[idx - ro_len], glen) (idx, &mut self.growable[idx - ro_len], glen)
} }
} }
if let Element::Block(idx) = element { if let Element::Block(idx) = element {
self.visit = idx; self.visit = idx;
} else { } else {
self.done = true; self.done = true;
} }
Some(NodeTreeVisitItem { Some(NodeTreeVisitItem {
block_idx: visit, block_idx: visit,
nybble: nybble, nybble,
element: element, element,
}) })
} }
} }
impl NodeTreeVisitItem { impl NodeTreeVisitItem {
// Return `Some(opt)` if this item is final, with `opt` being the // Return `Some(opt)` if this item is final, with `opt` being the
// `Revision` that it may represent. // `Revision` that it may represent.
// //

rust/hg-core/src/utils.rs

pub trait SliceExt { pub trait SliceExt {
fn trim_end(&self) -> &Self; fn trim_end(&self) -> &Self;
fn trim_start(&self) -> &Self; fn trim_start(&self) -> &Self;
fn trim(&self) -> &Self; fn trim(&self) -> &Self;
fn drop_prefix(&self, needle: &Self) -> Option<&Self>; fn drop_prefix(&self, needle: &Self) -> Option<&Self>;
} }
#[allow(clippy::trivially_copy_pass_by_ref)]
fn is_not_whitespace(c: &u8) -> bool { fn is_not_whitespace(c: &u8) -> bool {
!(*c as char).is_whitespace() !(*c as char).is_whitespace()
} }
impl SliceExt for [u8] { impl SliceExt for [u8] {
fn trim_end(&self) -> &[u8] { fn trim_end(&self) -> &[u8] {
if let Some(last) = self.iter().rposition(is_not_whitespace) { if let Some(last) = self.iter().rposition(is_not_whitespace) {
&self[..last + 1] &self[..=last]
} else { } else {
&[] &[]
} }
} }
fn trim_start(&self) -> &[u8] { fn trim_start(&self) -> &[u8] {
if let Some(first) = self.iter().position(is_not_whitespace) { if let Some(first) = self.iter().position(is_not_whitespace) {
&self[first..] &self[first..]
} else { } else {
} }
} }
acc acc
} }
} }
impl<'a, T: Escaped> Escaped for &'a [T] { impl<'a, T: Escaped> Escaped for &'a [T] {
fn escaped_bytes(&self) -> Vec<u8> { fn escaped_bytes(&self) -> Vec<u8> {
self.iter().flat_map(|item| item.escaped_bytes()).collect() self.iter().flat_map(Escaped::escaped_bytes).collect()
} }
} }
impl<T: Escaped> Escaped for Vec<T> { impl<T: Escaped> Escaped for Vec<T> {
fn escaped_bytes(&self) -> Vec<u8> { fn escaped_bytes(&self) -> Vec<u8> {
self.deref().escaped_bytes() self.deref().escaped_bytes()
} }
} }
impl<'a> Escaped for &'a HgPath { impl<'a> Escaped for &'a HgPath {
fn escaped_bytes(&self) -> Vec<u8> { fn escaped_bytes(&self) -> Vec<u8> {
self.as_bytes().escaped_bytes() self.as_bytes().escaped_bytes()
} }
} }

rust/hg-core/src/utils/files.rs

/// Returns an iterator yielding ancestor directories of the given repository /// Returns an iterator yielding ancestor directories of the given repository
/// path. /// path.
/// ///
/// The path is separated by '/', and must not start with '/'. /// The path is separated by '/', and must not start with '/'.
/// ///
/// The path itself isn't included unless it is b"" (meaning the root /// The path itself isn't included unless it is b"" (meaning the root
/// directory.) /// directory.)
pub fn find_dirs<'a>(path: &'a HgPath) -> Ancestors<'a> { pub fn find_dirs(path: &HgPath) -> Ancestors {
let mut dirs = Ancestors { next: Some(path) }; let mut dirs = Ancestors { next: Some(path) };
if !path.is_empty() { if !path.is_empty() {
dirs.next(); // skip itself dirs.next(); // skip itself
} }
dirs dirs
} }
/// Returns an iterator yielding ancestor directories of the given repository /// Returns an iterator yielding ancestor directories of the given repository
/// path. /// path.
/// ///
/// The path is separated by '/', and must not start with '/'. /// The path is separated by '/', and must not start with '/'.
/// ///
/// The path itself isn't included unless it is b"" (meaning the root /// The path itself isn't included unless it is b"" (meaning the root
/// directory.) /// directory.)
pub(crate) fn find_dirs_with_base<'a>( pub(crate) fn find_dirs_with_base(path: &HgPath) -> AncestorsWithBase {
path: &'a HgPath,
) -> AncestorsWithBase<'a> {
let mut dirs = AncestorsWithBase { let mut dirs = AncestorsWithBase {
next: Some((path, HgPath::new(b""))), next: Some((path, HgPath::new(b""))),
}; };
if !path.is_empty() { if !path.is_empty() {
dirs.next(); // skip itself dirs.next(); // skip itself
} }
dirs dirs
} }
root.join(&cwd).join(&name) root.join(&cwd).join(&name)
} else { } else {
name.to_owned() name.to_owned()
}; };
let auditor = PathAuditor::new(&root); let auditor = PathAuditor::new(&root);
if name != root && name.starts_with(&root) { if name != root && name.starts_with(&root) {
let name = name.strip_prefix(&root).unwrap(); let name = name.strip_prefix(&root).unwrap();
auditor.audit_path(path_to_hg_path_buf(name)?)?; auditor.audit_path(path_to_hg_path_buf(name)?)?;
return Ok(name.to_owned()); Ok(name.to_owned())
} else if name == root { } else if name == root {
return Ok("".into()); Ok("".into())
} else { } else {
// Determine whether `name' is in the hierarchy at or beneath `root', // Determine whether `name' is in the hierarchy at or beneath `root',
// by iterating name=name.parent() until it returns `None` (can't // by iterating name=name.parent() until it returns `None` (can't
// check name == '/', because that doesn't work on windows). // check name == '/', because that doesn't work on windows).
let mut name = name.deref(); let mut name = name.deref();
let original_name = name.to_owned(); let original_name = name.to_owned();
loop { loop {
let same = is_same_file(&name, &root).unwrap_or(false); let same = is_same_file(&name, &root).unwrap_or(false);

rust/hg-core/src/utils/hg_path.rs

Some(size) => ( Some(size) => (
HgPath::new(&self.inner[..*size]), HgPath::new(&self.inner[..*size]),
HgPath::new(&self.inner[*size + 1..]), HgPath::new(&self.inner[*size + 1..]),
), ),
} }
} }
pub fn join<T: ?Sized + AsRef<Self>>(&self, other: &T) -> HgPathBuf { pub fn join<T: ?Sized + AsRef<Self>>(&self, other: &T) -> HgPathBuf {
let mut inner = self.inner.to_owned(); let mut inner = self.inner.to_owned();
if inner.len() != 0 && inner.last() != Some(&b'/') { if !inner.is_empty() && inner.last() != Some(&b'/') {
inner.push(b'/'); inner.push(b'/');
} }
inner.extend(other.as_ref().bytes()); inner.extend(other.as_ref().bytes());
HgPathBuf::from_bytes(&inner) HgPathBuf::from_bytes(&inner)
} }
pub fn parent(&self) -> &Self { pub fn parent(&self) -> &Self {
let inner = self.as_bytes(); let inner = self.as_bytes();
HgPath::new(match inner.iter().rposition(|b| *b == b'/') { HgPath::new(match inner.iter().rposition(|b| *b == b'/') {
pub fn split_drive(&self) -> (&HgPath, &HgPath) { pub fn split_drive(&self) -> (&HgPath, &HgPath) {
(HgPath::new(b""), &self) (HgPath::new(b""), &self)
} }
/// Checks for errors in the path, short-circuiting at the first one. /// Checks for errors in the path, short-circuiting at the first one.
/// This generates fine-grained errors useful for debugging. /// This generates fine-grained errors useful for debugging.
/// To simply check if the path is valid during tests, use `is_valid`. /// To simply check if the path is valid during tests, use `is_valid`.
pub fn check_state(&self) -> Result<(), HgPathError> { pub fn check_state(&self) -> Result<(), HgPathError> {
if self.len() == 0 { if self.is_empty() {
return Ok(()); return Ok(());
} }
let bytes = self.as_bytes(); let bytes = self.as_bytes();
let mut previous_byte = None; let mut previous_byte = None;
if bytes[0] == b'/' { if bytes[0] == b'/' {
return Err(HgPathError::LeadingSlash(bytes.to_vec())); return Err(HgPathError::LeadingSlash(bytes.to_vec()));
} }
} }
impl fmt::Display for HgPath { impl fmt::Display for HgPath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", String::from_utf8_lossy(&self.inner)) write!(f, "{}", String::from_utf8_lossy(&self.inner))
} }
} }
#[derive(Eq, Ord, Clone, PartialEq, PartialOrd, Hash)] #[derive(Default, Eq, Ord, Clone, PartialEq, PartialOrd, Hash)]
pub struct HgPathBuf { pub struct HgPathBuf {
inner: Vec<u8>, inner: Vec<u8>,
} }
impl HgPathBuf { impl HgPathBuf {
pub fn new() -> Self { pub fn new() -> Self {
Self { inner: Vec::new() } Default::default()
} }
pub fn push(&mut self, byte: u8) { pub fn push(&mut self, byte: u8) {
self.inner.push(byte); self.inner.push(byte);
} }
pub fn from_bytes(s: &[u8]) -> HgPathBuf { pub fn from_bytes(s: &[u8]) -> HgPathBuf {
HgPath::new(s).to_owned() HgPath::new(s).to_owned()
} }
pub fn into_vec(self) -> Vec<u8> { pub fn into_vec(self) -> Vec<u8> {
self.inner self.inner
} }
pub fn as_ref(&self) -> &[u8] {
self.inner.as_ref()
}
} }
impl fmt::Debug for HgPathBuf { impl fmt::Debug for HgPathBuf {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "HgPathBuf({:?})", String::from_utf8_lossy(&self.inner)) write!(f, "HgPathBuf({:?})", String::from_utf8_lossy(&self.inner))
} }
} }

rust/hg-core/src/utils/path_auditor.rs

let parts = &parts[..parts.len().saturating_sub(1)]; let parts = &parts[..parts.len().saturating_sub(1)];
// We don't want to add "foo/bar/baz" to `audited_dirs` before checking // We don't want to add "foo/bar/baz" to `audited_dirs` before checking
// if there's a "foo/.hg" directory. This also means we won't // if there's a "foo/.hg" directory. This also means we won't
// accidentally traverse a symlink into some other filesystem (which // accidentally traverse a symlink into some other filesystem (which
// is potentially expensive to access). // is potentially expensive to access).
for index in 0..parts.len() { for index in 0..parts.len() {
let prefix = &parts[..index + 1].join(&b'/'); let prefix = &parts[..=index].join(&b'/');
let prefix = HgPath::new(prefix); let prefix = HgPath::new(prefix);
if self.audited_dirs.read().unwrap().contains(prefix) { if self.audited_dirs.read().unwrap().contains(prefix) {
continue; continue;
} }
self.check_filesystem(&prefix, &path)?; self.check_filesystem(&prefix, &path)?;
self.audited_dirs.write().unwrap().insert(prefix.to_owned()); self.audited_dirs.write().unwrap().insert(prefix.to_owned());
} }

rust/hg-cpython/src/cindex.rs

py, py,
format!( format!(
"ABI version mismatch: the C ABI revlog version {} \ "ABI version mismatch: the C ABI revlog version {} \
does not match the {} expected by Rust hg-cpython", does not match the {} expected by Rust hg-cpython",
capi.abi_version, REVLOG_CABI_VERSION capi.abi_version, REVLOG_CABI_VERSION
), ),
)); ));
} }
Ok(Index { Ok(Index { index, capi })
index: index,
capi: capi,
})
} }
/// return a reference to the CPython Index object in this Struct /// return a reference to the CPython Index object in this Struct
pub fn inner(&self) -> &PyObject { pub fn inner(&self) -> &PyObject {
&self.index &self.index
} }
pub fn append(&mut self, py: Python, tup: PyTuple) -> PyResult<PyObject> { pub fn append(&mut self, py: Python, tup: PyTuple) -> PyResult<PyObject> {
impl RevlogIndex for Index { impl RevlogIndex for Index {
/// Note C return type is Py_ssize_t (hence signed), but we shall /// Note C return type is Py_ssize_t (hence signed), but we shall
/// force it to unsigned, because it's a length /// force it to unsigned, because it's a length
fn len(&self) -> usize { fn len(&self) -> usize {
unsafe { (self.capi.index_length)(self.index.as_ptr()) as usize } unsafe { (self.capi.index_length)(self.index.as_ptr()) as usize }
} }
fn node<'a>(&'a self, rev: Revision) -> Option<&'a Node> { fn node(&self, rev: Revision) -> Option<&Node> {
let raw = unsafe { let raw = unsafe {
(self.capi.index_node)(self.index.as_ptr(), rev as c_int) (self.capi.index_node)(self.index.as_ptr(), rev as c_int)
}; };
if raw.is_null() { if raw.is_null() {
None None
} else { } else {
// TODO it would be much better for the C layer to give us // TODO it would be much better for the C layer to give us
// a length, since the hash length will change in the near // a length, since the hash length will change in the near

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

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: (&HgPathBuf, &HgPathBuf), res: (&HgPathBuf, &HgPathBuf),
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, res.0.as_ref()))) Ok(Some(PyBytes::new(py, res.0.as_bytes())))
} }
fn translate_key_value( fn translate_key_value(
py: Python, py: Python,
res: (&HgPathBuf, &HgPathBuf), res: (&HgPathBuf, &HgPathBuf),
) -> PyResult<Option<(PyBytes, PyBytes)>> { ) -> PyResult<Option<(PyBytes, PyBytes)>> {
let (k, v) = res; let (k, v) = res;
Ok(Some(( Ok(Some((
PyBytes::new(py, k.as_ref()), PyBytes::new(py, k.as_bytes()),
PyBytes::new(py, v.as_ref()), PyBytes::new(py, v.as_bytes()),
))) )))
} }
} }
py_shared_iterator!( py_shared_iterator!(
CopyMapKeysIterator, CopyMapKeysIterator,
UnsafePyLeaked<CopyMapIter<'static>>, UnsafePyLeaked<CopyMapIter<'static>>,
CopyMap::translate_key, CopyMap::translate_key,

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

pub fn from_inner(py: Python, d: DirsMultiset) -> PyResult<Self> { pub fn from_inner(py: Python, d: DirsMultiset) -> PyResult<Self> {
Self::create_instance(py, d) Self::create_instance(py, d)
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
res: &HgPathBuf, res: &HgPathBuf,
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, res.as_ref()))) Ok(Some(PyBytes::new(py, res.as_bytes())))
} }
} }
py_shared_iterator!( py_shared_iterator!(
DirsMultisetKeysIterator, DirsMultisetKeysIterator,
UnsafePyLeaked<DirsMultisetIter<'static>>, UnsafePyLeaked<DirsMultisetIter<'static>>,
Dirs::translate_key, Dirs::translate_key,
Option<PyBytes> Option<PyBytes>
); );

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

inner_shared.get_non_normal_other_parent_entries(); inner_shared.get_non_normal_other_parent_entries();
let locals = PyDict::new(py); let locals = PyDict::new(py);
locals.set_item( locals.set_item(
py, py,
"other_parent", "other_parent",
other_parent other_parent
.iter() .iter()
.map(|v| PyBytes::new(py, v.as_ref())) .map(|v| PyBytes::new(py, v.as_bytes()))
.collect::<Vec<PyBytes>>() .collect::<Vec<PyBytes>>()
.to_py_object(py), .to_py_object(py),
)?; )?;
py.eval("set(other_parent)", None, Some(&locals)) py.eval("set(other_parent)", None, Some(&locals))
} }
def non_normal_entries(&self) -> PyResult<NonNormalEntries> { def non_normal_entries(&self) -> PyResult<NonNormalEntries> {
} }
} }
def filefoldmapasdict(&self) -> PyResult<PyDict> { def filefoldmapasdict(&self) -> PyResult<PyDict> {
let dict = PyDict::new(py); let dict = PyDict::new(py);
for (key, value) in for (key, value) in
self.inner(py).borrow_mut().build_file_fold_map().iter() self.inner(py).borrow_mut().build_file_fold_map().iter()
{ {
dict.set_item(py, key.as_ref().to_vec(), value.as_ref().to_vec())?; dict.set_item(
py,
key.as_bytes().to_vec(),
value.as_bytes().to_vec(),
)?;
} }
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())
} }
} }
// 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 (key, value) in self.inner(py).borrow().copy_map.iter() {
dict.set_item( dict.set_item(
py, py,
PyBytes::new(py, key.as_ref()), PyBytes::new(py, key.as_bytes()),
PyBytes::new(py, value.as_ref()), 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))) {
Some(copy) => Ok(PyBytes::new(py, copy.as_ref())), 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))
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
match self match self
.inner(py) .inner(py)
.borrow() .borrow()
.copy_map .copy_map
.get(HgPath::new(key.data(py))) .get(HgPath::new(key.data(py)))
{ {
Some(copy) => Ok(Some( Some(copy) => Ok(Some(
PyBytes::new(py, copy.as_ref()).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
py: Python<'a>, py: Python<'a>,
) -> Ref<'a, RustDirstateMap> { ) -> Ref<'a, RustDirstateMap> {
self.inner(py).borrow() self.inner(py).borrow()
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
res: (&HgPathBuf, &DirstateEntry), res: (&HgPathBuf, &DirstateEntry),
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, res.0.as_ref()))) Ok(Some(PyBytes::new(py, res.0.as_bytes())))
} }
fn translate_key_value( fn translate_key_value(
py: Python, py: Python,
res: (&HgPathBuf, &DirstateEntry), res: (&HgPathBuf, &DirstateEntry),
) -> PyResult<Option<(PyBytes, PyObject)>> { ) -> PyResult<Option<(PyBytes, PyObject)>> {
let (f, entry) = res; let (f, entry) = res;
Ok(Some(( Ok(Some((
PyBytes::new(py, f.as_ref()), PyBytes::new(py, f.as_bytes()),
make_dirstate_tuple(py, entry)?, make_dirstate_tuple(py, entry)?,
))) )))
} }
} }
py_shared_iterator!( py_shared_iterator!(
DirstateMapKeysIterator, DirstateMapKeysIterator,
UnsafePyLeaked<StateMapIter<'static>>, UnsafePyLeaked<StateMapIter<'static>>,

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

} }
Ok(true) Ok(true)
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
key: &HgPathBuf, key: &HgPathBuf,
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, key.as_ref()))) Ok(Some(PyBytes::new(py, key.as_bytes())))
} }
} }
type NonNormalEntriesIter<'a> = hash_set::Iter<'a, HgPathBuf>; type NonNormalEntriesIter<'a> = hash_set::Iter<'a, HgPathBuf>;
py_shared_iterator!( py_shared_iterator!(
NonNormalEntriesIterator, NonNormalEntriesIterator,
UnsafePyLeaked<NonNormalEntriesIter<'static>>, UnsafePyLeaked<NonNormalEntriesIter<'static>>,
NonNormalEntries::translate_key, NonNormalEntries::translate_key,
Option<PyBytes> Option<PyBytes>
); );

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

}, },
) )
.map_err(|e| handle_fallback(py, e))?; .map_err(|e| handle_fallback(py, e))?;
all_warnings.extend(warnings); all_warnings.extend(warnings);
build_response(py, lookup, status_res, all_warnings) build_response(py, lookup, status_res, all_warnings)
} }
e => { e => Err(PyErr::new::<ValueError, _>(
return Err(PyErr::new::<ValueError, _>(
py, py,
format!("Unsupported matcher {}", e), format!("Unsupported matcher {}", e),
)); )),
}
} }
} }
fn build_response( fn build_response(
py: Python, py: Python,
lookup: Vec<Cow<HgPath>>, lookup: Vec<Cow<HgPath>>,
status_res: DirstateStatus, status_res: DirstateStatus,
warnings: Vec<PatternFileWarning>, warnings: Vec<PatternFileWarning>,

rust/hg-cpython/src/parsers.rs

let mut dirstate_map = FastHashMap::default(); let mut dirstate_map = FastHashMap::default();
let mut copies = FastHashMap::default(); let mut copies = FastHashMap::default();
match parse_dirstate(&mut dirstate_map, &mut copies, st.data(py)) { match parse_dirstate(&mut dirstate_map, &mut copies, st.data(py)) {
Ok(parents) => { Ok(parents) => {
for (filename, entry) in &dirstate_map { for (filename, entry) in &dirstate_map {
dmap.set_item( dmap.set_item(
py, py,
PyBytes::new(py, filename.as_ref()), PyBytes::new(py, filename.as_bytes()),
make_dirstate_tuple(py, entry)?, make_dirstate_tuple(py, entry)?,
)?; )?;
} }
for (path, copy_path) in copies { for (path, copy_path) in copies {
copymap.set_item( copymap.set_item(
py, py,
PyBytes::new(py, path.as_ref()), PyBytes::new(py, path.as_bytes()),
PyBytes::new(py, copy_path.as_ref()), PyBytes::new(py, copy_path.as_bytes()),
)?; )?;
} }
Ok( Ok(
(PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2)) (PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2))
.to_py_object(py), .to_py_object(py),
) )
} }
Err(e) => Err(PyErr::new::<exc::ValueError, _>( Err(e) => Err(PyErr::new::<exc::ValueError, _>(
p2: p2.try_into().unwrap(), p2: p2.try_into().unwrap(),
}, },
Duration::from_secs(now.as_object().extract::<u64>(py)?), Duration::from_secs(now.as_object().extract::<u64>(py)?),
) { ) {
Ok(packed) => { Ok(packed) => {
for (filename, entry) in &dirstate_map { for (filename, entry) in &dirstate_map {
dmap.set_item( dmap.set_item(
py, py,
PyBytes::new(py, filename.as_ref()), PyBytes::new(py, filename.as_bytes()),
make_dirstate_tuple(py, entry)?, make_dirstate_tuple(py, entry)?,
)?; )?;
} }
Ok(PyBytes::new(py, &packed)) Ok(PyBytes::new(py, &packed))
} }
Err(error) => Err(PyErr::new::<exc::ValueError, _>( Err(error) => Err(PyErr::new::<exc::ValueError, _>(
py, py,
match error { match error {

rust/hg-cpython/src/utils.rs

bytes: &'a PyObject, bytes: &'a PyObject,
) -> PyResult<Node> { ) -> PyResult<Node> {
let as_py_bytes: &'a PyBytes = bytes.extract(py)?; let as_py_bytes: &'a PyBytes = bytes.extract(py)?;
node_from_py_bytes(py, as_py_bytes) node_from_py_bytes(py, as_py_bytes)
} }
/// Clone incoming Python bytes given as `PyBytes` as a `Node`, /// Clone incoming Python bytes given as `PyBytes` as a `Node`,
/// doing the necessary checks. /// doing the necessary checks.
pub fn node_from_py_bytes<'a>( pub fn node_from_py_bytes(py: Python, bytes: &PyBytes) -> PyResult<Node> {
py: Python,
bytes: &'a PyBytes,
) -> PyResult<Node> {
<NodeData>::try_from(bytes.data(py)) <NodeData>::try_from(bytes.data(py))
.map_err(|_| { .map_err(|_| {
PyErr::new::<ValueError, _>( PyErr::new::<ValueError, _>(
py, py,
format!("{}-byte hash required", NODE_BYTES_LENGTH), format!("{}-byte hash required", NODE_BYTES_LENGTH),
) )
}) })
.map(|n| n.into()) .map(Into::into)
} }